mirror of
https://github.com/ton-blockchain/ton
synced 2025-02-12 11:12:16 +00:00
52b010ff34
Block size estimation can decrease, so it was possible that soft limit was reached, but the block is not considered overloaded
381 lines
18 KiB
C++
381 lines
18 KiB
C++
/*
|
|
This file is part of TON Blockchain Library.
|
|
|
|
TON Blockchain Library is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
TON Blockchain Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
Copyright 2017-2020 Telegram Systems LLP
|
|
*/
|
|
#pragma once
|
|
#include "interfaces/validator-manager.h"
|
|
#include "shard.hpp"
|
|
#include "top-shard-descr.hpp"
|
|
#include "common/refcnt.hpp"
|
|
#include "vm/cells.h"
|
|
#include "vm/dict.h"
|
|
#include "block/mc-config.h"
|
|
#include "block/block.h"
|
|
#include "block/transaction.h"
|
|
#include "block/block-db.h"
|
|
#include "block/output-queue-merger.h"
|
|
#include "vm/cells/MerkleProof.h"
|
|
#include "vm/cells/MerkleUpdate.h"
|
|
#include <map>
|
|
#include <queue>
|
|
#include "common/global-version.h"
|
|
|
|
namespace ton {
|
|
|
|
namespace validator {
|
|
using td::Ref;
|
|
|
|
class Collator final : public td::actor::Actor {
|
|
static constexpr int supported_version() {
|
|
return SUPPORTED_VERSION;
|
|
}
|
|
static constexpr long long supported_capabilities() {
|
|
return ton::capCreateStatsEnabled | ton::capBounceMsgBody | ton::capReportVersion | ton::capShortDequeue |
|
|
ton::capStoreOutMsgQueueSize | ton::capMsgMetadata | ton::capDeferMessages;
|
|
}
|
|
using LtCellRef = block::LtCellRef;
|
|
using NewOutMsg = block::NewOutMsg;
|
|
const ShardIdFull shard_;
|
|
ton::BlockId new_id;
|
|
bool busy_{false};
|
|
bool before_split_{false};
|
|
bool after_split_{false};
|
|
bool after_merge_{false};
|
|
bool want_split_{false};
|
|
bool want_merge_{false};
|
|
bool right_child_{false};
|
|
bool preinit_complete{false};
|
|
bool is_key_block_{false};
|
|
bool block_full_{false};
|
|
bool inbound_queues_empty_{false};
|
|
bool libraries_changed_{false};
|
|
bool prev_key_block_exists_{false};
|
|
bool is_hardfork_{false};
|
|
BlockIdExt min_mc_block_id;
|
|
std::vector<BlockIdExt> prev_blocks;
|
|
std::vector<Ref<ShardState>> prev_states;
|
|
std::vector<Ref<BlockData>> prev_block_data;
|
|
Ed25519_PublicKey created_by_;
|
|
Ref<CollatorOptions> collator_opts_;
|
|
Ref<ValidatorSet> validator_set_;
|
|
td::actor::ActorId<ValidatorManager> manager;
|
|
td::Timestamp timeout;
|
|
td::Timestamp queue_cleanup_timeout_, soft_timeout_, medium_timeout_;
|
|
td::Promise<BlockCandidate> main_promise;
|
|
unsigned mode_ = 0;
|
|
int attempt_idx_;
|
|
bool allow_repeat_collation_ = false;
|
|
ton::BlockSeqno last_block_seqno{0};
|
|
ton::BlockSeqno prev_mc_block_seqno{0};
|
|
ton::BlockSeqno new_block_seqno{0};
|
|
ton::BlockSeqno prev_key_block_seqno_{0};
|
|
int step{0};
|
|
int pending{0};
|
|
static constexpr int max_ihr_msg_size = 65535; // 64k
|
|
static constexpr int max_ext_msg_size = 65535; // 64k
|
|
static constexpr int max_blk_sign_size = 65535; // 64k
|
|
static constexpr bool shard_splitting_enabled = true;
|
|
|
|
public:
|
|
Collator(ShardIdFull shard, bool is_hardfork, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
|
|
Ref<ValidatorSet> validator_set, Ed25519_PublicKey collator_id, Ref<CollatorOptions> collator_opts,
|
|
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout, td::Promise<BlockCandidate> promise,
|
|
td::CancellationToken cancellation_token, unsigned mode, int attempt_idx);
|
|
~Collator() override = default;
|
|
bool is_busy() const {
|
|
return busy_;
|
|
}
|
|
ShardId get_shard() const {
|
|
return shard_.shard;
|
|
}
|
|
WorkchainId workchain() const {
|
|
return shard_.workchain;
|
|
}
|
|
static constexpr td::uint32 priority() {
|
|
return 2;
|
|
}
|
|
|
|
static td::Result<std::unique_ptr<block::transaction::Transaction>>
|
|
impl_create_ordinary_transaction(Ref<vm::Cell> msg_root,
|
|
block::Account* acc,
|
|
UnixTime utime, LogicalTime lt,
|
|
block::StoragePhaseConfig* storage_phase_cfg,
|
|
block::ComputePhaseConfig* compute_phase_cfg,
|
|
block::ActionPhaseConfig* action_phase_cfg,
|
|
bool external, LogicalTime after_lt);
|
|
|
|
private:
|
|
void start_up() override;
|
|
void alarm() override;
|
|
int verbosity{3 * 0};
|
|
int verify{1};
|
|
ton::LogicalTime start_lt, max_lt;
|
|
ton::UnixTime now_;
|
|
ton::UnixTime prev_now_;
|
|
ton::UnixTime now_upper_limit_{~0U};
|
|
unsigned out_msg_queue_ops_{}, in_descr_cnt_{}, out_descr_cnt_{};
|
|
Ref<MasterchainStateQ> mc_state_;
|
|
Ref<BlockData> prev_mc_block;
|
|
BlockIdExt mc_block_id_;
|
|
Ref<vm::Cell> mc_state_root;
|
|
Ref<vm::Cell> mc_block_root;
|
|
td::BitArray<256> rand_seed_ = td::Bits256::zero();
|
|
std::unique_ptr<block::ConfigInfo> config_;
|
|
std::unique_ptr<block::ShardConfig> shard_conf_;
|
|
std::map<BlockSeqno, Ref<MasterchainStateQ>> aux_mc_states_;
|
|
std::vector<block::McShardDescr> neighbors_;
|
|
std::unique_ptr<block::OutputQueueMerger> nb_out_msgs_;
|
|
std::vector<ton::StdSmcAddress> special_smcs;
|
|
std::vector<std::pair<ton::StdSmcAddress, int>> ticktock_smcs;
|
|
Ref<vm::Cell> prev_block_root;
|
|
Ref<vm::Cell> prev_state_root_, prev_state_root_pure_;
|
|
Ref<vm::Cell> state_root; // (new) shardchain state
|
|
Ref<vm::Cell> state_update; // Merkle update from prev_state_root to state_root
|
|
std::shared_ptr<vm::CellUsageTree> state_usage_tree_; // used to construct Merkle update
|
|
Ref<vm::CellSlice> new_config_params_;
|
|
Ref<vm::Cell> old_mparams_;
|
|
ton::LogicalTime prev_state_lt_;
|
|
ton::LogicalTime shards_max_end_lt_{0};
|
|
ton::UnixTime prev_state_utime_;
|
|
int global_id_{0};
|
|
ton::BlockSeqno min_ref_mc_seqno_{~0U};
|
|
ton::BlockSeqno vert_seqno_{~0U}, prev_vert_seqno_{~0U};
|
|
ton::BlockIdExt prev_key_block_;
|
|
ton::LogicalTime prev_key_block_lt_;
|
|
bool accept_msgs_{true};
|
|
bool shard_conf_adjusted_{false};
|
|
bool ihr_enabled_{false};
|
|
bool create_stats_enabled_{false};
|
|
bool report_version_{false};
|
|
bool skip_topmsgdescr_{false};
|
|
bool skip_extmsg_{false};
|
|
bool short_dequeue_records_{false};
|
|
td::uint64 overload_history_{0}, underload_history_{0};
|
|
td::uint64 block_size_estimate_{};
|
|
Ref<block::WorkchainInfo> wc_info_;
|
|
std::vector<Ref<ShardTopBlockDescription>> shard_block_descr_;
|
|
std::vector<Ref<ShardTopBlockDescrQ>> used_shard_block_descr_;
|
|
std::unique_ptr<vm::Dictionary> shard_libraries_;
|
|
Ref<vm::Cell> mc_state_extra_;
|
|
std::unique_ptr<vm::AugmentedDictionary> account_dict;
|
|
std::map<ton::StdSmcAddress, std::unique_ptr<block::Account>> accounts;
|
|
std::vector<block::StoragePrices> storage_prices_;
|
|
block::StoragePhaseConfig storage_phase_cfg_{&storage_prices_};
|
|
block::ComputePhaseConfig compute_phase_cfg_;
|
|
block::ActionPhaseConfig action_phase_cfg_;
|
|
td::RefInt256 masterchain_create_fee_, basechain_create_fee_;
|
|
std::unique_ptr<block::BlockLimits> block_limits_;
|
|
std::unique_ptr<block::BlockLimitStatus> block_limit_status_;
|
|
int block_limit_class_ = 0;
|
|
ton::LogicalTime min_new_msg_lt{std::numeric_limits<td::uint64>::max()};
|
|
block::CurrencyCollection total_balance_, old_total_balance_, total_validator_fees_;
|
|
block::CurrencyCollection global_balance_, old_global_balance_, import_created_{0};
|
|
Ref<vm::Cell> recover_create_msg_, mint_msg_;
|
|
Ref<vm::Cell> new_block;
|
|
block::ValueFlow value_flow_{block::ValueFlow::SetZero()};
|
|
std::unique_ptr<vm::AugmentedDictionary> fees_import_dict_;
|
|
std::map<ton::Bits256, int> ext_msg_map;
|
|
struct ExtMsg {
|
|
Ref<vm::Cell> cell;
|
|
ExtMessage::Hash hash;
|
|
int priority;
|
|
};
|
|
std::vector<ExtMsg> ext_msg_list_;
|
|
std::priority_queue<NewOutMsg, std::vector<NewOutMsg>, std::greater<NewOutMsg>> new_msgs;
|
|
std::pair<ton::LogicalTime, ton::Bits256> last_proc_int_msg_, first_unproc_int_msg_;
|
|
std::unique_ptr<vm::AugmentedDictionary> in_msg_dict, out_msg_dict, out_msg_queue_, sibling_out_msg_queue_;
|
|
std::map<StdSmcAddress, size_t> unprocessed_deferred_messages_; // number of messages from dispatch queue in new_msgs
|
|
td::uint64 out_msg_queue_size_ = 0;
|
|
td::uint64 old_out_msg_queue_size_ = 0;
|
|
bool have_out_msg_queue_size_in_state_ = false;
|
|
std::unique_ptr<vm::Dictionary> ihr_pending;
|
|
std::shared_ptr<block::MsgProcessedUptoCollection> processed_upto_, sibling_processed_upto_;
|
|
std::unique_ptr<vm::Dictionary> block_create_stats_;
|
|
std::map<td::Bits256, int> block_create_count_;
|
|
unsigned block_create_total_{0};
|
|
std::vector<ExtMessage::Hash> bad_ext_msgs_, delay_ext_msgs_;
|
|
Ref<vm::Cell> shard_account_blocks_; // ShardAccountBlocks
|
|
std::vector<Ref<vm::Cell>> collated_roots_;
|
|
std::unique_ptr<ton::BlockCandidate> block_candidate;
|
|
|
|
std::unique_ptr<vm::AugmentedDictionary> dispatch_queue_;
|
|
std::map<StdSmcAddress, td::uint32> sender_generated_messages_count_;
|
|
unsigned dispatch_queue_ops_{0};
|
|
std::map<StdSmcAddress, LogicalTime> last_dispatch_queue_emitted_lt_;
|
|
bool have_unprocessed_account_dispatch_queue_ = false;
|
|
bool dispatch_queue_total_limit_reached_ = false;
|
|
td::uint64 defer_out_queue_size_limit_;
|
|
td::uint64 hard_defer_out_queue_size_limit_;
|
|
|
|
std::unique_ptr<vm::AugmentedDictionary> account_dict_estimator_;
|
|
std::set<td::Bits256> account_dict_estimator_added_accounts_;
|
|
unsigned account_dict_ops_{0};
|
|
|
|
bool msg_metadata_enabled_ = false;
|
|
bool deferring_messages_enabled_ = false;
|
|
bool store_out_msg_queue_size_ = false;
|
|
|
|
td::PerfWarningTimer perf_timer_;
|
|
//
|
|
block::Account* lookup_account(td::ConstBitPtr addr) const;
|
|
std::unique_ptr<block::Account> make_account_from(td::ConstBitPtr addr, Ref<vm::CellSlice> account,
|
|
bool force_create);
|
|
td::Result<block::Account*> make_account(td::ConstBitPtr addr, bool force_create = false);
|
|
td::actor::ActorId<Collator> get_self() {
|
|
return actor_id(this);
|
|
}
|
|
bool init_utime();
|
|
bool init_lt();
|
|
bool fetch_config_params();
|
|
bool fatal_error(td::Status error);
|
|
bool fatal_error(int err_code, std::string err_msg);
|
|
bool fatal_error(std::string err_msg, int err_code = -666);
|
|
void check_pending();
|
|
void after_get_mc_state(td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res);
|
|
void after_get_shard_state(int idx, td::Result<Ref<ShardState>> res);
|
|
void after_get_block_data(int idx, td::Result<Ref<BlockData>> res);
|
|
void after_get_shard_blocks(td::Result<std::vector<Ref<ShardTopBlockDescription>>> res);
|
|
bool preprocess_prev_mc_state();
|
|
bool register_mc_state(Ref<MasterchainStateQ> other_mc_state);
|
|
bool request_aux_mc_state(BlockSeqno seqno, Ref<MasterchainStateQ>& state);
|
|
Ref<MasterchainStateQ> get_aux_mc_state(BlockSeqno seqno) const;
|
|
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_out_queue(int i, td::Result<Ref<MessageQueue>> res);
|
|
void got_out_queue_size(size_t i, td::Result<td::uint64> res);
|
|
bool adjust_shard_config();
|
|
bool store_shard_fees(ShardIdFull shard, const block::CurrencyCollection& fees,
|
|
const block::CurrencyCollection& created);
|
|
bool store_shard_fees(Ref<block::McShardHash> descr);
|
|
bool import_new_shard_top_blocks();
|
|
bool register_shard_block_creators(std::vector<td::Bits256> creator_list);
|
|
bool init_block_limits();
|
|
bool compute_minted_amount(block::CurrencyCollection& to_mint);
|
|
bool init_value_create();
|
|
bool try_collate();
|
|
bool do_preinit();
|
|
bool do_collate();
|
|
bool create_special_transactions();
|
|
bool create_special_transaction(block::CurrencyCollection amount, Ref<vm::Cell> dest_addr_cell,
|
|
Ref<vm::Cell>& in_msg);
|
|
bool create_ticktock_transactions(int mask);
|
|
bool create_ticktock_transaction(const ton::StdSmcAddress& smc_addr, ton::LogicalTime req_start_lt, int mask);
|
|
Ref<vm::Cell> create_ordinary_transaction(Ref<vm::Cell> msg_root, td::optional<block::MsgMetadata> msg_metadata,
|
|
LogicalTime after_lt, bool is_special_tx = false);
|
|
bool check_cur_validator_set();
|
|
bool unpack_last_mc_state();
|
|
bool unpack_last_state();
|
|
bool unpack_merge_last_state();
|
|
bool unpack_one_last_state(block::ShardState& ss, BlockIdExt blkid, Ref<vm::Cell> prev_state_root);
|
|
bool split_last_state(block::ShardState& ss);
|
|
bool import_shard_state_data(block::ShardState& ss);
|
|
bool add_trivial_neighbor();
|
|
bool add_trivial_neighbor_after_merge();
|
|
bool out_msg_queue_cleanup();
|
|
bool dequeue_message(Ref<vm::Cell> msg_envelope, ton::LogicalTime delivered_lt);
|
|
bool check_prev_block(const BlockIdExt& listed, const BlockIdExt& prev, bool chk_chain_len = true);
|
|
bool check_prev_block_exact(const BlockIdExt& listed, const BlockIdExt& prev);
|
|
bool check_this_shard_mc_info();
|
|
bool request_neighbor_msg_queues();
|
|
bool request_out_msg_queue_size();
|
|
void update_max_lt(ton::LogicalTime lt);
|
|
bool is_masterchain() const {
|
|
return shard_.is_masterchain();
|
|
}
|
|
bool is_our_address(Ref<vm::CellSlice> addr_ref) const;
|
|
bool is_our_address(ton::AccountIdPrefixFull addr_prefix) const;
|
|
bool is_our_address(const ton::StdSmcAddress& addr) const;
|
|
void after_get_external_messages(td::Result<std::vector<std::pair<Ref<ExtMessage>, int>>> res);
|
|
td::Result<bool> register_external_message_cell(Ref<vm::Cell> ext_msg, const ExtMessage::Hash& ext_hash,
|
|
int priority);
|
|
// td::Result<bool> register_external_message(td::Slice ext_msg_boc);
|
|
void register_new_msg(block::NewOutMsg msg);
|
|
void register_new_msgs(block::transaction::Transaction& trans, td::optional<block::MsgMetadata> msg_metadata);
|
|
bool process_new_messages(bool enqueue_only = false);
|
|
int process_one_new_message(block::NewOutMsg msg, bool enqueue_only = false, Ref<vm::Cell>* is_special = nullptr);
|
|
bool process_inbound_internal_messages();
|
|
bool process_inbound_message(Ref<vm::CellSlice> msg, ton::LogicalTime lt, td::ConstBitPtr key,
|
|
const block::McShardDescr& src_nb);
|
|
bool process_inbound_external_messages();
|
|
int process_external_message(Ref<vm::Cell> msg);
|
|
bool process_dispatch_queue();
|
|
bool process_deferred_message(Ref<vm::CellSlice> enq_msg, StdSmcAddress src_addr, LogicalTime lt,
|
|
td::optional<block::MsgMetadata>& msg_metadata);
|
|
bool enqueue_message(block::NewOutMsg msg, td::RefInt256 fwd_fees_remaining, StdSmcAddress src_addr,
|
|
bool defer = false);
|
|
bool enqueue_transit_message(Ref<vm::Cell> msg, Ref<vm::Cell> old_msg_env, ton::AccountIdPrefixFull prev_prefix,
|
|
ton::AccountIdPrefixFull cur_prefix, ton::AccountIdPrefixFull dest_prefix,
|
|
td::RefInt256 fwd_fee_remaining, td::optional<block::MsgMetadata> msg_metadata,
|
|
td::optional<LogicalTime> emitted_lt = {});
|
|
bool delete_out_msg_queue_msg(td::ConstBitPtr key);
|
|
bool insert_in_msg(Ref<vm::Cell> in_msg);
|
|
bool insert_out_msg(Ref<vm::Cell> out_msg);
|
|
bool insert_out_msg(Ref<vm::Cell> out_msg, td::ConstBitPtr msg_hash);
|
|
bool register_out_msg_queue_op(bool force = false);
|
|
bool register_dispatch_queue_op(bool force = false);
|
|
bool update_account_dict_estimation(const block::transaction::Transaction& trans);
|
|
bool update_min_mc_seqno(ton::BlockSeqno some_mc_seqno);
|
|
bool combine_account_transactions();
|
|
bool update_public_libraries();
|
|
bool update_account_public_libraries(Ref<vm::Cell> orig_libs, Ref<vm::Cell> final_libs, const td::Bits256& addr);
|
|
bool add_public_library(td::ConstBitPtr key, td::ConstBitPtr addr, Ref<vm::Cell> library);
|
|
bool remove_public_library(td::ConstBitPtr key, td::ConstBitPtr addr);
|
|
bool check_block_overload();
|
|
bool update_block_creator_count(td::ConstBitPtr key, unsigned shard_incr, unsigned mc_incr);
|
|
int creator_count_outdated(td::ConstBitPtr key, vm::CellSlice& cs);
|
|
bool update_block_creator_stats();
|
|
bool create_mc_state_extra();
|
|
bool create_shard_state();
|
|
td::Result<Ref<vm::Cell>> get_config_data_from_smc(const ton::StdSmcAddress& cfg_addr);
|
|
bool try_fetch_new_config(const ton::StdSmcAddress& cfg_addr, Ref<vm::Cell>& new_config);
|
|
bool update_processed_upto();
|
|
bool compute_out_msg_queue_info(Ref<vm::Cell>& out_msg_queue_info);
|
|
bool compute_total_balance();
|
|
bool store_master_ref(vm::CellBuilder& cb);
|
|
bool store_prev_blk_ref(vm::CellBuilder& cb, bool after_merge);
|
|
bool store_zero_state_ref(vm::CellBuilder& cb);
|
|
bool store_version(vm::CellBuilder& cb) const;
|
|
bool create_block_info(Ref<vm::Cell>& block_info);
|
|
bool check_value_flow();
|
|
bool create_block_extra(Ref<vm::Cell>& block_extra);
|
|
bool update_shard_config(const block::WorkchainSet& wc_set, const block::CatchainValidatorsConfig& ccvc,
|
|
bool update_cc);
|
|
bool create_mc_block_extra(Ref<vm::Cell>& mc_block_extra);
|
|
bool create_block();
|
|
Ref<vm::Cell> collate_shard_block_descr_set();
|
|
bool create_collated_data();
|
|
|
|
bool create_block_candidate();
|
|
void return_block_candidate(td::Result<td::Unit> saved);
|
|
bool update_last_proc_int_msg(const std::pair<ton::LogicalTime, ton::Bits256>& new_lt_hash);
|
|
|
|
td::CancellationToken cancellation_token_;
|
|
bool check_cancelled();
|
|
|
|
public:
|
|
static td::uint32 get_skip_externals_queue_size();
|
|
|
|
private:
|
|
td::Timer work_timer_{true};
|
|
td::ThreadCpuTimer cpu_work_timer_{true};
|
|
CollationStats stats_;
|
|
};
|
|
|
|
} // namespace validator
|
|
|
|
} // namespace ton
|