Pass correct state split depth to DownloadShardState

... and let DownloadShardState do nothing with it.

With this commit, we are expecting DownloadShardState to pass correct
PersistentStateType from one side and are passing split depth from the
other side. So, only state merging in that single actor remains to be
done.

Author: DanShaders

validator/downloaders/download-state.cpp

@@ -26,15 +26,22 @@ namespace ton {
 
 namespace validator {
 
-DownloadShardState::DownloadShardState(BlockIdExt block_id, BlockIdExt masterchain_block_id, td::uint32 priority,
-                                       td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-                                       td::Promise<td::Ref<ShardState>> promise)
+DownloadShardState::DownloadShardState(BlockIdExt block_id, BlockIdExt masterchain_block_id, td::uint32 split_depth,
+                                       td::uint32 priority, td::actor::ActorId<ValidatorManager> manager,
+                                       td::Timestamp timeout, td::Promise<td::Ref<ShardState>> promise)
     : block_id_(block_id)
     , masterchain_block_id_(masterchain_block_id)
+    , split_depth_(split_depth)
     , priority_(priority)
     , manager_(manager)
     , timeout_(timeout)
     , promise_(std::move(promise)) {
+  CHECK(masterchain_block_id_.is_valid() || split_depth_ == 0);
+
+  int shard_prefix_length = shard_pfx_len(block_id_.shard_full().shard);
+  if (shard_prefix_length >= static_cast<int>(split_depth_)) {
+    split_depth_ = 0;
+  }
 }
 
 void DownloadShardState::start_up() {

validator/downloaders/download-state.hpp

@@ -27,7 +27,7 @@ namespace validator {
 
 class DownloadShardState : public td::actor::Actor {
  public:
-  DownloadShardState(BlockIdExt block_id, BlockIdExt masterchain_block_id, td::uint32 priority,
+  DownloadShardState(BlockIdExt block_id, BlockIdExt masterchain_block_id, td::uint32 split_depth, td::uint32 priority,
                      td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                      td::Promise<td::Ref<ShardState>> promise);
 
@@ -58,6 +58,7 @@ class DownloadShardState : public td::actor::Actor {
  private:
   BlockIdExt block_id_;
   BlockIdExt masterchain_block_id_;
+  td::uint32 split_depth_;
 
   BlockHandle handle_;
   td::uint32 priority_;

validator/downloaders/wait-block-state.cpp

@@ -117,10 +117,26 @@ void WaitBlockState::start() {
         td::actor::send_closure(SelfId, &WaitBlockState::written_state, R.move_as_ok());
       }
     });
+
     BlockIdExt masterchain_id = persistent_state_desc_->masterchain_id;
-    td::actor::create_actor<DownloadShardState>("downloadstate", handle_->id(), masterchain_id, priority_, manager_,
-                                                timeout_, std::move(P))
-        .release();
+    td::uint32 split_depth = 0;
+    bool block_found = false;
+    for (auto const& [block, block_split_depth] : persistent_state_desc_->shard_blocks) {
+      if (block == handle_->id()) {
+        split_depth = block_split_depth;
+        block_found = true;
+        break;
+      }
+    }
+    if (!block_found) {
+      LOG(ERROR) << "invalid persistent state description passed to WaitBlockState for block "
+                 << handle_->id().to_str();
+      P.set_error(td::Status::Error("invalid persistent state description"));
+    } else {
+      td::actor::create_actor<DownloadShardState>("downloadstate", handle_->id(), masterchain_id, split_depth,
+                                                  priority_, manager_, timeout_, std::move(P))
+          .release();
+    }
   } else if (!handle_->inited_prev() || (!handle_->inited_proof() && !handle_->inited_proof_link())) {
     auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), handle = handle_](td::Result<td::BufferSlice> R) {
       if (R.is_error()) {

validator/import-db-slice.cpp

@@ -418,8 +418,10 @@ void ArchiveImporter::apply_shard_block_cont1(BlockHandle handle, BlockIdExt mas
   if (handle->id().seqno() == 0) {
     auto P = td::PromiseCreator::lambda(
         [promise = std::move(promise)](td::Result<td::Ref<ShardState>>) mutable { promise.set_value(td::Unit()); });
-    td::actor::create_actor<DownloadShardState>("downloadstate", handle->id(), masterchain_block_id, 2, manager_,
-                                                td::Timestamp::in(3600), std::move(P))
+    td::actor::create_actor<DownloadShardState>(
+        "downloadstate", handle->id(), masterchain_block_id,
+        start_state_->persistent_state_split_depth(handle->id().shard_full().workchain), 2, manager_,
+        td::Timestamp::in(3600), std::move(P))
         .release();
     return;
   }

validator/manager-init.cpp

@@ -65,7 +65,7 @@ void ValidatorManagerMasterchainReiniter::got_masterchain_handle(BlockHandle han
       R.ensure();
       td::actor::send_closure(SelfId, &ValidatorManagerMasterchainReiniter::download_masterchain_state);
     });
-    td::actor::create_actor<DownloadShardState>("downloadstate", handle_->id(), BlockIdExt{}, 2, manager_,
+    td::actor::create_actor<DownloadShardState>("downloadstate", handle_->id(), BlockIdExt{}, 0, 2, manager_,
                                                 td::Timestamp::in(3600), std::move(P))
         .release();
     return;
@@ -80,7 +80,7 @@ void ValidatorManagerMasterchainReiniter::download_proof_link() {
       R.ensure();
       td::actor::send_closure(SelfId, &ValidatorManagerMasterchainReiniter::downloaded_zero_state);
     });
-    td::actor::create_actor<DownloadShardState>("downloadstate", handle_->id(), BlockIdExt{}, 2, manager_,
+    td::actor::create_actor<DownloadShardState>("downloadstate", handle_->id(), BlockIdExt{}, 0, 2, manager_,
                                                 td::Timestamp::in(3600), std::move(P))
         .release();
   } else {
@@ -263,7 +263,7 @@ void ValidatorManagerMasterchainReiniter::download_masterchain_state() {
                               R.move_as_ok());
     }
   });
-  td::actor::create_actor<DownloadShardState>("downloadstate", block_id_, block_id_, 2, manager_,
+  td::actor::create_actor<DownloadShardState>("downloadstate", block_id_, block_id_, 0, 2, manager_,
                                               td::Timestamp::in(3600 * 3), std::move(P))
       .release();
 }

validator/shard-client.cpp

@@ -74,24 +74,29 @@ void ShardClient::got_init_state_from_db(td::Ref<MasterchainState> state) {
 }
 
 void ShardClient::start_up_init_mode() {
-  std::vector<BlockIdExt> shards;
-  for (const auto& s : masterchain_state_->get_shards()) {
+  std::vector<DownloadableShard> shards;
+  for (const auto &s : masterchain_state_->get_shards()) {
     if (opts_->need_monitor(s->shard(), masterchain_state_)) {
-      shards.push_back(s->top_block_id());
+      auto shard = s->top_block_id();
+      shards.push_back({
+          .shard = shard,
+          .split_depth = masterchain_state_->persistent_state_split_depth(shard.shard_full().workchain),
+      });
     }
   }
   download_shard_states(masterchain_block_handle_->id(), std::move(shards), 0);
 }
 
-void ShardClient::download_shard_states(BlockIdExt masterchain_block_id, std::vector<BlockIdExt> shards, size_t idx) {
+void ShardClient::download_shard_states(BlockIdExt masterchain_block_id, std::vector<DownloadableShard> shards,
+                                        size_t idx) {
   if (idx >= shards.size()) {
     LOG(WARNING) << "downloaded all shard states";
     applied_all_shards();
     return;
   }
-  BlockIdExt block_id = shards[idx];
+  auto [block_id, split_depth] = shards[idx];
   td::actor::create_actor<DownloadShardState>(
-      "downloadstate", block_id, masterchain_block_handle_->id(), 2, manager_, td::Timestamp::in(3600 * 5),
+      "downloadstate", block_id, masterchain_block_handle_->id(), split_depth, 2, manager_, td::Timestamp::in(3600 * 5),
       [=, SelfId = actor_id(this), shards = std::move(shards)](td::Result<td::Ref<ShardState>> R) {
         R.ensure();
         td::actor::send_closure(SelfId, &ShardClient::download_shard_states, masterchain_block_id, std::move(shards),

validator/shard-client.hpp

@@ -27,6 +27,11 @@ namespace validator {
 
 class ShardClient : public td::actor::Actor {
  private:
+  struct DownloadableShard {
+    BlockIdExt shard;
+    td::uint32 split_depth;
+  };
+
   td::Ref<ValidatorManagerOptions> opts_;
 
   BlockHandle masterchain_block_handle_;
@@ -64,7 +69,7 @@ class ShardClient : public td::actor::Actor {
 
   void start_up() override;
   void start_up_init_mode();
-  void download_shard_states(BlockIdExt masterchain_block_id, std::vector<BlockIdExt> shards, size_t idx);
+  void download_shard_states(BlockIdExt masterchain_block_id, std::vector<DownloadableShard> shards, size_t idx);
   void start();
   void got_state_from_db(BlockIdExt masterchain_block_id);
   void got_init_handle_from_db(BlockHandle handle);