LS queries to nonfinal blocks (#941)

Co-authored-by: SpyCheese <mikle98@yandex.ru>

validator/impl/CMakeLists.txt

@@ -7,6 +7,7 @@ endif()
 set(TON_VALIDATOR_SOURCE
   accept-block.cpp
   block.cpp
+  candidates-buffer.cpp
   check-proof.cpp
   collator.cpp
   config.cpp
@@ -24,6 +25,7 @@ set(TON_VALIDATOR_SOURCE
 
   accept-block.hpp
   block.hpp
+  candidates-buffer.hpp
   check-proof.hpp
   collate-query-impl.h
   collator-impl.h

validator/impl/candidates-buffer.cpp

@@ -0,0 +1,213 @@
+/*
+    This file is part of TON Blockchain Library.
+
+    TON Blockchain Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    TON Blockchain Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "candidates-buffer.hpp"
+#include "fabric.h"
+
+namespace ton::validator {
+
+void CandidatesBuffer::start_up() {
+  alarm_timestamp() = td::Timestamp::in(60.0);
+}
+
+void CandidatesBuffer::alarm() {
+  alarm_timestamp() = td::Timestamp::in(60.0);
+  for (auto it = candidates_.begin(); it != candidates_.end();) {
+    Candidate &entry = it->second;
+    if (entry.ttl_.is_in_past()) {
+      for (auto &p : entry.data_waiters_) {
+        p.set_error(td::Status::Error(ErrorCode::timeout, "timeout"));
+      }
+      for (auto &p : entry.state_waiters_) {
+        p.set_error(td::Status::Error(ErrorCode::timeout, "timeout"));
+      }
+      it = candidates_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+void CandidatesBuffer::add_new_candidate(BlockIdExt id, PublicKey source, FileHash collated_data_file_hash) {
+  auto it = candidates_.emplace(id, Candidate{});
+  Candidate &entry = it.first->second;
+  entry.ttl_ = td::Timestamp::in(120.0);
+  if (!it.second) {  // not inserted
+    return;
+  }
+  LOG(DEBUG) << "New block candidate " << id.to_str();
+  entry.source_ = source;
+  entry.collated_data_file_hash_ = collated_data_file_hash;
+}
+
+void CandidatesBuffer::get_block_data(BlockIdExt id, td::Promise<td::Ref<BlockData>> promise) {
+  auto it = candidates_.find(id);
+  if (it == candidates_.end()) {
+    promise.set_error(td::Status::Error(ErrorCode::notready, "unknown block candidate"));
+    return;
+  }
+  Candidate &entry = it->second;
+  if (entry.data_.not_null()) {
+    promise.set_result(entry.data_);
+    return;
+  }
+  entry.data_waiters_.push_back(std::move(promise));
+  if (entry.data_requested_) {
+    return;
+  }
+  entry.data_requested_ = true;
+  td::actor::send_closure(manager_, &ValidatorManager::get_block_candidate_from_db, entry.source_, id,
+                          entry.collated_data_file_hash_, [SelfId = actor_id(this), id](td::Result<BlockCandidate> R) {
+                            td::actor::send_closure(SelfId, &CandidatesBuffer::got_block_candidate, id, std::move(R));
+                          });
+}
+
+void CandidatesBuffer::got_block_candidate(BlockIdExt id, td::Result<BlockCandidate> R) {
+  if (R.is_error()) {
+    finish_get_block_data(id, R.move_as_error());
+    return;
+  }
+  BlockCandidate cand = R.move_as_ok();
+  CHECK(cand.id == id);
+  finish_get_block_data(id, create_block(id, std::move(cand.data)));
+}
+
+void CandidatesBuffer::get_block_state(BlockIdExt id, td::Promise<td::Ref<ShardState>> promise) {
+  auto it = candidates_.find(id);
+  if (it == candidates_.end()) {
+    promise.set_error(td::Status::Error(ErrorCode::notready, "unknown block candidate"));
+    return;
+  }
+  Candidate &entry = it->second;
+  if (entry.state_.not_null()) {
+    promise.set_result(entry.state_);
+    return;
+  }
+  entry.state_waiters_.push_back(std::move(promise));
+  if (entry.state_requested_) {
+    return;
+  }
+  entry.state_requested_ = true;
+  get_block_data(id, [SelfId = actor_id(this), id](td::Result<td::Ref<BlockData>> R) {
+    if (R.is_error()) {
+      td::actor::send_closure(SelfId, &CandidatesBuffer::finish_get_block_state, id, R.move_as_error());
+      return;
+    }
+    td::actor::send_closure(SelfId, &CandidatesBuffer::get_block_state_cont, id, R.move_as_ok());
+  });
+}
+
+void CandidatesBuffer::get_block_state_cont(BlockIdExt id, td::Ref<BlockData> data) {
+  CHECK(id == data->block_id());
+  std::vector<BlockIdExt> prev;
+  BlockIdExt mc_blkid;
+  bool after_split;
+  auto S = block::unpack_block_prev_blk_ext(data->root_cell(), id, prev, mc_blkid, after_split);
+  if (S.is_error()) {
+    finish_get_block_state(id, std::move(S));
+    return;
+  }
+  get_block_state_cont2(std::move(data), std::move(prev), {});
+}
+
+void CandidatesBuffer::get_block_state_cont2(td::Ref<BlockData> block, std::vector<BlockIdExt> prev,
+                                             std::vector<td::Ref<ShardState>> prev_states) {
+  if (prev_states.size() < prev.size()) {
+    BlockIdExt prev_id = prev[prev_states.size()];
+    td::actor::send_closure(manager_, &ValidatorManager::get_shard_state_from_db_short, prev_id,
+                            [SelfId = actor_id(this), block = std::move(block), prev = std::move(prev),
+                             prev_states = std::move(prev_states)](td::Result<td::Ref<ShardState>> R) mutable {
+                              if (R.is_error()) {
+                                td::actor::send_closure(SelfId, &CandidatesBuffer::finish_get_block_state,
+                                                        block->block_id(), R.move_as_error());
+                                return;
+                              }
+                              prev_states.push_back(R.move_as_ok());
+                              td::actor::send_closure(SelfId, &CandidatesBuffer::get_block_state_cont2,
+                                                      std::move(block), std::move(prev), std::move(prev_states));
+                            });
+    return;
+  }
+
+  BlockIdExt id = block->block_id();
+  td::Ref<ShardState> state;
+  CHECK(prev_states.size() == 1 || prev_states.size() == 2);
+  if (prev_states.size() == 2) {  // after merge
+    auto R = prev_states[0]->merge_with(*prev_states[1]);
+    if (R.is_error()) {
+      finish_get_block_state(id, R.move_as_error());
+      return;
+    }
+    state = R.move_as_ok();
+  } else if (id.shard_full() != prev[0].shard_full()) {  // after split
+    auto R = prev_states[0]->split();
+    if (R.is_error()) {
+      finish_get_block_state(id, R.move_as_error());
+      return;
+    }
+    auto s = R.move_as_ok();
+    state = is_left_child(id.shard_full()) ? std::move(s.first) : std::move(s.second);
+  } else {  // no split/merge
+    state = std::move(prev_states[0]);
+  }
+
+  auto S = state.write().apply_block(id, std::move(block));
+  if (S.is_error()) {
+    finish_get_block_state(id, std::move(S));
+    return;
+  }
+  finish_get_block_state(id, std::move(state));
+}
+
+void CandidatesBuffer::finish_get_block_data(BlockIdExt id, td::Result<td::Ref<BlockData>> res) {
+  auto it = candidates_.find(id);
+  if (it == candidates_.end()) {
+    return;
+  }
+  Candidate &entry = it->second;
+  for (auto &p : entry.data_waiters_) {
+    p.set_result(res.clone());
+  }
+  entry.data_waiters_.clear();
+  entry.data_requested_ = false;
+  if (res.is_ok()) {
+    entry.data_ = res.move_as_ok();
+    LOG(DEBUG) << "Loaded block data for " << id.to_str();
+  } else {
+    LOG(DEBUG) << "Failed to load block data for " << id.to_str() << ": " << res.move_as_error();
+  }
+}
+
+void CandidatesBuffer::finish_get_block_state(BlockIdExt id, td::Result<td::Ref<ShardState>> res) {
+  auto it = candidates_.find(id);
+  if (it == candidates_.end()) {
+    return;
+  }
+  Candidate &entry = it->second;
+  for (auto &p : entry.state_waiters_) {
+    p.set_result(res.clone());
+  }
+  entry.state_waiters_.clear();
+  entry.state_requested_ = false;
+  if (res.is_ok()) {
+    entry.state_ = res.move_as_ok();
+    LOG(DEBUG) << "Loaded block state for " << id.to_str();
+  } else {
+    LOG(DEBUG) << "Failed to load block state for " << id.to_str() << ": " << res.move_as_error();
+  }
+}
+
+}  // namespace ton::validator

validator/impl/candidates-buffer.hpp

@@ -0,0 +1,64 @@
+/*
+    This file is part of TON Blockchain Library.
+
+    TON Blockchain Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    TON Blockchain Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+#include "ton/ton-types.h"
+#include "td/actor/actor.h"
+#include "interfaces/validator-manager.h"
+
+namespace ton::validator {
+
+class CandidatesBuffer : public td::actor::Actor {
+ public:
+  explicit CandidatesBuffer(td::actor::ActorId<ValidatorManager> manager) : manager_(std::move(manager)) {
+  }
+
+  void start_up() override;
+  void alarm() override;
+
+  void add_new_candidate(BlockIdExt id, PublicKey source, FileHash collated_data_file_hash);
+  void get_block_data(BlockIdExt id, td::Promise<td::Ref<BlockData>> promise);
+  void get_block_state(BlockIdExt id, td::Promise<td::Ref<ShardState>> promise);
+
+ private:
+  td::actor::ActorId<ValidatorManager> manager_;
+
+  struct Candidate {
+    PublicKey source_;
+    FileHash collated_data_file_hash_;
+    td::Timestamp ttl_;
+
+    td::Ref<BlockData> data_;
+    std::vector<td::Promise<td::Ref<BlockData>>> data_waiters_;
+    bool data_requested_{false};
+
+    td::Ref<ShardState> state_;
+    std::vector<td::Promise<td::Ref<ShardState>>> state_waiters_;
+    bool state_requested_{false};
+  };
+  std::map<BlockIdExt, Candidate> candidates_;
+
+  void got_block_candidate(BlockIdExt id, td::Result<BlockCandidate> R);
+
+  void get_block_state_cont(BlockIdExt id, td::Ref<BlockData> data);
+  void get_block_state_cont2(td::Ref<BlockData> block, std::vector<BlockIdExt> prev,
+                             std::vector<td::Ref<ShardState>> prev_states);
+
+  void finish_get_block_data(BlockIdExt id, td::Result<td::Ref<BlockData>> res);
+  void finish_get_block_state(BlockIdExt id, td::Result<td::Ref<ShardState>> res);
+};
+
+}  // namespace ton::validator

validator/impl/liteserver.cpp

@@ -275,6 +275,13 @@ void LiteQuery::perform() {
           [&](lite_api::liteServer_getShardBlockProof& q) {
             this->perform_getShardBlockProof(create_block_id(q.id_));
           },
+          [&](lite_api::liteServer_nonfinal_getCandidate& q) {
+            this->perform_nonfinal_getCandidate(q.id_->creator_, create_block_id(q.id_->block_id_),
+                                                q.id_->collated_data_hash_);
+          },
+          [&](lite_api::liteServer_nonfinal_getValidatorGroups& q) {
+            this->perform_nonfinal_getValidatorGroups(q.mode_, ShardIdFull{q.wc_, (ShardId)q.shard_});
+          },
           [&](auto& obj) { this->abort_query(td::Status::Error(ErrorCode::protoviolation, "unknown query")); }));
 }
 
@@ -343,21 +350,15 @@ void LiteQuery::perform_getBlock(BlockIdExt blkid) {
     fatal_error("invalid BlockIdExt");
     return;
   }
-  get_block_handle_checked(blkid, [manager = manager_, Self = actor_id(this), blkid](td::Result<ConstBlockHandle> R) {
-    if (R.is_error()) {
-      td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
-      return;
-    }
-    td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(),
-                                  [=](td::Result<Ref<ton::validator::BlockData>> res) {
-                                    if (res.is_error()) {
-                                      td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
-                                    } else {
-                                      td::actor::send_closure_later(Self, &LiteQuery::continue_getBlock, blkid,
-                                                                    res.move_as_ok());
-                                    }
-                                  });
-  });
+  td::actor::send_closure(manager_, &ValidatorManager::get_block_data_for_litequery, blkid,
+                          [Self = actor_id(this), blkid](td::Result<Ref<ton::validator::BlockData>> res) {
+                            if (res.is_error()) {
+                              td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
+                            } else {
+                              td::actor::send_closure_later(Self, &LiteQuery::continue_getBlock, blkid,
+                                                            res.move_as_ok());
+                            }
+                          });
 }
 
 void LiteQuery::continue_getBlock(BlockIdExt blkid, Ref<ton::validator::BlockData> block) {
@@ -375,21 +376,15 @@ void LiteQuery::perform_getBlockHeader(BlockIdExt blkid, int mode) {
     fatal_error("invalid BlockIdExt");
     return;
   }
-  get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
-    if (R.is_error()) {
-      td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
-      return;
-    }
-    td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(),
-                                  [=](td::Result<Ref<ton::validator::BlockData>> res) {
-                                    if (res.is_error()) {
-                                      td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
-                                    } else {
-                                      td::actor::send_closure_later(Self, &LiteQuery::continue_getBlockHeader, blkid,
-                                                                    mode, res.move_as_ok());
-                                    }
-                                  });
-  });
+  td::actor::send_closure(manager_, &ValidatorManager::get_block_data_for_litequery, blkid,
+                          [Self = actor_id(this), blkid, mode](td::Result<Ref<ton::validator::BlockData>> res) {
+                            if (res.is_error()) {
+                              td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
+                            } else {
+                              td::actor::send_closure_later(Self, &LiteQuery::continue_getBlockHeader, blkid, mode,
+                                                            res.move_as_ok());
+                            }
+                          });
 }
 
 static bool visit(Ref<vm::Cell> cell);
@@ -495,33 +490,27 @@ void LiteQuery::perform_getState(BlockIdExt blkid) {
     fatal_error("cannot request total state: possibly too large");
     return;
   }
-  get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
-    if (R.is_error()) {
-      td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
-      return;
-    }
-    if (blkid.id.seqno) {
-      td::actor::send_closure_later(manager, &ValidatorManager::get_shard_state_from_db, R.move_as_ok(),
-                                    [=](td::Result<Ref<ton::validator::ShardState>> res) {
-                                      if (res.is_error()) {
-                                        td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
-                                      } else {
-                                        td::actor::send_closure_later(Self, &LiteQuery::continue_getState, blkid,
-                                                                      res.move_as_ok());
-                                      }
-                                    });
-    } else {
-      td::actor::send_closure_later(manager, &ValidatorManager::get_zero_state, blkid,
-                                    [=](td::Result<td::BufferSlice> res) {
-                                      if (res.is_error()) {
-                                        td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
-                                      } else {
-                                        td::actor::send_closure_later(Self, &LiteQuery::continue_getZeroState, blkid,
-                                                                      res.move_as_ok());
-                                      }
-                                    });
-    }
-  });
+  if (blkid.id.seqno) {
+    td::actor::send_closure(manager_, &ValidatorManager::get_block_state_for_litequery, blkid,
+                            [Self = actor_id(this), blkid](td::Result<Ref<ShardState>> res) {
+                              if (res.is_error()) {
+                                td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
+                              } else {
+                                td::actor::send_closure_later(Self, &LiteQuery::continue_getState, blkid,
+                                                              res.move_as_ok());
+                              }
+                            });
+  } else {
+    td::actor::send_closure_later(manager_, &ValidatorManager::get_zero_state, blkid,
+                                  [Self = actor_id(this), blkid](td::Result<td::BufferSlice> res) {
+                                    if (res.is_error()) {
+                                      td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
+                                    } else {
+                                      td::actor::send_closure_later(Self, &LiteQuery::continue_getZeroState, blkid,
+                                                                    res.move_as_ok());
+                                    }
+                                  });
+  }
 }
 
 void LiteQuery::continue_getState(BlockIdExt blkid, Ref<ton::validator::ShardState> state) {
@@ -583,7 +572,7 @@ bool LiteQuery::request_mc_block_data(BlockIdExt blkid) {
   base_blk_id_ = blkid;
   ++pending_;
   td::actor::send_closure_later(
-      manager_, &ValidatorManager::get_block_data_from_db_short, blkid,
+      manager_, &ValidatorManager::get_block_data_for_litequery, blkid,
       [Self = actor_id(this), blkid](td::Result<Ref<BlockData>> res) {
         if (res.is_error()) {
           td::actor::send_closure(Self, &LiteQuery::abort_query,
@@ -641,7 +630,7 @@ bool LiteQuery::request_mc_block_state(BlockIdExt blkid) {
   base_blk_id_ = blkid;
   ++pending_;
   td::actor::send_closure_later(
-      manager_, &ValidatorManager::get_shard_state_from_db_short, blkid,
+      manager_, &ValidatorManager::get_block_state_for_litequery, blkid,
       [Self = actor_id(this), blkid](td::Result<Ref<ShardState>> res) {
         if (res.is_error()) {
           td::actor::send_closure(Self, &LiteQuery::abort_query,
@@ -671,22 +660,16 @@ bool LiteQuery::request_block_state(BlockIdExt blkid) {
   }
   blk_id_ = blkid;
   ++pending_;
-  get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
-    if (R.is_error()) {
-      td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
-      return;
-    }
-    td::actor::send_closure_later(
-        manager, &ValidatorManager::get_shard_state_from_db, R.move_as_ok(),
-        [=](td::Result<Ref<ShardState>> res) {
-          if (res.is_error()) {
-            td::actor::send_closure(Self, &LiteQuery::abort_query,
-                                    res.move_as_error_prefix("cannot load state for "s + blkid.to_str() + " : "));
-          } else {
-            td::actor::send_closure_later(Self, &LiteQuery::got_block_state, blkid, res.move_as_ok());
-          }
-        });
-  });
+  td::actor::send_closure(manager_, &ValidatorManager::get_block_state_for_litequery, blkid,
+                          [Self = actor_id(this), blkid](td::Result<Ref<ShardState>> res) {
+                            if (res.is_error()) {
+                              td::actor::send_closure(
+                                  Self, &LiteQuery::abort_query,
+                                  res.move_as_error_prefix("cannot load state for "s + blkid.to_str() + " : "));
+                            } else {
+                              td::actor::send_closure_later(Self, &LiteQuery::got_block_state, blkid, res.move_as_ok());
+                            }
+                          });
   return true;
 }
 
@@ -699,22 +682,16 @@ bool LiteQuery::request_block_data(BlockIdExt blkid) {
   }
   blk_id_ = blkid;
   ++pending_;
-  get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
-    if (R.is_error()) {
-      td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
-      return;
-    }
-    td::actor::send_closure_later(
-        manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(),
-        [=](td::Result<Ref<BlockData>> res) {
-          if (res.is_error()) {
-            td::actor::send_closure(Self, &LiteQuery::abort_query,
-                                    res.move_as_error_prefix("cannot load block "s + blkid.to_str() + " : "));
-          } else {
-            td::actor::send_closure_later(Self, &LiteQuery::got_block_data, blkid, res.move_as_ok());
-          }
-        });
-  });
+  td::actor::send_closure(manager_, &ValidatorManager::get_block_data_for_litequery, blkid,
+                          [Self = actor_id(this), blkid](td::Result<Ref<BlockData>> res) {
+                            if (res.is_error()) {
+                              td::actor::send_closure(
+                                  Self, &LiteQuery::abort_query,
+                                  res.move_as_error_prefix("cannot load block "s + blkid.to_str() + " : "));
+                            } else {
+                              td::actor::send_closure_later(Self, &LiteQuery::got_block_data, blkid, res.move_as_ok());
+                            }
+                          });
   return true;
 }
 
@@ -1712,7 +1689,7 @@ void LiteQuery::continue_getTransactions(unsigned remaining, bool exact) {
   LOG(DEBUG) << "sending get_block_by_lt_from_db() query to manager for " << acc_workchain_ << ":" << acc_addr_.to_hex()
              << " " << trans_lt_;
   td::actor::send_closure_later(
-      manager_, &ValidatorManager::get_block_by_lt_from_db_for_litequery, ton::extract_addr_prefix(acc_workchain_, acc_addr_),
+      manager_, &ValidatorManager::get_block_by_lt_for_litequery, ton::extract_addr_prefix(acc_workchain_, acc_addr_),
       trans_lt_, [Self = actor_id(this), remaining, manager = manager_](td::Result<ConstBlockHandle> res) {
         if (res.is_error()) {
           td::actor::send_closure(Self, &LiteQuery::abort_getTransactions, res.move_as_error(), ton::BlockIdExt{});
@@ -2088,11 +2065,13 @@ void LiteQuery::perform_lookupBlockWithProof(BlockId blkid, BlockIdExt mc_blkid,
   });
 
   if (mode & 2) {
-    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_lt_from_db_for_litequery, pfx, lt, std::move(P));
+    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_lt_for_litequery, pfx, lt, std::move(P));
   } else if (mode & 4) {
-    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_unix_time_from_db_for_litequery, pfx, utime, std::move(P));
+    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_unix_time_for_litequery, pfx, utime,
+                                  std::move(P));
   } else {
-    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_seqno_from_db_for_litequery, pfx, blkid.seqno, std::move(P));
+    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_seqno_for_litequery, pfx, blkid.seqno,
+                                  std::move(P));
   }
 }
 
@@ -2368,13 +2347,13 @@ void LiteQuery::perform_lookupBlock(BlockId blkid, int mode, LogicalTime lt, Uni
 
   ton::AccountIdPrefixFull pfx{blkid.workchain, blkid.shard};
   if (mode & 2) {
-    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_lt_from_db_for_litequery, pfx, lt,
+    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_lt_for_litequery, pfx, lt,
                                   std::move(P));
   } else if (mode & 4) {
-    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_unix_time_from_db_for_litequery, pfx, utime,
+    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_unix_time_for_litequery, pfx, utime,
                                   std::move(P));
   } else {
-    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_seqno_from_db_for_litequery, pfx,
+    td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_seqno_for_litequery, pfx,
                                   blkid.seqno, std::move(P));
   }
 }
@@ -3133,7 +3112,7 @@ void LiteQuery::perform_getShardBlockProof(BlockIdExt blkid) {
     }
     AccountIdPrefixFull pfx{masterchainId, shardIdAll};
     td::actor::send_closure_later(
-        manager, &ValidatorManager::get_block_by_seqno_from_db_for_litequery, pfx, handle->masterchain_ref_block(),
+        manager, &ValidatorManager::get_block_by_seqno_for_litequery, pfx, handle->masterchain_ref_block(),
         [Self, manager](td::Result<ConstBlockHandle> R) {
           if (R.is_error()) {
             td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
@@ -3237,5 +3216,45 @@ void LiteQuery::continue_getShardBlockProof(Ref<BlockData> cur_block,
       });
 }
 
+void LiteQuery::perform_nonfinal_getCandidate(td::Bits256 source, BlockIdExt blkid, td::Bits256 collated_data_hash) {
+  LOG(INFO) << "started a nonfinal.getCandidate liteserver query";
+  td::actor::send_closure_later(
+      manager_, &ValidatorManager::get_block_candidate_for_litequery, PublicKey{pubkeys::Ed25519{source}}, blkid, collated_data_hash,
+      [Self = actor_id(this)](td::Result<BlockCandidate> R) {
+        if (R.is_error()) {
+          td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
+        } else {
+          BlockCandidate cand = R.move_as_ok();
+          td::actor::send_closure_later(
+              Self, &LiteQuery::finish_query,
+              create_serialize_tl_object<lite_api::liteServer_nonfinal_candidate>(
+                  create_tl_object<lite_api::liteServer_nonfinal_candidateId>(
+                      create_tl_lite_block_id(cand.id), cand.pubkey.as_bits256(), cand.collated_file_hash),
+                  std::move(cand.data), std::move(cand.collated_data)),
+              false);
+        }
+      });
+}
+
+void LiteQuery::perform_nonfinal_getValidatorGroups(int mode, ShardIdFull shard) {
+  bool with_shard = mode & 1;
+  LOG(INFO) << "started a nonfinal.getValidatorGroups" << (with_shard ? shard.to_str() : "(all)")
+            << " liteserver query";
+  td::optional<ShardIdFull> maybe_shard;
+  if (with_shard) {
+    maybe_shard = shard;
+  }
+  td::actor::send_closure(
+      manager_, &ValidatorManager::get_validator_groups_info_for_litequery, maybe_shard,
+      [Self = actor_id(this)](td::Result<tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroups>> R) {
+        if (R.is_error()) {
+          td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
+        } else {
+          td::actor::send_closure_later(Self, &LiteQuery::finish_query, serialize_tl_object(R.move_as_ok(), true),
+                                        false);
+        }
+      });
+}
+
 }  // namespace validator
 }  // namespace ton

validator/impl/liteserver.hpp

@@ -168,6 +168,8 @@ class LiteQuery : public td::actor::Actor {
   void perform_getShardBlockProof(BlockIdExt blkid);
   void continue_getShardBlockProof(Ref<BlockData> cur_block,
                                    std::vector<std::pair<BlockIdExt, td::BufferSlice>> result);
+  void perform_nonfinal_getCandidate(td::Bits256 source, BlockIdExt blkid, td::Bits256 collated_data_hash);
+  void perform_nonfinal_getValidatorGroups(int mode, ShardIdFull shard);
 
   void load_prevKeyBlock(ton::BlockIdExt blkid, td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>>);
   void continue_loadPrevKeyBlock(ton::BlockIdExt blkid, td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res,