Version 10: extra currencies, anycasts (#1595)

* Disable anycast address, allow deploying with "fixed prefix length"

* GETEXTRABALANCE instruction, changes in reserve

* Change exitcode for "too many extra currencies"

* Revert end_lt and collect action fine if state limits are exceeded

* Fix consuming gas in RUNVM

* Fix checking message balance

* Add "supported-version" and capability constants to fift

* Add unpacked in msg params to TVM c7

* Remove excessive logs in celldb

* Fix moving libraries and log in runvm

* Move "in msg params" in c7 to version 11

* Add msg value (with extra) to INMSGPARAMS

Author: SpyCheese

crypto/block/block-parse.cpp

@@ -738,7 +738,7 @@ const TickTock t_TickTock;
 const RefAnything t_RefCell;
 
 bool StateInit::validate_skip(int* ops, vm::CellSlice& cs, bool weak) const {
-  return Maybe<UInt>{5}.validate_skip(ops, cs, weak)            // split_depth:(Maybe (## 5))
+  return Maybe<UInt>{5}.validate_skip(ops, cs, weak)            // fixed_prefix_length:(Maybe (## 5))
          && Maybe<TickTock>{}.validate_skip(ops, cs, weak)      // special:(Maybe TickTock)
          && Maybe<RefAnything>{}.validate_skip(ops, cs, weak)   // code:(Maybe ^Cell)
          && Maybe<RefAnything>{}.validate_skip(ops, cs, weak)   // data:(Maybe ^Cell)
@@ -1078,7 +1078,7 @@ bool Account::skip_copy_depth_balance(vm::CellBuilder& cb, vm::CellSlice& cs) co
     case account:
       return cs.advance(1)                                   // account$1
              && t_MsgAddressInt.skip_get_depth(cs, depth)    // addr:MsgAddressInt
-             && cb.store_uint_leq(30, depth)                 // -> store split_depth:(#<= 30)
+             && cb.store_uint_leq(30, depth)                 // -> store fixed_prefix_length:(#<= 30)
              && t_StorageInfo.skip(cs)                       // storage_stat:StorageInfo
              && t_AccountStorage.skip_copy_balance(cb, cs);  // storage:AccountStorage
   }
@@ -1223,13 +1223,14 @@ bool HashmapAugE::extract_extra(vm::CellSlice& cs) const {
 bool DepthBalanceInfo::skip(vm::CellSlice& cs) const {
   return cs.advance(5) &&
          t_CurrencyCollection.skip(
-             cs);  // depth_balance$_ split_depth:(#<= 30) balance:CurrencyCollection = DepthBalanceInfo;
+             cs);  // depth_balance$_ fixed_prefix_length:(#<= 30) balance:CurrencyCollection = DepthBalanceInfo;
 }
 
 bool DepthBalanceInfo::validate_skip(int* ops, vm::CellSlice& cs, bool weak) const {
   return cs.fetch_ulong(5) <= 30 &&
-         t_CurrencyCollection.validate_skip(ops, cs,
-                                            weak);  // depth_balance$_ split_depth:(#<= 30) balance:CurrencyCollection
+         t_CurrencyCollection.validate_skip(
+             ops, cs,
+             weak);  // depth_balance$_ fixed_prefix_length:(#<= 30) balance:CurrencyCollection
 }
 
 bool DepthBalanceInfo::null_value(vm::CellBuilder& cb) const {

crypto/block/block.tlb

@@ -141,12 +141,12 @@ ext_out_msg_info$11 src:MsgAddress dest:MsgAddressExt
 
 tick_tock$_ tick:Bool tock:Bool = TickTock;
 
-_ split_depth:(Maybe (## 5)) special:(Maybe TickTock)
+_ fixed_prefix_length:(Maybe (## 5)) special:(Maybe TickTock)
   code:(Maybe ^Cell) data:(Maybe ^Cell)
   library:(Maybe ^Cell) = StateInit;
 
 // StateInitWithLibs is used to validate sent and received messages
-_ split_depth:(Maybe (## 5)) special:(Maybe TickTock)
+_ fixed_prefix_length:(Maybe (## 5)) special:(Maybe TickTock)
   code:(Maybe ^Cell) data:(Maybe ^Cell)
   library:(HashmapE 256 SimpleLib) = StateInitWithLibs;
 
@@ -272,14 +272,6 @@ acc_state_frozen$01 = AccountStatus;
 acc_state_active$10 = AccountStatus;
 acc_state_nonexist$11 = AccountStatus;
 
-/* duplicates
-tick_tock$_ tick:Bool tock:Bool = TickTock;
-
-_ split_depth:(Maybe (## 5)) special:(Maybe TickTock)
-  code:(Maybe ^Cell) data:(Maybe ^Cell)
-  library:(Maybe ^Cell) = StateInit;
-*/
-
 account_descr$_ account:^Account last_trans_hash:bits256 
   last_trans_lt:uint64 = ShardAccount;
 
@@ -800,7 +792,8 @@ size_limits_config#01 max_msg_bits:uint32 max_msg_cells:uint32 max_library_cells
   max_ext_msg_size:uint32 max_ext_msg_depth:uint16 = SizeLimitsConfig;
 size_limits_config_v2#02 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 max_acc_state_cells:uint32 max_acc_state_bits:uint32
-  max_acc_public_libraries:uint32 defer_out_queue_size_limit:uint32 max_msg_extra_currencies:uint32 = SizeLimitsConfig;
+  max_acc_public_libraries:uint32 defer_out_queue_size_limit:uint32 max_msg_extra_currencies:uint32
+  max_acc_fixed_prefix_length:uint8 = SizeLimitsConfig;
 _ SizeLimitsConfig = ConfigParam 43;
 
 // key is [ wc:int32 addr:uint256 ]

crypto/block/create-state.cpp

@@ -94,12 +94,12 @@ typedef td::BitArray<256> hash_t;
 
 struct SmcDescr {
   hash_t addr;
-  int split_depth;
+  int fixed_prefix_length;
   bool preinit_only;
   td::RefInt256 gram_balance;
   Ref<vm::DataCell> state_init;  // StateInit
   Ref<vm::DataCell> account;     // Account
-  SmcDescr(const hash_t& _addr) : addr(_addr), split_depth(0), preinit_only(false) {
+  SmcDescr(const hash_t& _addr) : addr(_addr), fixed_prefix_length(0), preinit_only(false) {
   }
 };
 
@@ -123,7 +123,7 @@ vm::Dictionary config_dict{32};
 ton::UnixTime now;
 
 bool set_config_smc(const SmcDescr& smc) {
-  if (config_addr_set || smc.preinit_only || workchain_id != wc_master || smc.split_depth) {
+  if (config_addr_set || smc.preinit_only || workchain_id != wc_master || smc.fixed_prefix_length) {
     return false;
   }
   vm::CellSlice cs = load_cell_slice(smc.state_init);
@@ -221,7 +221,7 @@ bool add_public_library(hash_t lib_addr, hash_t smc_addr, Ref<vm::Cell> lib_root
 }
 
 td::RefInt256 create_smartcontract(td::RefInt256 smc_addr, Ref<vm::Cell> code, Ref<vm::Cell> data,
-                                   Ref<vm::Cell> library, td::RefInt256 balance, int special, int split_depth,
+                                   Ref<vm::Cell> library, td::RefInt256 balance, int special, int fixed_prefix_length,
                                    int mode) {
   if (is_empty_cell(code)) {
     code.clear();
@@ -238,12 +238,12 @@ td::RefInt256 create_smartcontract(td::RefInt256 smc_addr, Ref<vm::Cell> code, R
     THRERR("not a valid library collection");
   }
   vm::CellBuilder cb;
-  if (!split_depth) {
+  if (!fixed_prefix_length) {
     PDO(cb.store_long_bool(0, 1));
   } else {
-    PDO(cb.store_long_bool(1, 1) && cb.store_ulong_rchk_bool(split_depth, 5));
+    PDO(cb.store_long_bool(1, 1) && cb.store_ulong_rchk_bool(fixed_prefix_length, 5));
   }
-  THRERR("invalid split_depth for a smart contract");
+  THRERR("invalid fixed_prefix_length for a smart contract");
   if (!special) {
     PDO(cb.store_long_bool(0, 1));
   } else {
@@ -287,7 +287,7 @@ td::RefInt256 create_smartcontract(td::RefInt256 smc_addr, Ref<vm::Cell> code, R
   auto ins = smart_contracts.emplace(addr, addr);
   assert(ins.second);
   SmcDescr& smc = ins.first->second;
-  smc.split_depth = split_depth;
+  smc.fixed_prefix_length = fixed_prefix_length;
   smc.preinit_only = (mode == 1);
   smc.gram_balance = balance;
   total_smc_balance += balance;
@@ -328,10 +328,10 @@ td::RefInt256 create_smartcontract(td::RefInt256 smc_addr, Ref<vm::Cell> code, R
     ctor = 2;  // addr_std$10
   }
   PDO(cb.store_long_bool(ctor, 2));  // addr_std$10 or addr_var$11
-  if (split_depth) {
+  if (fixed_prefix_length) {
     PDO(cb.store_long_bool(1, 1)                            // just$1
-        && cb.store_ulong_rchk_bool(split_depth, 5)         // depth:(## 5)
-        && cb.store_bits_bool(addr.cbits(), split_depth));  // rewrite pfx:(depth * Bit)
+        && cb.store_ulong_rchk_bool(fixed_prefix_length, 5)         // depth:(## 5)
+        && cb.store_bits_bool(addr.cbits(), fixed_prefix_length));  // rewrite pfx:(depth * Bit)
   } else {
     PDO(cb.store_long_bool(0, 1));  // nothing$0
   }
@@ -515,7 +515,7 @@ Ref<vm::Cell> create_state() {
 // data (cell)
 // library (cell)
 // balance (int)
-// split_depth (int 0..32)
+// fixed_prefix_length (int 0..32)
 // special (int 0..3, +2 = tick, +1 = tock)
 // [ address (uint256) ]
 // mode (0 = compute address only, 1 = create uninit, 2 = create complete; +4 = with specified address)
@@ -537,7 +537,7 @@ void interpret_register_smartcontract(vm::Stack& stack) {
   if (special && workchain_id != wc_master) {
     throw fift::IntError{"cannot create special smartcontracts outside of the masterchain"};
   }
-  int split_depth = stack.pop_smallint_range(32);
+  int fixed_prefix_length = stack.pop_smallint_range(32);
   td::RefInt256 balance = stack.pop_int_finite();
   if (sgn(balance) < 0) {
     throw fift::IntError{"initial balance of a smartcontract cannot be negative"};
@@ -549,7 +549,7 @@ void interpret_register_smartcontract(vm::Stack& stack) {
   Ref<vm::Cell> data = stack.pop_cell();
   Ref<vm::Cell> code = stack.pop_cell();
   td::RefInt256 addr = create_smartcontract(std::move(spec_addr), std::move(code), std::move(data), std::move(library),
-                                            std::move(balance), special, split_depth, mode);
+                                            std::move(balance), special, fixed_prefix_length, mode);
   if (addr.is_null()) {
     throw fift::IntError{"internal error while creating smartcontract"};
   }

crypto/block/mc-config.cpp

@@ -2040,6 +2040,7 @@ td::Result<SizeLimitsConfig> Config::do_get_size_limits_config(td::Ref<vm::CellS
     limits.max_acc_public_libraries = rec.max_acc_public_libraries;
     limits.defer_out_queue_size_limit = rec.defer_out_queue_size_limit;
     limits.max_msg_extra_currencies = rec.max_msg_extra_currencies;
+    limits.max_acc_fixed_prefix_length = rec.max_acc_fixed_prefix_length;
   };
   gen::SizeLimitsConfig::Record_size_limits_config rec_v1;
   gen::SizeLimitsConfig::Record_size_limits_config_v2 rec_v2;

crypto/block/mc-config.h

@@ -402,6 +402,7 @@ struct SizeLimitsConfig {
   td::uint32 max_acc_public_libraries = 256;
   td::uint32 defer_out_queue_size_limit = 256;
   td::uint32 max_msg_extra_currencies = 2;
+  td::uint32 max_acc_fixed_prefix_length = 8;
 };
 
 struct CatchainValidatorsConfig {