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

updated submodules, bugfixes

Browse source 
- 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 2020-04-27 16:01:46 +04:00
parent 16a4566091
commit 9f008b129f
129 changed files with 8438 additions and 879 deletions
Download patch file Download diff file Expand all files Collapse all files

6
validator/impl/accept-block.cpp
View file

@ -262,9 +262,9 @@ bool AcceptBlockQuery::create_new_proof() {
} else { // FAKE
vm::CellBuilder cb2;
if (!(cb2.store_long_bool(0x11, 8) // block_signatures#11
&& cb2.store_long_bool(validator_set_->get_validator_set_hash(),
&& cb2.store_long_bool(validator_set_.not_null() ? validator_set_->get_validator_set_hash() : 0,
32) // validator_info$_ validator_set_hash_short:uint32
&& cb2.store_long_bool(validator_set_->get_catchain_seqno(),
&& cb2.store_long_bool(validator_set_.not_null() ? validator_set_->get_catchain_seqno() : 0,
32) // validator_set_ts:uint32 = ValidatorInfo
&& cb2.store_long_bool(0, 32) // sig_count:uint32
&& cb2.store_long_bool(0, 64) // sig_weight:uint32
@ -355,7 +355,7 @@ void AcceptBlockQuery::start_up() {
VLOG(VALIDATOR_DEBUG) << "start_up()";
alarm_timestamp() = timeout_;
if (validator_set_.is_null()) {
if (!is_fork_ && validator_set_.is_null()) {
fatal_error("no real ValidatorSet passed to AcceptBlockQuery");
return;
}

17
validator/impl/check-proof.cpp
View file

@ -313,8 +313,8 @@ void CheckProof::start_up() {
return;
}
td::actor::send_closure(manager_, &ValidatorManager::get_block_handle, id_,
true, [SelfId = actor_id(this)](td::Result<BlockHandle> R) {
td::actor::send_closure(manager_, &ValidatorManager::get_block_handle, id_, true,
[SelfId = actor_id(this)](td::Result<BlockHandle> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &CheckProof::abort_query, R.move_as_error());
} else {
@ -344,8 +344,8 @@ void CheckProof::got_block_handle(BlockHandle handle) {
process_masterchain_state();
return;
}
td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, prev_[0], priority(),
timeout_, [SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, prev_[0], priority(), timeout_,
[SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
check_send_error(SelfId, R) ||
td::actor::send_closure_bool(SelfId, &CheckProof::got_masterchain_state,
td::Ref<MasterchainState>{R.move_as_ok()});
@ -440,8 +440,8 @@ void CheckProof::check_signatures(Ref<ValidatorSet> s) {
if (handle_) {
got_block_handle_2(handle_);
} else {
td::actor::send_closure(manager_, &ValidatorManager::get_block_handle, id_,
true, [SelfId = actor_id(this)](td::Result<BlockHandle> R) {
td::actor::send_closure(manager_, &ValidatorManager::get_block_handle, id_, true,
[SelfId = actor_id(this)](td::Result<BlockHandle> R) {
check_send_error(SelfId, R) ||
td::actor::send_closure_bool(SelfId, &CheckProof::got_block_handle_2, R.move_as_ok());
});
@ -466,7 +466,10 @@ void CheckProof::got_block_handle_2(BlockHandle handle) {
});
if (skip_check_signatures_) {
// do not save proof if we skipped signatures
handle_->flush(manager_, handle_, std::move(P));
auto proof = Ref<Proof>(proof_);
CHECK(proof.not_null());
td::actor::send_closure_later(manager_, &ValidatorManager::set_block_proof, handle_, std::move(proof),
std::move(P));
} else if (is_proof()) {
auto proof = Ref<Proof>(proof_);
CHECK(proof.not_null());

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

@ -63,6 +63,7 @@ class Collator final : public td::actor::Actor {
bool inbound_queues_empty_{false};
bool libraries_changed_{false};
bool prev_key_block_exists_{false};
bool is_hardfork_{false};
UnixTime min_ts;
BlockIdExt min_mc_block_id;
std::vector<BlockIdExt> prev_blocks;
@ -85,9 +86,9 @@ class Collator final : public td::actor::Actor {
static constexpr bool shard_splitting_enabled = true;
public:
Collator(ShardIdFull shard, td::uint32 min_ts, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
Ref<ValidatorSet> validator_set, Ed25519_PublicKey collator_id, td::actor::ActorId<ValidatorManager> manager,
td::Timestamp timeout, td::Promise<BlockCandidate> promise);
Collator(ShardIdFull shard, bool is_hardfork, td::uint32 min_ts, BlockIdExt min_masterchain_block_id,
std::vector<BlockIdExt> prev, Ref<ValidatorSet> validator_set, Ed25519_PublicKey collator_id,
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout, td::Promise<BlockCandidate> promise);
~Collator() override = default;
bool is_busy() const {
return busy_;

88
validator/impl/collator.cpp
View file

@ -54,11 +54,12 @@ static inline bool dbg(int c) {
return true;
}
Collator::Collator(ShardIdFull shard, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
Collator::Collator(ShardIdFull shard, bool is_hardfork, UnixTime min_ts, BlockIdExt min_masterchain_block_id,
std::vector<BlockIdExt> prev, td::Ref<ValidatorSet> validator_set, Ed25519_PublicKey collator_id,
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
td::Promise<BlockCandidate> promise)
: shard_(shard)
, is_hardfork_(is_hardfork)
, min_ts(min_ts)
, min_mc_block_id{min_masterchain_block_id}
, prev_blocks(std::move(prev))
@ -75,6 +76,9 @@ void Collator::start_up() {
if (prev_blocks.size() > 1) {
LOG(DEBUG) << "Previous block #2 is " << prev_blocks.at(1).to_str();
}
if (is_hardfork_ && workchain() == masterchainId) {
is_key_block_ = true;
}
// 1. check validity of parameters, especially prev_blocks, shard and min_mc_block_id
if (workchain() != ton::masterchainId && workchain() != ton::basechainId) {
fatal_error(-667, "can create block candidates only for masterchain (-1) and base workchain (0)");
@ -162,12 +166,26 @@ void Collator::start_up() {
// 2. learn latest masterchain state and block id
LOG(DEBUG) << "sending get_top_masterchain_state_block() to Manager";
++pending;
td::actor::send_closure_later(manager, &ValidatorManager::get_top_masterchain_state_block,
[self = get_self()](td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) {
LOG(DEBUG) << "got answer to get_top_masterchain_state_block";
td::actor::send_closure_later(std::move(self), &Collator::after_get_mc_state,
std::move(res));
});
if (!is_hardfork_) {
td::actor::send_closure_later(manager, &ValidatorManager::get_top_masterchain_state_block,
[self = get_self()](td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) {
LOG(DEBUG) << "got answer to get_top_masterchain_state_block";
td::actor::send_closure_later(std::move(self), &Collator::after_get_mc_state,
std::move(res));
});
} else {
td::actor::send_closure_later(
manager, &ValidatorManager::get_shard_state_from_db_short, min_mc_block_id,
[self = get_self(), block_id = min_mc_block_id](td::Result<Ref<ShardState>> res) {
LOG(DEBUG) << "got answer to get_top_masterchain_state_block";
if (res.is_error()) {
td::actor::send_closure_later(std::move(self), &Collator::after_get_mc_state, res.move_as_error());
} else {
td::actor::send_closure_later(std::move(self), &Collator::after_get_mc_state,
std::make_pair(Ref<MasterchainState>(res.move_as_ok()), block_id));
}
});
}
}
// 3. load previous block(s) and corresponding state(s)
prev_states.resize(prev_blocks.size());
@ -195,16 +213,21 @@ void Collator::start_up() {
});
}
}
if (is_hardfork_) {
LOG(WARNING) << "generating a hardfork block";
}
// 4. load external messages
LOG(DEBUG) << "sending get_external_messages() query to Manager";
++pending;
td::actor::send_closure_later(manager, &ValidatorManager::get_external_messages, shard_,
[self = get_self()](td::Result<std::vector<Ref<ExtMessage>>> res) -> void {
LOG(DEBUG) << "got answer to get_external_messages() query";
td::actor::send_closure_later(std::move(self), &Collator::after_get_external_messages,
std::move(res));
});
if (is_masterchain()) {
if (!is_hardfork_) {
LOG(DEBUG) << "sending get_external_messages() query to Manager";
++pending;
td::actor::send_closure_later(manager, &ValidatorManager::get_external_messages, shard_,
[self = get_self()](td::Result<std::vector<Ref<ExtMessage>>> res) -> void {
LOG(DEBUG) << "got answer to get_external_messages() query";
td::actor::send_closure_later(
std::move(self), &Collator::after_get_external_messages, std::move(res));
});
}
if (is_masterchain() && !is_hardfork_) {
// 5. load shard block info messages
LOG(DEBUG) << "sending get_shard_blocks() query to Manager";
++pending;
@ -487,6 +510,7 @@ void Collator::after_get_shard_blocks(td::Result<std::vector<Ref<ShardTopBlockDe
--pending;
if (res.is_error()) {
fatal_error(res.move_as_error());
return;
}
auto vect = res.move_as_ok();
shard_block_descr_ = std::move(vect);
@ -521,7 +545,7 @@ bool Collator::unpack_last_mc_state() {
prev_key_block_seqno_ = 0;
}
LOG(DEBUG) << "previous key block is " << prev_key_block_.to_str() << " (exists=" << prev_key_block_exists_ << ")";
vert_seqno_ = config_->get_vert_seqno();
vert_seqno_ = config_->get_vert_seqno() + (is_hardfork_ ? 1 : 0);
LOG(DEBUG) << "vertical seqno (vert_seqno) is " << vert_seqno_;
auto limits = config_->get_block_limits(is_masterchain());
if (limits.is_error()) {
@ -549,6 +573,9 @@ bool Collator::unpack_last_mc_state() {
}
bool Collator::check_cur_validator_set() {
if (is_hardfork_) {
return true;
}
CatchainSeqno cc_seqno = 0;
auto nodes = config_->compute_validator_set_cc(shard_, now_, &cc_seqno);
if (nodes.empty()) {
@ -3083,12 +3110,16 @@ bool Collator::create_mc_state_extra() {
auto cfg_smc_config = cfg_res.move_as_ok();
CHECK(cfg_smc_config.not_null());
vm::Dictionary cfg_dict{cfg_smc_config, 32};
bool ignore_cfg_changes = false;
Ref<vm::Cell> cfg0;
if (!block::valid_config_data(cfg_smc_config, config_addr, true, true, old_mparams_)) {
block::gen::t_Hashmap_32_Ref_Cell.print_ref(std::cerr, cfg_smc_config);
return fatal_error("configuration smart contract "s + config_addr.to_hex() +
" contains an invalid configuration in its data");
LOG(ERROR) << "configuration smart contract "s + config_addr.to_hex() +
" contains an invalid configuration in its data, IGNORING CHANGES";
ignore_cfg_changes = true;
} else {
cfg0 = cfg_dict.lookup_ref(td::BitArray<32>(1 - 1));
}
Ref<vm::Cell> cfg0 = cfg_dict.lookup_ref(td::BitArray<32>(1 - 1));
bool changed_cfg = false;
if (cfg0.not_null()) {
ton::StdSmcAddress new_config_addr;
@ -3101,7 +3132,11 @@ bool Collator::create_mc_state_extra() {
changed_cfg = true;
}
}
if (block::important_config_parameters_changed(cfg_smc_config, state_extra.config->prefetch_ref()) || changed_cfg) {
if (ignore_cfg_changes) {
LOG(ERROR) << "configuration changes ignored";
return fatal_error("attempting to install invalid new configuration");
} else if (block::important_config_parameters_changed(cfg_smc_config, state_extra.config->prefetch_ref()) ||
changed_cfg) {
LOG(WARNING) << "global configuration changed, updating";
vm::CellBuilder cb;
CHECK(cb.store_bits_bool(config_addr) && cb.store_ref_bool(cfg_smc_config));
@ -3625,6 +3660,7 @@ bool Collator::store_master_ref(vm::CellBuilder& cb) {
bool Collator::update_processed_upto() {
auto ref_mc_seqno = is_masterchain() ? new_block_seqno : prev_mc_block_seqno;
update_min_mc_seqno(ref_mc_seqno);
if (last_proc_int_msg_.first) {
if (!processed_upto_->insert(ref_mc_seqno, last_proc_int_msg_.first, last_proc_int_msg_.second.cbits())) {
return fatal_error("cannot update our ProcessedUpto to reflect processed inbound message");
@ -3694,8 +3730,8 @@ bool Collator::compute_total_balance() {
bool Collator::create_block_info(Ref<vm::Cell>& block_info) {
vm::CellBuilder cb, cb2;
bool mc = is_masterchain();
td::uint32 val_hash = validator_set_->get_validator_set_hash();
CatchainSeqno cc_seqno = validator_set_->get_catchain_seqno();
td::uint32 val_hash = is_hardfork_ ? 0 : validator_set_->get_validator_set_hash();
CatchainSeqno cc_seqno = is_hardfork_ ? 0 : validator_set_->get_catchain_seqno();
return cb.store_long_bool(0x9bc7a987, 32) // block_info#9bc7a987
&& cb.store_long_bool(0, 32) // version:uint32
&& cb.store_bool_bool(!mc) // not_master:(## 1)
@ -3705,7 +3741,8 @@ bool Collator::create_block_info(Ref<vm::Cell>& block_info) {
&& cb.store_bool_bool(want_split_) // want_split:Bool
&& cb.store_bool_bool(want_merge_) // want_merge:Bool
&& cb.store_bool_bool(is_key_block_) // key_block:Bool
&& cb.store_long_bool((int)report_version_, 9) // vert_seqno_incr:(## 1) flags:(## 8)
&& cb.store_bool_bool(is_hardfork_) // vert_seqno_incr:(## 1)
&& cb.store_long_bool((int)report_version_, 8) // flags:(## 8)
&& cb.store_long_bool(new_block_seqno, 32) // seq_no:#
&& cb.store_long_bool(vert_seqno_, 32) // vert_seq_no:#
&& block::ShardId{shard_}.serialize(cb) // shard:ShardIdent
@ -3721,6 +3758,9 @@ bool Collator::create_block_info(Ref<vm::Cell>& block_info) {
&& cb.store_builder_ref_bool(std::move(cb2)))) // .. ^BlkMasterInfo
&& store_prev_blk_ref(cb2, after_merge_) // prev_ref:..
&& cb.store_builder_ref_bool(std::move(cb2)) // .. ^(PrevBlkInfo after_merge)
&& (!is_hardfork_ || // prev_vert_ref:vert_seqno_incr?..
(store_master_ref(cb2) //
&& cb.store_builder_ref_bool(std::move(cb2)))) // .. ^(BlkPrevInfo 0)
&& cb.finalize_to(block_info);
}

32
validator/impl/fabric.cpp
View file

@ -39,9 +39,8 @@ namespace ton {
namespace validator {
td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_,
td::uint32 depth) {
return td::actor::create_actor<RootDb>("db", manager, db_root_, depth);
td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_) {
return td::actor::create_actor<RootDb>("db", manager, db_root_);
}
td::actor::ActorOwn<LiteServerCache> create_liteserver_cache_actor(td::actor::ActorId<ValidatorManager> manager,
@ -93,7 +92,11 @@ td::Result<td::Ref<ShardState>> create_shard_state(BlockIdExt block_id, td::Ref<
}
td::Result<BlockHandle> create_block_handle(td::BufferSlice data) {
return ton::validator::BlockHandleImpl::create(std::move(data));
return ton::validator::BlockHandleImpl::create(data.as_slice());
}
td::Result<BlockHandle> create_block_handle(td::Slice data) {
return ton::validator::BlockHandleImpl::create(data);
}
td::Result<ConstBlockHandle> create_temp_block_handle(td::BufferSlice data) {
@ -208,9 +211,24 @@ void run_collate_query(ShardIdFull shard, td::uint32 min_ts, const BlockIdExt& m
seqno = p.seqno();
}
}
td::actor::create_actor<Collator>(PSTRING() << "collate" << shard.to_str() << ":" << (seqno + 1), shard, min_ts,
min_masterchain_block_id, std::move(prev), std::move(validator_set), collator_id,
std::move(manager), timeout, std::move(promise))
td::actor::create_actor<Collator>(PSTRING() << "collate" << shard.to_str() << ":" << (seqno + 1), shard, false,
min_ts, min_masterchain_block_id, std::move(prev), std::move(validator_set),
collator_id, std::move(manager), timeout, std::move(promise))
.release();
}
void run_collate_hardfork(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
td::Promise<BlockCandidate> promise) {
BlockSeqno seqno = 0;
for (auto& p : prev) {
if (p.seqno() > seqno) {
seqno = p.seqno();
}
}
td::actor::create_actor<Collator>(PSTRING() << "collate" << shard.to_str() << ":" << (seqno + 1), shard, true, 0,
min_masterchain_block_id, std::move(prev), td::Ref<ValidatorSet>{},
Ed25519_PublicKey{Bits256::zero()}, std::move(manager), timeout, std::move(promise))
.release();
}

177
validator/impl/liteserver.cpp
View file

@ -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 {

9
validator/impl/liteserver.hpp
View file

@ -23,6 +23,7 @@
#include "interfaces/block-handle.h"
#include "interfaces/validator-manager.h"
#include "interfaces/shard.h"
#include "block.hpp"
#include "shard.hpp"
#include "proof.hpp"
@ -45,7 +46,7 @@ class LiteQuery : public td::actor::Actor {
BlockIdExt base_blk_id_, base_blk_id_alt_, blk_id_;
Ref<MasterchainStateQ> mc_state_, mc_state0_;
Ref<ShardStateQ> state_;
Ref<BlockData> mc_block_, block_;
Ref<BlockQ> mc_block_, block_;
Ref<ProofQ> mc_proof_, mc_proof_alt_;
Ref<ProofLinkQ> proof_link_;
td::BufferSlice buffer_;
@ -131,6 +132,12 @@ class LiteQuery : public td::actor::Actor {
bool adjust_last_proof_link(ton::BlockIdExt cur, Ref<vm::Cell> block_root);
bool finish_proof_chain(ton::BlockIdExt id);
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,
td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>>);
void finish_loadPrevKeyBlock(ton::BlockIdExt blkid, td::Result<Ref<BlockData>> res,
td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>> promise);
bool request_block_data(BlockIdExt blkid);
bool request_block_state(BlockIdExt blkid);
bool request_block_data_state(BlockIdExt blkid);

7
validator/impl/validate-query.cpp
View file

@ -4822,14 +4822,15 @@ bool ValidateQuery::check_new_state() {
// seq_no:uint32 vert_seq_no:# -> checked in unpack_next_state()
// gen_utime:uint32 gen_lt:uint64 -> checked in unpack_next_state()
// min_ref_mc_seqno:uint32
ton::BlockSeqno ref_mc_seqno = std::min(std::min(is_masterchain() ? id_.seqno() : mc_seqno_, min_shard_ref_mc_seqno_),
ns_.processed_upto_->min_mc_seqno());
ton::BlockSeqno my_mc_seqno = is_masterchain() ? id_.seqno() : mc_seqno_;
ton::BlockSeqno ref_mc_seqno =
std::min(std::min(my_mc_seqno, min_shard_ref_mc_seqno_), ns_.processed_upto_->min_mc_seqno());
if (ns_.min_ref_mc_seqno_ != ref_mc_seqno) {
return reject_query(
PSTRING() << "new state of " << id_.to_str() << " has minimal referenced masterchain block seqno "
<< ns_.min_ref_mc_seqno_
<< " but the value computed from all shard references and previous masterchain block reference is "
<< ref_mc_seqno << " = min(" << mc_seqno_ << "," << min_shard_ref_mc_seqno_ << ","
<< ref_mc_seqno << " = min(" << my_mc_seqno << "," << min_shard_ref_mc_seqno_ << ","
<< ns_.processed_upto_->min_mc_seqno() << ")");
}
// out_msg_queue_info:^OutMsgQueueInfo