tonlib updated

- updated tonlib
- added documentation
- speed up full node synchronization

validator/full-node-shard.cpp

@@ -32,6 +32,8 @@
 #include "net/download-proof.hpp"
 #include "net/get-next-key-blocks.hpp"
 
+#include "td/utils/Random.h"
+
 #include "common/delay.h"
 
 namespace ton {
@@ -40,6 +42,29 @@ namespace validator {
 
 namespace fullnode {
 
+Neighbour Neighbour::zero = Neighbour{adnl::AdnlNodeIdShort::zero()};
+
+void Neighbour::update_proto_version(const ton_api::tonNode_capabilities &q) {
+  proto_version = q.version_;
+  capabilities = q.capabilities_;
+}
+
+void Neighbour::query_success(td::Clocks::Duration t) {
+  unreliability--;
+  if (unreliability < 0) {
+    unreliability = 0;
+  }
+  update_roundtrip(t);
+}
+
+void Neighbour::query_failed() {
+  unreliability++;
+}
+
+void Neighbour::update_roundtrip(td::Clocks::Duration t) {
+  roundtrip = (t + roundtrip) * 0.5;
+}
+
 void FullNodeShardImpl::create_overlay() {
   class Callback : public overlay::Overlays::Callback {
    public:
@@ -80,15 +105,19 @@ void FullNodeShardImpl::try_get_next_block(td::Timestamp timeout, td::Promise<Re
     promise.set_error(td::Status::Error(ErrorCode::timeout, "timeout"));
     return;
   }
-  if (use_new_download()) {
-    td::actor::create_actor<DownloadBlockNew>("downloadnext", adnl_id_, overlay_id_, handle_->id(),
-                                              ton::adnl::AdnlNodeIdShort::zero(), download_next_priority(), timeout,
-                                              validator_manager_, rldp_, overlays_, adnl_, client_, std::move(promise))
+
+  auto &b = choose_neighbour();
+  if (!b.adnl_id.is_zero() && b.proto_version >= 1) {
+    VLOG(FULL_NODE_DEBUG) << "using new download method with adnlid=" << b.adnl_id;
+    td::actor::create_actor<DownloadBlockNew>("downloadnext", adnl_id_, overlay_id_, handle_->id(), b.adnl_id,
+                                              download_next_priority(), timeout, validator_manager_, rldp_, overlays_,
+                                              adnl_, client_, create_neighbour_promise(b, std::move(promise)))
         .release();
   } else {
-    td::actor::create_actor<DownloadNextBlock>("downloadnext", adnl_id_, overlay_id_, handle_, download_next_priority(),
-                                               timeout, validator_manager_, rldp_, overlays_, adnl_, client_,
-                                               std::move(promise))
+    VLOG(FULL_NODE_DEBUG) << "using old download method with adnlid=" << b.adnl_id;
+    td::actor::create_actor<DownloadNextBlock>("downloadnext", adnl_id_, overlay_id_, handle_, b.adnl_id,
+                                               download_next_priority(), timeout, validator_manager_, rldp_, overlays_,
+                                               adnl_, client_, create_neighbour_promise(b, std::move(promise)))
         .release();
   }
 }
@@ -549,15 +578,18 @@ void FullNodeShardImpl::send_broadcast(BlockBroadcast broadcast) {
 
 void FullNodeShardImpl::download_block(BlockIdExt id, td::uint32 priority, td::Timestamp timeout,
                                        td::Promise<ReceivedBlock> promise) {
-  if (use_new_download()) {
-    td::actor::create_actor<DownloadBlockNew>("downloadreq", id, adnl_id_, overlay_id_, adnl::AdnlNodeIdShort::zero(),
-                                              priority, timeout, validator_manager_, rldp_, overlays_, adnl_, client_,
-                                              std::move(promise))
+  auto &b = choose_neighbour();
+  if (!b.adnl_id.is_zero() && b.proto_version >= 1) {
+    VLOG(FULL_NODE_DEBUG) << "new block download";
+    td::actor::create_actor<DownloadBlockNew>("downloadreq", id, adnl_id_, overlay_id_, b.adnl_id, priority, timeout,
+                                              validator_manager_, rldp_, overlays_, adnl_, client_,
+                                              create_neighbour_promise(b, std::move(promise)))
         .release();
   } else {
-    td::actor::create_actor<DownloadBlock>("downloadreq", id, adnl_id_, overlay_id_, adnl::AdnlNodeIdShort::zero(),
-                                           priority, timeout, validator_manager_, rldp_, overlays_, adnl_, client_,
-                                           std::move(promise))
+    VLOG(FULL_NODE_DEBUG) << "old block download";
+    td::actor::create_actor<DownloadBlock>("downloadreq", id, adnl_id_, overlay_id_, b.adnl_id, priority, timeout,
+                                           validator_manager_, rldp_, overlays_, adnl_, client_,
+                                           create_neighbour_promise(b, std::move(promise)))
         .release();
   }
 }
@@ -580,25 +612,28 @@ void FullNodeShardImpl::download_persistent_state(BlockIdExt id, BlockIdExt mast
 
 void FullNodeShardImpl::download_block_proof(BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
                                              td::Promise<td::BufferSlice> promise) {
-  td::actor::create_actor<DownloadProof>("downloadproofreq", block_id, false, adnl_id_, overlay_id_,
-                                         adnl::AdnlNodeIdShort::zero(), priority, timeout, validator_manager_, rldp_,
-                                         overlays_, adnl_, client_, std::move(promise))
+  auto &b = choose_neighbour();
+  td::actor::create_actor<DownloadProof>("downloadproofreq", block_id, false, adnl_id_, overlay_id_, b.adnl_id,
+                                         priority, timeout, validator_manager_, rldp_, overlays_, adnl_, client_,
+                                         create_neighbour_promise(b, std::move(promise)))
       .release();
 }
 
 void FullNodeShardImpl::download_block_proof_link(BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
                                                   td::Promise<td::BufferSlice> promise) {
+  auto &b = choose_neighbour();
   td::actor::create_actor<DownloadProof>("downloadproofreq", block_id, true, adnl_id_, overlay_id_,
                                          adnl::AdnlNodeIdShort::zero(), priority, timeout, validator_manager_, rldp_,
-                                         overlays_, adnl_, client_, std::move(promise))
+                                         overlays_, adnl_, client_, create_neighbour_promise(b, std::move(promise)))
       .release();
 }
 
 void FullNodeShardImpl::get_next_key_blocks(BlockIdExt block_id, td::Timestamp timeout,
                                             td::Promise<std::vector<BlockIdExt>> promise) {
+  auto &b = choose_neighbour();
   td::actor::create_actor<GetNextKeyBlocks>("next", block_id, 16, adnl_id_, overlay_id_, adnl::AdnlNodeIdShort::zero(),
                                             1, timeout, validator_manager_, rldp_, overlays_, adnl_, client_,
-                                            std::move(promise))
+                                            create_neighbour_promise(b, std::move(promise)))
       .release();
 }
 
@@ -619,6 +654,14 @@ void FullNodeShardImpl::alarm() {
     }
     sync_completed_at_ = td::Timestamp::never();
   }
+  if (reload_neighbours_at_ && reload_neighbours_at_.is_in_past()) {
+    reload_neighbours();
+    reload_neighbours_at_ = td::Timestamp::in(td::Random::fast(10.0, 30.0));
+  }
+  if (ping_neighbours_at_ && ping_neighbours_at_.is_in_past()) {
+    ping_neighbours();
+    ping_neighbours_at_ = td::Timestamp::in(td::Random::fast(0.5, 1.0));
+  }
   if (update_certificate_at_ && update_certificate_at_.is_in_past()) {
     if (!sign_cert_by_.is_zero()) {
       sign_new_certificate(sign_cert_by_);
@@ -629,6 +672,8 @@ void FullNodeShardImpl::alarm() {
   }
   alarm_timestamp().relax(sync_completed_at_);
   alarm_timestamp().relax(update_certificate_at_);
+  alarm_timestamp().relax(reload_neighbours_at_);
+  alarm_timestamp().relax(ping_neighbours_at_);
 }
 
 void FullNodeShardImpl::start_up() {
@@ -642,6 +687,11 @@ void FullNodeShardImpl::start_up() {
     rules_ = overlay::OverlayPrivacyRules{overlay::Overlays::max_fec_broadcast_size()};
 
     create_overlay();
+
+    reload_neighbours_at_ = td::Timestamp::now();
+    ping_neighbours_at_ = td::Timestamp::now();
+    alarm_timestamp().relax(reload_neighbours_at_);
+    alarm_timestamp().relax(ping_neighbours_at_);
   }
 }
 
@@ -701,6 +751,149 @@ void FullNodeShardImpl::update_validators(std::vector<PublicKeyHash> public_key_
   }
 }
 
+void FullNodeShardImpl::reload_neighbours() {
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<std::vector<adnl::AdnlNodeIdShort>> R) {
+    if (R.is_error()) {
+      return;
+    }
+    auto vec = R.move_as_ok();
+    if (vec.size() == 0) {
+      return;
+    } else {
+      td::actor::send_closure(SelfId, &FullNodeShardImpl::got_neighbours, std::move(vec));
+    }
+  });
+  td::actor::send_closure(overlays_, &overlay::Overlays::get_overlay_random_peers, adnl_id_, overlay_id_,
+                          max_neighbours(), std::move(P));
+}
+
+void FullNodeShardImpl::got_neighbours(std::vector<adnl::AdnlNodeIdShort> vec) {
+  bool ex = false;
+
+  for (auto &el : vec) {
+    auto it = neighbours_.find(el);
+    if (it != neighbours_.end()) {
+      continue;
+    }
+    if (neighbours_.size() == max_neighbours()) {
+      adnl::AdnlNodeIdShort a = adnl::AdnlNodeIdShort::zero();
+      adnl::AdnlNodeIdShort b = adnl::AdnlNodeIdShort::zero();
+      td::uint32 cnt = 0;
+      double u = 0;
+      for (auto &n : neighbours_) {
+        if (n.second.unreliability > u) {
+          u = n.second.unreliability;
+          a = n.first;
+        }
+        if (td::Random::fast(0, cnt++) == 0) {
+          b = n.first;
+        }
+      }
+
+      if (u > stop_unreliability()) {
+        neighbours_.erase(a);
+      } else {
+        neighbours_.erase(b);
+        ex = true;
+      }
+    }
+    neighbours_.emplace(el, Neighbour{el});
+    if (ex) {
+      break;
+    }
+  }
+}
+
+const Neighbour &FullNodeShardImpl::choose_neighbour() const {
+  if (neighbours_.size() == 0) {
+    return Neighbour::zero;
+  }
+
+  const Neighbour *best = nullptr;
+  td::uint32 sum = 0;
+
+  for (auto &x : neighbours_) {
+    td::uint32 unr = static_cast<td::uint32>(x.second.unreliability);
+
+    if (x.second.proto_version < proto_version()) {
+      unr += 4;
+    } else if (x.second.proto_version == proto_version() && x.second.capabilities < proto_capabilities()) {
+      unr += 2;
+    }
+
+    auto f = static_cast<td::uint32>(fail_unreliability());
+
+    if (unr <= f) {
+      auto w = 1 << (f - unr);
+      sum += w;
+      if (td::Random::fast(0, sum - 1) <= w - 1) {
+        best = &x.second;
+      }
+    }
+  }
+  return best ? *best : Neighbour::zero;
+}
+
+void FullNodeShardImpl::update_neighbour_stats(adnl::AdnlNodeIdShort adnl_id, td::Clocks::Duration t, bool success) {
+  auto it = neighbours_.find(adnl_id);
+  if (it != neighbours_.end()) {
+    if (success) {
+      it->second.query_success(t);
+    } else {
+      it->second.query_failed();
+    }
+  }
+}
+
+void FullNodeShardImpl::got_neighbour_capabilities(adnl::AdnlNodeIdShort adnl_id, td::Clocks::Duration t,
+                                                   td::BufferSlice data) {
+  auto it = neighbours_.find(adnl_id);
+  if (it == neighbours_.end()) {
+    return;
+  }
+  auto F = fetch_tl_object<ton_api::tonNode_capabilities>(std::move(data), true);
+  if (F.is_error()) {
+    it->second.query_failed();
+  } else {
+    it->second.update_proto_version(*F.move_as_ok().get());
+    it->second.update_roundtrip(t);
+  }
+}
+
+void FullNodeShardImpl::ping_neighbours() {
+  if (neighbours_.size() == 0) {
+    return;
+  }
+  td::uint32 max_cnt = 6;
+  if (max_cnt > neighbours_.size()) {
+    max_cnt = td::narrow_cast<td::uint32>(neighbours_.size());
+  }
+  auto it = neighbours_.lower_bound(last_pinged_neighbour_);
+  while (max_cnt > 0) {
+    if (it == neighbours_.end()) {
+      it = neighbours_.begin();
+    }
+
+    auto P = td::PromiseCreator::lambda(
+        [SelfId = actor_id(this), start_time = td::Time::now(), id = it->first](td::Result<td::BufferSlice> R) {
+          if (R.is_error()) {
+            td::actor::send_closure(SelfId, &FullNodeShardImpl::update_neighbour_stats, id,
+                                    td::Time::now() - start_time, false);
+          } else {
+            td::actor::send_closure(SelfId, &FullNodeShardImpl::got_neighbour_capabilities, id,
+                                    td::Time::now() - start_time, R.move_as_ok());
+          }
+        });
+    auto q = create_serialize_tl_object<ton_api::tonNode_getCapabilities>();
+    td::actor::send_closure(overlays_, &overlay::Overlays::send_query, it->first, adnl_id_, overlay_id_,
+                            "get_prepare_block", std::move(P), td::Timestamp::in(1.0), std::move(q));
+
+    last_pinged_neighbour_ = it->first;
+    it++;
+    max_cnt--;
+  }
+}
+
 FullNodeShardImpl::FullNodeShardImpl(ShardIdFull shard, PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id,
                                      FileHash zero_state_file_hash, td::actor::ActorId<keyring::Keyring> keyring,
                                      td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,

validator/full-node-shard.hpp

@@ -26,6 +26,25 @@ namespace validator {
 
 namespace fullnode {
 
+struct Neighbour {
+  adnl::AdnlNodeIdShort adnl_id;
+  td::uint32 proto_version = 0;
+  td::uint64 capabilities = 0;
+  td::Clocks::Duration roundtrip = 0;
+  td::Clocks::Duration roundtrip_relax_at = 0;
+  double roundtrip_weight = 0;
+  double unreliability = 0;
+
+  Neighbour(adnl::AdnlNodeIdShort adnl_id) : adnl_id(std::move(adnl_id)) {
+  }
+  void update_proto_version(const ton_api::tonNode_capabilities &q);
+  void query_success(td::Clocks::Duration t);
+  void query_failed();
+  void update_roundtrip(td::Clocks::Duration t);
+
+  static Neighbour zero;
+};
+
 class FullNodeShardImpl : public FullNodeShard {
  public:
   WorkchainId get_workchain() const override {
@@ -47,6 +66,15 @@ class FullNodeShardImpl : public FullNodeShard {
   static constexpr td::uint64 proto_capabilities() {
     return 0;
   }
+  static constexpr td::uint32 max_neighbours() {
+    return 16;
+  }
+  static constexpr double stop_unreliability() {
+    return 5.0;
+  }
+  static constexpr double fail_unreliability() {
+    return 10.0;
+  }
 
   void create_overlay();
   void update_adnl_id(adnl::AdnlNodeIdShort adnl_id, td::Promise<td::Unit> promise) override;
@@ -130,6 +158,26 @@ class FullNodeShardImpl : public FullNodeShard {
   void sign_new_certificate(PublicKeyHash sign_by);
   void signed_new_certificate(ton::overlay::Certificate cert);
 
+  void ping_neighbours();
+  void reload_neighbours();
+  void got_neighbours(std::vector<adnl::AdnlNodeIdShort> res);
+  void update_neighbour_stats(adnl::AdnlNodeIdShort adnl_id, td::Clocks::Duration t, bool success);
+  void got_neighbour_capabilities(adnl::AdnlNodeIdShort adnl_id, td::Clocks::Duration t, td::BufferSlice data);
+  const Neighbour &choose_neighbour() const;
+
+  template <typename T>
+  td::Promise<T> create_neighbour_promise(const Neighbour &x, td::Promise<T> p) {
+    return td::PromiseCreator::lambda([id = x.adnl_id, SelfId = actor_id(this), p = std::move(p),
+                                       ts = td::Time::now()](td::Result<T> R) mutable {
+      if (R.is_error() && R.error().code() != ErrorCode::notready && R.error().code() != ErrorCode::cancelled) {
+        td::actor::send_closure(SelfId, &FullNodeShardImpl::update_neighbour_stats, id, td::Time::now() - ts, false);
+      } else {
+        td::actor::send_closure(SelfId, &FullNodeShardImpl::update_neighbour_stats, id, td::Time::now() - ts, true);
+      }
+      p.set_result(std::move(R));
+    });
+  }
+
   FullNodeShardImpl(ShardIdFull shard, PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id,
                     FileHash zero_state_file_hash, td::actor::ActorId<keyring::Keyring> keyring,
                     td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,
@@ -167,6 +215,11 @@ class FullNodeShardImpl : public FullNodeShard {
 
   std::shared_ptr<ton::overlay::Certificate> cert_;
   overlay::OverlayPrivacyRules rules_;
+
+  std::map<adnl::AdnlNodeIdShort, Neighbour> neighbours_;
+  td::Timestamp reload_neighbours_at_;
+  td::Timestamp ping_neighbours_at_;
+  adnl::AdnlNodeIdShort last_pinged_neighbour_ = adnl::AdnlNodeIdShort::zero();
 };
 
 }  // namespace fullnode

validator/net/download-block-new.cpp

@@ -226,7 +226,7 @@ void DownloadBlockNew::got_data(td::BufferSlice data) {
           [&](ton_api::tonNode_dataFullEmpty &x) {
             abort_query(td::Status::Error(ErrorCode::notready, "node doesn't have this block"));
           },
-          [&](ton_api::tonNode_dataFull &x) {
+          [&, self = this](ton_api::tonNode_dataFull &x) {
             if (!allow_partial_proof_ && x.is_link_) {
               abort_query(td::Status::Error(ErrorCode::notready, "node doesn't have proof for this block"));
               return;
@@ -243,7 +243,7 @@ void DownloadBlockNew::got_data(td::BufferSlice data) {
               return;
             }
 
-            auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
+            auto P = td::PromiseCreator::lambda([SelfId = actor_id(self)](td::Result<td::Unit> R) {
               if (R.is_error()) {
                 td::actor::send_closure(SelfId, &DownloadBlockNew::abort_query,
                                         R.move_as_error_prefix("received bad proof: "));

validator/net/download-next-block.cpp

@@ -29,7 +29,8 @@ namespace validator {
 namespace fullnode {
 
 DownloadNextBlock::DownloadNextBlock(adnl::AdnlNodeIdShort local_id, overlay::OverlayIdShort overlay_id,
-                                     BlockHandle prev, td::uint32 priority, td::Timestamp timeout,
+                                     BlockHandle prev, adnl::AdnlNodeIdShort download_from, td::uint32 priority,
+                                     td::Timestamp timeout,
                                      td::actor::ActorId<ValidatorManagerInterface> validator_manager,
                                      td::actor::ActorId<rldp::Rldp> rldp,
                                      td::actor::ActorId<overlay::Overlays> overlays,
@@ -38,6 +39,7 @@ DownloadNextBlock::DownloadNextBlock(adnl::AdnlNodeIdShort local_id, overlay::Ov
     : local_id_(local_id)
     , overlay_id_(overlay_id)
     , prev_(prev)
+    , download_from_(download_from)
     , priority_(priority)
     , timeout_(timeout)
     , validator_manager_(validator_manager)
@@ -51,11 +53,11 @@ DownloadNextBlock::DownloadNextBlock(adnl::AdnlNodeIdShort local_id, overlay::Ov
 void DownloadNextBlock::abort_query(td::Status reason) {
   if (promise_) {
     if (reason.code() == ErrorCode::notready || reason.code() == ErrorCode::timeout) {
-      VLOG(FULL_NODE_DEBUG) << "failed to download next block after " << prev_->id() << " from " << node_ << ": "
-                            << reason;
+      VLOG(FULL_NODE_DEBUG) << "failed to download next block after " << prev_->id() << " from " << download_from_
+                            << ": " << reason;
     } else {
-      VLOG(FULL_NODE_INFO) << "failed to download next block after " << prev_->id() << " from " << node_ << ": "
-                           << reason;
+      VLOG(FULL_NODE_INFO) << "failed to download next block after " << prev_->id() << " from " << download_from_
+                           << ": " << reason;
     }
     promise_.set_error(std::move(reason));
   }
@@ -79,30 +81,34 @@ void DownloadNextBlock::start_up() {
     return;
   }
   if (!client_.empty()) {
-    got_node(node_);
+    got_node(download_from_);
     return;
   }
 
-  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<std::vector<adnl::AdnlNodeIdShort>> R) {
-    if (R.is_error()) {
-      td::actor::send_closure(SelfId, &DownloadNextBlock::abort_query, R.move_as_error());
-    } else {
-      auto vec = R.move_as_ok();
-      if (vec.size() == 0) {
-        td::actor::send_closure(SelfId, &DownloadNextBlock::abort_query,
-                                td::Status::Error(ErrorCode::notready, "no neighbours found"));
+  if (download_from_.is_zero()) {
+    auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<std::vector<adnl::AdnlNodeIdShort>> R) {
+      if (R.is_error()) {
+        td::actor::send_closure(SelfId, &DownloadNextBlock::abort_query, R.move_as_error());
       } else {
-        td::actor::send_closure(SelfId, &DownloadNextBlock::got_node, vec[0]);
+        auto vec = R.move_as_ok();
+        if (vec.size() == 0) {
+          td::actor::send_closure(SelfId, &DownloadNextBlock::abort_query,
+                                  td::Status::Error(ErrorCode::notready, "no neighbours found"));
+        } else {
+          td::actor::send_closure(SelfId, &DownloadNextBlock::got_node, vec[0]);
+        }
       }
-    }
-  });
+    });
 
-  td::actor::send_closure(overlays_, &overlay::Overlays::get_overlay_random_peers, local_id_, overlay_id_, 1,
-                          std::move(P));
+    td::actor::send_closure(overlays_, &overlay::Overlays::get_overlay_random_peers, local_id_, overlay_id_, 1,
+                            std::move(P));
+  } else {
+    got_node(download_from_);
+  }
 }
 
 void DownloadNextBlock::got_node(adnl::AdnlNodeIdShort id) {
-  node_ = id;
+  download_from_ = id;
 
   auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
     if (R.is_error()) {
@@ -114,8 +120,8 @@ void DownloadNextBlock::got_node(adnl::AdnlNodeIdShort id) {
 
   auto query = create_serialize_tl_object<ton_api::tonNode_getNextBlockDescription>(create_tl_block_id(prev_->id()));
   if (client_.empty()) {
-    td::actor::send_closure(overlays_, &overlay::Overlays::send_query, id, local_id_, overlay_id_, "get_prepare",
-                            std::move(P), td::Timestamp::in(1.0), std::move(query));
+    td::actor::send_closure(overlays_, &overlay::Overlays::send_query, download_from_, local_id_, overlay_id_,
+                            "get_prepare", std::move(P), td::Timestamp::in(1.0), std::move(query));
   } else {
     td::actor::send_closure(client_, &adnl::AdnlExtClient::send_query, "get_prepare",
                             create_serialize_tl_object_suffix<ton_api::tonNode_query>(std::move(query)),
@@ -149,9 +155,9 @@ void DownloadNextBlock::got_next_node_handle(BlockHandle handle) {
 
 void DownloadNextBlock::finish_query() {
   if (promise_) {
-    td::actor::create_actor<DownloadBlock>("downloadnext", next_block_id_, local_id_, overlay_id_, prev_, node_,
-                                           priority_, timeout_, validator_manager_, rldp_, overlays_, adnl_, client_,
-                                           std::move(promise_))
+    td::actor::create_actor<DownloadBlock>("downloadnext", next_block_id_, local_id_, overlay_id_, prev_,
+                                           download_from_, priority_, timeout_, validator_manager_, rldp_, overlays_,
+                                           adnl_, client_, std::move(promise_))
         .release();
   }
   stop();

validator/net/download-next-block.hpp

@@ -34,7 +34,7 @@ namespace fullnode {
 class DownloadNextBlock : public td::actor::Actor {
  public:
   DownloadNextBlock(adnl::AdnlNodeIdShort local_id, overlay::OverlayIdShort overlay_id, BlockHandle prev,
-                    td::uint32 priority, td::Timestamp timeout,
+                    adnl::AdnlNodeIdShort download_from, td::uint32 priority, td::Timestamp timeout,
                     td::actor::ActorId<ValidatorManagerInterface> validator_manager,
                     td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<overlay::Overlays> overlays,
                     td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<adnl::AdnlExtClient> client,
@@ -57,6 +57,8 @@ class DownloadNextBlock : public td::actor::Actor {
 
   BlockIdExt next_block_id_;
 
+  adnl::AdnlNodeIdShort download_from_ = adnl::AdnlNodeIdShort::zero();
+
   td::uint32 priority_;
 
   td::Timestamp timeout_;
@@ -66,8 +68,6 @@ class DownloadNextBlock : public td::actor::Actor {
   td::actor::ActorId<adnl::Adnl> adnl_;
   td::actor::ActorId<adnl::AdnlExtClient> client_;
   td::Promise<ReceivedBlock> promise_;
-
-  adnl::AdnlNodeIdShort node_ = adnl::AdnlNodeIdShort::zero();
 };
 
 }  // namespace fullnode