Remove unused code

validator/fabric.h

@@ -72,12 +72,12 @@ void run_check_proof_query(BlockIdExt id, td::Ref<Proof> proof, td::actor::Actor
                            td::Ref<ProofLink> rel_key_block_proof, bool skip_check_signatures = false);
 void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::actor::ActorId<ValidatorManager> manager,
                                 td::Timestamp timeout, td::Promise<BlockHandle> promise);
-void run_validate_query(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
+void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                        std::vector<BlockIdExt> prev, BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
+                        BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
                         td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                         td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
-void run_collate_query(ShardIdFull shard, td::uint32 min_ts, const BlockIdExt& min_masterchain_block_id,
+void run_collate_query(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                       std::vector<BlockIdExt> prev, Ed25519_PublicKey local_id, td::Ref<ValidatorSet> validator_set,
+                       Ed25519_PublicKey local_id, td::Ref<ValidatorSet> validator_set,
                        td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                        td::Promise<BlockCandidate> promise);
 void run_collate_hardfork(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,

validator/impl/CMakeLists.txt

@@ -25,7 +25,6 @@ set(TON_VALIDATOR_SOURCE
   accept-block.hpp
   block.hpp
   check-proof.hpp
-  collate-query-impl.h
   collator-impl.h
   collator.h
   config.hpp

validator/impl/collate-query-impl.h

@@ -1,63 +0,0 @@
-/*
-    This file is part of TON Blockchain Library.
-
-    TON Blockchain Library is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
-
-    TON Blockchain Library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
-
-    Copyright 2017-2020 Telegram Systems LLP
-*/
-#pragma once
-
-#include "validator/interfaces/validator-manager.h"
-
-namespace ton {
-
-namespace validator {
-
-class CollateQuery : public td::actor::Actor {
- public:
-  CollateQuery(ShardIdFull shard, td::uint32 min_ts, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
-               td::Ref<ValidatorSet> validator_set, td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-               td::Promise<BlockCandidate> promise);
-  CollateQuery(ShardIdFull shard, td::uint32 min_ts, BlockIdExt min_masterchain_block_id, ZeroStateIdExt zero_state_id,
-               td::Ref<ValidatorSet> validator_set, td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-               td::Promise<BlockCandidate> promise);
-
-  void alarm() override;
-
-  void abort_query(td::Status reason);
-  void finish_query();
-
-  void start_up() override;
-  void got_prev_state(td::Ref<MasterchainState> state);
-  void written_block_data();
-  void written_block_collated_data();
-
- private:
-  ShardIdFull shard_;
-  UnixTime min_ts_;
-  BlockIdExt min_masterchain_block_id_;
-  std::vector<BlockIdExt> prev_;
-  ZeroStateIdExt zero_state_id_;
-  td::Ref<ValidatorSet> validator_set_;
-  td::actor::ActorId<ValidatorManager> manager_;
-  td::Timestamp timeout_;
-  td::Promise<BlockCandidate> promise_;
-
-  BlockCandidate candidate_;
-  UnixTime ts_;
-};
-
-}  // namespace validator
-
-}  // namespace ton

validator/impl/collator-impl.h

@@ -64,7 +64,6 @@ class Collator final : public td::actor::Actor {
   bool libraries_changed_{false};
   bool prev_key_block_exists_{false};
   bool is_hardfork_{false};
-  UnixTime min_ts;
   BlockIdExt min_mc_block_id;
   std::vector<BlockIdExt> prev_blocks;
   std::vector<Ref<ShardState>> prev_states;
@@ -86,7 +85,7 @@ class Collator final : public td::actor::Actor {
   static constexpr bool shard_splitting_enabled = true;
 
  public:
-  Collator(ShardIdFull shard, bool is_hardfork, td::uint32 min_ts, BlockIdExt min_masterchain_block_id,
+  Collator(ShardIdFull shard, bool is_hardfork, BlockIdExt min_masterchain_block_id,
            std::vector<BlockIdExt> prev, Ref<ValidatorSet> validator_set, Ed25519_PublicKey collator_id,
            td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout, td::Promise<BlockCandidate> promise);
   ~Collator() override = default;

validator/impl/collator.cpp

@@ -54,13 +54,12 @@ static inline bool dbg(int c) {
   return true;
 }
 
-Collator::Collator(ShardIdFull shard, bool is_hardfork, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
+Collator::Collator(ShardIdFull shard, bool is_hardfork, BlockIdExt min_masterchain_block_id,
                    std::vector<BlockIdExt> prev, td::Ref<ValidatorSet> validator_set, Ed25519_PublicKey collator_id,
                    td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                    td::Promise<BlockCandidate> promise)
     : shard_(shard)
     , is_hardfork_(is_hardfork)
-    , min_ts(min_ts)
     , min_mc_block_id{min_masterchain_block_id}
     , prev_blocks(std::move(prev))
     , created_by_(collator_id)

validator/impl/collator.h

@@ -24,26 +24,7 @@
 #include "vm/cells.h"
 
 namespace ton {
-using td::Ref;
 
 extern int collator_settings;  // +1 = force want_split, +2 = force want_merge
 
-class Collator : public td::actor::Actor {
- protected:
-  Collator() = default;
-
- public:
-  virtual ~Collator() = default;
-  static td::actor::ActorOwn<Collator> create_collator(
-      td::actor::ActorId<block::BlockDb> block_db,
-      ShardIdFull shard /* , td::actor::ActorId<ValidatorManager> validator_manager */);
-  virtual void generate_block_candidate(ShardIdFull shard, td::Promise<BlockCandidate> promise) = 0;
-  virtual td::Result<bool> register_external_message_cell(Ref<vm::Cell> ext_msg) = 0;
-  virtual td::Result<bool> register_external_message(td::Slice ext_msg_boc) = 0;
-  virtual td::Result<bool> register_ihr_message_cell(Ref<vm::Cell> ihr_msg) = 0;
-  virtual td::Result<bool> register_ihr_message(td::Slice ihr_msg_boc) = 0;
-  virtual td::Result<bool> register_shard_signatures_cell(Ref<vm::Cell> shard_blk_signatures) = 0;
-  virtual td::Result<bool> register_shard_signatures(td::Slice shard_blk_signatures_boc) = 0;
-};
-
 }  // namespace ton

validator/impl/fabric.cpp

@@ -188,7 +188,7 @@ void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::act
       .release();
 }
 
-void run_validate_query(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
+void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
                         std::vector<BlockIdExt> prev, BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
                         td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                         td::Promise<ValidateCandidateResult> promise, unsigned mode) {
@@ -200,14 +200,14 @@ void run_validate_query(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_maste
   }
   bool is_fake = mode & ValidateMode::fake;
   td::actor::create_actor<ValidateQuery>(
-      PSTRING() << (is_fake ? "fakevalidate" : "validateblock") << shard.to_str() << ":" << (seqno + 1), shard, min_ts,
+      PSTRING() << (is_fake ? "fakevalidate" : "validateblock") << shard.to_str() << ":" << (seqno + 1), shard,
       min_masterchain_block_id, std::move(prev), std::move(candidate), std::move(validator_set), std::move(manager),
       timeout, std::move(promise), mode)
       .release();
 }
 
-void run_collate_query(ShardIdFull shard, td::uint32 min_ts, const BlockIdExt& min_masterchain_block_id,
+void run_collate_query(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                       std::vector<BlockIdExt> prev, Ed25519_PublicKey collator_id, td::Ref<ValidatorSet> validator_set,
+                       Ed25519_PublicKey collator_id, td::Ref<ValidatorSet> validator_set,
                        td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                        td::Promise<BlockCandidate> promise) {
   BlockSeqno seqno = 0;
@@ -217,8 +217,8 @@ void run_collate_query(ShardIdFull shard, td::uint32 min_ts, const BlockIdExt& m
     }
   }
   td::actor::create_actor<Collator>(PSTRING() << "collate" << shard.to_str() << ":" << (seqno + 1), shard, false,
-                                    min_ts, min_masterchain_block_id, std::move(prev), std::move(validator_set),
+                                    min_masterchain_block_id, std::move(prev), std::move(validator_set), collator_id,
-                                    collator_id, std::move(manager), timeout, std::move(promise))
+                                    std::move(manager), timeout, std::move(promise))
       .release();
 }
 
@@ -231,7 +231,7 @@ void run_collate_hardfork(ShardIdFull shard, const BlockIdExt& min_masterchain_b
       seqno = p.seqno();
     }
   }
-  td::actor::create_actor<Collator>(PSTRING() << "collate" << shard.to_str() << ":" << (seqno + 1), shard, true, 0,
+  td::actor::create_actor<Collator>(PSTRING() << "collate" << shard.to_str() << ":" << (seqno + 1), shard, true,
                                     min_masterchain_block_id, std::move(prev), td::Ref<ValidatorSet>{},
                                     Ed25519_PublicKey{Bits256::zero()}, std::move(manager), timeout, std::move(promise))
       .release();

validator/impl/validate-query.cpp

@@ -49,13 +49,12 @@ std::string ErrorCtx::as_string() const {
   return a;
 }
 
-ValidateQuery::ValidateQuery(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
+ValidateQuery::ValidateQuery(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
                              std::vector<BlockIdExt> prev, BlockCandidate candidate, Ref<ValidatorSet> validator_set,
                              td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                              td::Promise<ValidateCandidateResult> promise, unsigned mode)
     : shard_(shard)
     , id_(candidate.id)
-    , min_ts(min_ts)
     , min_mc_block_id(min_masterchain_block_id)
     , prev_blocks(std::move(prev))
     , block_candidate(std::move(candidate))

validator/impl/validate-query.hpp

@@ -115,7 +115,7 @@ class ValidateQuery : public td::actor::Actor {
   }
 
  public:
-  ValidateQuery(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
+  ValidateQuery(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
                 BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
                 td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                 td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
@@ -125,7 +125,6 @@ class ValidateQuery : public td::actor::Actor {
   int pending{0};
   const ShardIdFull shard_;
   const BlockIdExt id_;
-  UnixTime min_ts;
   BlockIdExt min_mc_block_id;
   std::vector<BlockIdExt> prev_blocks;
   std::vector<Ref<ShardState>> prev_states;

validator/manager-disk.cpp

@@ -128,7 +128,7 @@ void ValidatorManagerImpl::sync_complete(td::Promise<td::Unit> promise) {
   }
   Ed25519_PublicKey created_by{td::Bits256::zero()};
   td::as<td::uint32>(created_by.as_bits256().data() + 32 - 4) = ((unsigned)std::time(nullptr) >> 8);
-  run_collate_query(shard_id, 0, last_masterchain_block_id_, prev, created_by, val_set, actor_id(this),
+  run_collate_query(shard_id, last_masterchain_block_id_, prev, created_by, val_set, actor_id(this),
                     td::Timestamp::in(10.0), std::move(P));
 }
 
@@ -152,7 +152,7 @@ void ValidatorManagerImpl::validate_fake(BlockCandidate candidate, std::vector<B
     }
   });
   auto shard = candidate.id.shard_full();
-  run_validate_query(shard, 0, last, prev, std::move(candidate), std::move(val_set), actor_id(this),
+  run_validate_query(shard, last, prev, std::move(candidate), std::move(val_set), actor_id(this),
                      td::Timestamp::in(10.0), std::move(P), ValidateMode::fake);
 }
 

validator/manager.cpp

@@ -1831,15 +1831,13 @@ void ValidatorManagerImpl::update_shards() {
           auto it2 = next_validator_groups_.find(legacy_val_group_id);
           if (it2 != next_validator_groups_.end()) {
             if (!it2->second.empty()) {
-              td::actor::send_closure(it2->second, &ValidatorGroup::start, prev, last_masterchain_block_id_,
+              td::actor::send_closure(it2->second, &ValidatorGroup::start, prev, last_masterchain_block_id_);
-                                      last_masterchain_state_->get_unix_time());
             }
             new_validator_groups_.emplace(val_group_id, std::move(it2->second));
           } else {
             auto G = create_validator_group(val_group_id, shard, val_set, opts, started_);
             if (!G.empty()) {
-              td::actor::send_closure(G, &ValidatorGroup::start, prev, last_masterchain_block_id_,
+              td::actor::send_closure(G, &ValidatorGroup::start, prev, last_masterchain_block_id_);
-                                      last_masterchain_state_->get_unix_time());
             }
             new_validator_groups_.emplace(val_group_id, std::move(G));
           }
@@ -1887,15 +1885,13 @@ void ValidatorManagerImpl::update_shards() {
           auto it2 = next_validator_groups_.find(val_group_id);
           if (it2 != next_validator_groups_.end()) {
             if (!it2->second.empty()) {
-              td::actor::send_closure(it2->second, &ValidatorGroup::start, prev, last_masterchain_block_id_,
+              td::actor::send_closure(it2->second, &ValidatorGroup::start, prev, last_masterchain_block_id_);
-                                      last_masterchain_state_->get_unix_time());
             }
             new_validator_groups_.emplace(val_group_id, std::move(it2->second));
           } else {
             auto G = create_validator_group(val_group_id, shard, val_set, opts, started_);
             if (!G.empty()) {
-              td::actor::send_closure(G, &ValidatorGroup::start, prev, last_masterchain_block_id_,
+              td::actor::send_closure(G, &ValidatorGroup::start, prev, last_masterchain_block_id_);
-                                      last_masterchain_state_->get_unix_time());
             }
             new_validator_groups_.emplace(val_group_id, std::move(G));
           }
@@ -2640,8 +2636,8 @@ void ValidatorManagerImpl::generate_block_candidate(BlockId block_id, td::Promis
     promise.set_error(td::Status::Error("cannot get validator set"));
     return;
   }
-  run_collate_query(shard_id, last_masterchain_state_->get_unix_time(), last_masterchain_block_id_, std::move(prev),
+  run_collate_query(shard_id, last_masterchain_block_id_, std::move(prev), local_id, std::move(validator_set),
-                    local_id, std::move(validator_set), actor_id(this), td::Timestamp::in(10.0), std::move(promise));
+                    actor_id(this), td::Timestamp::in(10.0), std::move(promise));
 }
 
 void ValidatorManagerImpl::get_required_block_candidates(td::Promise<std::vector<BlockId>> promise) {

validator/validator-group.cpp

@@ -51,7 +51,7 @@ void ValidatorGroup::generate_block_candidate(td::uint32 round_id, td::Promise<B
                             td::Timestamp::in(15.0), std::move(P));
     return;
   }
-  run_collate_query(shard_, min_ts_, min_masterchain_block_id_, prev_block_ids_,
+  run_collate_query(shard_, min_masterchain_block_id_, prev_block_ids_,
                     Ed25519_PublicKey{local_id_full_.ed25519_value().raw()}, validator_set_, manager_,
                     td::Timestamp::in(10.0), std::move(promise));
 }
@@ -94,8 +94,8 @@ void ValidatorGroup::validate_block_candidate(td::uint32 round_id, BlockCandidat
   auto next_block_id = create_next_block_id(block.id.root_hash, block.id.file_hash);
   VLOG(VALIDATOR_DEBUG) << "validating block candidate " << next_block_id;
   block.id = next_block_id;
-  run_validate_query(shard_, min_ts_, min_masterchain_block_id_, prev_block_ids_, std::move(block), validator_set_,
+  run_validate_query(shard_, min_masterchain_block_id_, prev_block_ids_, std::move(block), validator_set_, manager_,
-                     manager_, td::Timestamp::in(10.0), std::move(P), lite_mode_ ? ValidateMode::lite : 0);
+                     td::Timestamp::in(10.0), std::move(P), lite_mode_ ? ValidateMode::lite : 0);
 }
 
 void ValidatorGroup::accept_block_candidate(td::uint32 round_id, PublicKeyHash src, td::BufferSlice block_data,
@@ -295,10 +295,9 @@ void ValidatorGroup::create_session() {
   }
 }
 
-void ValidatorGroup::start(std::vector<BlockIdExt> prev, BlockIdExt min_masterchain_block_id, UnixTime min_ts) {
+void ValidatorGroup::start(std::vector<BlockIdExt> prev, BlockIdExt min_masterchain_block_id) {
   prev_block_ids_ = prev;
   min_masterchain_block_id_ = min_masterchain_block_id;
-  min_ts_ = min_ts;
   started_ = true;
 
   if (init_) {

validator/validator-group.hpp

@@ -47,7 +47,7 @@ class ValidatorGroup : public td::actor::Actor {
   BlockId create_next_block_id_simple() const;
   BlockIdExt create_next_block_id(RootHash root_hash, FileHash file_hash) const;
 
-  void start(std::vector<BlockIdExt> prev, BlockIdExt min_masterchain_block_id, UnixTime min_ts);
+  void start(std::vector<BlockIdExt> prev, BlockIdExt min_masterchain_block_id);
   void create_session();
   void destroy();
   void start_up() override {
@@ -103,7 +103,6 @@ class ValidatorGroup : public td::actor::Actor {
 
   std::vector<BlockIdExt> prev_block_ids_;
   BlockIdExt min_masterchain_block_id_;
-  UnixTime min_ts_;
 
   td::Ref<ValidatorSet> validator_set_;
   validatorsession::ValidatorSessionOptions config_;