ton-blockchain · SpyCheese · Jul 8, 2026 · Jun 30, 2026 · Jun 30, 2026 · Jun 30, 2026
diff --git a/adnl/adnl-peer.cpp b/adnl/adnl-peer.cpp
@@ -820,7 +820,8 @@ void AdnlPeerPairImpl::update_addr_list(AdnlAddressList addr_list) {
   VLOG(adnl, INFO) << this << ": updating addr list to version " << addr_list.version() << " size=" << addr_list.size();
 
   const auto addrs = addr_list.adnl_addrs();
-  has_reverse_addr_ = addr_list.has_reverse();
+  // has_reverse_addr_ = addr_list.has_reverse();
+  has_reverse_addr_ = false;
   if (has_reverse_addr_ && addrs.empty()) {
     return;
   }

diff --git a/dht/dht.cpp b/dht/dht.cpp
@@ -312,6 +312,8 @@ static td::BufferSlice register_reverse_connection_to_sign(adnl::AdnlNodeIdShort
 
 void DhtMemberImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::dht_registerReverseConnection &query,
                                   td::Promise<td::BufferSlice> promise) {
+  promise.set_error(td::Status::Error("reverse ping is not supported"));
+  return;
   td::uint32 ttl = query.ttl_, now = (td::uint32)td::Clocks::system();
   if (ttl <= now) {
     promise.set_error(td::Status::Error("too old ttl"));
@@ -335,6 +337,8 @@ void DhtMemberImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::dht_regist
 
 void DhtMemberImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::dht_requestReversePing &query,
                                   td::Promise<td::BufferSlice> promise) {
+  promise.set_error(td::Status::Error("reverse ping is not supported"));
+  return;
   adnl::AdnlNodeIdShort client{query.client_};
   auto it = reverse_connections_.find(client);
   if (it != reverse_connections_.end() && !it->second.ttl_.is_in_past()) {
@@ -428,6 +432,8 @@ void DhtMemberImpl::receive_ping(DhtKeyId key, DhtNode result) {
 }
 
 void DhtMemberImpl::receive_message(adnl::AdnlNodeIdShort src, td::BufferSlice data) {
+  VLOG(dht, DEBUG) << "reverse ping is not supported";
+  return;
   auto F = fetch_tl_object<ton_api::dht_requestReversePingCont>(data, true);
   if (F.is_ok()) {
     auto S = [&]() -> td::Status {

diff --git a/validator-engine/validator-engine.cpp b/validator-engine/validator-engine.cpp
@@ -2244,10 +2244,18 @@ void ValidatorEngine::started_adnl() {
 }
 
 void ValidatorEngine::add_dht(ton::PublicKeyHash id) {
-  auto D = ton::dht::Dht::create(ton::adnl::AdnlNodeIdShort{id}, db_root_, dht_config_, keyring_.get(), adnl_.get());
-  D.ensure();
+  if (dht_server_) {
+    dht_nodes_[id] =
+        ton::dht::Dht::create(ton::adnl::AdnlNodeIdShort{id}, db_root_, dht_config_, keyring_.get(), adnl_.get())
+            .ensure()
+            .move_as_ok();
+  } else {
+    dht_nodes_[id] =
+        ton::dht::Dht::create_client(ton::adnl::AdnlNodeIdShort{id}, db_root_, dht_config_, keyring_.get(), adnl_.get())
+            .ensure()
+            .move_as_ok();
+  }
 
-  dht_nodes_[id] = D.move_as_ok();
   if (default_dht_node_.is_zero()) {
     default_dht_node_ = id;
   }
@@ -6211,6 +6219,8 @@ int main(int argc, char *argv[]) {
         return td::Status::OK();
       });
 #endif
+  p.add_option('\0', "dht-server", "run DHT server (default: DHT in client mode)",
+               [&]() { acts.push_back([&] { td::actor::send_closure(x, &ValidatorEngine::set_dht_server, true); }); });
   auto S = p.run(argc, argv);
   if (S.is_error()) {
     LOG(ERROR) << "failed to parse options: " << S.move_as_error();

diff --git a/validator-engine/validator-engine.hpp b/validator-engine/validator-engine.hpp
@@ -262,6 +262,7 @@ class ValidatorEngine : public td::actor::Actor {
   bool started_keyring_ = false;
   bool started_ = false;
   td::FileFd console_ready_fd_;
+  bool dht_server_ = false;
   ton::BlockSeqno truncate_seqno_{0};
   std::string session_logs_file_;
   std::string validator_telemetry_filename_;
@@ -326,6 +327,9 @@ class ValidatorEngine : public td::actor::Actor {
   void set_console_ready_fd(td::FileFd fd) {
     console_ready_fd_ = std::move(fd);
   }
+  void set_dht_server(bool value) {
+    dht_server_ = value;
+  }
   void add_ip(td::IPAddress addr) {
     addrs_.push_back(addr);
   }

diff --git a/validator/manager.cpp b/validator/manager.cpp
@@ -276,7 +276,8 @@ void ValidatorManagerImpl::validate_block_broadcast_signatures(BlockBroadcast br
 
 td::actor::Task<> ValidatorManagerImpl::validated_accepted_block_broadcast(BlockIdExt block_id,
                                                                            CatchainSeqno cc_seqno) {
-  if (opts_->nonfinal_ls_queries_enabled()) {
+  if (!block_id.is_masterchain() && opts_->nonfinal_ls_queries_enabled() && shard_client_handle_ &&
+      shard_client_handle_->unix_time() > (UnixTime)td::Clocks::system() - 60) {
     co_await td::actor::ask(actor_id(this), &ValidatorManagerImpl::wait_block_state_short, block_id, 0,
                             td::Timestamp::in(60.0), true);
   }
@@ -541,7 +542,8 @@ td::actor::Task<> ValidatorManagerImpl::new_block_candidate_broadcast(BlockIdExt
   update_block_receive_stats(block_id, BlockReceiveStats::from(source, /*is_candidate=*/true));
   add_cached_block_data(block_id, data.clone());
 
-  if (opts_->nonfinal_ls_queries_enabled()) {
+  if (opts_->nonfinal_ls_queries_enabled() && shard_client_handle_ &&
+      shard_client_handle_->unix_time() > (UnixTime)td::Clocks::system() - 60) {
     auto handle = co_await td::actor::ask(actor_id(this), &ValidatorManagerImpl::get_block_handle, block_id, true);
     Ref<BlockData> block = CO_TRY(create_block(block_id, std::move(data)));
     co_await td::actor::ask(actor_id(this), &ValidatorManagerImpl::set_block_data, handle, std::move(block));
@@ -657,6 +659,9 @@ void ValidatorManagerImpl::add_shard_block_description(td::Ref<ShardTopBlockDesc
   }
   shard_blocks_[ShardTopBlockDescriptionId{desc->block_id().shard_full(), desc->catchain_seqno()}].latest_desc = desc;
   VLOG(validator, DEBUG) << "new shard block descr for " << desc->block_id();
+  if (!shard_client_handle_ || shard_client_handle_->unix_time() <= (UnixTime)td::Clocks::system() - 60) {
+    return;
+  }
   if (need_monitor(desc->block_id().shard_full())) {
     ShardIdFull shard = desc->shard();
     shard.shard |= 1;
@@ -1999,6 +2004,7 @@ void ValidatorManagerImpl::send_block_broadcast(BlockBroadcast broadcast, int mo
 }
 
 void ValidatorManagerImpl::send_block_finality_broadcast(BlockFinalityBroadcast finality, int mode) {
+  new_block_finality_broadcast(finality.clone(), BroadcastSource::consensus_overlay).start().detach();
   callback_->send_block_finality_broadcast(std::move(finality), mode);
 }
 
@@ -2239,10 +2245,10 @@ void ValidatorManagerImpl::started(ValidatorManagerInitResult R) {
       });
   td::actor::send_closure(db_, &Db::get_persistent_state_descriptions, std::move(Q));
   update_shard_overlays();
-  finish_start_up();
+  finish_start_up().start().detach_ensure();
 }
 
-void ValidatorManagerImpl::finish_start_up() {
+td::actor::Task<> ValidatorManagerImpl::finish_start_up() {
   new_masterchain_block();
 
   serializer_ =
@@ -2270,15 +2276,38 @@ void ValidatorManagerImpl::finish_start_up() {
         run_hardfork_accept_block_query(b, dataR.move_as_ok(), SelfId, std::move(P));
       });
       td::actor::send_closure(db_, &Db::try_get_static_file, b.file_hash, std::move(P));
-      return;
+      co_return {};
     }
   }
 
+  auto S = co_await start_up_advance_mc().wrap();
+  if (S.is_error()) {
+    VLOG(validator, ERROR) << "Initial advancing of masterchain: " << S.move_as_error();
+  }
   if (!out_of_sync()) {
     completed_prestart_sync();
   } else {
     prestart_sync();
   }
+  co_return {};
+}
+
+td::actor::Task<> ValidatorManagerImpl::start_up_advance_mc() {
+  while (last_masterchain_block_handle_->inited_next()) {
+    auto next_handle = co_await td::actor::ask(actor_id(this), &ValidatorManager::get_block_handle,
+                                               last_masterchain_block_handle_->one_next(true), true);
+    if (!next_handle->is_applied()) {
+      break;
+    }
+    auto data = co_await td::actor::ask(actor_id(this), &ValidatorManager::get_block_data, next_handle);
+    auto block = CO_TRY(create_block(next_handle->id(), std::move(data)));
+    auto [task, promise] = td::actor::StartedTask<>::make_bridge();
+    run_apply_block_query(next_handle->id(), block, next_handle->id(), actor_id(this), td::Timestamp::in(10.0),
+                          std::move(promise));
+    co_await std::move(task);
+    VLOG(validator, INFO) << "Initial advancing mc to seqno " << next_handle->id().seqno();
+  }
+  co_return {};
 }
 
 void ValidatorManagerImpl::applied_hardfork() {
@@ -2419,18 +2448,6 @@ void ValidatorManagerImpl::new_masterchain_block() {
     td::actor::send_closure(shard_client_, &ShardClient::new_masterchain_block_notification);
   }
 
-  if (validating_masterchain()) {
-    std::set<ShardIdFull> collating_shards;
-    collating_shards.emplace(masterchainId);
-    if (!collating_shards.empty()) {
-      if (out_msg_queue_importer_.empty()) {
-        out_msg_queue_importer_ = td::actor::create_actor<OutMsgQueueImporter>("outmsgqueueimporter", actor_id(this),
-                                                                               opts_, last_masterchain_state_);
-      }
-      td::actor::send_closure(out_msg_queue_importer_, &OutMsgQueueImporter::new_masterchain_block_notification,
-                              last_masterchain_state_, std::move(collating_shards));
-    }
-  }
   if (!shard_block_verifier_.empty()) {
     td::actor::send_closure(shard_block_verifier_, &ShardBlockVerifier::update_masterchain_state,
                             last_masterchain_state_);

diff --git a/validator/manager.hpp b/validator/manager.hpp
@@ -588,7 +588,8 @@ class ValidatorManagerImpl : public ValidatorManager {
   void start_up() override;
   void init_last_masterchain_state(td::Ref<MasterchainState> state) override;
   void started(ValidatorManagerInitResult result);
-  void finish_start_up();
+  td::actor::Task<> finish_start_up();
+  td::actor::Task<> start_up_advance_mc();
 
   bool is_validator();
   bool validating_masterchain();

diff --git a/validator/net/download-next-blocks.cpp b/validator/net/download-next-blocks.cpp
@@ -97,10 +97,6 @@ td::actor::Task<> DownloadNextBlocks::run() {
     }
   }
 
-  token_ = co_await td::actor::ask(validator_manager_, &ValidatorManagerInterface::get_download_token, 1, priority_,
-                                   td::Timestamp::in(2.0))
-               .trace("get_download_token");
-
   bool allow_many = query_sender_->get_proto_version() >= std::make_pair<td::uint32, td::uint32>(3, 2);
   VLOG(full_node, DEBUG) << "Download from " << query_sender_->to_str() << ", allow_many=" << allow_many;
   td::BufferSlice query;

diff --git a/validator/net/download-next-blocks.hpp b/validator/net/download-next-blocks.hpp
@@ -51,8 +51,6 @@ class DownloadNextBlocks : public td::actor::Actor {
   bool success_ = false;
   bool success_local_ = false;
 
-  std::unique_ptr<ActionToken> token_;
-
   static constexpr td::uint32 MAX_BLOCKS = 10;
   static constexpr size_t MAX_SIZE_MANY = (1 << 20) + 128;
 };

diff --git a/validator/token-manager.cpp b/validator/token-manager.cpp
@@ -47,21 +47,19 @@ void TokenManager::token_cleared(size_t size, td::uint32 priority) {
   }
 
   for (auto it = pending_.begin(); it != pending_.end();) {
-    if (it->first.priority && (free_tokens_ || free_priority_tokens_)) {
-      it->second.promise.set_value(gen_token(size, priority));
+    if (free_priority_tokens_ > 0 && it->first.priority > 0) {
+      it->second.promise.set_value(gen_token(it->first.size, it->first.priority));
+      --free_priority_tokens_;
       it = pending_.erase(it);
-      if (free_priority_tokens_ > 0) {
-        free_priority_tokens_--;
-      } else {
-        free_tokens_--;
-      }
-    } else if (!it->first.priority && free_tokens_) {
-      it->second.promise.set_value(gen_token(size, priority));
+      continue;
+    }
+    if (free_tokens_ > 0) {
+      it->second.promise.set_value(gen_token(it->first.size, it->first.priority));
+      --free_tokens_;
       it = pending_.erase(it);
-      free_tokens_--;
-    } else {
-      break;
+      continue;
     }
+    break;
   }
 }