Don't store candidates on collator nodes

create-hardfork/create-hardfork.cpp

@@ -271,7 +271,8 @@ class HardforkCreator : public td::actor::Actor {
 
                             td::Promise<std::string> promise) override {
       }
-      void download_out_msg_queue_proof(ton::BlockIdExt block_id, ton::ShardIdFull dst_shard, td::Timestamp timeout,
+      void download_out_msg_queue_proof(ton::BlockIdExt block_id, ton::ShardIdFull dst_shard,
+                                        block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
                                         td::Promise<td::Ref<ton::validator::OutMsgQueueProof>> promise) override {
       }
 

test/test-ton-collator.cpp

@@ -372,7 +372,8 @@ class TestNode : public td::actor::Actor {
 
                             td::Promise<std::string> promise) override {
       }
-      void download_out_msg_queue_proof(ton::BlockIdExt block_id, ton::ShardIdFull dst_shard, td::Timestamp timeout,
+      void download_out_msg_queue_proof(ton::BlockIdExt block_id, ton::ShardIdFull dst_shard,
+                                        block::ImportedMsgQueueLimits, td::Timestamp timeout,
                                         td::Promise<td::Ref<ton::validator::OutMsgQueueProof>> promise) override {
       }
 

validator/collator-node.cpp

@@ -272,7 +272,8 @@ void CollatorNode::receive_query_cont(ShardIdFull shard, td::Ref<MasterchainStat
                                       std::vector<BlockIdExt> prev_blocks, Ed25519_PublicKey creator,
                                       td::Promise<BlockCandidate> promise) {
   run_collate_query(shard, min_mc_state->get_block_id(), std::move(prev_blocks), creator,
-                    min_mc_state->get_validator_set(shard), manager_, td::Timestamp::in(10.0), std::move(promise));
+                    min_mc_state->get_validator_set(shard), manager_, td::Timestamp::in(10.0), std::move(promise),
+                    CollateMode::skip_store_candidate);
 }
 
 void CollatorNode::process_result(std::shared_ptr<CacheEntry> cache_entry, td::Result<BlockCandidate> R) {

validator/fabric.h

@@ -26,6 +26,7 @@ namespace ton {
 namespace validator {
 
 enum ValidateMode { fake = 1, full_collated_data = 2 };
+enum CollateMode { skip_store_candidate = 1 };
 
 td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_);
 td::actor::ActorOwn<LiteServerCache> create_liteserver_cache_actor(td::actor::ActorId<ValidatorManager> manager,
@@ -83,9 +84,9 @@ void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
                         td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                         td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
 void run_collate_query(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                       Ed25519_PublicKey local_id, td::Ref<ValidatorSet> validator_set,
+                       Ed25519_PublicKey creator, td::Ref<ValidatorSet> validator_set,
                        td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-                       td::Promise<BlockCandidate> promise);
+                       td::Promise<BlockCandidate> promise, unsigned mode = 0);
 void run_collate_hardfork(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,
                           td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                           td::Promise<BlockCandidate> promise);

validator/impl/collator-impl.h

@@ -75,6 +75,7 @@ class Collator final : public td::actor::Actor {
   td::Timestamp timeout;
   td::Timestamp queue_cleanup_timeout_, soft_timeout_, medium_timeout_;
   td::Promise<BlockCandidate> main_promise;
+  unsigned mode_ = 0;
   ton::BlockSeqno last_block_seqno{0};
   ton::BlockSeqno prev_mc_block_seqno{0};
   ton::BlockSeqno new_block_seqno{0};
@@ -89,7 +90,8 @@ class Collator final : public td::actor::Actor {
  public:
   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);
+           td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout, td::Promise<BlockCandidate> promise,
+           unsigned mode);
   ~Collator() override = default;
   bool is_busy() const {
     return busy_;

validator/impl/collator.cpp

@@ -57,7 +57,7 @@ static inline bool dbg(int c) {
 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)
+                   td::Promise<BlockCandidate> promise, unsigned mode)
     : shard_(shard)
     , is_hardfork_(is_hardfork)
     , min_mc_block_id{min_masterchain_block_id}
@@ -71,6 +71,7 @@ Collator::Collator(ShardIdFull shard, bool is_hardfork, BlockIdExt min_mastercha
     , soft_timeout_(td::Timestamp::at(timeout.at() - 3.0))
     , medium_timeout_(td::Timestamp::at(timeout.at() - 1.5))
     , main_promise(std::move(promise))
+    , mode_(mode)
     , perf_timer_("collate", 0.1, [manager](double duration) {
       send_closure(manager, &ValidatorManager::add_perf_timer_stat, "collate", duration);
     }) {
@@ -4200,6 +4201,9 @@ bool Collator::create_block_candidate() {
                                  << consensus_config.max_collated_data_size << ")");
   }
   // 4. save block candidate
+  if (mode_ & CollateMode::skip_store_candidate) {
+    td::actor::send_closure_later(actor_id(this), &Collator::return_block_candidate, td::Unit());
+  } else {
     LOG(INFO) << "saving new BlockCandidate";
     td::actor::send_closure_later(manager, &ValidatorManager::set_block_candidate, block_candidate->id,
                                   block_candidate->clone(), [self = get_self()](td::Result<td::Unit> saved) -> void {
@@ -4207,6 +4211,7 @@ bool Collator::create_block_candidate() {
                                     td::actor::send_closure_later(std::move(self), &Collator::return_block_candidate,
                                                                   std::move(saved));
                                   });
+  }
   // 5. communicate about bad and delayed external messages
   if (!bad_ext_msgs_.empty() || !delay_ext_msgs_.empty()) {
     LOG(INFO) << "sending complete_external_messages() to Manager";

validator/impl/fabric.cpp

@@ -210,9 +210,9 @@ void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
 }
 
 void run_collate_query(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                       Ed25519_PublicKey collator_id, td::Ref<ValidatorSet> validator_set,
+                       Ed25519_PublicKey creator, td::Ref<ValidatorSet> validator_set,
                        td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-                       td::Promise<BlockCandidate> promise) {
+                       td::Promise<BlockCandidate> promise, unsigned mode) {
   BlockSeqno seqno = 0;
   for (auto& p : prev) {
     if (p.seqno() > seqno) {
@@ -220,8 +220,8 @@ void run_collate_query(ShardIdFull shard, const BlockIdExt& min_masterchain_bloc
     }
   }
   td::actor::create_actor<Collator>(PSTRING() << "collate" << shard.to_str() << ":" << (seqno + 1), shard, false,
-                                    min_masterchain_block_id, std::move(prev), std::move(validator_set), collator_id,
+                                    min_masterchain_block_id, std::move(prev), std::move(validator_set), creator,
-                                    std::move(manager), timeout, std::move(promise))
+                                    std::move(manager), timeout, std::move(promise), mode)
       .release();
 }
 
@@ -236,7 +236,8 @@ void run_collate_hardfork(ShardIdFull shard, const BlockIdExt& min_masterchain_b
   }
   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))
+                                    Ed25519_PublicKey{Bits256::zero()}, std::move(manager), timeout, std::move(promise),
+                                    0)
       .release();
 }