external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00
Code Issues Releases Wiki Activity

Optimize importing out queues

Browse source
This commit is contained in:
SpyCheese 2023-07-31 18:12:09 +03:00
parent 44ba040934
commit 5c02459fd8
22 changed files with 588 additions and 450 deletions
Download patch file Download diff file Expand all files Collapse all files

7
create-hardfork/create-hardfork.cpp
View file

@ -268,12 +268,11 @@ class HardforkCreator : public td::actor::Actor {
td::Promise<std::vector<ton::BlockIdExt>> promise) override {
}
void download_archive(ton::BlockSeqno masterchain_seqno, std::string tmp_dir, td::Timestamp timeout,
td::Promise<std::string> promise) override {
}
void download_out_msg_queue_proof(ton::BlockIdExt block_id, ton::ShardIdFull dst_shard,
block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
td::Promise<td::Ref<ton::validator::OutMsgQueueProof>> promise) override {
void download_out_msg_queue_proof(
ton::ShardIdFull dst_shard, std::vector<ton::BlockIdExt> blocks, block::ImportedMsgQueueLimits limits,
td::Timestamp timeout, td::Promise<std::vector<td::Ref<ton::validator::OutMsgQueueProof>>> promise) override {
}
void new_key_block(ton::validator::BlockHandle handle) override {

4
crypto/block/block.h
View file

@ -218,8 +218,8 @@ static inline std::ostream& operator<<(std::ostream& os, const MsgProcessedUptoC
struct ImportedMsgQueueLimits {
// Default values
td::uint32 max_bytes = 1 << 18;
td::uint32 max_msgs = 40;
td::uint32 max_bytes = 1 << 19;
td::uint32 max_msgs = 500;
bool deserialize(vm::CellSlice& cs);
};

6
test/test-ton-collator.cpp
View file

@ -372,9 +372,9 @@ class TestNode : public td::actor::Actor {
td::Promise<std::string> promise) override {
}
void download_out_msg_queue_proof(ton::BlockIdExt block_id, ton::ShardIdFull dst_shard,
block::ImportedMsgQueueLimits, td::Timestamp timeout,
td::Promise<td::Ref<ton::validator::OutMsgQueueProof>> promise) override {
void download_out_msg_queue_proof(
ton::ShardIdFull dst_shard, std::vector<ton::BlockIdExt> blocks, block::ImportedMsgQueueLimits limits,
td::Timestamp timeout, td::Promise<std::vector<td::Ref<ton::validator::OutMsgQueueProof>>> promise) override {
}
void new_key_block(ton::validator::BlockHandle handle) override {

4
tl/generate/scheme/ton_api.tl
View file

@ -416,7 +416,7 @@ tonNode.archiveNotFound = tonNode.ArchiveInfo;
tonNode.archiveInfo id:long = tonNode.ArchiveInfo;
tonNode.importedMsgQueueLimits max_bytes:int max_msgs:int = ImportedMsgQueueLimits;
tonNode.outMsgQueueProof queue_proof:bytes block_state_proof:bytes msg_count:int = tonNode.OutMsgQueueProof;
tonNode.outMsgQueueProof queue_proofs:bytes block_state_proofs:bytes msg_counts:(vector int) = tonNode.OutMsgQueueProof;
tonNode.outMsgQueueProofEmpty = tonNode.OutMsgQueueProof;
tonNode.forgetPeer = tonNode.ForgetPeer;
@ -452,7 +452,7 @@ tonNode.downloadBlockProofLinks blocks:(vector tonNode.blockIdExt) = tonNode.Dat
tonNode.downloadKeyBlockProofLinks blocks:(vector tonNode.blockIdExt) = tonNode.DataList;
tonNode.getArchiveInfo masterchain_seqno:int = tonNode.ArchiveInfo;
tonNode.getArchiveSlice archive_id:long offset:long max_size:int = tonNode.Data;
tonNode.getOutMsgQueueProof block_id:tonNode.blockIdExt dst_workchain:int dst_shard:long
tonNode.getOutMsgQueueProof dst_shard:tonNode.shardId blocks:(vector tonNode.blockIdExt)
limits:tonNode.importedMsgQueueLimits = tonNode.OutMsgQueueProof;
tonNode.getCapabilities = tonNode.Capabilities;

BIN
tl/generate/scheme/ton_api.tlo
View file

Binary file not shown.

29
validator/collator-node.cpp
View file

@ -74,37 +74,8 @@ void CollatorNode::new_masterchain_block_notification(td::Ref<MasterchainState>
last_masterchain_block_ = state->get_block_id();
last_top_blocks_.clear();
last_top_blocks_[ShardIdFull{masterchainId, shardIdAll}] = last_masterchain_block_;
if (state->get_unix_time() > (td::uint32)td::Clocks::system() - 20) {
std::vector<ShardIdFull> next_shards;
if (can_collate_shard(ShardIdFull(masterchainId))) {
next_shards.push_back(ShardIdFull(masterchainId));
}
for (const auto& desc : state->get_shards()) {
last_top_blocks_[desc->shard()] = desc->top_block_id();
ShardIdFull shard = desc->shard();
if (desc->before_split()) {
if (can_collate_shard(shard_child(shard, true))) {
next_shards.push_back(shard_child(shard, true));
}
if (can_collate_shard(shard_child(shard, false))) {
next_shards.push_back(shard_child(shard, false));
}
} else if (desc->before_merge()) {
if (is_left_child(shard) && can_collate_shard(shard_parent(shard))) {
next_shards.push_back(shard_parent(shard));
}
} else if (can_collate_shard(shard)) {
next_shards.push_back(shard);
}
}
for (const ShardIdFull& shard : next_shards) {
for (const auto& neighbor : last_top_blocks_) {
if (neighbor.first != shard && block::ShardConfig::is_neighbor(shard, neighbor.first)) {
td::actor::send_closure(manager_, &ValidatorManager::wait_out_msg_queue_proof, neighbor.second, shard, 0,
td::Timestamp::in(10.0), [](td::Ref<OutMsgQueueProof>) {});
}
}
}
}
if (validators_.empty() || state->is_key_state()) {
validators_.clear();

60
validator/full-node-shard.cpp
View file

@ -670,18 +670,26 @@ void FullNodeShardImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNod
void FullNodeShardImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_getOutMsgQueueProof &query,
td::Promise<td::BufferSlice> promise) {
BlockIdExt block_id = create_block_id(query.block_id_);
ShardIdFull dst_shard(query.dst_workchain_, query.dst_shard_);
block::ImportedMsgQueueLimits limits{(td::uint32)query.limits_->max_bytes_, (td::uint32)query.limits_->max_msgs_};
if (!block_id.is_valid_ext()) {
std::vector<BlockIdExt> blocks;
for (const auto& x : query.blocks_) {
BlockIdExt id = create_block_id(x);
if (!id.is_valid_ext()) {
promise.set_error(td::Status::Error("invalid block_id"));
return;
}
if (!shard_is_ancestor(shard_, id.shard_full())) {
promise.set_error(td::Status::Error("query in wrong overlay"));
return;
}
blocks.push_back(create_block_id(x));
}
ShardIdFull dst_shard = create_shard_id(query.dst_shard_);
if (!dst_shard.is_valid_ext()) {
promise.set_error(td::Status::Error("invalid shard"));
return;
}
if (limits.max_bytes > (1 << 21)) {
block::ImportedMsgQueueLimits limits{(td::uint32)query.limits_->max_bytes_, (td::uint32)query.limits_->max_msgs_};
if (limits.max_bytes > (1 << 24)) {
promise.set_error(td::Status::Error("max_bytes is too big"));
return;
}
@ -693,10 +701,10 @@ void FullNodeShardImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNod
promise.set_result(serialize_tl_object(R.move_as_ok(), true));
}
});
VLOG(FULL_NODE_DEBUG) << "Got query getOutMsgQueueProof " << block_id.to_str() << " " << dst_shard.to_str()
<< " from " << src;
td::actor::create_actor<BuildOutMsgQueueProof>("buildqueueproof", block_id, dst_shard, limits, validator_manager_,
std::move(P))
VLOG(FULL_NODE_DEBUG) << "Got query getOutMsgQueueProof (" << blocks.size() << " blocks) to shard "
<< dst_shard.to_str() << " from " << src;
td::actor::create_actor<BuildOutMsgQueueProof>("buildqueueproof", dst_shard, std::move(blocks), limits,
validator_manager_, std::move(P))
.release();
}
@ -935,33 +943,43 @@ void FullNodeShardImpl::download_archive(BlockSeqno masterchain_seqno, std::stri
.release();
}
void FullNodeShardImpl::download_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard,
void FullNodeShardImpl::download_out_msg_queue_proof(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) {
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) {
// TODO: maybe more complex download (like other requests here)
auto &b = choose_neighbour(true);
if (b.adnl_id == adnl::AdnlNodeIdShort::zero()) {
promise.set_error(td::Status::Error(ErrorCode::notready, "no nodes"));
return;
}
auto P = td::PromiseCreator::lambda(
[=, promise = create_neighbour_promise(b, std::move(promise), true)](td::Result<td::BufferSlice> R) mutable {
std::vector<tl_object_ptr<ton_api::tonNode_blockIdExt>> blocks_tl;
for (const BlockIdExt &id : blocks) {
blocks_tl.push_back(create_tl_block_id(id));
}
td::BufferSlice query = create_serialize_tl_object<ton_api::tonNode_getOutMsgQueueProof>(
create_tl_shard_id(dst_shard), std::move(blocks_tl),
create_tl_object<ton_api::tonNode_importedMsgQueueLimits>(limits.max_bytes, limits.max_msgs));
auto P = td::PromiseCreator::lambda([=, promise = create_neighbour_promise(b, std::move(promise), true),
blocks = std::move(blocks)](td::Result<td::BufferSlice> R) mutable {
if (R.is_error()) {
promise.set_result(R.move_as_error());
return;
}
TRY_RESULT_PROMISE(promise, f, fetch_tl_object<ton_api::tonNode_OutMsgQueueProof>(R.move_as_ok(), true));
ton_api::downcast_call(*f, td::overloaded(
ton_api::downcast_call(
*f, td::overloaded(
[&](ton_api::tonNode_outMsgQueueProofEmpty &x) {
promise.set_error(td::Status::Error("node doesn't have this block"));
},
[&](ton_api::tonNode_outMsgQueueProof &x) {
promise.set_result(OutMsgQueueProof::fetch(block_id, dst_shard, limits, x));
delay_action(
[=, promise = std::move(promise), blocks = std::move(blocks), x = std::move(x)]() mutable {
promise.set_result(OutMsgQueueProof::fetch(dst_shard, blocks, limits, x));
},
td::Timestamp::now());
}));
});
td::BufferSlice query = create_serialize_tl_object<ton_api::tonNode_getOutMsgQueueProof>(
create_tl_block_id(block_id), dst_shard.workchain, dst_shard.shard,
create_tl_object<ton_api::tonNode_importedMsgQueueLimits>(limits.max_bytes, limits.max_msgs));
td::actor::send_closure(overlays_, &overlay::Overlays::send_query_via, b.adnl_id, adnl_id_, overlay_id_,
"get_msg_queue", std::move(P), timeout, std::move(query), 1 << 22, rldp_);
}
@ -1356,9 +1374,9 @@ td::actor::ActorOwn<FullNodeShard> FullNodeShard::create(
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<rldp2::Rldp> rldp2,
td::actor::ActorId<overlay::Overlays> overlays, td::actor::ActorId<ValidatorManagerInterface> validator_manager,
td::actor::ActorId<adnl::AdnlExtClient> client, FullNodeShardMode mode) {
return td::actor::create_actor<FullNodeShardImpl>("tonnode", shard, local_id, adnl_id, zero_state_file_hash, config,
keyring, adnl, rldp, rldp2, overlays, validator_manager, client,
mode);
return td::actor::create_actor<FullNodeShardImpl>(PSTRING() << "fullnode" << shard.to_str(), shard, local_id, adnl_id,
zero_state_file_hash, config, keyring, adnl, rldp, rldp2, overlays,
validator_manager, client, mode);
}
} // namespace fullnode

4
validator/full-node-shard.h
View file

@ -70,9 +70,9 @@ class FullNodeShard : public td::actor::Actor {
td::Promise<std::vector<BlockIdExt>> promise) = 0;
virtual void download_archive(BlockSeqno masterchain_seqno, std::string tmp_dir, td::Timestamp timeout,
td::Promise<std::string> promise) = 0;
virtual void download_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard,
virtual void download_out_msg_queue_proof(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) = 0;
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) = 0;
virtual void set_handle(BlockHandle handle, td::Promise<td::Unit> promise) = 0;

5
validator/full-node-shard.hpp
View file

@ -187,8 +187,9 @@ class FullNodeShardImpl : public FullNodeShard {
td::Promise<std::vector<BlockIdExt>> promise) override;
void download_archive(BlockSeqno masterchain_seqno, std::string tmp_dir, td::Timestamp timeout,
td::Promise<std::string> promise) override;
void download_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard, block::ImportedMsgQueueLimits limits,
td::Timestamp timeout, td::Promise<td::Ref<OutMsgQueueProof>> promise) override;
void download_out_msg_queue_proof(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) override;
void set_handle(BlockHandle handle, td::Promise<td::Unit> promise) override;

24
validator/full-node.cpp
View file

@ -378,17 +378,22 @@ void FullNodeImpl::download_archive(BlockSeqno masterchain_seqno, std::string tm
std::move(promise));
}
void FullNodeImpl::download_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard,
void FullNodeImpl::download_out_msg_queue_proof(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) {
auto shard = get_shard(block_id.shard_full());
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) {
if (blocks.empty()) {
promise.set_value({});
return;
}
// All blocks are expected to have the same minsplit shard prefix
auto shard = get_shard(blocks[0].shard_full());
if (shard.empty()) {
VLOG(FULL_NODE_WARNING) << "dropping download msg queue query to unknown shard";
promise.set_error(td::Status::Error(ErrorCode::notready, "shard not ready"));
return;
}
td::actor::send_closure(shard, &FullNodeShard::download_out_msg_queue_proof, block_id, dst_shard, limits, timeout,
std::move(promise));
td::actor::send_closure(shard, &FullNodeShard::download_out_msg_queue_proof, dst_shard, std::move(blocks), limits,
timeout, std::move(promise));
}
td::actor::ActorId<FullNodeShard> FullNodeImpl::get_shard(ShardIdFull shard) {
@ -588,10 +593,11 @@ void FullNodeImpl::start_up() {
td::actor::send_closure(id_, &FullNodeImpl::download_archive, masterchain_seqno, std::move(tmp_dir), timeout,
std::move(promise));
}
void download_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard, block::ImportedMsgQueueLimits limits,
td::Timestamp timeout, td::Promise<td::Ref<OutMsgQueueProof>> promise) override {
td::actor::send_closure(id_, &FullNodeImpl::download_out_msg_queue_proof, block_id, dst_shard, limits, timeout,
std::move(promise));
void download_out_msg_queue_proof(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) override {
td::actor::send_closure(id_, &FullNodeImpl::download_out_msg_queue_proof, dst_shard, std::move(blocks), limits,
timeout, std::move(promise));
}
void new_key_block(BlockHandle handle) override {

5
validator/full-node.hpp
View file

@ -74,8 +74,9 @@ class FullNodeImpl : public FullNode {
void get_next_key_blocks(BlockIdExt block_id, td::Timestamp timeout, td::Promise<std::vector<BlockIdExt>> promise);
void download_archive(BlockSeqno masterchain_seqno, std::string tmp_dir, td::Timestamp timeout,
td::Promise<std::string> promise);
void download_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard, block::ImportedMsgQueueLimits limits,
td::Timestamp timeout, td::Promise<td::Ref<OutMsgQueueProof>> promise);
void download_out_msg_queue_proof(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise);
void got_key_block_proof(td::Ref<ProofLink> proof);
void got_zero_block_state(td::Ref<ShardState> state);

3
validator/impl/collator-impl.h
View file

@ -233,7 +233,8 @@ class Collator final : public td::actor::Actor {
void after_get_aux_shard_state(ton::BlockIdExt blkid, td::Result<Ref<ShardState>> res);
bool fix_one_processed_upto(block::MsgProcessedUpto& proc, const ton::ShardIdFull& owner);
bool fix_processed_upto(block::MsgProcessedUptoCollection& upto);
void got_neighbor_msg_queue(unsigned i, td::Result<Ref<OutMsgQueueProof>> R);
void got_neighbor_msg_queues(td::Result<std::map<BlockIdExt, Ref<OutMsgQueueProof>>> R);
void got_neighbor_msg_queue(unsigned i, Ref<OutMsgQueueProof> res);
bool adjust_shard_config();
bool store_shard_fees(ShardIdFull shard, const block::CurrencyCollection& fees,
const block::CurrencyCollection& created);

38
validator/impl/collator.cpp
View file

@ -632,27 +632,45 @@ bool Collator::request_neighbor_msg_queues() {
}
neighbors_.emplace_back(*shard_ptr);
}
std::vector<BlockIdExt> top_blocks;
unsigned i = 0;
for (block::McShardDescr& descr : neighbors_) {
LOG(DEBUG) << "neighbor #" << i << " : " << descr.blk_.to_str();
++pending;
send_closure_later(manager, &ValidatorManager::wait_out_msg_queue_proof, descr.blk_, shard_, priority(), timeout,
[self = get_self(), i](td::Result<Ref<OutMsgQueueProof>> res) {
LOG(DEBUG) << "got msg queue for neighbor #" << i;
send_closure_later(std::move(self), &Collator::got_neighbor_msg_queue, i, std::move(res));
});
top_blocks.push_back(descr.blk_);
++i;
}
++pending;
td::actor::send_closure_later(
manager, &ValidatorManager::wait_neighbor_msg_queue_proofs, shard_, std::move(top_blocks), timeout,
[self = get_self()](td::Result<std::map<BlockIdExt, Ref<OutMsgQueueProof>>> res) {
td::actor::send_closure_later(std::move(self), &Collator::got_neighbor_msg_queues, std::move(res));
});
return true;
}
void Collator::got_neighbor_msg_queue(unsigned i, td::Result<Ref<OutMsgQueueProof>> R) {
void Collator::got_neighbor_msg_queues(td::Result<std::map<BlockIdExt, Ref<OutMsgQueueProof>>> R) {
--pending;
if (R.is_error()) {
fatal_error(R.move_as_error());
fatal_error(R.move_as_error_prefix("failed to get neighbor msg queues: "));
return;
}
LOG(INFO) << "neighbor output queues fetched";
auto res = R.move_as_ok();
unsigned i = 0;
for (block::McShardDescr& descr : neighbors_) {
LOG(DEBUG) << "neighbor #" << i << " : " << descr.blk_.to_str();
auto it = res.find(descr.blk_);
if (it == res.end()) {
fatal_error(PSTRING() << "no msg queue from neighbor #" << i);
return;
}
got_neighbor_msg_queue(i, it->second);
++i;
}
check_pending();
}
void Collator::got_neighbor_msg_queue(unsigned i, Ref<OutMsgQueueProof> res) {
BlockIdExt block_id = neighbors_.at(i).blk_;
if (res->block_state_proof_.not_null() && !block_id.is_masterchain()) {
block_state_proofs_.emplace(block_id.root_hash, res->block_state_proof_);
@ -732,10 +750,6 @@ void Collator::got_neighbor_msg_queue(unsigned i, td::Result<Ref<OutMsgQueueProo
}
}
} while (false);
if (!pending) {
LOG(INFO) << "all neighbor output queues fetched";
}
check_pending();
}
bool Collator::unpack_merge_last_state() {

493
validator/impl/out-msg-queue-proof.cpp
View file

@ -46,9 +46,9 @@ static td::Status check_no_prunned(const vm::CellSlice& cs) {
return td::Status::OK();
}
static td::Result<td::int32> process_queue(BlockIdExt block_id, ShardIdFull dst_shard,
block::ImportedMsgQueueLimits limits,
const block::gen::OutMsgQueueInfo::Record& qinfo) {
static td::Result<std::vector<td::int32>> process_queue(
ShardIdFull dst_shard, std::vector<std::pair<BlockIdExt, block::gen::OutMsgQueueInfo::Record>> blocks,
block::ImportedMsgQueueLimits limits) {
td::uint64 estimated_proof_size = 0;
td::HashSet<vm::Cell::Hash> visited;
@ -66,14 +66,18 @@ static td::Result<td::int32> process_queue(BlockIdExt block_id, ShardIdFull dst_
dfs(cs.prefetch_ref(i));
}
};
TRY_STATUS_PREFIX(check_no_prunned(*qinfo.proc_info), "invalid proc_info proof: ")
TRY_STATUS_PREFIX(check_no_prunned(*qinfo.ihr_pending), "invalid ihr_pending proof: ")
dfs_cs(*qinfo.proc_info);
dfs_cs(*qinfo.ihr_pending);
std::vector<block::OutputQueueMerger::Neighbor> neighbors;
for (auto& b : blocks) {
TRY_STATUS_PREFIX(check_no_prunned(*b.second.proc_info), "invalid proc_info proof: ")
TRY_STATUS_PREFIX(check_no_prunned(*b.second.ihr_pending), "invalid ihr_pending proof: ")
dfs_cs(*b.second.proc_info);
dfs_cs(*b.second.ihr_pending);
neighbors.emplace_back(b.first, b.second.out_queue->prefetch_ref());
}
block::OutputQueueMerger queue_merger{
dst_shard, {block::OutputQueueMerger::Neighbor{block_id, qinfo.out_queue->prefetch_ref()}}};
td::int32 msg_count = 0;
block::OutputQueueMerger queue_merger{dst_shard, std::move(neighbors)};
std::vector<td::int32> msg_count(blocks.size());
td::int32 msg_count_total = 0;
bool limit_reached = false;
while (!queue_merger.is_eof()) {
@ -87,7 +91,8 @@ static td::Result<td::int32> process_queue(BlockIdExt block_id, ShardIdFull dst_
if (limit_reached) {
break;
}
++msg_count;
++msg_count[kv->source];
++msg_count_total;
// TODO: Get processed_upto from destination shard (in request?)
/*
@ -114,234 +119,410 @@ static td::Result<td::int32> process_queue(BlockIdExt block_id, ShardIdFull dst_
dfs_cs(*kv->msg);
TRY_STATUS_PREFIX(check_no_prunned(*kv->msg), "invalid message proof: ")
if (estimated_proof_size >= limits.max_bytes || msg_count >= (long long)limits.max_msgs) {
if (estimated_proof_size >= limits.max_bytes || msg_count_total >= (long long)limits.max_msgs) {
limit_reached = true;
}
}
return limit_reached ? msg_count : -1;
if (!limit_reached) {
std::fill(msg_count.begin(), msg_count.end(), -1);
}
return msg_count;
}
td::Result<tl_object_ptr<ton_api::tonNode_outMsgQueueProof>> OutMsgQueueProof::build(
BlockIdExt block_id, ShardIdFull dst_shard,
block::ImportedMsgQueueLimits limits, Ref<vm::Cell> state_root, Ref<vm::Cell> block_root) {
ShardIdFull dst_shard, std::vector<OneBlock> blocks, block::ImportedMsgQueueLimits limits) {
if (!dst_shard.is_valid_ext()) {
return td::Status::Error("invalid shard");
}
if (blocks.empty()) {
return create_tl_object<ton_api::tonNode_outMsgQueueProof>(td::BufferSlice{}, td::BufferSlice{},
std::vector<td::int32>{});
}
vm::MerkleProofBuilder mpb{std::move(state_root)};
TRY_RESULT(state, ShardStateQ::fetch(block_id, {}, mpb.root()));
std::vector<td::Ref<vm::Cell>> block_state_proofs;
for (auto& block : blocks) {
if (block.id.seqno() != 0) {
if (block.block_root.is_null()) {
return td::Status::Error("block is null");
}
TRY_RESULT(proof, create_block_state_proof(block.block_root));
block_state_proofs.push_back(std::move(proof));
}
if (!block::ShardConfig::is_neighbor(dst_shard, block.id.shard_full())) {
return td::Status::Error("shards are not neighbors");
}
}
TRY_RESULT(block_state_proof, vm::std_boc_serialize_multi(block_state_proofs));
vm::Dictionary states_dict_pure{32};
for (size_t i = 0; i < blocks.size(); ++i) {
if (blocks[i].state_root.is_null()) {
return td::Status::Error("state is null");
}
states_dict_pure.set_ref(td::BitArray<32>{(long long)i}, blocks[i].state_root);
}
vm::MerkleProofBuilder mpb{states_dict_pure.get_root_cell()};
vm::Dictionary states_dict{mpb.root(), 32};
std::vector<std::pair<BlockIdExt, block::gen::OutMsgQueueInfo::Record>> data(blocks.size());
for (size_t i = 0; i < blocks.size(); ++i) {
data[i].first = blocks[i].id;
TRY_RESULT(state, ShardStateQ::fetch(blocks[i].id, {}, states_dict.lookup_ref(td::BitArray<32>{(long long)i})));
TRY_RESULT(outq_descr, state->message_queue());
block::gen::OutMsgQueueInfo::Record qinfo;
if (!tlb::unpack_cell(outq_descr->root_cell(), qinfo)) {
if (!tlb::unpack_cell(outq_descr->root_cell(), data[i].second)) {
return td::Status::Error("invalid message queue");
}
TRY_RESULT(cnt, process_queue(block_id, dst_shard, limits, qinfo));
TRY_RESULT(queue_proof, mpb.extract_proof_boc());
td::BufferSlice block_state_proof;
if (block_id.seqno() != 0) {
TRY_RESULT(proof, create_block_state_proof(std::move(block_root)));
TRY_RESULT_ASSIGN(block_state_proof, vm::std_boc_serialize(std::move(proof), 31));
}
TRY_RESULT(msg_count, process_queue(dst_shard, std::move(data), limits));
TRY_RESULT(proof, mpb.extract_proof());
vm::Dictionary states_dict_proof{vm::CellSlice{vm::NoVm(), proof}.prefetch_ref(), 32};
std::vector<td::Ref<vm::Cell>> state_proofs;
for (size_t i = 0; i < blocks.size(); ++i) {
td::Ref<vm::Cell> proof_raw = states_dict_proof.lookup_ref(td::BitArray<32>{(long long)i});
CHECK(proof_raw.not_null());
state_proofs.push_back(vm::CellBuilder::create_merkle_proof(proof_raw));
}
TRY_RESULT(queue_proof, vm::std_boc_serialize_multi(state_proofs));
return create_tl_object<ton_api::tonNode_outMsgQueueProof>(std::move(queue_proof), std::move(block_state_proof),
cnt);
std::move(msg_count));
}
td::Result<td::Ref<OutMsgQueueProof>> OutMsgQueueProof::fetch(BlockIdExt block_id, ShardIdFull dst_shard,
td::Result<std::vector<td::Ref<OutMsgQueueProof>>> OutMsgQueueProof::fetch(ShardIdFull dst_shard,
std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits,
const ton_api::tonNode_outMsgQueueProof& f) {
try {
Ref<vm::Cell> block_state_proof;
std::vector<td::Ref<OutMsgQueueProof>> res;
TRY_RESULT(queue_proofs, vm::std_boc_deserialize_multi(f.queue_proofs_, (int)blocks.size()));
TRY_RESULT(block_state_proofs, vm::std_boc_deserialize_multi(f.block_state_proofs_, (int)blocks.size()));
if (queue_proofs.size() != blocks.size()) {
return td::Status::Error("invalid size of queue_proofs");
}
if (f.msg_counts_.size() != blocks.size()) {
return td::Status::Error("invalid size of msg_counts");
}
size_t j = 0;
std::vector<std::pair<BlockIdExt, block::gen::OutMsgQueueInfo::Record>> data(blocks.size());
for (size_t i = 0; i < blocks.size(); ++i) {
td::Bits256 state_root_hash;
if (block_id.seqno() == 0) {
if (!f.block_state_proof_.empty()) {
return td::Status::Error("expected empty block state proof");
}
state_root_hash = block_id.root_hash;
Ref<vm::Cell> block_state_proof = {};
if (blocks[i].seqno() == 0) {
state_root_hash = blocks[i].root_hash;
} else {
TRY_RESULT_ASSIGN(block_state_proof, vm::std_boc_deserialize(f.block_state_proof_.as_slice()));
TRY_RESULT_ASSIGN(state_root_hash, unpack_block_state_proof(block_id, block_state_proof));
if (j == block_state_proofs.size()) {
return td::Status::Error("invalid size of block_state_proofs");
}
TRY_RESULT(queue_proof, vm::std_boc_deserialize(f.queue_proof_.as_slice()));
auto virtual_root = vm::MerkleProof::virtualize(queue_proof, 1);
if (virtual_root.is_null()) {
return td::Status::Error("invalid queue proof");
block_state_proof = block_state_proofs[j++];
TRY_RESULT_ASSIGN(state_root_hash, unpack_block_state_proof(blocks[i], block_state_proof));
}
if (virtual_root->get_hash().as_slice() != state_root_hash.as_slice()) {
auto state_root = vm::MerkleProof::virtualize(queue_proofs[i], 1);
if (state_root->get_hash().as_slice() != state_root_hash.as_slice()) {
return td::Status::Error("state root hash mismatch");
}
res.emplace_back(true, blocks[i], state_root, block_state_proof, f.msg_counts_[i]);
// Validate proof
TRY_RESULT_PREFIX(state, ShardStateQ::fetch(block_id, {}, virtual_root), "invalid proof: ");
TRY_RESULT_PREFIX(outq_descr, state->message_queue(), "invalid proof: ");
data[i].first = blocks[i];
TRY_RESULT(state, ShardStateQ::fetch(blocks[i], {}, state_root));
TRY_RESULT(outq_descr, state->message_queue());
block::gen::OutMsgQueueInfo::Record qinfo;
if (!tlb::unpack_cell(outq_descr->root_cell(), qinfo)) {
return td::Status::Error("invalid proof: invalid message queue");
if (!tlb::unpack_cell(outq_descr->root_cell(), data[i].second)) {
return td::Status::Error("invalid message queue");
}
TRY_STATUS_PREFIX(check_no_prunned(qinfo.proc_info->prefetch_ref(0)), "invalid proc_info: ")
TRY_STATUS_PREFIX(check_no_prunned(qinfo.ihr_pending->prefetch_ref(0)), "invalid ihr_pending: ")
TRY_RESULT(cnt, process_queue(block_id, dst_shard, limits, qinfo));
if (cnt != f.msg_count_) {
return td::Status::Error(PSTRING() << "invalid msg_count: expected=" << f.msg_count_ << ", found=" << cnt);
}
return Ref<OutMsgQueueProof>(true, std::move(virtual_root), std::move(block_state_proof), cnt);
if (j != block_state_proofs.size()) {
return td::Status::Error("invalid size of block_state_proofs");
}
TRY_RESULT(msg_count, process_queue(dst_shard, std::move(data), limits));
if (msg_count != f.msg_counts_) {
return td::Status::Error("incorrect msg_count");
}
return res;
} catch (vm::VmVirtError& err) {
return td::Status::Error(PSTRING() << "invalid proof: " << err.get_msg());
}
}
void WaitOutMsgQueueProof::alarm() {
abort_query(td::Status::Error(ErrorCode::timeout, "timeout"));
}
void WaitOutMsgQueueProof::abort_query(td::Status reason) {
if (promise_) {
LOG(DEBUG) << "aborting wait msg queue query for " << block_id_.to_str() << " priority=" << priority_ << ": "
<< reason;
promise_.set_error(
reason.move_as_error_prefix(PSTRING() << "failed to get msg queue for " << block_id_.to_str() << ": "));
}
stop();
}
void WaitOutMsgQueueProof::finish_query(Ref<OutMsgQueueProof> result) {
promise_.set_result(std::move(result));
stop();
}
void WaitOutMsgQueueProof::start_up() {
alarm_timestamp() = timeout_;
if (local_) {
run_local();
} else {
run_net();
}
}
void WaitOutMsgQueueProof::run_local() {
++pending;
td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, block_id_, priority_, timeout_,
[SelfId = actor_id(this)](td::Result<Ref<ShardState>> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &WaitOutMsgQueueProof::abort_query,
R.move_as_error_prefix("failed to get shard state: "));
} else {
td::actor::send_closure(SelfId, &WaitOutMsgQueueProof::got_state_root,
R.move_as_ok()->root_cell());
}
});
if (block_id_.seqno() != 0) {
++pending;
td::actor::send_closure(manager_, &ValidatorManager::wait_block_data_short, block_id_, priority_, timeout_,
[SelfId = actor_id(this)](td::Result<Ref<BlockData>> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &WaitOutMsgQueueProof::abort_query,
R.move_as_error_prefix("failed to get block data: "));
} else {
td::actor::send_closure(SelfId, &WaitOutMsgQueueProof::got_block_root,
R.move_as_ok()->root_cell());
}
});
}
}
void WaitOutMsgQueueProof::got_state_root(Ref<vm::Cell> root) {
state_root_ = std::move(root);
if (--pending == 0) {
run_local_cont();
}
}
void WaitOutMsgQueueProof::got_block_root(Ref<vm::Cell> root) {
block_root_ = std::move(root);
if (--pending == 0) {
run_local_cont();
}
}
void WaitOutMsgQueueProof::run_local_cont() {
Ref<vm::Cell> block_state_proof;
if (block_id_.seqno() != 0) {
auto R = create_block_state_proof(std::move(block_root_));
if (R.is_error()) {
abort_query(R.move_as_error_prefix("failed to create block state proof"));
void OutMsgQueueImporter::new_masterchain_block_notification(td::Ref<MasterchainState> state,
std::set<ShardIdFull> collating_shards) {
last_masterchain_state_ = state;
if (collating_shards.empty() || state->get_unix_time() < (td::uint32)td::Clocks::system() - 20) {
return;
}
block_state_proof = R.move_as_ok();
auto can_collate_shard = [&](const ShardIdFull& shard) -> bool {
return std::any_of(collating_shards.begin(), collating_shards.end(),
[&](ShardIdFull our_shard) { return shard_intersects(shard, our_shard); });
};
auto shards = state->get_shards();
auto process_dst_shard = [&](const ShardIdFull& dst_shard) {
if (!can_collate_shard(dst_shard)) {
return;
}
finish_query(td::Ref<OutMsgQueueProof>(true, std::move(state_root_), std::move(block_state_proof)));
std::vector<BlockIdExt> top_blocks;
for (const auto& shard : shards) {
if (block::ShardConfig::is_neighbor(dst_shard, shard->shard())) {
top_blocks.push_back(shard->top_block_id());
}
void WaitOutMsgQueueProof::run_net() {
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), block_id = block_id_,
retry_after = td::Timestamp::in(0.5)](td::Result<Ref<OutMsgQueueProof>> R) {
if (R.is_error()) {
LOG(DEBUG) << "failed to get msg queue for " << block_id.to_str() << " from net: " << R.move_as_error();
delay_action([SelfId]() mutable { td::actor::send_closure(SelfId, &WaitOutMsgQueueProof::run_net); },
retry_after);
}
get_neighbor_msg_queue_proofs(dst_shard, std::move(top_blocks), td::Timestamp::in(15.0),
[](td::Result<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>>) {});
};
for (const auto& shard : shards) {
if (shard->before_merge()) {
if (is_left_child(shard->shard())) {
process_dst_shard(shard_parent(shard->shard()));
}
} else if (shard->before_split()) {
process_dst_shard(shard_child(shard->shard(), true));
process_dst_shard(shard_child(shard->shard(), false));
} else {
td::actor::send_closure(SelfId, &WaitOutMsgQueueProof::finish_query, R.move_as_ok());
process_dst_shard(shard->shard());
}
}
}
});
td::actor::send_closure(manager_, &ValidatorManager::send_get_out_msg_queue_proof_request, block_id_, dst_shard_,
limits_, priority_, std::move(P));
void OutMsgQueueImporter::get_neighbor_msg_queue_proofs(
ShardIdFull dst_shard, std::vector<BlockIdExt> blocks, td::Timestamp timeout,
td::Promise<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>> promise) {
std::sort(blocks.begin(), blocks.end());
auto entry = cache_[{dst_shard, blocks}];
if (entry) {
if (entry->done) {
promise.set_result(entry->result);
alarm_timestamp().relax(entry->timeout = td::Timestamp::in(CACHE_TTL));
} else {
entry->timeout = std::max(entry->timeout, timeout);
entry->promises.emplace_back(std::move(promise), timeout);
alarm_timestamp().relax(timeout);
}
return;
}
LOG(DEBUG) << "Importing neighbor msg queues for shard " << dst_shard.to_str() << ", " << blocks.size() << " blocks";
cache_[{dst_shard, blocks}] = entry = std::make_shared<CacheEntry>();
entry->dst_shard = dst_shard;
entry->blocks = blocks;
entry->promises.emplace_back(std::move(promise), timeout);
alarm_timestamp().relax(entry->timeout = timeout);
std::map<ShardIdFull, std::vector<BlockIdExt>> new_queries;
for (const BlockIdExt& block : blocks) {
if (opts_->need_monitor(block.shard_full(), last_masterchain_state_)) {
++entry->pending;
get_proof_local(entry, block);
} else {
ShardIdFull prefix = block.shard_full();
int min_split = last_masterchain_state_->monitor_min_split_depth(prefix.workchain);
if (prefix.pfx_len() > min_split) {
prefix = shard_prefix(prefix, min_split);
}
new_queries[prefix].push_back(block);
}
};
auto limits = last_masterchain_state_->get_imported_msg_queue_limits(dst_shard.workchain);
for (auto& p : new_queries) {
++entry->pending;
get_proof_import(entry, std::move(p.second), limits);
}
if (entry->pending == 0) {
finish_query(entry);
}
}
void OutMsgQueueImporter::get_proof_local(std::shared_ptr<CacheEntry> entry, BlockIdExt block) {
if (!check_timeout(entry)) {
return;
}
td::actor::send_closure(
manager_, &ValidatorManager::wait_block_state_short, block, 0, entry->timeout,
[=, SelfId = actor_id(this), manager = manager_, timeout = entry->timeout,
retry_after = td::Timestamp::in(0.5)](td::Result<Ref<ShardState>> R) mutable {
if (R.is_error()) {
LOG(DEBUG) << "Failed to get block state for " << block.to_str() << ": " << R.move_as_error();
delay_action([=]() { td::actor::send_closure(SelfId, &OutMsgQueueImporter::get_proof_local, entry, block); },
retry_after);
return;
}
auto state = R.move_as_ok();
if (block.seqno() == 0) {
std::vector<td::Ref<OutMsgQueueProof>> proof = {
td::Ref<OutMsgQueueProof>(true, block, state->root_cell(), td::Ref<vm::Cell>{})};
td::actor::send_closure(SelfId, &OutMsgQueueImporter::got_proof, entry, std::move(proof));
return;
}
td::actor::send_closure(
manager, &ValidatorManager::wait_block_data_short, block, 0, timeout,
[=](td::Result<Ref<BlockData>> R) mutable {
if (R.is_error()) {
LOG(DEBUG) << "Failed to get block data for " << block.to_str() << ": " << R.move_as_error();
delay_action(
[=]() { td::actor::send_closure(SelfId, &OutMsgQueueImporter::get_proof_local, entry, block); },
retry_after);
return;
}
Ref<vm::Cell> block_state_proof = create_block_state_proof(R.ok()->root_cell()).move_as_ok();
std::vector<td::Ref<OutMsgQueueProof>> proof = {
td::Ref<OutMsgQueueProof>(true, block, state->root_cell(), std::move(block_state_proof))};
td::actor::send_closure(SelfId, &OutMsgQueueImporter::got_proof, entry, std::move(proof));
});
});
}
void OutMsgQueueImporter::get_proof_import(std::shared_ptr<CacheEntry> entry, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits) {
if (!check_timeout(entry)) {
return;
}
td::actor::send_closure(
manager_, &ValidatorManager::send_get_out_msg_queue_proof_request, entry->dst_shard, blocks, limits,
[=, SelfId = actor_id(this), retry_after = td::Timestamp::in(0.5),
dst_shard = entry->dst_shard](td::Result<std::vector<td::Ref<OutMsgQueueProof>>> R) {
if (R.is_error()) {
LOG(DEBUG) << "Failed to get out msg queue for " << dst_shard.to_str() << ": " << R.move_as_error();
delay_action(
[=]() {
td::actor::send_closure(SelfId, &OutMsgQueueImporter::get_proof_import, entry, std::move(blocks),
limits);
},
retry_after);
return;
}
td::actor::send_closure(SelfId, &OutMsgQueueImporter::got_proof, entry, R.move_as_ok());
});
}
void OutMsgQueueImporter::got_proof(std::shared_ptr<CacheEntry> entry, std::vector<td::Ref<OutMsgQueueProof>> proofs) {
if (!check_timeout(entry)) {
return;
}
for (auto& p : proofs) {
entry->result[p->block_id_] = std::move(p);
}
CHECK(entry->pending > 0);
if (--entry->pending == 0) {
finish_query(entry);
}
}
void OutMsgQueueImporter::finish_query(std::shared_ptr<CacheEntry> entry) {
LOG(DEBUG) << "Done importing neighbor msg queues for shard " << entry->dst_shard.to_str() << ", "
<< entry->blocks.size() << " blocks in " << entry->timer.elapsed() << "s";
entry->done = true;
alarm_timestamp().relax(entry->timeout = td::Timestamp::in(CACHE_TTL));
for (auto& p : entry->promises) {
p.first.set_result(entry->result);
}
entry->promises.clear();
}
bool OutMsgQueueImporter::check_timeout(std::shared_ptr<CacheEntry> entry) {
if (entry->timeout.is_in_past()) {
LOG(DEBUG) << "Aborting importing neighbor msg queues for shard " << entry->dst_shard.to_str() << ", "
<< entry->blocks.size() << " blocks: timeout";
for (auto& p : entry->promises) {
p.first.set_error(td::Status::Error(ErrorCode::timeout, "timeout"));
}
entry->promises.clear();
auto it = cache_.find({entry->dst_shard, entry->blocks});
if (it != cache_.end() && it->second == entry) {
cache_.erase(it);
}
return false;
}
return true;
}
void OutMsgQueueImporter::alarm() {
auto it = cache_.begin();
while (it != cache_.end()) {
auto& promises = it->second->promises;
if (it->second->timeout.is_in_past()) {
if (!it->second->done) {
LOG(DEBUG) << "Aborting importing neighbor msg queues for shard " << it->second->dst_shard.to_str() << ", "
<< it->second->blocks.size() << " blocks: timeout";
for (auto& p : promises) {
p.first.set_error(td::Status::Error(ErrorCode::timeout, "timeout"));
}
promises.clear();
}
it = cache_.erase(it);
continue;
}
alarm_timestamp().relax(it->second->timeout);
size_t j = 0;
for (auto& p : promises) {
if (p.second.is_in_past()) {
p.first.set_error(td::Status::Error(ErrorCode::timeout, "timeout"));
} else {
alarm_timestamp().relax(p.second);
promises[j++] = std::move(p);
}
}
promises.resize(j);
++it;
}
}
void BuildOutMsgQueueProof::abort_query(td::Status reason) {
if (promise_) {
LOG(DEBUG) << "failed to build msg queue proof for " << block_id_.to_str() << ": " << reason;
LOG(DEBUG) << "failed to build msg queue proof to " << dst_shard_.to_str() << ": " << reason;
promise_.set_error(
reason.move_as_error_prefix(PSTRING() << "failed to build msg queue proof for " << block_id_.to_str() << ": "));
reason.move_as_error_prefix(PSTRING() << "failed to build msg queue proof to " << dst_shard_.to_str() << ": "));
}
stop();
}
void BuildOutMsgQueueProof::start_up() {
for (size_t i = 0; i < blocks_.size(); ++i) {
BlockIdExt id = blocks_[i].id;
++pending;
td::actor::send_closure(manager_, &ValidatorManagerInterface::get_shard_state_from_db_short, block_id_,
[SelfId = actor_id(this)](td::Result<Ref<ShardState>> R) {
td::actor::send_closure(manager_, &ValidatorManagerInterface::get_shard_state_from_db_short, id,
[SelfId = actor_id(this), i](td::Result<Ref<ShardState>> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &BuildOutMsgQueueProof::abort_query,
R.move_as_error_prefix("failed to get shard state: "));
} else {
td::actor::send_closure(SelfId, &BuildOutMsgQueueProof::got_state_root,
td::actor::send_closure(SelfId, &BuildOutMsgQueueProof::got_state_root, i,
R.move_as_ok()->root_cell());
}
});
if (block_id_.seqno() != 0) {
if (id.seqno() != 0) {
++pending;
td::actor::send_closure(manager_, &ValidatorManagerInterface::get_block_data_from_db_short, block_id_,
[SelfId = actor_id(this)](td::Result<Ref<BlockData>> R) {
td::actor::send_closure(manager_, &ValidatorManagerInterface::get_block_data_from_db_short, id,
[SelfId = actor_id(this), i](td::Result<Ref<BlockData>> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &BuildOutMsgQueueProof::abort_query,
R.move_as_error_prefix("failed to get block data: "));
} else {
td::actor::send_closure(SelfId, &BuildOutMsgQueueProof::got_block_root,
td::actor::send_closure(SelfId, &BuildOutMsgQueueProof::got_block_root, i,
R.move_as_ok()->root_cell());
}
});
}
}
if (pending == 0) {
build_proof();
}
}
void BuildOutMsgQueueProof::got_state_root(Ref<vm::Cell> root) {
state_root_ = std::move(root);
void BuildOutMsgQueueProof::got_state_root(size_t i, Ref<vm::Cell> root) {
blocks_[i].state_root = std::move(root);
if (--pending == 0) {
build_proof();
}
}
void BuildOutMsgQueueProof::got_block_root(Ref<vm::Cell> root) {
block_root_ = std::move(root);
void BuildOutMsgQueueProof::got_block_root(size_t i, Ref<vm::Cell> root) {
blocks_[i].block_root = std::move(root);
if (--pending == 0) {
build_proof();
}
}
void BuildOutMsgQueueProof::build_proof() {
auto result = OutMsgQueueProof::build(block_id_, dst_shard_, limits_, std::move(state_root_), std::move(block_root_));
auto result = OutMsgQueueProof::build(dst_shard_, std::move(blocks_), limits_);
if (result.is_error()) {
LOG(ERROR) << "Failed to build msg queue proof: " << result.error();
}

92
validator/impl/out-msg-queue-proof.hpp
View file

@ -20,6 +20,8 @@
#include "auto/tl/ton_api.h"
#include "interfaces/out-msg-queue-proof.h"
#include "td/actor/actor.h"
#include "interfaces/shard.h"
#include "validator.h"
namespace ton {
@ -29,83 +31,77 @@ using td::Ref;
class ValidatorManager;
class ValidatorManagerInterface;
class WaitOutMsgQueueProof : public td::actor::Actor {
class OutMsgQueueImporter : public td::actor::Actor {
public:
WaitOutMsgQueueProof(BlockIdExt block_id, ShardIdFull dst_shard, block::ImportedMsgQueueLimits limits, bool local,
td::uint32 priority, td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
td::Promise<Ref<OutMsgQueueProof>> promise)
: block_id_(std::move(block_id))
, dst_shard_(dst_shard)
, limits_(limits)
, local_(local)
, priority_(priority)
, manager_(manager)
, timeout_(timeout)
, promise_(std::move(promise)) {
OutMsgQueueImporter(td::actor::ActorId<ValidatorManager> manager, td::Ref<ValidatorManagerOptions> opts,
td::Ref<MasterchainState> last_masterchain_state)
: manager_(manager), opts_(opts), last_masterchain_state_(last_masterchain_state) {
}
void update_timeout(td::Timestamp timeout, td::uint32 priority) {
timeout_ = timeout;
alarm_timestamp() = timeout_;
priority_ = priority;
void new_masterchain_block_notification(td::Ref<MasterchainState> state, std::set<ShardIdFull> collating_shards);
void get_neighbor_msg_queue_proofs(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks, td::Timestamp timeout,
td::Promise<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>> promise);
void update_options(td::Ref<ValidatorManagerOptions> opts) {
opts_ = std::move(opts);
}
void abort_query(td::Status reason);
void finish_query(Ref<OutMsgQueueProof> result);
void alarm() override;
void start_up() override;
void run_local();
void got_state_root(Ref<vm::Cell> root);
void got_block_root(Ref<vm::Cell> root);
void run_local_cont();
void run_net();
private:
BlockIdExt block_id_;
ShardIdFull dst_shard_;
block::ImportedMsgQueueLimits limits_;
bool local_;
td::uint32 priority_;
td::actor::ActorId<ValidatorManager> manager_;
td::Timestamp timeout_;
td::Promise<Ref<OutMsgQueueProof>> promise_;
td::Ref<ValidatorManagerOptions> opts_;
td::Ref<MasterchainState> last_masterchain_state_;
Ref<vm::Cell> state_root_, block_root_;
unsigned pending = 0;
struct CacheEntry {
ShardIdFull dst_shard;
std::vector<BlockIdExt> blocks;
bool done = false;
std::map<BlockIdExt, td::Ref<OutMsgQueueProof>> result;
std::vector<std::pair<td::Promise<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>>, td::Timestamp>> promises;
td::Timestamp timeout = td::Timestamp::never();
td::Timer timer;
size_t pending = 0;
};
std::map<std::pair<ShardIdFull, std::vector<BlockIdExt>>, std::shared_ptr<CacheEntry>> cache_;
void get_proof_local(std::shared_ptr<CacheEntry> entry, BlockIdExt block);
void get_proof_import(std::shared_ptr<CacheEntry> entry, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits);
void got_proof(std::shared_ptr<CacheEntry> entry, std::vector<td::Ref<OutMsgQueueProof>> proofs);
void finish_query(std::shared_ptr<CacheEntry> entry);
bool check_timeout(std::shared_ptr<CacheEntry> entry);
constexpr static const double CACHE_TTL = 30.0;
};
class BuildOutMsgQueueProof : public td::actor::Actor {
public:
BuildOutMsgQueueProof(BlockIdExt block_id, ShardIdFull dst_shard, block::ImportedMsgQueueLimits limits,
BuildOutMsgQueueProof(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks, block::ImportedMsgQueueLimits limits,
td::actor::ActorId<ValidatorManagerInterface> manager,
td::Promise<tl_object_ptr<ton_api::tonNode_outMsgQueueProof>> promise)
: block_id_(std::move(block_id))
, dst_shard_(dst_shard)
, limits_(limits)
, manager_(manager)
, promise_(std::move(promise)) {
: dst_shard_(dst_shard), limits_(limits), manager_(manager), promise_(std::move(promise)) {
blocks_.resize(blocks.size());
for (size_t i = 0; i < blocks_.size(); ++i) {
blocks_[i].id = blocks[i];
}
}
void abort_query(td::Status reason);
void start_up() override;
void got_state_root(Ref<vm::Cell> root);
void got_block_root(Ref<vm::Cell> root);
void got_state_root(size_t i, Ref<vm::Cell> root);
void got_block_root(size_t i, Ref<vm::Cell> root);
void build_proof();
private:
BlockIdExt block_id_;
ShardIdFull dst_shard_;
std::vector<OutMsgQueueProof::OneBlock> blocks_;
block::ImportedMsgQueueLimits limits_;
td::actor::ActorId<ValidatorManagerInterface> manager_;
td::Promise<tl_object_ptr<ton_api::tonNode_outMsgQueueProof>> promise_;
Ref<vm::Cell> state_root_, block_root_;
unsigned pending = 0;
size_t pending = 0;
};
} // namespace validator

25
validator/interfaces/out-msg-queue-proof.h
View file

@ -26,22 +26,31 @@ namespace validator {
using td::Ref;
struct OutMsgQueueProof : public td::CntObject {
OutMsgQueueProof(Ref<vm::Cell> state_root, Ref<vm::Cell> block_state_proof, td::int32 msg_count = -1)
: state_root_(std::move(state_root)), block_state_proof_(std::move(block_state_proof)), msg_count_(msg_count) {
OutMsgQueueProof(BlockIdExt block_id, Ref<vm::Cell> state_root, Ref<vm::Cell> block_state_proof,
td::int32 msg_count = -1)
: block_id_(block_id)
, state_root_(std::move(state_root))
, block_state_proof_(std::move(block_state_proof))
, msg_count_(msg_count) {
}
BlockIdExt block_id_;
Ref<vm::Cell> state_root_;
Ref<vm::Cell> block_state_proof_;
td::int32 msg_count_; // -1 - up to end of queue
td::int32 msg_count_; // -1 - no limit
static td::Result<td::Ref<OutMsgQueueProof>> fetch(BlockIdExt block_id, ShardIdFull dst_shard,
static td::Result<std::vector<td::Ref<OutMsgQueueProof>>> fetch(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits,
const ton_api::tonNode_outMsgQueueProof &f);
static td::Result<tl_object_ptr<ton_api::tonNode_outMsgQueueProof>> build(BlockIdExt block_id, ShardIdFull dst_shard,
block::ImportedMsgQueueLimits limits,
Ref<vm::Cell> state_root,
Ref<vm::Cell> block_root);
struct OneBlock {
BlockIdExt id;
Ref<vm::Cell> state_root;
Ref<vm::Cell> block_root;
};
static td::Result<tl_object_ptr<ton_api::tonNode_outMsgQueueProof>> build(ShardIdFull dst_shard,
std::vector<OneBlock> blocks,
block::ImportedMsgQueueLimits limits);
};
} // namespace validator

6
validator/interfaces/validator-manager.h
View file

@ -129,9 +129,9 @@ class ValidatorManager : public ValidatorManagerInterface {
virtual void send_ihr_message(td::Ref<IhrMessage> message) = 0;
virtual void send_top_shard_block_description(td::Ref<ShardTopBlockDescription> desc) = 0;
virtual void send_block_broadcast(BlockBroadcast broadcast) = 0;
virtual void send_get_out_msg_queue_proof_request(BlockIdExt id, ShardIdFull dst_shard,
block::ImportedMsgQueueLimits limits, td::uint32 priority,
td::Promise<td::Ref<OutMsgQueueProof>> promise) = 0;
virtual void send_get_out_msg_queue_proof_request(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits,
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) = 0;
virtual void update_shard_client_state(BlockIdExt masterchain_block_id, td::Promise<td::Unit> promise) = 0;
virtual void get_shard_client_state(bool from_db, td::Promise<BlockIdExt> promise) = 0;

10
validator/manager-disk.hpp
View file

@ -152,8 +152,8 @@ class ValidatorManagerImpl : public ValidatorManager {
td::Promise<td::Ref<ShardState>> promise) override;
void wait_block_state_short(BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
td::Promise<td::Ref<ShardState>> promise) override;
void wait_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard, td::uint32 priority, td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) override {
void wait_neighbor_msg_queue_proofs(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks, td::Timestamp timeout,
td::Promise<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>> promise) override {
UNREACHABLE();
}
@ -255,9 +255,9 @@ class ValidatorManagerImpl : public ValidatorManager {
void send_top_shard_block_description(td::Ref<ShardTopBlockDescription> desc) override;
void send_block_broadcast(BlockBroadcast broadcast) override {
}
void send_get_out_msg_queue_proof_request(BlockIdExt id, ShardIdFull dst_shard, block::ImportedMsgQueueLimits limits,
td::uint32 priority,
td::Promise<td::Ref<OutMsgQueueProof>> promise) override {
void send_get_out_msg_queue_proof_request(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits,
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) override {
UNREACHABLE();
}

10
validator/manager-hardfork.hpp
View file

@ -182,8 +182,8 @@ class ValidatorManagerImpl : public ValidatorManager {
td::Promise<td::Ref<ShardState>> promise) override;
void wait_block_state_short(BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
td::Promise<td::Ref<ShardState>> promise) override;
void wait_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard, td::uint32 priority, td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) override {
void wait_neighbor_msg_queue_proofs(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks, td::Timestamp timeout,
td::Promise<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>> promise) override {
UNREACHABLE();
}
@ -321,9 +321,9 @@ class ValidatorManagerImpl : public ValidatorManager {
}
void send_block_broadcast(BlockBroadcast broadcast) override {
}
void send_get_out_msg_queue_proof_request(BlockIdExt id, ShardIdFull dst_shard, block::ImportedMsgQueueLimits limits,
td::uint32 priority,
td::Promise<td::Ref<OutMsgQueueProof>> promise) override {
void send_get_out_msg_queue_proof_request(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits,
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) override {
UNREACHABLE();
}

123
validator/manager.cpp
View file

@ -618,33 +618,15 @@ void ValidatorManagerImpl::wait_block_state_short(BlockIdExt block_id, td::uint3
get_block_handle(block_id, true, std::move(P));
}
void ValidatorManagerImpl::wait_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard, td::uint32 priority,
td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) {
auto key = std::make_pair(block_id, dst_shard);
auto it = wait_out_msg_queue_proof_.find(key);
if (it == wait_out_msg_queue_proof_.end()) {
auto P = td::PromiseCreator::lambda(
[SelfId = actor_id(this), block_id, dst_shard](td::Result<td::Ref<OutMsgQueueProof>> R) {
td::actor::send_closure(SelfId, &ValidatorManagerImpl::finished_wait_msg_queue, block_id, dst_shard,
std::move(R));
});
auto id = td::actor::create_actor<WaitOutMsgQueueProof>(
"waitmsgqueue", block_id, dst_shard,
last_masterchain_state_->get_imported_msg_queue_limits(block_id.is_masterchain()),
need_monitor(block_id.shard_full()), priority, actor_id(this), td::Timestamp::at(timeout.at() + 10.0),
std::move(P))
.release();
wait_out_msg_queue_proof_[key].actor_ = id;
it = wait_out_msg_queue_proof_.find(key);
} else if (it->second.done_) {
promise.set_result(it->second.result_);
it->second.remove_at_ = td::Timestamp::in(30.0);
return;
void ValidatorManagerImpl::wait_neighbor_msg_queue_proofs(
ShardIdFull dst_shard, std::vector<BlockIdExt> blocks, td::Timestamp timeout,
td::Promise<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>> promise) {
if (out_msg_queue_importer_.empty()) {
out_msg_queue_importer_ = td::actor::create_actor<OutMsgQueueImporter>("outmsgqueueimporter", actor_id(this), opts_,
last_masterchain_state_);
}
it->second.waiting_.emplace_back(timeout, priority, std::move(promise));
auto X = it->second.get_timeout();
td::actor::send_closure(it->second.actor_, &WaitOutMsgQueueProof::update_timeout, X.first, X.second);
td::actor::send_closure(out_msg_queue_importer_, &OutMsgQueueImporter::get_neighbor_msg_queue_proofs, dst_shard,
std::move(blocks), timeout, std::move(promise));
}
void ValidatorManagerImpl::wait_block_data(BlockHandle handle, td::uint32 priority, td::Timestamp timeout,
@ -1082,44 +1064,6 @@ void ValidatorManagerImpl::finished_wait_data(BlockHandle handle, td::Result<td:
}
}
void ValidatorManagerImpl::finished_wait_msg_queue(BlockIdExt block_id, ShardIdFull dst_shard,
td::Result<td::Ref<OutMsgQueueProof>> R) {
auto it = wait_out_msg_queue_proof_.find({block_id, dst_shard});
if (it != wait_out_msg_queue_proof_.end()) {
if (R.is_error()) {
auto S = R.move_as_error();
if (S.code() != ErrorCode::timeout) {
for (auto &X : it->second.waiting_) {
X.promise.set_error(S.clone());
}
} else {
auto X = it->second.get_timeout();
auto P = td::PromiseCreator::lambda(
[SelfId = actor_id(this), block_id, dst_shard](td::Result<td::Ref<OutMsgQueueProof>> R) {
td::actor::send_closure(SelfId, &ValidatorManagerImpl::finished_wait_msg_queue, block_id, dst_shard,
std::move(R));
});
auto id = td::actor::create_actor<WaitOutMsgQueueProof>(
"waitmsgqueue", block_id, dst_shard,
last_masterchain_state_->get_imported_msg_queue_limits(block_id.is_masterchain()),
need_monitor(block_id.shard_full()), X.second, actor_id(this), X.first, std::move(P))
.release();
it->second.actor_ = id;
return;
}
wait_out_msg_queue_proof_.erase(it);
} else {
auto r = R.move_as_ok();
for (auto &X : it->second.waiting_) {
X.promise.set_result(r);
}
it->second.done_ = true;
it->second.result_ = std::move(r);
it->second.remove_at_ = td::Timestamp::in(30.0);
}
}
}
void ValidatorManagerImpl::set_block_state(BlockHandle handle, td::Ref<ShardState> state,
td::Promise<td::Ref<ShardState>> promise) {
auto P = td::PromiseCreator::lambda(
@ -1513,11 +1457,11 @@ void ValidatorManagerImpl::send_block_broadcast(BlockBroadcast broadcast) {
callback_->send_broadcast(std::move(broadcast));
}
void ValidatorManagerImpl::send_get_out_msg_queue_proof_request(BlockIdExt id, ShardIdFull dst_shard,
block::ImportedMsgQueueLimits limits,
td::uint32 priority,
td::Promise<td::Ref<OutMsgQueueProof>> promise) {
callback_->download_out_msg_queue_proof(id, dst_shard, limits, td::Timestamp::in(10.0), std::move(promise));
void ValidatorManagerImpl::send_get_out_msg_queue_proof_request(
ShardIdFull dst_shard, std::vector<BlockIdExt> blocks, block::ImportedMsgQueueLimits limits,
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) {
callback_->download_out_msg_queue_proof(dst_shard, std::move(blocks), limits, td::Timestamp::in(10.0),
std::move(promise));
}
void ValidatorManagerImpl::start_up() {
@ -1836,18 +1780,26 @@ void ValidatorManagerImpl::new_masterchain_block() {
td::actor::send_closure(shard_client_, &ShardClient::new_masterchain_block_notification,
last_masterchain_block_handle_, last_masterchain_state_);
}
if (is_collator()) {
std::set<ShardIdFull> collating_shards;
if (validating_masterchain()) {
collating_shards.emplace(masterchainId);
}
for (const auto &collator : collator_nodes_) {
collating_shards.insert(collator.second.shards.begin(), collator.second.shards.end());
}
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));
}
}
for (auto &c : collator_nodes_) {
td::actor::send_closure(c.second.actor, &CollatorNode::new_masterchain_block_notification, last_masterchain_state_);
}
if (opts_->validator_mode() == ValidatorManagerOptions::validator_lite_shards && validating_masterchain() &&
last_masterchain_state_->get_unix_time() > (td::uint32)td::Clocks::system() - 20) {
// Prepare neighboours' queues for collating masterchain
for (const auto &desc : last_masterchain_state_->get_shards()) {
wait_out_msg_queue_proof(desc->top_block_id(), ShardIdFull(masterchainId), 0, td::Timestamp::in(10.0),
[](td::Result<td::Ref<OutMsgQueueProof>>) {});
}
}
if (last_masterchain_seqno_ % 1024 == 0) {
LOG(WARNING) << "applied masterchain block " << last_masterchain_block_id_;
}
@ -2514,18 +2466,6 @@ void ValidatorManagerImpl::alarm() {
}
}
alarm_timestamp().relax(check_shard_clients_);
if (cleanup_wait_caches_at_.is_in_past()) {
auto it = wait_out_msg_queue_proof_.begin();
while (it != wait_out_msg_queue_proof_.end()) {
if (it->second.done_ && it->second.remove_at_.is_in_past()) {
it = wait_out_msg_queue_proof_.erase(it);
} else {
++it;
}
}
cleanup_wait_caches_at_ = td::Timestamp::in(10.0);
}
alarm_timestamp().relax(cleanup_wait_caches_at_);
}
void ValidatorManagerImpl::update_shard_client_state(BlockIdExt masterchain_block_id, td::Promise<td::Unit> promise) {
@ -2809,6 +2749,9 @@ void ValidatorManagerImpl::update_options(td::Ref<ValidatorManagerOptions> opts)
if (!serializer_.empty()) {
td::actor::send_closure(serializer_, &AsyncStateSerializer::update_options, opts);
}
if (!out_msg_queue_importer_.empty()) {
td::actor::send_closure(out_msg_queue_importer_, &OutMsgQueueImporter::update_options, opts);
}
opts_ = std::move(opts);
}

16
validator/manager.hpp
View file

@ -189,15 +189,14 @@ class ValidatorManagerImpl : public ValidatorManager {
};
std::map<BlockIdExt, WaitList<WaitBlockState, td::Ref<ShardState>>> wait_state_;
std::map<BlockIdExt, WaitList<WaitBlockData, td::Ref<BlockData>>> wait_block_data_;
std::map<std::pair<BlockIdExt, ShardIdFull>, WaitListCaching<WaitOutMsgQueueProof, td::Ref<OutMsgQueueProof>>>
wait_out_msg_queue_proof_;
td::Timestamp cleanup_wait_caches_at_ = td::Timestamp::now();
struct WaitBlockHandle {
std::vector<td::Promise<BlockHandle>> waiting_;
};
std::map<BlockIdExt, WaitBlockHandle> wait_block_handle_;
td::actor::ActorOwn<OutMsgQueueImporter> out_msg_queue_importer_;
private:
// HANDLES CACHE
std::map<BlockIdExt, std::weak_ptr<BlockHandleInterface>> handles_;
@ -372,8 +371,8 @@ class ValidatorManagerImpl : public ValidatorManager {
td::Promise<td::Ref<ShardState>> promise) override;
void wait_block_state_short(BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
td::Promise<td::Ref<ShardState>> promise) override;
void wait_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard, td::uint32 priority, td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) override;
void wait_neighbor_msg_queue_proofs(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks, td::Timestamp timeout,
td::Promise<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>> promise) override;
void set_block_data(BlockHandle handle, td::Ref<BlockData> data, td::Promise<td::Unit> promise) override;
void wait_block_data(BlockHandle handle, td::uint32 priority, td::Timestamp,
@ -462,9 +461,9 @@ class ValidatorManagerImpl : public ValidatorManager {
void send_ihr_message(td::Ref<IhrMessage> message) override;
void send_top_shard_block_description(td::Ref<ShardTopBlockDescription> desc) override;
void send_block_broadcast(BlockBroadcast broadcast) override;
void send_get_out_msg_queue_proof_request(BlockIdExt id, ShardIdFull dst_shard, block::ImportedMsgQueueLimits limits,
td::uint32 priority,
td::Promise<td::Ref<OutMsgQueueProof>> promise) override;
void send_get_out_msg_queue_proof_request(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits,
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) override;
void update_shard_client_state(BlockIdExt masterchain_block_id, td::Promise<td::Unit> promise) override;
void get_shard_client_state(bool from_db, td::Promise<BlockIdExt> promise) override;
@ -499,7 +498,6 @@ class ValidatorManagerImpl : public ValidatorManager {
void finished_wait_state(BlockHandle handle, td::Result<td::Ref<ShardState>> R);
void finished_wait_data(BlockHandle handle, td::Result<td::Ref<BlockData>> R);
void finished_wait_msg_queue(BlockIdExt block_id, ShardIdFull dst_shard, td::Result<td::Ref<OutMsgQueueProof>> R);
void start_up() override;
void started(ValidatorManagerInitResult result);

8
validator/validator.h
View file

@ -140,9 +140,9 @@ class ValidatorManagerInterface : public td::actor::Actor {
td::Promise<std::vector<BlockIdExt>> promise) = 0;
virtual void download_archive(BlockSeqno masterchain_seqno, std::string tmp_dir, td::Timestamp timeout,
td::Promise<std::string> promise) = 0;
virtual void download_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard,
virtual void download_out_msg_queue_proof(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
block::ImportedMsgQueueLimits limits, td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) = 0;
td::Promise<std::vector<td::Ref<OutMsgQueueProof>>> promise) = 0;
virtual void new_key_block(BlockHandle handle) = 0;
};
@ -226,9 +226,9 @@ class ValidatorManagerInterface : public td::actor::Actor {
virtual void wait_block_state_short(BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
td::Promise<td::Ref<ShardState>> promise) = 0;
virtual void wait_out_msg_queue_proof(BlockIdExt block_id, ShardIdFull dst_shard, td::uint32 priority,
virtual void wait_neighbor_msg_queue_proofs(ShardIdFull dst_shard, std::vector<BlockIdExt> blocks,
td::Timestamp timeout,
td::Promise<td::Ref<OutMsgQueueProof>> promise) = 0;
td::Promise<std::map<BlockIdExt, td::Ref<OutMsgQueueProof>>> promise) = 0;
virtual void get_archive_id(BlockSeqno masterchain_seqno, td::Promise<td::uint64> promise) = 0;
virtual void get_archive_slice(td::uint64 archive_id, td::uint64 offset, td::uint32 limit,