Merge branch 'testnet' into block-generation

crypto/block/block-parse.h

@@ -653,16 +653,20 @@ struct TrComputeInternal1 final : TLB_Complex {
 };
 
 struct ComputeSkipReason final : TLB {
-  enum { cskip_no_state = 0, cskip_bad_state = 1, cskip_no_gas = 2 };
+  enum { cskip_no_state = 0, cskip_bad_state = 1, cskip_no_gas = 2, cskip_suspended = 3 };
   int get_size(const vm::CellSlice& cs) const override {
-    return 2;
+    return cs.prefetch_ulong(2) == 3 ? 3 : 2;
   }
   bool validate_skip(int* ops, vm::CellSlice& cs, bool weak = false) const override {
-    return get_tag(cs) >= 0 && cs.advance(2);
+    int tag = get_tag(cs);
+    return tag >= 0 && cs.advance(tag == 3 ? 3 : 2);
   }
   int get_tag(const vm::CellSlice& cs) const override {
     int t = (int)cs.prefetch_ulong(2);
-    return t < 3 ? t : -1;
+    if (t == 3 && cs.prefetch_ulong(3) != 0b110) {
+      return -1;
+    }
+    return t;
   }
 };
 

crypto/block/block.tlb

@@ -309,6 +309,7 @@ tr_phase_compute_vm$1 success:Bool msg_state_used:Bool
 cskip_no_state$00 = ComputeSkipReason;
 cskip_bad_state$01 = ComputeSkipReason;
 cskip_no_gas$10 = ComputeSkipReason;
+cskip_suspended$110 = ComputeSkipReason;
 
 tr_phase_action$_ success:Bool valid:Bool no_funds:Bool
   status_change:AccStatusChange
@@ -762,6 +763,10 @@ size_limits_config_v2#02 max_msg_bits:uint32 max_msg_cells:uint32 max_library_ce
   max_ext_msg_size:uint32 max_ext_msg_depth:uint16 max_acc_state_cells:uint32 max_acc_state_bits:uint32 = SizeLimitsConfig;
 _ SizeLimitsConfig = ConfigParam 43;
 
+// key is [ wc:int32 addr:uint256 ]
+suspended_address_list#00 addresses:(HashmapE 288 Unit) suspended_until:uint32 = SuspendedAddressList;
+_ SuspendedAddressList = ConfigParam 44;
+
 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
@@ -883,6 +888,8 @@ cap_method_pubkey#71f4 = SmcCapability;
 cap_is_wallet#2177 = SmcCapability;
 cap_name#ff name:Text = SmcCapability;
 
+dns_storage_address#7473 bag_id:bits256 = DNSRecord;
+
 //
 // PAYMENT CHANNELS
 //

crypto/block/mc-config.cpp

@@ -1945,6 +1945,15 @@ td::Result<SizeLimitsConfig> Config::get_size_limits_config() const {
   return limits;
 }
 
+std::unique_ptr<vm::Dictionary> Config::get_suspended_addresses(ton::UnixTime now) const {
+  td::Ref<vm::Cell> param = get_config_param(44);
+  gen::SuspendedAddressList::Record rec;
+  if (param.is_null() || !tlb::unpack_cell(param, rec) || rec.suspended_until <= now) {
+    return {};
+  }
+  return std::make_unique<vm::Dictionary>(rec.addresses->prefetch_ref(), 288);
+}
+
 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");

crypto/block/mc-config.h

@@ -628,6 +628,7 @@ class Config {
   std::vector<ton::ValidatorDescr> compute_total_validator_set(int next) const;
   CollatorConfig get_collator_config(bool need_collator_nodes) const;
   td::Result<SizeLimitsConfig> get_size_limits_config() const;
+  std::unique_ptr<vm::Dictionary> get_suspended_addresses(ton::UnixTime now) 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,

crypto/block/transaction.cpp

@@ -794,6 +794,20 @@ bool ComputePhaseConfig::parse_GasLimitsPrices_internal(Ref<vm::CellSlice> cs, t
   return true;
 }
 
+bool ComputePhaseConfig::is_address_suspended(ton::WorkchainId wc, td::Bits256 addr) const {
+  if (!suspended_addresses) {
+    return false;
+  }
+  try {
+    vm::CellBuilder key;
+    key.store_long_bool(wc, 32);
+    key.store_bits_bool(addr);
+    return !suspended_addresses->lookup(key.data_bits(), 288).is_null();
+  } catch (vm::VmError) {
+    return false;
+  }
+}
+
 void ComputePhaseConfig::compute_threshold() {
   gas_price256 = td::make_refint(gas_price);
   if (gas_limit > flat_gas_limit) {
@@ -1006,6 +1020,11 @@ bool Transaction::prepare_compute_phase(const ComputePhaseConfig& cfg) {
   if (in_msg_state.not_null() &&
       (acc_status == Account::acc_uninit ||
        (acc_status == Account::acc_frozen && account.state_hash == in_msg_state->get_hash().bits()))) {
+    if (acc_status == Account::acc_uninit && cfg.is_address_suspended(account.workchain, account.addr)) {
+      LOG(DEBUG) << "address is suspended, skipping compute phase";
+      cp.skip_reason = ComputePhase::sk_suspended;
+      return true;
+    }
     use_msg_state = true;
     if (!(unpack_msg_state() && account.check_split_depth(new_split_depth))) {
       LOG(DEBUG) << "cannot unpack in_msg_state, or it has bad split_depth; cannot init account state";
@@ -2263,6 +2282,8 @@ bool Transaction::serialize_compute_phase(vm::CellBuilder& cb) {
       return cb.store_long_bool(1, 3);  // cskip_bad_state$01 = ComputeSkipReason;
     case ComputePhase::sk_no_gas:
       return cb.store_long_bool(2, 3);  // cskip_no_gas$10 = ComputeSkipReason;
+    case ComputePhase::sk_suspended:
+      return cb.store_long_bool(0b0110, 4);  // cskip_suspended$110 = ComputeSkipReason;
     case ComputePhase::sk_none:
       break;
     default:

crypto/block/transaction.h

@@ -108,6 +108,7 @@ struct ComputePhaseConfig {
   td::BitArray<256> block_rand_seed;
   bool with_vm_log{false};
   td::uint16 max_vm_data_depth = 512;
+  std::unique_ptr<vm::Dictionary> suspended_addresses;
   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();
@@ -132,6 +133,7 @@ struct ComputePhaseConfig {
   }
   bool parse_GasLimitsPrices(Ref<vm::CellSlice> cs, td::RefInt256& freeze_due_limit, td::RefInt256& delete_due_limit);
   bool parse_GasLimitsPrices(Ref<vm::Cell> cell, td::RefInt256& freeze_due_limit, td::RefInt256& delete_due_limit);
+  bool is_address_suspended(ton::WorkchainId wc, td::Bits256 addr) const;
 
  private:
   bool parse_GasLimitsPrices_internal(Ref<vm::CellSlice> cs, td::RefInt256& freeze_due_limit,
@@ -157,7 +159,7 @@ struct CreditPhase {
 };
 
 struct ComputePhase {
-  enum { sk_none, sk_no_state, sk_bad_state, sk_no_gas };
+  enum { sk_none, sk_no_state, sk_bad_state, sk_no_gas, sk_suspended };
   int skip_reason{sk_none};
   bool success{false};
   bool msg_state_used{false};