Send block broadcasts directly to collators

validator/full-node-shard.cpp

@@ -127,6 +127,10 @@ void FullNodeShardImpl::create_overlay() {
   if (cert_) {
     td::actor::send_closure(overlays_, &overlay::Overlays::update_certificate, adnl_id_, overlay_id_, local_id_, cert_);
   }
+  if (!collator_nodes_.empty()) {
+    td::actor::send_closure(overlays_, &overlay::Overlays::set_priority_broadcast_receivers, adnl_id_, overlay_id_,
+                            collator_nodes_);
+  }
 }
 
 void FullNodeShardImpl::check_broadcast(PublicKeyHash src, td::BufferSlice broadcast, td::Promise<td::Unit> promise) {
@@ -1031,6 +1035,15 @@ void FullNodeShardImpl::update_validators(std::vector<PublicKeyHash> public_key_
   }
 }
 
+void FullNodeShardImpl::update_collators(std::vector<adnl::AdnlNodeIdShort> nodes) {
+  if (!client_.empty()) {
+    return;
+  }
+  collator_nodes_ = std::move(nodes);
+  td::actor::send_closure(overlays_, &overlay::Overlays::set_priority_broadcast_receivers, adnl_id_, overlay_id_,
+                          collator_nodes_);
+}
+
 void FullNodeShardImpl::reload_neighbours() {
   auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<std::vector<adnl::AdnlNodeIdShort>> R) {
     if (R.is_error()) {

validator/full-node-shard.h

@@ -75,6 +75,7 @@ class FullNodeShard : public td::actor::Actor {
   virtual void set_handle(BlockHandle handle, td::Promise<td::Unit> promise) = 0;
 
   virtual void update_validators(std::vector<PublicKeyHash> public_key_hashes, PublicKeyHash local_hash) = 0;
+  virtual void update_collators(std::vector<adnl::AdnlNodeIdShort> nodes) = 0;
 
   static td::actor::ActorOwn<FullNodeShard> create(
       ShardIdFull shard, PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id, FileHash zero_state_file_hash,

validator/full-node-shard.hpp

@@ -181,6 +181,7 @@ class FullNodeShardImpl : public FullNodeShard {
   void alarm() override;
 
   void update_validators(std::vector<PublicKeyHash> public_key_hashes, PublicKeyHash local_hash) override;
+  void update_collators(std::vector<adnl::AdnlNodeIdShort> nodes) override;
 
   void sign_overlay_certificate(PublicKeyHash signed_key, td::uint32 expiry_at, td::uint32 max_size, td::Promise<td::BufferSlice> promise) override;
   void import_overlay_certificate(PublicKeyHash signed_key, std::shared_ptr<ton::overlay::Certificate> cert, td::Promise<td::Unit> promise) override;
@@ -258,6 +259,7 @@ class FullNodeShardImpl : public FullNodeShard {
   adnl::AdnlNodeIdShort last_pinged_neighbour_ = adnl::AdnlNodeIdShort::zero();
 
   FullNodeShardMode mode_;
+  std::vector<adnl::AdnlNodeIdShort> collator_nodes_;
 };
 
 }  // namespace fullnode

validator/full-node.cpp

@@ -205,6 +205,33 @@ void FullNodeImpl::update_shard_configuration(td::Ref<MasterchainState> state, s
       ++it;
     }
   }
+
+  if (!collators_inited_ || state->is_key_state()) {
+    update_collators(state);
+  }
+}
+
+void FullNodeImpl::update_collators(td::Ref<MasterchainState> state) {
+  collators_inited_ = true;
+  collator_config_ = state->get_collator_config(true);
+  for (auto& s : shards_) {
+    update_shard_collators(s.first, s.second);
+  }
+}
+
+void FullNodeImpl::update_shard_collators(ShardIdFull shard, ShardInfo& info) {
+  if (info.actor.empty()) {
+    return;
+  }
+  std::vector<adnl::AdnlNodeIdShort> nodes;
+  for (const block::CollatorNodeDescr& desc : collator_config_.collator_nodes) {
+    if (!desc.full_node_id.is_zero() && shard_intersects(shard, desc.shard)) {
+      nodes.emplace_back(desc.full_node_id);
+    }
+  }
+  std::sort(nodes.begin(), nodes.end());
+  nodes.erase(std::unique(nodes.begin(), nodes.end()), nodes.end());
+  td::actor::send_closure(info.actor, &FullNodeShard::update_collators, std::move(nodes));
 }
 
 void FullNodeImpl::add_shard_actor(ShardIdFull shard, FullNodeShardMode mode) {
@@ -219,6 +246,9 @@ void FullNodeImpl::add_shard_actor(ShardIdFull shard, FullNodeShardMode mode) {
   if (all_validators_.size() > 0) {
     td::actor::send_closure(info.actor, &FullNodeShard::update_validators, all_validators_, sign_cert_by_);
   }
+  if (collators_inited_) {
+    update_shard_collators(shard, info);
+  }
 }
 
 void FullNodeImpl::sync_completed() {

validator/full-node.hpp

@@ -92,7 +92,16 @@ class FullNodeImpl : public FullNode {
                td::Promise<td::Unit> started_promise);
 
  private:
+  struct ShardInfo {
+    bool exists = false;
+    td::actor::ActorOwn<FullNodeShard> actor;
+    FullNodeShardMode mode = FullNodeShardMode::inactive;
+    td::Timestamp delete_at = td::Timestamp::never();
+  };
+
   void add_shard_actor(ShardIdFull shard, FullNodeShardMode mode);
+  void update_collators(td::Ref<MasterchainState> state);
+  void update_shard_collators(ShardIdFull shard, ShardInfo& info);
 
   PublicKeyHash local_id_;
   adnl::AdnlNodeIdShort adnl_id_;
@@ -100,13 +109,6 @@ class FullNodeImpl : public FullNode {
 
   td::actor::ActorId<FullNodeShard> get_shard(AccountIdPrefixFull dst);
   td::actor::ActorId<FullNodeShard> get_shard(ShardIdFull shard, bool exact = false);
-
-  struct ShardInfo {
-    bool exists = false;
-    td::actor::ActorOwn<FullNodeShard> actor;
-    FullNodeShardMode mode = FullNodeShardMode::inactive;
-    td::Timestamp delete_at = td::Timestamp::never();
-  };
   std::map<ShardIdFull, ShardInfo> shards_;
 
   td::actor::ActorId<keyring::Keyring> keyring_;
@@ -125,6 +127,8 @@ class FullNodeImpl : public FullNode {
   std::set<PublicKeyHash> local_keys_;
 
   td::Promise<td::Unit> started_promise_;
+  bool collators_inited_ = false;
+  block::CollatorConfig collator_config_;
 };
 
 }  // namespace fullnode

validator/impl/shard.cpp

@@ -556,5 +556,9 @@ BlockIdExt MasterchainStateQ::prev_key_block_id(BlockSeqno seqno) const {
   return block_id;
 }
 
+bool MasterchainStateQ::is_key_state() const {
+  return config_ ? config_->is_key_state() : false;
+}
+
 }  // namespace validator
 }  // namespace ton

validator/impl/shard.hpp

@@ -129,6 +129,7 @@ class MasterchainStateQ : public MasterchainState, public ShardStateQ {
   BlockIdExt last_key_block_id() const override;
   BlockIdExt next_key_block_id(BlockSeqno seqno) const override;
   BlockIdExt prev_key_block_id(BlockSeqno seqno) const override;
+  bool is_key_state() const override;
   MasterchainStateQ* make_copy() const override;
 
   static td::Result<Ref<MasterchainStateQ>> fetch(const BlockIdExt& _id, td::BufferSlice _data,

validator/interfaces/shard.h

@@ -77,6 +77,7 @@ class MasterchainState : virtual public ShardState {
   virtual BlockIdExt last_key_block_id() const = 0;
   virtual BlockIdExt next_key_block_id(BlockSeqno seqno) const = 0;
   virtual BlockIdExt prev_key_block_id(BlockSeqno seqno) const = 0;
+  virtual bool is_key_state() const = 0;
   virtual bool get_old_mc_block_id(ton::BlockSeqno seqno, ton::BlockIdExt& blkid,
                                    ton::LogicalTime* end_lt = nullptr) const = 0;
   virtual bool check_old_mc_block_id(const ton::BlockIdExt& blkid, bool strict = false) const = 0;