mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
updated submodules, bugfixes
- added new fift/func code for validator complaint creation - bugfixes in validator - updates in tonlib - new versions of rocksdb/abseil - hardfork support
This commit is contained in:
ton
parent
16a4566091
commit
9f008b129f
129 changed files with 8438 additions and 879 deletions
|
|
@ -32,6 +32,7 @@
|
|||
#include "block/block.h"
|
||||
#include "block/block-parse.h"
|
||||
#include "block/block-auto.h"
|
||||
#include "block/check-proof.h"
|
||||
#include "vm/dict.h"
|
||||
#include "vm/cells/MerkleProof.h"
|
||||
#include "vm/vm.h"
|
||||
|
|
@ -160,10 +161,10 @@ void LiteQuery::start_up() {
|
|||
static_cast<LogicalTime>((q.mode_ & 128) ? (q.after_->lt_) : 0));
|
||||
},
|
||||
[&](lite_api::liteServer_getConfigParams& q) {
|
||||
this->perform_getConfigParams(ton::create_block_id(q.id_), (q.mode_ & 0xfff) | 0x1000, q.param_list_);
|
||||
this->perform_getConfigParams(ton::create_block_id(q.id_), (q.mode_ & 0xffff) | 0x10000, q.param_list_);
|
||||
},
|
||||
[&](lite_api::liteServer_getConfigAll& q) {
|
||||
this->perform_getConfigParams(ton::create_block_id(q.id_), (q.mode_ & 0xfff) | 0x2000);
|
||||
this->perform_getConfigParams(ton::create_block_id(q.id_), (q.mode_ & 0xffff) | 0x20000);
|
||||
},
|
||||
[&](lite_api::liteServer_getBlockProof& q) {
|
||||
this->perform_getBlockProof(ton::create_block_id(q.known_block_),
|
||||
|
|
@ -204,7 +205,7 @@ void LiteQuery::perform_getMasterchainInfo(int mode) {
|
|||
}
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
|
||||
[ Self = actor_id(this), mode ](td::Result<std::pair<Ref<ton::validator::MasterchainState>, BlockIdExt>> res) {
|
||||
[Self = actor_id(this), mode](td::Result<std::pair<Ref<ton::validator::MasterchainState>, BlockIdExt>> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
|
|
@ -242,7 +243,7 @@ void LiteQuery::perform_getBlock(BlockIdExt blkid) {
|
|||
return;
|
||||
}
|
||||
td::actor::send_closure_later(manager_, &ValidatorManager::get_block_data_from_db_short, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<Ref<ton::validator::BlockData>> res) {
|
||||
[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 {
|
||||
|
|
@ -268,7 +269,7 @@ void LiteQuery::perform_getBlockHeader(BlockIdExt blkid, int mode) {
|
|||
return;
|
||||
}
|
||||
td::actor::send_closure_later(manager_, &ValidatorManager::get_block_data_from_db_short, blkid,
|
||||
[ Self = actor_id(this), blkid, mode ](td::Result<Ref<ton::validator::BlockData>> res) {
|
||||
[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 {
|
||||
|
|
@ -383,7 +384,7 @@ void LiteQuery::perform_getState(BlockIdExt blkid) {
|
|||
}
|
||||
if (blkid.id.seqno) {
|
||||
td::actor::send_closure_later(manager_, &ValidatorManager::get_shard_state_from_db_short, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<Ref<ton::validator::ShardState>> res) {
|
||||
[Self = actor_id(this), blkid](td::Result<Ref<ton::validator::ShardState>> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
|
|
@ -393,7 +394,7 @@ void LiteQuery::perform_getState(BlockIdExt blkid) {
|
|||
});
|
||||
} else {
|
||||
td::actor::send_closure_later(manager_, &ValidatorManager::get_zero_state, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<td::BufferSlice> res) {
|
||||
[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 {
|
||||
|
|
@ -452,7 +453,7 @@ bool LiteQuery::request_mc_block_data(BlockIdExt blkid) {
|
|||
++pending_;
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ValidatorManager::get_block_data_from_db_short, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<Ref<BlockData>> res) {
|
||||
[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() + " : "));
|
||||
|
|
@ -478,7 +479,7 @@ bool LiteQuery::request_mc_proof(BlockIdExt blkid, int mode) {
|
|||
++pending_;
|
||||
td::actor::send_closure(
|
||||
manager_, &ValidatorManager::get_key_block_proof, blkid,
|
||||
[ Self = actor_id(this), manager = manager_, blkid, mode ](td::Result<td::BufferSlice> R) {
|
||||
[Self = actor_id(this), manager = manager_, blkid, mode](td::Result<td::BufferSlice> R) {
|
||||
if (R.is_ok()) {
|
||||
auto proof = create_proof(blkid, R.move_as_ok());
|
||||
proof.ensure();
|
||||
|
|
@ -510,7 +511,7 @@ bool LiteQuery::request_mc_block_state(BlockIdExt blkid) {
|
|||
++pending_;
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ValidatorManager::get_shard_state_from_db_short, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<Ref<ShardState>> res) {
|
||||
[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() + " : "));
|
||||
|
|
@ -541,7 +542,7 @@ bool LiteQuery::request_block_state(BlockIdExt blkid) {
|
|||
++pending_;
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ValidatorManager::get_shard_state_from_db_short, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<Ref<ShardState>> res) {
|
||||
[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() + " : "));
|
||||
|
|
@ -563,7 +564,7 @@ bool LiteQuery::request_block_data(BlockIdExt blkid) {
|
|||
++pending_;
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ValidatorManager::get_block_data_from_db_short, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<Ref<BlockData>> res) {
|
||||
[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() + " : "));
|
||||
|
|
@ -586,7 +587,7 @@ bool LiteQuery::request_proof_link(BlockIdExt blkid) {
|
|||
if (blkid.is_masterchain()) {
|
||||
td::actor::send_closure(
|
||||
manager_, &ValidatorManager::get_key_block_proof_link, blkid,
|
||||
[ Self = actor_id(this), manager = manager_, blkid ](td::Result<td::BufferSlice> R) {
|
||||
[Self = actor_id(this), manager = manager_, blkid](td::Result<td::BufferSlice> R) {
|
||||
if (R.is_ok()) {
|
||||
auto proof = create_proof(blkid, R.move_as_ok());
|
||||
proof.ensure();
|
||||
|
|
@ -608,7 +609,7 @@ bool LiteQuery::request_proof_link(BlockIdExt blkid) {
|
|||
} else {
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ValidatorManager::get_block_proof_link_from_db_short, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<Ref<ProofLink>> res) {
|
||||
[Self = actor_id(this), blkid](td::Result<Ref<ProofLink>> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query,
|
||||
res.move_as_error_prefix("cannot load proof link for "s + blkid.to_str() + " : "));
|
||||
|
|
@ -634,7 +635,7 @@ bool LiteQuery::request_zero_state(BlockIdExt blkid) {
|
|||
++pending_;
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ValidatorManager::get_zero_state, blkid,
|
||||
[ Self = actor_id(this), blkid ](td::Result<td::BufferSlice> res) {
|
||||
[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_prefix("cannot load zerostate of "s + blkid.to_str() + " : "));
|
||||
|
|
@ -679,7 +680,7 @@ void LiteQuery::perform_getAccountState(BlockIdExt blkid, WorkchainId workchain,
|
|||
LOG(INFO) << "sending a get_top_masterchain_state_block query to manager";
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
|
||||
[Self = actor_id(this)](td::Result<std::pair<Ref<ton::validator::MasterchainState>, BlockIdExt>> res)->void {
|
||||
[Self = actor_id(this)](td::Result<std::pair<Ref<ton::validator::MasterchainState>, BlockIdExt>> res) -> void {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
|
|
@ -781,7 +782,7 @@ void LiteQuery::got_mc_block_state(BlockIdExt blkid, Ref<ShardState> state) {
|
|||
void LiteQuery::got_block_data(BlockIdExt blkid, Ref<BlockData> data) {
|
||||
LOG(INFO) << "obtained data for getBlock(" << blkid.to_str() << ") needed by a liteserver query";
|
||||
CHECK(data.not_null());
|
||||
block_ = std::move(data);
|
||||
block_ = Ref<BlockQ>(std::move(data));
|
||||
CHECK(block_.not_null());
|
||||
CHECK(blkid == blk_id_);
|
||||
dec_pending();
|
||||
|
|
@ -790,7 +791,7 @@ void LiteQuery::got_block_data(BlockIdExt blkid, Ref<BlockData> data) {
|
|||
void LiteQuery::got_mc_block_data(BlockIdExt blkid, Ref<BlockData> data) {
|
||||
LOG(INFO) << "obtained data for getBlock(" << blkid.to_str() << ") needed by a liteserver query";
|
||||
CHECK(data.not_null());
|
||||
mc_block_ = std::move(data);
|
||||
mc_block_ = Ref<BlockQ>(std::move(data));
|
||||
CHECK(mc_block_.not_null());
|
||||
CHECK(blkid == base_blk_id_);
|
||||
dec_pending();
|
||||
|
|
@ -1268,14 +1269,14 @@ void LiteQuery::continue_getTransactions(unsigned remaining, bool exact) {
|
|||
<< " " << trans_lt_;
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ValidatorManager::get_block_by_lt_from_db, ton::extract_addr_prefix(acc_workchain_, acc_addr_),
|
||||
trans_lt_, [ Self = actor_id(this), remaining, manager = manager_ ](td::Result<ConstBlockHandle> res) {
|
||||
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{});
|
||||
} else {
|
||||
auto handle = res.move_as_ok();
|
||||
LOG(DEBUG) << "requesting data for block " << handle->id().to_str();
|
||||
td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, handle,
|
||||
[ Self, blkid = handle->id(), remaining ](td::Result<Ref<BlockData>> res) {
|
||||
[Self, blkid = handle->id(), remaining](td::Result<Ref<BlockData>> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_getTransactions,
|
||||
res.move_as_error(), blkid);
|
||||
|
|
@ -1293,7 +1294,7 @@ void LiteQuery::continue_getTransactions_2(BlockIdExt blkid, Ref<BlockData> bloc
|
|||
--pending_;
|
||||
CHECK(!pending_);
|
||||
CHECK(block.not_null());
|
||||
block_ = block;
|
||||
block_ = Ref<BlockQ>(std::move(block));
|
||||
blk_id_ = blkid;
|
||||
continue_getTransactions(remaining, true);
|
||||
}
|
||||
|
|
@ -1339,24 +1340,122 @@ void LiteQuery::perform_getShardInfo(BlockIdExt blkid, ShardIdFull shard, bool e
|
|||
request_mc_block_data_state(blkid);
|
||||
}
|
||||
|
||||
void LiteQuery::load_prevKeyBlock(ton::BlockIdExt blkid, td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>> promise) {
|
||||
td::actor::send_closure_later(manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
|
||||
[Self = actor_id(this), blkid, promise = std::move(promise)](
|
||||
td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) mutable {
|
||||
td::actor::send_closure_later(Self, &LiteQuery::continue_loadPrevKeyBlock, blkid,
|
||||
std::move(res), std::move(promise));
|
||||
});
|
||||
}
|
||||
|
||||
void LiteQuery::continue_loadPrevKeyBlock(ton::BlockIdExt blkid,
|
||||
td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res,
|
||||
td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>> promise) {
|
||||
TRY_RESULT_PROMISE(promise, pair, std::move(res));
|
||||
base_blk_id_ = pair.second;
|
||||
if (!base_blk_id_.is_masterchain_ext()) {
|
||||
promise.set_error(
|
||||
td::Status::Error(PSTRING() << "the most recent masterchain block " << base_blk_id_.to_str() << " is invalid"));
|
||||
return;
|
||||
}
|
||||
auto state = Ref<MasterchainStateQ>(std::move(pair.first));
|
||||
if (state.is_null()) {
|
||||
promise.set_error(
|
||||
td::Status::Error(PSLICE() << "obtained no valid masterchain state for block " << base_blk_id_.to_str()));
|
||||
return;
|
||||
}
|
||||
if (blkid.seqno() > base_blk_id_.seqno()) {
|
||||
promise.set_error(td::Status::Error(PSLICE()
|
||||
<< "client knows block " << blkid.to_str()
|
||||
<< " newer than the reference masterchain block " << base_blk_id_.to_str()));
|
||||
return;
|
||||
}
|
||||
mc_state0_ = Ref<MasterchainStateQ>(state);
|
||||
if (base_blk_id_ != state->get_block_id()) {
|
||||
promise.set_error(td::Status::Error(PSLICE() << "the state for " << base_blk_id_.to_str()
|
||||
<< " is in fact a state for different block "
|
||||
<< state->get_block_id().to_str()));
|
||||
return;
|
||||
}
|
||||
if (!state->check_old_mc_block_id(blkid)) {
|
||||
promise.set_error(td::Status::Error(PSLICE() << "requested masterchain block " << blkid.to_str()
|
||||
<< " is unknown from the perspective of reference block "
|
||||
<< base_blk_id_.to_str()));
|
||||
return;
|
||||
}
|
||||
LOG(INFO) << "continuing load_prevKeyBlock(" << blkid.to_str() << ") query with a state for "
|
||||
<< base_blk_id_.to_str();
|
||||
auto key_blk_id = state->prev_key_block_id(blkid.seqno());
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ValidatorManager::get_block_data_from_db_short, key_blk_id,
|
||||
[Self = actor_id(this), key_blk_id, promise = std::move(promise)](td::Result<Ref<BlockData>> res) mutable {
|
||||
td::actor::send_closure_later(Self, &LiteQuery::finish_loadPrevKeyBlock, key_blk_id, std::move(res),
|
||||
std::move(promise));
|
||||
});
|
||||
}
|
||||
|
||||
void LiteQuery::finish_loadPrevKeyBlock(ton::BlockIdExt blkid, td::Result<Ref<BlockData>> res,
|
||||
td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>> promise) {
|
||||
TRY_RESULT_PROMISE_PREFIX(promise, data, std::move(res), PSLICE() << "cannot load block " << blkid.to_str() << " : ");
|
||||
Ref<BlockQ> data0{std::move(data)};
|
||||
if (data0.is_null()) {
|
||||
promise.set_error(td::Status::Error("no block data for key block "s + blkid.to_str()));
|
||||
return;
|
||||
}
|
||||
promise.set_result(std::make_pair(blkid, std::move(data0)));
|
||||
}
|
||||
|
||||
void LiteQuery::perform_getConfigParams(BlockIdExt blkid, int mode, std::vector<int> param_list) {
|
||||
LOG(INFO) << "started a getConfigParams(" << blkid.to_str() << ", " << mode << ", <list of " << param_list.size()
|
||||
<< " parameters>) liteserver query";
|
||||
set_continuation([ this, mode, param_list = std::move(param_list) ]() mutable {
|
||||
continue_getConfigParams(mode, std::move(param_list));
|
||||
});
|
||||
request_mc_block_data_state(blkid);
|
||||
if (!blkid.is_masterchain_ext()) {
|
||||
fatal_error("configuration parameters can be loaded with respect to a masterchain block only");
|
||||
return;
|
||||
}
|
||||
if (!(mode & 0x8000)) {
|
||||
// ordinary case: get configuration from masterchain state
|
||||
set_continuation([this, mode, param_list = std::move(param_list)]() mutable {
|
||||
continue_getConfigParams(mode, std::move(param_list));
|
||||
});
|
||||
request_mc_block_data_state(blkid);
|
||||
} else {
|
||||
// get configuration from previous key block
|
||||
load_prevKeyBlock(blkid, [this, blkid, mode, param_list = std::move(param_list)](
|
||||
td::Result<std::pair<BlockIdExt, Ref<BlockQ>>> res) mutable {
|
||||
if (res.is_error()) {
|
||||
this->abort_query(res.move_as_error());
|
||||
} else {
|
||||
this->base_blk_id_ = res.ok().first;
|
||||
this->mc_block_ = res.move_as_ok().second;
|
||||
this->continue_getConfigParams(mode, std::move(param_list));
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void LiteQuery::continue_getConfigParams(int mode, std::vector<int> param_list) {
|
||||
LOG(INFO) << "completing getConfigParams(" << base_blk_id_.to_str() << ", " << mode << ", <list of "
|
||||
<< param_list.size() << " parameters>) liteserver query";
|
||||
Ref<vm::Cell> proof1;
|
||||
if (!make_mc_state_root_proof(proof1)) {
|
||||
bool keyblk = (mode & 0x8000);
|
||||
Ref<vm::Cell> proof1, block;
|
||||
if (keyblk) {
|
||||
block = mc_block_->root_cell();
|
||||
} else if (!make_mc_state_root_proof(proof1)) {
|
||||
return;
|
||||
}
|
||||
vm::MerkleProofBuilder mpb{mc_state_->root_cell()};
|
||||
auto res = block::Config::extract_from_state(mpb.root(), mode);
|
||||
|
||||
vm::MerkleProofBuilder mpb{keyblk ? block : mc_state_->root_cell()};
|
||||
if (keyblk) {
|
||||
auto res = block::check_block_header_proof(mpb.root(), base_blk_id_);
|
||||
if (res.is_error()) {
|
||||
fatal_error(res.move_as_error_prefix("invalid key block header:"));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
auto res = keyblk ? block::Config::extract_from_key_block(mpb.root(), mode)
|
||||
: block::Config::extract_from_state(mpb.root(), mode);
|
||||
if (res.is_error()) {
|
||||
fatal_error(res.move_as_error());
|
||||
return;
|
||||
|
|
@ -1367,9 +1466,9 @@ void LiteQuery::continue_getConfigParams(int mode, std::vector<int> param_list)
|
|||
return;
|
||||
}
|
||||
try {
|
||||
if (mode & 0x2000) {
|
||||
if (mode & 0x20000) {
|
||||
visit(cfg->get_root_cell());
|
||||
} else if (mode & 0x1000) {
|
||||
} else if (mode & 0x10000) {
|
||||
for (int i : param_list) {
|
||||
visit(cfg->get_config_param(i));
|
||||
}
|
||||
|
|
@ -1378,7 +1477,7 @@ void LiteQuery::continue_getConfigParams(int mode, std::vector<int> param_list)
|
|||
fatal_error("error while traversing required configuration parameters: "s + err.get_msg());
|
||||
return;
|
||||
}
|
||||
auto res1 = vm::std_boc_serialize(std::move(proof1));
|
||||
auto res1 = !keyblk ? vm::std_boc_serialize(std::move(proof1)) : td::BufferSlice();
|
||||
if (res1.is_error()) {
|
||||
fatal_error("cannot serialize Merkle proof : "s + res1.move_as_error().to_string());
|
||||
return;
|
||||
|
|
@ -1390,7 +1489,7 @@ void LiteQuery::continue_getConfigParams(int mode, std::vector<int> param_list)
|
|||
}
|
||||
LOG(INFO) << "getConfigParams() query completed";
|
||||
auto b = ton::create_serialize_tl_object<ton::lite_api::liteServer_configInfo>(
|
||||
mode & 0xfff, ton::create_tl_lite_block_id(base_blk_id_), res1.move_as_ok(), res2.move_as_ok());
|
||||
mode & 0xffff, ton::create_tl_lite_block_id(base_blk_id_), res1.move_as_ok(), res2.move_as_ok());
|
||||
finish_query(std::move(b));
|
||||
}
|
||||
|
||||
|
|
@ -1495,14 +1594,14 @@ void LiteQuery::perform_lookupBlock(BlockId blkid, int mode, LogicalTime lt, Uni
|
|||
LOG(INFO) << "performing a lookupBlock(" << blkid.to_str() << ", " << mode << ", " << lt << ", " << utime
|
||||
<< ") query";
|
||||
auto P = td::PromiseCreator::lambda(
|
||||
[ Self = actor_id(this), manager = manager_, mode = (mode >> 4) ](td::Result<ConstBlockHandle> res) {
|
||||
[Self = actor_id(this), manager = manager_, mode = (mode >> 4)](td::Result<ConstBlockHandle> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
auto handle = res.move_as_ok();
|
||||
LOG(DEBUG) << "requesting data for block " << handle->id().to_str();
|
||||
td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, handle,
|
||||
[ Self, blkid = handle->id(), mode ](td::Result<Ref<BlockData>> res) {
|
||||
[Self, blkid = handle->id(), mode](td::Result<Ref<BlockData>> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
|
|
@ -1650,7 +1749,7 @@ void LiteQuery::perform_getBlockProof(ton::BlockIdExt from, ton::BlockIdExt to,
|
|||
if (mode & 0x1000) {
|
||||
BlockIdExt bblk = (from.seqno() > to.seqno()) ? from : to;
|
||||
td::actor::send_closure_later(manager_, &ValidatorManager::get_shard_state_from_db_short, bblk,
|
||||
[ Self = actor_id(this), from, to, bblk, mode ](td::Result<Ref<ShardState>> res) {
|
||||
[Self = actor_id(this), from, to, bblk, mode](td::Result<Ref<ShardState>> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
|
|
@ -1662,7 +1761,7 @@ void LiteQuery::perform_getBlockProof(ton::BlockIdExt from, ton::BlockIdExt to,
|
|||
} else {
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
|
||||
[ Self = actor_id(this), from, to, mode ](td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) {
|
||||
[Self = actor_id(this), from, to, mode](td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
|
|
@ -1675,7 +1774,7 @@ void LiteQuery::perform_getBlockProof(ton::BlockIdExt from, ton::BlockIdExt to,
|
|||
} else if (mode & 2) {
|
||||
td::actor::send_closure_later(
|
||||
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
|
||||
[ Self = actor_id(this), from, mode ](td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) {
|
||||
[Self = actor_id(this), from, mode](td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
|
|
@ -1686,7 +1785,7 @@ void LiteQuery::perform_getBlockProof(ton::BlockIdExt from, ton::BlockIdExt to,
|
|||
});
|
||||
} else {
|
||||
td::actor::send_closure_later(manager_, &ton::validator::ValidatorManager::get_shard_client_state, false,
|
||||
[ Self = actor_id(this), from, mode ](td::Result<BlockIdExt> res) {
|
||||
[Self = actor_id(this), from, mode](td::Result<BlockIdExt> res) {
|
||||
if (res.is_error()) {
|
||||
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
|
||||
} else {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue