Move some constants to global config (ton-blockchain#484)

coalars · Oct 10, 2022 · 1d42c38 · 1d42c38
1 parent 5808840
commit 1d42c38
Show file tree

Hide file tree

Showing 24 changed files with 218 additions and 88 deletions.
diff --git a/crypto/block/block.tlb b/crypto/block/block.tlb
@@ -611,15 +611,29 @@ wfmt_ext#0 min_addr_len:(## 12) max_addr_len:(## 12) addr_len_step:(## 12)
   workchain_type_id:(## 32) { workchain_type_id >= 1 }
   = WorkchainFormat 0;
 
-workchain#a6 enabled_since:uint32 actual_min_split:(## 8) 
-  min_split:(## 8) max_split:(## 8) { actual_min_split <= min_split }
+wc_split_merge_timings#0
+  split_merge_delay:uint32 split_merge_interval:uint32
+  min_split_merge_interval:uint32 max_split_merge_delay:uint32
+  = WcSplitMergeTimings;
+
 //workchain#a5 enabled_since:uint32 min_split:(## 8) max_split:(## 8)
 //  { min_split <= max_split } { max_split <= 60 }
+
+workchain#a6 enabled_since:uint32 actual_min_split:(## 8) 
+  min_split:(## 8) max_split:(## 8) { actual_min_split <= min_split }
   basic:(## 1) active:Bool accept_msgs:Bool flags:(## 13) { flags = 0 }
   zerostate_root_hash:bits256 zerostate_file_hash:bits256
   version:uint32 format:(WorkchainFormat basic)
   = WorkchainDescr;
 
+workchain_v2#a7 enabled_since:uint32 actual_min_split:(## 8)
+  min_split:(## 8) max_split:(## 8) { actual_min_split <= min_split }
+  basic:(## 1) active:Bool accept_msgs:Bool flags:(## 13) { flags = 0 }
+  zerostate_root_hash:bits256 zerostate_file_hash:bits256
+  version:uint32 format:(WorkchainFormat basic)
+  split_merge_timings:WcSplitMergeTimings
+  = WorkchainDescr;
+
 _ workchains:(HashmapE 32 WorkchainDescr) = ConfigParam 12;
 
 complaint_prices#1a deposit:Grams bit_price:Grams cell_price:Grams = ComplaintPricing; 
@@ -734,6 +748,10 @@ misbehaviour_punishment_config_v1#01
    = MisbehaviourPunishmentConfig;
 _ MisbehaviourPunishmentConfig = ConfigParam 40;
 
+size_limits_config#01 max_msg_bits:uint32 max_msg_cells:uint32 max_library_cells:uint32 max_vm_data_depth:uint16
+  max_ext_msg_size:uint32 max_ext_msg_depth:uint16 = SizeLimitsConfig;
+_ SizeLimitsConfig = ConfigParam 43;
+
 oracle_bridge_params#_ bridge_address:bits256 oracle_mutlisig_address:bits256 oracles:(HashmapE 256 uint256) external_chain_address:bits256 = OracleBridgeParams;
 _ OracleBridgeParams = ConfigParam 71; // Ethereum bridge
 _ OracleBridgeParams = ConfigParam 72; // Binance Smart Chain bridge

diff --git a/crypto/block/mc-config.cpp b/crypto/block/mc-config.cpp
@@ -1913,6 +1913,25 @@ std::vector<ton::ValidatorDescr> Config::compute_total_validator_set(int next) c
   return res.move_as_ok()->export_validator_set();
 }
 
+td::Result<SizeLimitsConfig> Config::get_size_limits_config() const {
+  SizeLimitsConfig limits;
+  td::Ref<vm::Cell> param = get_config_param(43);
+  if (param.is_null()) {
+    return limits;
+  }
+  gen::SizeLimitsConfig::Record rec;
+  if (!tlb::unpack_cell(param, rec)) {
+    return td::Status::Error("configuration parameter 43 is invalid");
+  }
+  limits.max_msg_bits = rec.max_msg_bits;
+  limits.max_msg_cells = rec.max_msg_cells;
+  limits.max_library_cells = rec.max_library_cells;
+  limits.max_vm_data_depth = static_cast<td::uint16>(rec.max_vm_data_depth);
+  limits.ext_msg_limits.max_size = rec.max_ext_msg_size;
+  limits.ext_msg_limits.max_depth = static_cast<td::uint16>(rec.max_ext_msg_depth);
+  return limits;
+}
+
 td::Result<std::pair<ton::UnixTime, ton::UnixTime>> Config::unpack_validator_set_start_stop(Ref<vm::Cell> vset_root) {
   if (vset_root.is_null()) {
     return td::Status::Error("validator set absent");
@@ -1942,31 +1961,58 @@ bool WorkchainInfo::unpack(ton::WorkchainId wc, vm::CellSlice& cs) {
   if (wc == ton::workchainInvalid) {
     return false;
   }
-  block::gen::WorkchainDescr::Record info;
-  if (!tlb::unpack(cs, info)) {
-    return false;
-  }
-  enabled_since = info.enabled_since;
-  actual_min_split = info.actual_min_split;
-  min_split = info.min_split;
-  max_split = info.max_split;
-  basic = info.basic;
-  active = info.active;
-  accept_msgs = info.accept_msgs;
-  flags = info.flags;
-  zerostate_root_hash = info.zerostate_root_hash;
-  zerostate_file_hash = info.zerostate_file_hash;
-  version = info.version;
-  if (basic) {
-    min_addr_len = max_addr_len = addr_len_step = 256;
-  } else {
-    block::gen::WorkchainFormat::Record_wfmt_ext ext;
-    if (!tlb::type_unpack(cs, block::gen::WorkchainFormat{basic}, ext)) {
+  auto unpack_v1 = [this](auto& info) {
+    enabled_since = info.enabled_since;
+    actual_min_split = info.actual_min_split;
+    min_split = info.min_split;
+    max_split = info.max_split;
+    basic = info.basic;
+    active = info.active;
+    accept_msgs = info.accept_msgs;
+    flags = info.flags;
+    zerostate_root_hash = info.zerostate_root_hash;
+    zerostate_file_hash = info.zerostate_file_hash;
+    version = info.version;
+    if (basic) {
+      min_addr_len = max_addr_len = addr_len_step = 256;
+    } else {
+      block::gen::WorkchainFormat::Record_wfmt_ext ext;
+      if (!tlb::csr_type_unpack(info.format, block::gen::WorkchainFormat{basic}, ext)) {
+        return false;
+      }
+      min_addr_len = ext.min_addr_len;
+      max_addr_len = ext.max_addr_len;
+      addr_len_step = ext.addr_len_step;
+    }
+    return true;
+  };
+  auto unpack_v2 = [&, this](auto& info) {
+    if (!unpack_v1(info)) {
+      return false;
+    }
+    block::gen::WcSplitMergeTimings::Record rec;
+    if (!tlb::csr_unpack(info.split_merge_timings, rec)) {
       return false;
     }
-    min_addr_len = ext.min_addr_len;
-    max_addr_len = ext.max_addr_len;
-    addr_len_step = ext.addr_len_step;
+    split_merge_delay = rec.split_merge_delay;
+    split_merge_interval = rec.split_merge_interval;
+    min_split_merge_interval = rec.min_split_merge_interval;
+    max_split_merge_delay = rec.max_split_merge_delay;
+    return true;
+  };
+  block::gen::WorkchainDescr::Record_workchain info_v1;
+  block::gen::WorkchainDescr::Record_workchain_v2 info_v2;
+  vm::CellSlice cs0 = cs;
+  if (tlb::unpack(cs, info_v1)) {
+    if (!unpack_v1(info_v1)) {
+      return false;
+    }
+  } else if (tlb::unpack(cs = cs0, info_v2)) {
+    if (!unpack_v2(info_v2)) {
+      return false;
+    }
+  } else {
+    return false;
   }
   workchain = wc;
   LOG(DEBUG) << "unpacked info for workchain " << wc << ": basic=" << basic << ", active=" << active

diff --git a/crypto/block/mc-config.h b/crypto/block/mc-config.h
@@ -376,6 +376,19 @@ struct MsgPrices {
   td::RefInt256 get_next_part(td::RefInt256 total) const;
 };
 
+struct SizeLimitsConfig {
+  // Default values are used when not present in global config
+  struct ExtMsgLimits {
+    td::uint32 max_size = 65535;
+    td::uint16 max_depth = 512;
+  };
+  td::uint32 max_msg_bits = 1 << 21;
+  td::uint32 max_msg_cells = 1 << 13;
+  td::uint32 max_library_cells = 1000;
+  td::uint16 max_vm_data_depth = 512;
+  ExtMsgLimits ext_msg_limits;
+};
+
 struct CatchainValidatorsConfig {
   td::uint32 mc_cc_lifetime, shard_cc_lifetime, shard_val_lifetime, shard_val_num;
   bool shuffle_mc_val;
@@ -402,6 +415,13 @@ struct WorkchainInfo : public td::CntObject {
   ton::RootHash zerostate_root_hash;
   ton::FileHash zerostate_file_hash;
   int min_addr_len, max_addr_len, addr_len_step;
+
+  // Default values are used when split_merge_timings is not set in config
+  unsigned split_merge_delay = 100;       // prepare (delay) split/merge for 100 seconds
+  unsigned split_merge_interval = 100;    // split/merge is enabled during 60 second interval
+  unsigned min_split_merge_interval = 30; // split/merge interval must be at least 30 seconds
+  unsigned max_split_merge_delay = 1000;  // end of split/merge interval must be at most 1000 seconds in the future
+
   bool is_valid() const {
     return workchain != ton::workchainInvalid;
   }
@@ -593,6 +613,7 @@ class Config {
   std::vector<ton::ValidatorDescr> compute_validator_set(ton::ShardIdFull shard, ton::UnixTime time,
                                                          ton::CatchainSeqno cc_seqno) const;
   std::vector<ton::ValidatorDescr> compute_total_validator_set(int next) const;
+  td::Result<SizeLimitsConfig> get_size_limits_config() const;
   static std::vector<ton::ValidatorDescr> do_compute_validator_set(const block::CatchainValidatorsConfig& ccv_conf,
                                                                    ton::ShardIdFull shard,
                                                                    const block::ValidatorSet& vset, ton::UnixTime time,

diff --git a/crypto/block/transaction.cpp b/crypto/block/transaction.cpp
@@ -593,7 +593,7 @@ bool Transaction::unpack_input_msg(bool ihr_delivered, const ActionPhaseConfig*
       sstat.bits -= cs.size();         // bits in the root cells are free
       sstat.cells--;                   // the root cell itself is not counted as a cell
       LOG(DEBUG) << "storage paid for a message: " << sstat.cells << " cells, " << sstat.bits << " bits";
-      if (sstat.bits > max_msg_bits || sstat.cells > max_msg_cells) {
+      if (sstat.bits > cfg->size_limits.max_msg_bits || sstat.cells > cfg->size_limits.max_msg_cells) {
         LOG(DEBUG) << "inbound external message too large, invalid";
         return false;
       }
@@ -1043,6 +1043,7 @@ bool Transaction::prepare_compute_phase(const ComputePhaseConfig& cfg) {
     vm_log.log_options = td::LogOptions(VERBOSITY_NAME(DEBUG), true, false);
   }
   vm::VmState vm{new_code, std::move(stack), gas, 1, new_data, vm_log, compute_vm_libraries(cfg)};
+  vm.set_max_data_depth(cfg.max_vm_data_depth);
   vm.set_c7(prepare_vm_c7(cfg));  // tuple with SmartContractInfo
   // vm.incr_stack_trace(1);    // enable stack dump after each step
 
@@ -1272,6 +1273,11 @@ int Transaction::try_action_change_library(vm::CellSlice& cs, ActionPhase& ap, c
         // library code not found
         return 41;
       }
+      vm::CellStorageStat sstat;
+      sstat.compute_used_storage(lib_ref);
+      if (sstat.cells > cfg.size_limits.max_library_cells) {
+        return 43;
+      }
       vm::CellBuilder cb;
       CHECK(cb.store_bool_bool(rec.mode >> 1) && cb.store_ref_bool(std::move(lib_ref)));
       CHECK(dict.set_builder(hash, cb));
@@ -1546,7 +1552,7 @@ int Transaction::try_action_send_msg(const vm::CellSlice& cs0, ActionPhase& ap,
     sstat.add_used_storage(info.value->prefetch_ref());
   }
   LOG(DEBUG) << "storage paid for a message: " << sstat.cells << " cells, " << sstat.bits << " bits";
-  if (sstat.bits > max_msg_bits || sstat.cells > max_msg_cells) {
+  if (sstat.bits > cfg.size_limits.max_msg_bits || sstat.cells > cfg.size_limits.max_msg_cells) {
     LOG(DEBUG) << "message too large, invalid";
     return skip_invalid ? 0 : 40;
   }

diff --git a/crypto/block/transaction.h b/crypto/block/transaction.h
@@ -107,6 +107,7 @@ struct ComputePhaseConfig {
   Ref<vm::Cell> global_config;
   td::BitArray<256> block_rand_seed;
   bool with_vm_log{false};
+  td::uint16 max_vm_data_depth = 512;
   ComputePhaseConfig(td::uint64 _gas_price = 0, td::uint64 _gas_limit = 0, td::uint64 _gas_credit = 0)
       : gas_price(_gas_price), gas_limit(_gas_limit), special_gas_limit(_gas_limit), gas_credit(_gas_credit) {
     compute_threshold();
@@ -143,6 +144,7 @@ struct ActionPhaseConfig {
   int bounce_msg_body{0};  // usually 0 or 256 bits
   MsgPrices fwd_std;
   MsgPrices fwd_mc;  // from/to masterchain
+  SizeLimitsConfig size_limits;
   const WorkchainSet* workchains{nullptr};
   const MsgPrices& fetch_msg_prices(bool is_masterchain) const {
     return is_masterchain ? fwd_mc : fwd_std;
@@ -283,7 +285,6 @@ struct Account {
 };
 
 struct Transaction {
-  static constexpr unsigned max_msg_bits = (1 << 21), max_msg_cells = (1 << 13);
   enum {
     tr_none,
     tr_ord,

diff --git a/crypto/vm/vm.h b/crypto/vm/vm.h
@@ -97,6 +97,7 @@ class VmState final : public VmStateInterface {
   int stack_trace{0}, debug_off{0};
   bool chksig_always_succeed{false};
   td::ConstBitPtr missing_library{0};
+  td::uint16 max_data_depth = 512; // Default value
 
  public:
   enum {
@@ -108,8 +109,7 @@ class VmState final : public VmStateInterface {
     implicit_jmpref_gas_price = 10,
     implicit_ret_gas_price = 5,
     free_stack_depth = 32,
-    stack_entry_gas_price = 1,
-    max_data_depth = 512
+    stack_entry_gas_price = 1
   };
   VmState();
   VmState(Ref<CellSlice> _code);
@@ -325,6 +325,9 @@ class VmState final : public VmStateInterface {
   td::ConstBitPtr get_missing_library() const {
     return missing_library;
   }
+  void set_max_data_depth(td::uint16 depth) {
+    max_data_depth = depth;
+  }
 
  private:
   void init_cregs(bool same_c3 = false, bool push_0 = true);

diff --git a/ton/ton-types.h b/ton/ton-types.h
@@ -51,12 +51,6 @@ using ValidatorSessionId = td::Bits256;
 constexpr WorkchainId masterchainId = -1, basechainId = 0, workchainInvalid = 0x80000000;
 constexpr ShardId shardIdAll = (1ULL << 63);
 
-constexpr unsigned split_merge_delay = 100;        // prepare (delay) split/merge for 100 seconds
-constexpr unsigned split_merge_interval = 100;     // split/merge is enabled during 60 second interval
-constexpr unsigned min_split_merge_interval = 30;  // split/merge interval must be at least 30 seconds
-constexpr unsigned max_split_merge_delay =
-    1000;  // end of split/merge interval must be at most 1000 seconds in the future
-
 enum GlobalCapabilities {
   capIhrEnabled = 1,
   capCreateStatsEnabled = 2,

diff --git a/validator/fabric.h b/validator/fabric.h
@@ -40,13 +40,15 @@ td::Result<BlockHandle> create_block_handle(td::BufferSlice data);
 td::Result<BlockHandle> create_block_handle(td::Slice data);
 td::Result<ConstBlockHandle> create_temp_block_handle(td::BufferSlice data);
 BlockHandle create_empty_block_handle(BlockIdExt id);
-td::Result<td::Ref<ExtMessage>> create_ext_message(td::BufferSlice data);
+td::Result<td::Ref<ExtMessage>> create_ext_message(td::BufferSlice data,
+                                                   block::SizeLimitsConfig::ExtMsgLimits limits);
 td::Result<td::Ref<IhrMessage>> create_ihr_message(td::BufferSlice data);
 td::Result<std::vector<td::Ref<ShardTopBlockDescription>>> create_new_shard_block_descriptions(td::BufferSlice data);
 
 td::Ref<BlockSignatureSet> create_signature_set(std::vector<BlockSignature> sig_set);
 
-void run_check_external_message(td::BufferSlice data, td::actor::ActorId<ValidatorManager> manager, td::Promise<td::Unit> promise);
+void run_check_external_message(td::BufferSlice data, block::SizeLimitsConfig::ExtMsgLimits limits,
+                                td::actor::ActorId<ValidatorManager> manager, td::Promise<td::Ref<ExtMessage>> promise);
 
 void run_accept_block_query(BlockIdExt id, td::Ref<BlockData> data, std::vector<BlockIdExt> prev,
                             td::Ref<ValidatorSet> validator_set, td::Ref<BlockSignatureSet> signatures,

diff --git a/validator/full-node-shard.cpp b/validator/full-node-shard.cpp
@@ -109,7 +109,14 @@ void FullNodeShardImpl::check_broadcast(PublicKeyHash src, td::BufferSlice broad
 
   auto q = B.move_as_ok();
   td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::check_external_message,
-                          std::move(q->message_->data_), std::move(promise));
+                          std::move(q->message_->data_),
+                          [promise = std::move(promise)](td::Result<td::Ref<ExtMessage>> R) mutable {
+                            if (R.is_error()) {
+                              promise.set_error(R.move_as_error());
+                            } else {
+                              promise.set_result(td::Unit());
+                            }
+                          });
 }
 
 void FullNodeShardImpl::update_adnl_id(adnl::AdnlNodeIdShort adnl_id, td::Promise<td::Unit> promise) {

diff --git a/validator/impl/collator.cpp b/validator/impl/collator.cpp
@@ -1598,6 +1598,7 @@ td::Result<std::unique_ptr<block::ConfigInfo>>
     prng::rand_gen().strong_rand_bytes(rand_seed->data(), 32);
     LOG(DEBUG) << "block random seed set to " << rand_seed->to_hex();
   }
+  TRY_RESULT(size_limits, config->get_size_limits_config());
   {
     // compute compute_phase_cfg / storage_phase_cfg
     auto cell = config->get_config_param(wc == ton::masterchainId ? 20 : 21);
@@ -1610,6 +1611,7 @@ td::Result<std::unique_ptr<block::ConfigInfo>>
     }
     compute_phase_cfg->block_rand_seed = *rand_seed;
     compute_phase_cfg->libraries = std::make_unique<vm::Dictionary>(config->get_libraries_root(), 256);
+    compute_phase_cfg->max_vm_data_depth = size_limits.max_vm_data_depth;
     compute_phase_cfg->global_config = config->get_root_cell();
   }
   {
@@ -1631,6 +1633,7 @@ td::Result<std::unique_ptr<block::ConfigInfo>>
                          (unsigned)rec.first_frac, (unsigned)rec.next_frac};
     action_phase_cfg->workchains = &config->get_workchain_list();
     action_phase_cfg->bounce_msg_body = (config->has_capability(ton::capBounceMsgBody) ? 256 : 0);
+    action_phase_cfg->size_limits = size_limits;
   }
   {
     // fetch block_grams_created
@@ -3095,15 +3098,15 @@ static int update_one_shard(block::McShardHash& info, const block::McShardHash*
     if (info.is_fsm_none() && (info.want_split_ || depth < wc_info->min_split) && depth < wc_info->max_split &&
         depth < 60) {
       // prepare split
-      info.set_fsm_split(now + ton::split_merge_delay, ton::split_merge_interval);
+      info.set_fsm_split(now + wc_info->split_merge_delay, wc_info->split_merge_interval);
       changed = true;
       LOG(INFO) << "preparing to split shard " << info.shard().to_str() << " during " << info.fsm_utime() << " .. "
                 << info.fsm_utime_end();
     } else if (info.is_fsm_none() && depth > wc_info->min_split && (info.want_merge_ || depth > wc_info->max_split) &&
                sibling && !sibling->before_split_ && sibling->is_fsm_none() &&
                (sibling->want_merge_ || depth > wc_info->max_split)) {
       // prepare merge
-      info.set_fsm_merge(now + ton::split_merge_delay, ton::split_merge_interval);
+      info.set_fsm_merge(now + wc_info->split_merge_delay, wc_info->split_merge_interval);
       changed = true;
       LOG(INFO) << "preparing to merge shard " << info.shard().to_str() << " with " << sibling->shard().to_str()
                 << " during " << info.fsm_utime() << " .. " << info.fsm_utime_end();