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

fixed crash in validator. Updated elector/config smartcontracts

Browse source
This commit is contained in:
ton 2020-04-02 17:08:42 +04:00
parent 9bff9285b8
commit 0e4277313c
9 changed files with 326 additions and 146 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -256,7 +256,7 @@ void ValidateQuery::start_up() {
LOG(DEBUG) << "sending wait_block_state() query #" << i << " for " << prev_blocks[i].to_str() << " to Manager";
++pending;
td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, prev_blocks[i], priority(),
timeout, [self = get_self(), i](td::Result<Ref<ShardState>> res) -> void {
timeout, [ self = get_self(), i ](td::Result<Ref<ShardState>> res)->void {
LOG(DEBUG) << "got answer to wait_block_state_short query #" << i;
td::actor::send_closure_later(
std::move(self), &ValidateQuery::after_get_shard_state, i, std::move(res));
@ -270,16 +270,16 @@ void ValidateQuery::start_up() {
// 5. request masterchain state referred to in the block
if (!is_masterchain()) {
++pending;
td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, mc_blkid_, priority(), timeout,
[self = get_self()](td::Result<Ref<ShardState>> res) {
td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, mc_blkid_, priority(),
timeout, [self = get_self()](td::Result<Ref<ShardState>> res) {
LOG(DEBUG) << "got answer to wait_block_state() query for masterchain block";
td::actor::send_closure_later(std::move(self), &ValidateQuery::after_get_mc_state,
std::move(res));
});
// 5.1. request corresponding block handle
++pending;
td::actor::send_closure_later(manager, &ValidatorManager::get_block_handle, mc_blkid_, true,
[self = get_self()](td::Result<BlockHandle> res) {
td::actor::send_closure_later(manager, &ValidatorManager::get_block_handle, mc_blkid_,
true, [self = get_self()](td::Result<BlockHandle> res) {
LOG(DEBUG) << "got answer to get_block_handle() query for masterchain block";
td::actor::send_closure_later(std::move(self), &ValidateQuery::got_mc_handle,
std::move(res));
@ -1205,7 +1205,7 @@ bool ValidateQuery::request_neighbor_queues() {
LOG(DEBUG) << "neighbor #" << i << " : " << descr.blk_.to_str();
++pending;
send_closure_later(manager, &ValidatorManager::wait_block_message_queue_short, descr.blk_, priority(), timeout,
[self = get_self(), i](td::Result<Ref<MessageQueue>> res) {
[ self = get_self(), i ](td::Result<Ref<MessageQueue>> res) {
td::actor::send_closure(std::move(self), &ValidateQuery::got_neighbor_out_queue, i,
std::move(res));
});
@ -1323,13 +1323,12 @@ bool ValidateQuery::request_aux_mc_state(BlockSeqno seqno, Ref<MasterchainStateQ
CHECK(blkid.is_valid_ext() && blkid.is_masterchain());
LOG(DEBUG) << "sending auxiliary wait_block_state() query for " << blkid.to_str() << " to Manager";
++pending;
td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, blkid, priority(), timeout,
[self = get_self(), blkid](td::Result<Ref<ShardState>> res) {
LOG(DEBUG) << "got answer to wait_block_state query for " << blkid.to_str();
td::actor::send_closure_later(std::move(self),
&ValidateQuery::after_get_aux_shard_state, blkid,
std::move(res));
});
td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, blkid, priority(), timeout, [
self = get_self(), blkid
](td::Result<Ref<ShardState>> res) {
LOG(DEBUG) << "got answer to wait_block_state query for " << blkid.to_str();
td::actor::send_closure_later(std::move(self), &ValidateQuery::after_get_aux_shard_state, blkid, std::move(res));
});
state.clear();
return true;
}
@ -1668,8 +1667,8 @@ bool ValidateQuery::check_shard_layout() {
WorkchainId wc_id{ton::workchainInvalid};
Ref<block::WorkchainInfo> wc_info;
if (!new_shard_conf_->process_sibling_shard_hashes([self = this, &wc_set, &wc_id, &wc_info, &ccvc](
block::McShardHash& cur, const block::McShardHash* sibling) {
if (!new_shard_conf_->process_sibling_shard_hashes([ self = this, &wc_set, &wc_id, &wc_info, &ccvc ](
block::McShardHash & cur, const block::McShardHash* sibling) {
if (!cur.is_valid()) {
return -2;
}
@ -1866,13 +1865,16 @@ bool ValidateQuery::fix_all_processed_upto() {
if (!fix_processed_upto(*ps_.processed_upto_)) {
return fatal_error("Cannot adjust old ProcessedUpto of our shard state");
}
if (sibling_processed_upto_ && !fix_processed_upto(*sibling_processed_upto_)) {
return fatal_error("Cannot adjust old ProcessedUpto of the shard state of our virtual sibling");
}
if (!fix_processed_upto(*ns_.processed_upto_, true)) {
return fatal_error("Cannot adjust new ProcessedUpto of our shard state");
}
for (auto& descr : neighbors_) {
CHECK(descr.processed_upto);
if (!fix_processed_upto(*descr.processed_upto)) {
return fatal_error(std::string{"Cannot adjust ProcessedUpto of neighbor "} + descr.blk_.to_str());
return fatal_error("Cannot adjust ProcessedUpto of neighbor "s + descr.blk_.to_str());
}
}
return true;
@ -1971,6 +1973,7 @@ bool ValidateQuery::add_trivial_neighbor() {
CHECK(found == 1);
CHECK(after_split_);
CHECK(sibling_out_msg_queue_);
CHECK(sibling_processed_upto_);
neighbors_.emplace_back(*descr_ref);
auto& nb2 = neighbors_.at(i);
nb2.set_queue_root(sibling_out_msg_queue_->get_root_cell());
@ -2327,14 +2330,14 @@ bool ValidateQuery::precheck_account_updates() {
LOG(INFO) << "pre-checking all Account updates between the old and the new state";
try {
CHECK(ps_.account_dict_ && ns_.account_dict_);
if (!ps_.account_dict_->scan_diff(
*ns_.account_dict_,
[this](td::ConstBitPtr key, int key_len, Ref<vm::CellSlice> old_val_extra,
Ref<vm::CellSlice> new_val_extra) {
CHECK(key_len == 256);
return precheck_one_account_update(key, std::move(old_val_extra), std::move(new_val_extra));
},
3 /* check augmentation of changed nodes */)) {
if (!ps_.account_dict_->scan_diff(*ns_.account_dict_,
[this](td::ConstBitPtr key, int key_len, Ref<vm::CellSlice> old_val_extra,
Ref<vm::CellSlice> new_val_extra) {
CHECK(key_len == 256);
return precheck_one_account_update(key, std::move(old_val_extra),
std::move(new_val_extra));
},
3 /* check augmentation of changed nodes */)) {
return reject_query("invalid ShardAccounts dictionary in the new state");
}
} catch (vm::VmError& err) {
@ -2688,14 +2691,14 @@ bool ValidateQuery::precheck_message_queue_update() {
try {
CHECK(ps_.out_msg_queue_ && ns_.out_msg_queue_);
CHECK(out_msg_dict_);
if (!ps_.out_msg_queue_->scan_diff(
*ns_.out_msg_queue_,
[this](td::ConstBitPtr key, int key_len, Ref<vm::CellSlice> old_val_extra,
Ref<vm::CellSlice> new_val_extra) {
CHECK(key_len == 352);
return precheck_one_message_queue_update(key, std::move(old_val_extra), std::move(new_val_extra));
},
3 /* check augmentation of changed nodes */)) {
if (!ps_.out_msg_queue_->scan_diff(*ns_.out_msg_queue_,
[this](td::ConstBitPtr key, int key_len, Ref<vm::CellSlice> old_val_extra,
Ref<vm::CellSlice> new_val_extra) {
CHECK(key_len == 352);
return precheck_one_message_queue_update(key, std::move(old_val_extra),
std::move(new_val_extra));
},
3 /* check augmentation of changed nodes */)) {
return reject_query("invalid OutMsgQueue dictionary in the new state");
}
} catch (vm::VmError& err) {
@ -3937,6 +3940,12 @@ bool ValidateQuery::check_in_queue() {
bool ValidateQuery::check_delivered_dequeued() {
LOG(INFO) << "scanning new outbound queue and checking delivery status of all messages";
bool ok = false;
for (const auto& nb : neighbors_) {
if (!nb.is_disabled() && (!nb.processed_upto || !nb.processed_upto->can_check_processed())) {
return fatal_error(-667, PSTRING() << "internal error: no info for checking processed messages from neighbor "
<< nb.blk_.to_str());
}
}
return ns_.out_msg_queue_->check_for_each([&](Ref<vm::CellSlice> cs_ref, td::ConstBitPtr key, int n) -> bool {
assert(n == 352);
// LOG(DEBUG) << "key is " << key.to_hex(n);
@ -4674,22 +4683,21 @@ bool ValidateQuery::check_one_library_update(td::ConstBitPtr key, Ref<vm::CellSl
} else {
old_publishers = std::make_unique<vm::Dictionary>(256);
}
if (!old_publishers->scan_diff(
*new_publishers,
[this, lib_key = key](td::ConstBitPtr key, int key_len, Ref<vm::CellSlice> old_val,
Ref<vm::CellSlice> new_val) {
CHECK(key_len == 256);
if (old_val.not_null() && !old_val->empty_ext()) {
return false;
}
if (new_val.not_null() && !new_val->empty_ext()) {
return false;
}
CHECK(old_val.not_null() != new_val.not_null());
lib_publishers2_.emplace_back(lib_key, key, new_val.not_null());
return true;
},
3 /* check augmentation of changed nodes */)) {
if (!old_publishers->scan_diff(*new_publishers,
[ this, lib_key = key ](td::ConstBitPtr key, int key_len, Ref<vm::CellSlice> old_val,
Ref<vm::CellSlice> new_val) {
CHECK(key_len == 256);
if (old_val.not_null() && !old_val->empty_ext()) {
return false;
}
if (new_val.not_null() && !new_val->empty_ext()) {
return false;
}
CHECK(old_val.not_null() != new_val.not_null());
lib_publishers2_.emplace_back(lib_key, key, new_val.not_null());
return true;
},
3 /* check augmentation of changed nodes */)) {
return reject_query("invalid publishers set for shard library with hash "s + key.to_hex(256));
}
return true;
@ -5011,15 +5019,14 @@ bool ValidateQuery::check_mc_state_extra() {
try {
vm::AugmentedDictionary old_prev_dict{old_extra.r1.prev_blocks, 32, block::tlb::aug_OldMcBlocksInfo};
vm::AugmentedDictionary new_prev_dict{new_extra.r1.prev_blocks, 32, block::tlb::aug_OldMcBlocksInfo};
if (!old_prev_dict.scan_diff(
new_prev_dict,
[this](td::ConstBitPtr key, int key_len, Ref<vm::CellSlice> old_val_extra,
Ref<vm::CellSlice> new_val_extra) {
CHECK(key_len == 32);
return check_one_prev_dict_update((unsigned)key.get_uint(32), std::move(old_val_extra),
std::move(new_val_extra));
},
3 /* check augmentation of changed nodes */)) {
if (!old_prev_dict.scan_diff(new_prev_dict,
[this](td::ConstBitPtr key, int key_len, Ref<vm::CellSlice> old_val_extra,
Ref<vm::CellSlice> new_val_extra) {
CHECK(key_len == 32);
return check_one_prev_dict_update(
(unsigned)key.get_uint(32), std::move(old_val_extra), std::move(new_val_extra));
},
3 /* check augmentation of changed nodes */)) {
return reject_query("invalid previous block dictionary in the new state");
}
td::BitArray<32> key;