Various changes in node (#1230)

* Remove unneeded "wait_neighbours_not_empty"

* Fix "round_started_at" for the first round

* Fix use after move in overlay.cpp

* Move "last gc masterchain state" stat to CellDbIn::prepare_stats

* Fix disabling state serializer

overlay/overlay-peers.cpp

@@ -633,14 +633,9 @@ std::vector<adnl::AdnlNodeIdShort> OverlayImpl::get_neighbours(td::uint32 max_si
 }
 
 void OverlayImpl::send_message_to_neighbours(td::BufferSlice data) {
-  wait_neighbours_not_empty([this, data = std::move(data)](td::Result<td::Unit> R) {
+  for (auto &n : peer_list_.neighbours_) {
-    if (R.is_error()) {
+    td::actor::send_closure(manager_, &OverlayManager::send_message, n, local_id_, overlay_id_, data.clone());
-      return;
+  }
-    }
-    for (auto &n : peer_list_.neighbours_) {
-      td::actor::send_closure(manager_, &OverlayManager::send_message, n, local_id_, overlay_id_, data.clone());
-    }
-  });
 }
 
 size_t OverlayImpl::neighbours_cnt() const {

overlay/overlay.cpp

@@ -101,9 +101,9 @@ OverlayImpl::OverlayImpl(td::actor::ActorId<keyring::Keyring> keyring, td::actor
 
   VLOG(OVERLAY_INFO) << this << ": creating";
 
-  update_root_member_list(std::move(nodes), std::move(root_public_keys), std::move(cert));
+  auto nodes_size = static_cast<td::uint32>(nodes.size());
-
+  OverlayImpl::update_root_member_list(std::move(nodes), std::move(root_public_keys), std::move(cert));
-  update_neighbours(static_cast<td::uint32>(nodes.size()));
+  update_neighbours(nodes_size);
 }
 
 void OverlayImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::overlay_getRandomPeers &query,
@@ -457,20 +457,6 @@ void OverlayImpl::bcast_gc() {
   CHECK(delivered_broadcasts_.size() == bcast_lru_.size());
 }
 
-void OverlayImpl::wait_neighbours_not_empty(td::Promise<td::Unit> promise, int max_retries) {
-  if (!peer_list_.neighbours_.empty()) {
-    promise.set_result(td::Unit());
-  } else if (max_retries > 0) {
-    delay_action(
-        [SelfId = actor_id(this), promise = std::move(promise), max_retries]() mutable {
-          td::actor::send_closure(SelfId, &OverlayImpl::wait_neighbours_not_empty, std::move(promise), max_retries - 1);
-        },
-        td::Timestamp::in(0.5));
-  } else {
-    promise.set_error(td::Status::Error(ErrorCode::timeout));
-  }
-}
-
 void OverlayImpl::send_broadcast(PublicKeyHash send_as, td::uint32 flags, td::BufferSlice data) {
   if (!has_valid_membership_certificate()) {
     VLOG(OVERLAY_WARNING) << "member certificate is invalid, valid_until="
@@ -481,20 +467,15 @@ void OverlayImpl::send_broadcast(PublicKeyHash send_as, td::uint32 flags, td::Bu
     VLOG(OVERLAY_WARNING) << "broadcast source certificate is invalid";
     return;
   }
-  wait_neighbours_not_empty([this, send_as, flags, data = std::move(data)](td::Result<td::Unit> R) mutable {
+  auto S = BroadcastSimple::create_new(actor_id(this), keyring_, send_as, std::move(data), flags);
-    if (R.is_error()) {
+  if (S.is_error()) {
-      return;
+    LOG(WARNING) << "failed to send broadcast: " << S;
-    }
+  }
-    auto S = BroadcastSimple::create_new(actor_id(this), keyring_, send_as, std::move(data), flags);
-    if (S.is_error()) {
-      LOG(WARNING) << "failed to send broadcast: " << S;
-    }
-  });
 }
 
 void OverlayImpl::send_broadcast_fec(PublicKeyHash send_as, td::uint32 flags, td::BufferSlice data) {
   if (!has_valid_membership_certificate()) {
-    VLOG(OVERLAY_WARNING) << "meber certificate ist invalid, valid_until="
+    VLOG(OVERLAY_WARNING) << "meber certificate is invalid, valid_until="
                           << peer_list_.local_cert_is_valid_until_.at_unix();
     return;
   }
@@ -502,12 +483,7 @@ void OverlayImpl::send_broadcast_fec(PublicKeyHash send_as, td::uint32 flags, td
     VLOG(OVERLAY_WARNING) << "broadcast source certificate is invalid";
     return;
   }
-  wait_neighbours_not_empty([this, send_as, flags, data = std::move(data)](td::Result<td::Unit> R) mutable {
+  OverlayOutboundFecBroadcast::create(std::move(data), flags, actor_id(this), send_as);
-    if (R.is_error()) {
-      return;
-    }
-    OverlayOutboundFecBroadcast::create(std::move(data), flags, actor_id(this), send_as);
-  });
 }
 
 void OverlayImpl::print(td::StringBuilder &sb) {
@@ -752,7 +728,8 @@ bool OverlayImpl::has_valid_broadcast_certificate(const PublicKeyHash &source, s
     return false;
   }
   auto it = certs_.find(source);
-  return check_source_eligible(source, it == certs_.end() ? nullptr : it->second.get(), (td::uint32)size, is_fec);
+  return check_source_eligible(source, it == certs_.end() ? nullptr : it->second.get(), (td::uint32)size, is_fec) !=
+         BroadcastCheckResult::Forbidden;
 }
 
 }  // namespace overlay

overlay/overlay.hpp

@@ -320,8 +320,6 @@ class OverlayImpl : public Overlay {
     del_peer(peer_id);
   }
 
-  void wait_neighbours_not_empty(td::Promise<td::Unit> promise, int max_retries = 20);
-
  private:
   template <class T>
   void process_query(adnl::AdnlNodeIdShort src, T &query, td::Promise<td::BufferSlice> promise) {

validator-session/validator-session.cpp

@@ -992,6 +992,9 @@ ValidatorSessionImpl::ValidatorSessionImpl(catchain::CatChainSessionId session_i
 }
 
 void ValidatorSessionImpl::start() {
+  round_started_at_ = td::Timestamp::now();
+  round_debug_at_ = td::Timestamp::in(60.0);
+  stats_init();
   started_ = true;
   VLOG(VALIDATOR_SESSION_NOTICE) << this << ": started";
 
@@ -1097,8 +1100,6 @@ void ValidatorSessionImpl::start_up() {
 
   check_all();
   td::actor::send_closure(rldp_, &rldp::Rldp::add_id, description().get_source_adnl_id(local_idx()));
-
-  stats_init();
 }
 
 void ValidatorSessionImpl::stats_init() {

validator/db/celldb.cpp

@@ -226,10 +226,6 @@ void CellDbIn::get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>>
   promise.set_result(boc_->get_cell_db_reader());
 }
 
-void CellDbIn::get_last_deleted_mc_state(td::Promise<BlockSeqno> promise) {
-  promise.set_result(last_deleted_mc_state_);
-}
-
 std::vector<std::pair<std::string, std::string>> CellDbIn::prepare_stats() {
   TD_PERF_COUNTER(celldb_prepare_stats);
   auto r_boc_stats = boc_->get_stats();
@@ -257,6 +253,7 @@ std::vector<std::pair<std::string, std::string>> CellDbIn::prepare_stats() {
                  double(celldb_size));
     add_stat("max_possible_ram_to_celldb_ratio", double(total_mem_stat.total_ram) / double(celldb_size));
   }
+  stats.emplace_back("last_deleted_mc_state", td::to_string(last_deleted_mc_state_));
 
   return stats;
   // do not clear statistics, it is needed for flush_db_stats
@@ -580,10 +577,6 @@ void CellDb::get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> p
   td::actor::send_closure(cell_db_, &CellDbIn::get_cell_db_reader, std::move(promise));
 }
 
-void CellDb::get_last_deleted_mc_state(td::Promise<BlockSeqno> promise) {
-  td::actor::send_closure(cell_db_, &CellDbIn::get_last_deleted_mc_state, std::move(promise));
-}
-
 void CellDb::start_up() {
   CellDbBase::start_up();
   boc_ = vm::DynamicBagOfCellsDb::create();

validator/db/celldb.hpp

@@ -65,7 +65,6 @@ class CellDbIn : public CellDbBase {
   void load_cell(RootHash hash, td::Promise<td::Ref<vm::DataCell>> promise);
   void store_cell(BlockIdExt block_id, td::Ref<vm::Cell> cell, td::Promise<td::Ref<vm::DataCell>> promise);
   void get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> promise);
-  void get_last_deleted_mc_state(td::Promise<BlockSeqno> promise);
 
   void migrate_cell(td::Bits256 hash);
 
@@ -190,7 +189,6 @@ class CellDb : public CellDbBase {
     in_memory_boc_ = std::move(in_memory_boc);
   }
   void get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> promise);
-  void get_last_deleted_mc_state(td::Promise<BlockSeqno> promise);
 
   CellDb(td::actor::ActorId<RootDb> root_db, std::string path, td::Ref<ValidatorManagerOptions> opts)
       : root_db_(root_db), path_(path), opts_(opts) {

validator/db/rootdb.cpp

@@ -285,10 +285,6 @@ void RootDb::get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> p
   td::actor::send_closure(cell_db_, &CellDb::get_cell_db_reader, std::move(promise));
 }
 
-void RootDb::get_last_deleted_mc_state(td::Promise<BlockSeqno> promise) {
-  td::actor::send_closure(cell_db_, &CellDb::get_last_deleted_mc_state, std::move(promise));
-}
-
 void RootDb::store_persistent_state_file(BlockIdExt block_id, BlockIdExt masterchain_block_id, td::BufferSlice state,
                                          td::Promise<td::Unit> promise) {
   td::actor::send_closure(archive_db_, &ArchiveManager::add_persistent_state, block_id, masterchain_block_id,

validator/db/rootdb.hpp

@@ -64,7 +64,6 @@ class RootDb : public Db {
                          td::Promise<td::Ref<ShardState>> promise) override;
   void get_block_state(ConstBlockHandle handle, td::Promise<td::Ref<ShardState>> promise) override;
   void get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> promise) override;
-  void get_last_deleted_mc_state(td::Promise<BlockSeqno> promise) override;
 
   void store_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) override;
   void get_block_handle(BlockIdExt id, td::Promise<BlockHandle> promise) override;

validator/interfaces/db.h

@@ -52,7 +52,6 @@ class Db : public td::actor::Actor {
                                  td::Promise<td::Ref<ShardState>> promise) = 0;
   virtual void get_block_state(ConstBlockHandle handle, td::Promise<td::Ref<ShardState>> promise) = 0;
   virtual void get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> promise) = 0;
-  virtual void get_last_deleted_mc_state(td::Promise<BlockSeqno> promise) = 0;
 
   virtual void store_persistent_state_file(BlockIdExt block_id, BlockIdExt masterchain_block_id, td::BufferSlice state,
                                            td::Promise<td::Unit> promise) = 0;

validator/manager.cpp

@@ -2178,20 +2178,10 @@ void ValidatorManagerImpl::update_shards() {
       td::actor::send_closure(SelfId, &ValidatorManagerImpl::written_destroyed_validator_sessions, std::move(gc));
     });
     td::actor::send_closure(db_, &Db::update_destroyed_validator_sessions, gc_list_, std::move(P));
-
-    if (!serializer_.empty()) {
-      td::actor::send_closure(
-          serializer_, &AsyncStateSerializer::auto_disable_serializer,
-          validating_masterchain &&
-              last_masterchain_state_->get_validator_set(ShardIdFull{masterchainId})->export_vector().size() * 2 <=
-                  last_masterchain_state_->get_total_validator_set(0)->export_vector().size());
-    }
   }
-
   if (!serializer_.empty()) {
-    td::actor::send_closure(
+    td::actor::send_closure(serializer_, &AsyncStateSerializer::auto_disable_serializer,
-        serializer_, &AsyncStateSerializer::auto_disable_serializer,
+                            is_validator() && last_masterchain_state_->get_global_id() == -239);  // mainnet only
-        !validator_groups_.empty() && last_masterchain_state_->get_global_id() == -239);  // mainnet only
   }
 }
 
@@ -2790,23 +2780,6 @@ void ValidatorManagerImpl::prepare_stats(td::Promise<std::vector<std::pair<std::
     vec.emplace_back("rotatemasterchainblock", last_rotate_block_id_.to_str());
     //vec.emplace_back("shardclientmasterchainseqno", td::to_string(min_confirmed_masterchain_seqno_));
     vec.emplace_back("stateserializermasterchainseqno", td::to_string(state_serializer_masterchain_seqno_));
-
-    td::actor::send_closure(db_, &Db::get_last_deleted_mc_state,
-                            [promise = merger.make_promise(""),
-                             gc_seqno = gc_masterchain_handle_->id().seqno()](td::Result<BlockSeqno> R) mutable {
-                              TRY_RESULT_PROMISE(promise, seqno, std::move(R));
-                              std::string s;
-                              if (seqno == 0) {
-                                s = "none";
-                              } else if (seqno <= gc_seqno) {
-                                s = PSTRING() << seqno << " (gc_seqno-" << (gc_seqno - seqno) << ")";
-                              } else {
-                                s = PSTRING() << seqno << " (gc_seqno+" << (seqno - gc_seqno) << ")";
-                              }
-                              std::vector<std::pair<std::string, std::string>> vec;
-                              vec.emplace_back("lastgcdmasterchainstate", std::move(s));
-                              promise.set_value(std::move(vec));
-                            });
   }
   td::NamedThreadSafeCounter::get_default().for_each([&](auto key, auto value) {
     vec.emplace_back("counter." + key, PSTRING() << value);