Changes in fast sync overlays

Join all overlays (not only monitoring shards) in order to be able to send broadcasts to other overlays

validator/full-node-fast-sync-overlays.cpp

@@ -201,8 +201,8 @@ void FullNodeFastSyncOverlay::init() {
                       current_validators_adnl_.end();
   if (!shard_.is_masterchain()) {
     options.default_permanent_members_flags_ = overlay::OverlayMemberFlags::DoNotReceiveBroadcasts;
-    options.local_overlay_member_flags_ = is_validator ? overlay::OverlayMemberFlags::DoNotReceiveBroadcasts : 0;
   }
+  options.local_overlay_member_flags_ = receive_broadcasts_ ? 0 : overlay::OverlayMemberFlags::DoNotReceiveBroadcasts;
   options.max_slaves_in_semiprivate_overlay_ = 100000;  // TODO: set lower limit (high limit for testing)
   td::actor::send_closure(overlays_, &overlay::Overlays::create_semiprivate_overlay, local_id_,
                           overlay_id_full_.clone(), current_validators_adnl_, root_public_keys_, member_certificate_,
@@ -235,6 +235,17 @@ void FullNodeFastSyncOverlay::set_member_certificate(overlay::OverlayMemberCerti
   }
 }
 
+void FullNodeFastSyncOverlay::set_receive_broadcasts(bool value) {
+  if (value == receive_broadcasts_) {
+    return;
+  }
+  receive_broadcasts_ = value;
+  if (inited_) {
+    td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_);
+    init();
+  }
+}
+
 void FullNodeFastSyncOverlay::get_stats_extra(td::Promise<std::string> promise) {
   auto res = create_tl_object<ton_api::engine_validator_fastSyncOverlayStats>();
   res->shard_ = shard_.to_str();
@@ -278,19 +289,21 @@ void FullNodeFastSyncOverlays::update_overlays(td::Ref<MasterchainState> state,
   monitoring_shards.insert(ShardIdFull{masterchainId});
   std::set<ShardIdFull> all_shards;
   all_shards.insert(ShardIdFull{masterchainId});
-  td::uint32 monitor_min_split = state->monitor_min_split_depth(basechainId);
+  for (const auto& desc : state->get_shards()) {
-  for (td::uint64 i = 0; i < (1ULL << monitor_min_split); ++i) {
+    ShardIdFull shard = desc->shard();
-    all_shards.insert(ShardIdFull{basechainId, (i * 2 + 1) << (63 - monitor_min_split)});
+    td::uint32 monitor_min_split = state->monitor_min_split_depth(shard.workchain);
+    if (shard.pfx_len() > monitor_min_split) {
+      shard = shard_prefix(shard, monitor_min_split);
+    }
+    all_shards.insert(shard);
   }
 
   // Remove overlays for removed adnl ids and shards
   for (auto it = id_to_overlays_.begin(); it != id_to_overlays_.end();) {
     if (my_adnl_ids.count(it->first)) {
       auto &overlays_info = it->second;
-      ;
-      auto &current_shards = overlays_info.is_validator_ ? all_shards : monitoring_shards;
       for (auto it2 = overlays_info.overlays_.begin(); it2 != overlays_info.overlays_.end();) {
-        if (current_shards.count(it2->first)) {
+        if (all_shards.count(it2->first)) {
           ++it2;
         } else {
           it2 = overlays_info.overlays_.erase(it2);
@@ -330,7 +343,7 @@ void FullNodeFastSyncOverlays::update_overlays(td::Ref<MasterchainState> state,
     for (auto &[local_id, overlays_info] : id_to_overlays_) {
       overlays_info.is_validator_ =
           std::binary_search(current_validators_adnl_.begin(), current_validators_adnl_.end(), local_id);
-      for (auto &[_, overlay] : overlays_info.overlays_) {
+      for (auto &[shard, overlay] : overlays_info.overlays_) {
         td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_validators, root_public_keys_,
                                 current_validators_adnl_);
       }
@@ -388,17 +401,20 @@ void FullNodeFastSyncOverlays::update_overlays(td::Ref<MasterchainState> state,
     }
 
     // Update shard overlays
-    auto &current_shards = overlays_info.is_validator_ ? all_shards : monitoring_shards;
+    for (ShardIdFull shard : all_shards) {
-    for (ShardIdFull shard_id : current_shards) {
+      bool receive_broadcasts = overlays_info.is_validator_ ? shard.is_masterchain() : monitoring_shards.count(shard);
-      auto &overlay = overlays_info.overlays_[shard_id];
+      auto &overlay = overlays_info.overlays_[shard];
       if (overlay.empty()) {
         overlay = td::actor::create_actor<FullNodeFastSyncOverlay>(
-            PSTRING() << "FastSyncOv" << shard_id.to_str(), local_id, shard_id, zero_state_file_hash,
+            PSTRING() << "FastSyncOv" << shard.to_str(), local_id, shard, zero_state_file_hash, root_public_keys_,
-            root_public_keys_, current_validators_adnl_, overlays_info.current_certificate_, keyring, adnl, overlays,
+            current_validators_adnl_, overlays_info.current_certificate_, receive_broadcasts, keyring, adnl, overlays,
             validator_manager, full_node);
-      } else if (changed_certificate) {
+      } else {
-        td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_member_certificate,
+        td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_receive_broadcasts, receive_broadcasts);
-                                overlays_info.current_certificate_);
+        if (changed_certificate) {
+          td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_member_certificate,
+                                  overlays_info.current_certificate_);
+        }
       }
     }
   }

validator/full-node-fast-sync-overlays.hpp

@@ -49,11 +49,12 @@ class FullNodeFastSyncOverlay : public td::actor::Actor {
   void set_validators(std::vector<PublicKeyHash> root_public_keys,
                       std::vector<adnl::AdnlNodeIdShort> current_validators_adnl);
   void set_member_certificate(overlay::OverlayMemberCertificate member_certificate);
+  void set_receive_broadcasts(bool value);
 
   FullNodeFastSyncOverlay(adnl::AdnlNodeIdShort local_id, ShardIdFull shard, FileHash zero_state_file_hash,
                           std::vector<PublicKeyHash> root_public_keys,
                           std::vector<adnl::AdnlNodeIdShort> current_validators_adnl,
-                          overlay::OverlayMemberCertificate member_certificate,
+                          overlay::OverlayMemberCertificate member_certificate, bool receive_broadcasts,
                           td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
                           td::actor::ActorId<overlay::Overlays> overlays,
                           td::actor::ActorId<ValidatorManagerInterface> validator_manager,
@@ -63,6 +64,7 @@ class FullNodeFastSyncOverlay : public td::actor::Actor {
       , root_public_keys_(std::move(root_public_keys))
       , current_validators_adnl_(std::move(current_validators_adnl))
       , member_certificate_(std::move(member_certificate))
+      , receive_broadcasts_(receive_broadcasts)
       , zero_state_file_hash_(zero_state_file_hash)
       , keyring_(keyring)
       , adnl_(adnl)
@@ -77,6 +79,7 @@ class FullNodeFastSyncOverlay : public td::actor::Actor {
   std::vector<PublicKeyHash> root_public_keys_;
   std::vector<adnl::AdnlNodeIdShort> current_validators_adnl_;
   overlay::OverlayMemberCertificate member_certificate_;
+  bool receive_broadcasts_;
   FileHash zero_state_file_hash_;
 
   td::actor::ActorId<keyring::Keyring> keyring_;