Send only first block candidate optimistically (#1260)

* Broadcast only the first block candidate

* Fix sending block broadcast

---------

Co-authored-by: SpyCheese <[email protected]>

Author: EmelyanenkoK

create-hardfork/create-hardfork.cpp

@@ -249,7 +249,7 @@ class HardforkCreator : public td::actor::Actor {
       void send_block_candidate(ton::BlockIdExt block_id, ton::CatchainSeqno cc_seqno, td::uint32 validator_set_hash,
                                 td::BufferSlice data) override {
       }
-      void send_broadcast(ton::BlockBroadcast broadcast, bool custom_overlays_only) override {
+      void send_broadcast(ton::BlockBroadcast broadcast, int mode) override {
       }
       void download_block(ton::BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
                           td::Promise<ton::ReceivedBlock> promise) override {

test/test-ton-collator.cpp

@@ -350,7 +350,7 @@ class TestNode : public td::actor::Actor {
       void send_block_candidate(ton::BlockIdExt block_id, ton::CatchainSeqno cc_seqno, td::uint32 validator_set_hash,
                                 td::BufferSlice data) override {
       }
-      void send_broadcast(ton::BlockBroadcast broadcast, bool custom_overlays_only) override {
+      void send_broadcast(ton::BlockBroadcast broadcast, int mode) override {
       }
       void download_block(ton::BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
                           td::Promise<ton::ReceivedBlock> promise) override {

validator-session/validator-session-types.h

@@ -178,6 +178,12 @@ struct EndValidatorGroupStats {
   std::vector<Node> nodes;
 };
 
+struct BlockSourceInfo {
+  td::uint32 round, first_block_round;
+  PublicKey source;
+  td::int32 source_priority;
+};
+
 }  // namespace validatorsession
 
 }  // namespace ton

validator-session/validator-session.cpp

@@ -553,7 +553,9 @@ void ValidatorSessionImpl::check_generate_slot() {
             LOG(WARNING) << print_id << ": failed to generate block candidate: " << R.move_as_error();
           }
         });
-        callback_->on_generate_slot(cur_round_, std::move(P));
+        callback_->on_generate_slot(
+            BlockSourceInfo{cur_round_, first_block_round_, description().get_source_public_key(local_idx()), priority},
+            std::move(P));
       } else {
         alarm_timestamp().relax(t);
       }
@@ -631,8 +633,10 @@ void ValidatorSessionImpl::try_approve_block(const SentBlock *block) {
       });
       pending_approve_.insert(block_id);
 
-      callback_->on_candidate(cur_round_, description().get_source_public_key(block->get_src_idx()), B->root_hash_,
-                              B->data_.clone(), B->collated_data_.clone(), std::move(P));
+      callback_->on_candidate(
+          BlockSourceInfo{cur_round_, first_block_round_, description().get_source_public_key(block->get_src_idx()),
+                          description().get_node_priority(block->get_src_idx(), cur_round_)},
+          B->root_hash_, B->data_.clone(), B->collated_data_.clone(), std::move(P));
     } else if (T.is_in_past()) {
       if (!active_requests_.count(block_id)) {
         auto v = virtual_state_->get_block_approvers(description(), block_id);
@@ -905,15 +909,19 @@ void ValidatorSessionImpl::on_new_round(td::uint32 round) {
         stats.rounds.pop_back();
       }
 
+      BlockSourceInfo source_info{cur_round_, first_block_round_,
+                                  description().get_source_public_key(block->get_src_idx()),
+                                  description().get_node_priority(block->get_src_idx(), cur_round_)};
       if (it == blocks_.end()) {
-        callback_->on_block_committed(cur_round_, description().get_source_public_key(block->get_src_idx()),
-                                      block->get_root_hash(), block->get_file_hash(), td::BufferSlice(),
-                                      std::move(export_sigs), std::move(export_approve_sigs), std::move(stats));
+        callback_->on_block_committed(std::move(source_info), block->get_root_hash(), block->get_file_hash(),
+                                      td::BufferSlice(), std::move(export_sigs), std::move(export_approve_sigs),
+                                      std::move(stats));
       } else {
-        callback_->on_block_committed(cur_round_, description().get_source_public_key(block->get_src_idx()),
-                                      block->get_root_hash(), block->get_file_hash(), it->second->data_.clone(),
-                                      std::move(export_sigs), std::move(export_approve_sigs), std::move(stats));
+        callback_->on_block_committed(std::move(source_info), block->get_root_hash(), block->get_file_hash(),
+                                      it->second->data_.clone(), std::move(export_sigs), std::move(export_approve_sigs),
+                                      std::move(stats));
       }
+      first_block_round_ = cur_round_ + 1;
     }
     cur_round_++;
     if (have_block) {

validator-session/validator-session.h

@@ -85,11 +85,10 @@ class ValidatorSession : public td::actor::Actor {
 
   class Callback {
    public:
-    virtual void on_candidate(td::uint32 round, PublicKey source, ValidatorSessionRootHash root_hash,
-                              td::BufferSlice data, td::BufferSlice collated_data,
-                              td::Promise<CandidateDecision> promise) = 0;
-    virtual void on_generate_slot(td::uint32 round, td::Promise<GeneratedCandidate> promise) = 0;
-    virtual void on_block_committed(td::uint32 round, PublicKey source, ValidatorSessionRootHash root_hash,
+    virtual void on_candidate(BlockSourceInfo source_info, ValidatorSessionRootHash root_hash, td::BufferSlice data,
+                              td::BufferSlice collated_data, td::Promise<CandidateDecision> promise) = 0;
+    virtual void on_generate_slot(BlockSourceInfo source_info, td::Promise<GeneratedCandidate> promise) = 0;
+    virtual void on_block_committed(BlockSourceInfo source_info, ValidatorSessionRootHash root_hash,
                                     ValidatorSessionFileHash file_hash, td::BufferSlice data,
                                     std::vector<std::pair<PublicKeyHash, td::BufferSlice>> signatures,
                                     std::vector<std::pair<PublicKeyHash, td::BufferSlice>> approve_signatures,

validator-session/validator-session.hpp

@@ -53,7 +53,7 @@ class ValidatorSessionImpl : public ValidatorSession {
   const ValidatorSessionState *real_state_ = nullptr;
   const ValidatorSessionState *virtual_state_ = nullptr;
 
-  td::uint32 cur_round_ = 0;
+  td::uint32 cur_round_ = 0, first_block_round_ = 0;
   td::Timestamp round_started_at_ = td::Timestamp::never();
   td::Timestamp round_debug_at_ = td::Timestamp::never();
   std::set<ValidatorSessionCandidateId> pending_approve_;

validator/fabric.h

@@ -56,7 +56,7 @@ void run_check_external_message(td::Ref<ExtMessage> message, td::actor::ActorId<
 
 void run_accept_block_query(BlockIdExt id, td::Ref<BlockData> data, std::vector<BlockIdExt> prev,
                             td::Ref<ValidatorSet> validator_set, td::Ref<BlockSignatureSet> signatures,
-                            td::Ref<BlockSignatureSet> approve_signatures, bool send_broadcast,
+                            td::Ref<BlockSignatureSet> approve_signatures, int send_broadcast_mode,
                             td::actor::ActorId<ValidatorManager> manager, td::Promise<td::Unit> promise);
 void run_fake_accept_block_query(BlockIdExt id, td::Ref<BlockData> data, std::vector<BlockIdExt> prev,
                                  td::Ref<ValidatorSet> validator_set, td::actor::ActorId<ValidatorManager> manager,

validator/full-node.cpp

@@ -261,21 +261,22 @@ void FullNodeImpl::send_block_candidate(BlockIdExt block_id, CatchainSeqno cc_se
   }
 }
 
-void FullNodeImpl::send_broadcast(BlockBroadcast broadcast, bool custom_overlays_only) {
-  send_block_broadcast_to_custom_overlays(broadcast);
-  if (custom_overlays_only) {
-    return;
+void FullNodeImpl::send_broadcast(BlockBroadcast broadcast, int mode) {
+  if (mode & broadcast_mode_custom) {
+    send_block_broadcast_to_custom_overlays(broadcast);
   }
   auto shard = get_shard(ShardIdFull{masterchainId});
   if (shard.empty()) {
     VLOG(FULL_NODE_WARNING) << "dropping OUT broadcast to unknown shard";
     return;
   }
-  if (broadcast.block_id.is_masterchain() && !private_block_overlays_.empty()) {
+  if (!private_block_overlays_.empty() && (mode & broadcast_mode_private_block)) {
     td::actor::send_closure(private_block_overlays_.begin()->second, &FullNodePrivateBlockOverlay::send_broadcast,
                             broadcast.clone());
   }
-  td::actor::send_closure(shard, &FullNodeShard::send_broadcast, std::move(broadcast));
+  if (mode & broadcast_mode_public) {
+    td::actor::send_closure(shard, &FullNodeShard::send_broadcast, std::move(broadcast));
+  }
 }
 
 void FullNodeImpl::download_block(BlockIdExt id, td::uint32 priority, td::Timestamp timeout,
@@ -496,8 +497,8 @@ void FullNodeImpl::start_up() {
       td::actor::send_closure(id_, &FullNodeImpl::send_block_candidate, block_id, cc_seqno, validator_set_hash,
                               std::move(data));
     }
-    void send_broadcast(BlockBroadcast broadcast, bool custom_overlays_only) override {
-      td::actor::send_closure(id_, &FullNodeImpl::send_broadcast, std::move(broadcast), custom_overlays_only);
+    void send_broadcast(BlockBroadcast broadcast, int mode) override {
+      td::actor::send_closure(id_, &FullNodeImpl::send_broadcast, std::move(broadcast), mode);
     }
     void download_block(BlockIdExt id, td::uint32 priority, td::Timestamp timeout,
                         td::Promise<ReceivedBlock> promise) override {

validator/full-node.h

@@ -99,6 +99,7 @@ class FullNode : public td::actor::Actor {
   static constexpr td::uint64 max_state_size() {
     return 4ull << 30;
   }
+  enum { broadcast_mode_public = 1, broadcast_mode_private_block = 2, broadcast_mode_custom = 4 };
 
   static td::actor::ActorOwn<FullNode> create(ton::PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id,
                                               FileHash zero_state_file_hash, FullNodeConfig config,

validator/full-node.hpp

@@ -68,7 +68,7 @@ class FullNodeImpl : public FullNode {
   void send_shard_block_info(BlockIdExt block_id, CatchainSeqno cc_seqnp, td::BufferSlice data);
   void send_block_candidate(BlockIdExt block_id, CatchainSeqno cc_seqno, td::uint32 validator_set_hash,
                             td::BufferSlice data);
-  void send_broadcast(BlockBroadcast broadcast, bool custom_overlays_only);
+  void send_broadcast(BlockBroadcast broadcast, int mode);
   void download_block(BlockIdExt id, td::uint32 priority, td::Timestamp timeout, td::Promise<ReceivedBlock> promise);
   void download_zero_state(BlockIdExt id, td::uint32 priority, td::Timestamp timeout,
                            td::Promise<td::BufferSlice> promise);