Merge pull request #1765 from ton-blockchain/version-12

Version 12: new bounce, BTOS, HASHBU opcodes

Author: EmelyanenkoK

common/global-version.h

@@ -19,6 +19,6 @@
 namespace ton {
 
 // See doc/GlobalVersions.md
-constexpr int SUPPORTED_VERSION = 11;
+constexpr int SUPPORTED_VERSION = 12;
 
 }

crypto/block/block-parse.cpp

@@ -665,7 +665,7 @@ bool CommonMsgInfo::validate_skip(int* ops, vm::CellSlice& cs, bool weak) const
              && t_MsgAddressInt.validate_skip(ops, cs, weak)       // src
              && t_MsgAddressInt.validate_skip(ops, cs, weak)       // dest
              && t_CurrencyCollection.validate_skip(ops, cs, weak)  // value
-             && t_Grams.validate_skip(ops, cs, weak)               // ihr_fee
+             && t_Grams.validate_skip(ops, cs, weak)               // extra_flags
              && t_Grams.validate_skip(ops, cs, weak)               // fwd_fee
              && cs.advance(64 + 32);                               // created_lt:uint64 created_at:uint32
     case ext_in_msg_info:
@@ -684,7 +684,7 @@ bool CommonMsgInfo::unpack(vm::CellSlice& cs, CommonMsgInfo::Record_int_msg_info
   return get_tag(cs) == int_msg_info && cs.advance(1) && cs.fetch_bool_to(data.ihr_disabled) &&
          cs.fetch_bool_to(data.bounce) && cs.fetch_bool_to(data.bounced) && t_MsgAddressInt.fetch_to(cs, data.src) &&
          t_MsgAddressInt.fetch_to(cs, data.dest) && t_CurrencyCollection.fetch_to(cs, data.value) &&
-         t_Grams.fetch_to(cs, data.ihr_fee) && t_Grams.fetch_to(cs, data.fwd_fee) &&
+         t_Grams.fetch_to(cs, data.extra_flags) && t_Grams.fetch_to(cs, data.fwd_fee) &&
          cs.fetch_uint_to(64, data.created_lt) && cs.fetch_uint_to(32, data.created_at);
 }
 
@@ -696,7 +696,7 @@ bool CommonMsgInfo::skip(vm::CellSlice& cs) const {
              && t_MsgAddressInt.skip(cs)       // src
              && t_MsgAddressInt.skip(cs)       // dest
              && t_CurrencyCollection.skip(cs)  // value
-             && t_Grams.skip(cs)               // ihr_fee
+             && t_Grams.skip(cs)               // extra_flags
              && t_Grams.skip(cs)               // fwd_fee
              && cs.advance(64 + 32);           // created_lt:uint64 created_at:uint32
     case ext_in_msg_info:
@@ -718,7 +718,7 @@ bool CommonMsgInfo::get_created_lt(vm::CellSlice& cs, unsigned long long& create
              && t_MsgAddressInt.skip(cs)             // src
              && t_MsgAddressInt.skip(cs)             // dest
              && t_CurrencyCollection.skip(cs)        // value
-             && t_Grams.skip(cs)                     // ihr_fee
+             && t_Grams.skip(cs)                     // extra_flags
              && t_Grams.skip(cs)                     // fwd_fee
              && cs.fetch_ulong_bool(64, created_lt)  // created_lt:uint64
              && cs.advance(32);                      // created_at:uint32
@@ -1843,26 +1843,18 @@ bool InMsg::validate_skip(int* ops, vm::CellSlice& cs, bool weak) const {
   return false;
 }
 
-bool InMsg::get_import_fees(vm::CellBuilder& cb, vm::CellSlice& cs) const {
+static td::RefInt256 get_ihr_fee(const CommonMsgInfo::Record_int_msg_info &info, int global_version) {
+  // Legacy: extra_flags was previously ihr_fee
+  return global_version >= 12 ? td::zero_refint() : t_Grams.as_integer(std::move(info.extra_flags));
+}
+
+bool InMsg::get_import_fees(vm::CellBuilder& cb, vm::CellSlice& cs, int global_version) const {
   int tag = get_tag(cs);
   switch (tag) {
     case msg_import_ext:                   // inbound external message
       return t_ImportFees.null_value(cb);  // external messages have no value and no import fees
     case msg_import_ihr:                   // IHR-forwarded internal message to its final destination
-      if (cs.advance(3) && cs.size_refs() >= 3) {
-        auto msg_cs = load_cell_slice(cs.fetch_ref());
-        CommonMsgInfo::Record_int_msg_info msg_info;
-        td::RefInt256 ihr_fee;
-        vm::CellBuilder aux;
-        // sort of Prolog-style in C++
-        return t_Message.extract_info(msg_cs) && t_CommonMsgInfo.unpack(msg_cs, msg_info) &&
-               cs.fetch_ref().not_null() && (ihr_fee = t_Grams.as_integer_skip(cs)).not_null() &&
-               cs.fetch_ref().not_null() && !cmp(ihr_fee, t_Grams.as_integer(*msg_info.ihr_fee)) &&
-               cb.append_cellslice_bool(msg_info.ihr_fee)  // fees_collected := ihr_fee
-               && aux.append_cellslice_bool(msg_info.ihr_fee) && t_ExtraCurrencyCollection.null_value(aux) &&
-               t_CurrencyCollection.add_values(cb, aux.as_cellslice_ref().write(),
-                                               msg_info.value.write());  // value_imported := ihr_fee + value
-      }
+      // IHR is not implemented
       return false;
     case msg_import_imm:  // internal message re-imported from this very block
       if (cs.advance(3) && cs.size_refs() >= 2) {
@@ -1888,7 +1880,7 @@ bool InMsg::get_import_fees(vm::CellBuilder& cb, vm::CellSlice& cs) const {
         return t_Message.extract_info(msg_cs) && t_CommonMsgInfo.unpack(msg_cs, msg_info) &&
                cb.append_cellslice_bool(in_msg.fwd_fee_remaining)  // fees_collected := fwd_fee_remaining
                && t_Grams.as_integer_skip_to(msg_info.value.write(), value_grams) &&
-               (ihr_fee = t_Grams.as_integer(std::move(msg_info.ihr_fee))).not_null() &&
+               (ihr_fee = get_ihr_fee(msg_info, global_version)).not_null() &&
                t_Grams.store_integer_ref(cb, value_grams + ihr_fee + fwd_fee_remaining) &&
                cb.append_cellslice_bool(
                    msg_info.value.write());  // value_imported = msg.value + msg.ihr_fee + fwd_fee_remaining
@@ -1911,7 +1903,7 @@ bool InMsg::get_import_fees(vm::CellBuilder& cb, vm::CellSlice& cs) const {
         return t_Message.extract_info(msg_cs) && t_CommonMsgInfo.unpack(msg_cs, msg_info) &&
                t_Grams.store_integer_ref(cb, std::move(transit_fee))  // fees_collected := transit_fees
                && t_Grams.as_integer_skip_to(msg_info.value.write(), value_grams) &&
-               (ihr_fee = t_Grams.as_integer(std::move(msg_info.ihr_fee))).not_null() &&
+               (ihr_fee = get_ihr_fee(msg_info, global_version)).not_null() &&
                t_Grams.store_integer_ref(cb, value_grams + ihr_fee + fwd_fee_remaining) &&
                cb.append_cellslice_bool(
                    msg_info.value.write());  // value_imported = msg.value + msg.ihr_fee + fwd_fee_remaining
@@ -1941,8 +1933,8 @@ bool InMsg::get_import_fees(vm::CellBuilder& cb, vm::CellSlice& cs) const {
 
 const InMsg t_InMsg;
 
-const Aug_InMsgDescr aug_InMsgDescr;
-const InMsgDescr t_InMsgDescr;
+const Aug_InMsgDescr aug_InMsgDescrDefault(ton::SUPPORTED_VERSION);
+const InMsgDescr t_InMsgDescrDefault(ton::SUPPORTED_VERSION);
 
 bool OutMsg::skip(vm::CellSlice& cs) const {
   switch (get_tag(cs)) {
@@ -2038,7 +2030,7 @@ bool OutMsg::validate_skip(int* ops, vm::CellSlice& cs, bool weak) const {
   return false;
 }
 
-bool OutMsg::get_export_value(vm::CellBuilder& cb, vm::CellSlice& cs) const {
+bool OutMsg::get_export_value(vm::CellBuilder& cb, vm::CellSlice& cs, int global_version) const {
   auto tag = get_tag(cs);
   switch (tag) {
     case msg_export_ext:  // external outbound message carries no value
@@ -2071,7 +2063,7 @@ bool OutMsg::get_export_value(vm::CellBuilder& cb, vm::CellSlice& cs) const {
         td::RefInt256 value_grams, ihr_fee, fwd_fee_remaining;
         return t_Message.extract_info(msg_cs) && t_CommonMsgInfo.unpack(msg_cs, msg_info) &&
                (value_grams = t_Grams.as_integer_skip(msg_info.value.write())).not_null() &&
-               (ihr_fee = t_Grams.as_integer(std::move(msg_info.ihr_fee))).not_null() &&
+               (ihr_fee = get_ihr_fee(msg_info, global_version)).not_null() &&
                (fwd_fee_remaining = t_Grams.as_integer(out_msg.fwd_fee_remaining)).not_null() &&
                t_Grams.store_integer_ref(cb, value_grams + ihr_fee + fwd_fee_remaining) &&
                cb.append_cellslice_bool(std::move(msg_info.value));
@@ -2112,8 +2104,8 @@ bool OutMsg::get_emitted_lt(vm::CellSlice& cs, unsigned long long& emitted_lt) c
 
 const OutMsg t_OutMsg;
 
-const Aug_OutMsgDescr aug_OutMsgDescr;
-const OutMsgDescr t_OutMsgDescr;
+const Aug_OutMsgDescr aug_OutMsgDescrDefault(ton::SUPPORTED_VERSION);
+const OutMsgDescr t_OutMsgDescrDefault(ton::SUPPORTED_VERSION);
 
 bool EnqueuedMsg::validate_skip(int* ops, vm::CellSlice& cs, bool weak) const {
   return cs.advance(64) && t_Ref_MsgEnvelope.validate_skip(ops, cs, weak);

crypto/block/block-parse.h

@@ -405,7 +405,7 @@ struct CommonMsgInfo final : TLB_Complex {
 
 struct CommonMsgInfo::Record_int_msg_info {
   bool ihr_disabled, bounce, bounced;
-  Ref<vm::CellSlice> src, dest, value, ihr_fee, fwd_fee;
+  Ref<vm::CellSlice> src, dest, value, extra_flags, fwd_fee;
   unsigned long long created_lt;
   unsigned created_at;
 };
@@ -604,7 +604,7 @@ extern const Aug_ShardAccounts aug_ShardAccounts;
 
 struct ShardAccounts final : TLB_Complex {
   HashmapAugE dict_type;
-  ShardAccounts() : dict_type(256, aug_ShardAccounts){};
+  ShardAccounts() : dict_type(256, aug_ShardAccounts) {};
   bool skip(vm::CellSlice& cs) const override {
     return dict_type.skip(cs);
   }
@@ -814,7 +814,7 @@ struct InMsg final : TLB_Complex {
     }
     return (int)cs.prefetch_ulong(5) - 0b00100 + 8;
   }
-  bool get_import_fees(vm::CellBuilder& cb, vm::CellSlice& cs) const;
+  bool get_import_fees(vm::CellBuilder& cb, vm::CellSlice& cs, int global_version) const;
 };
 
 extern const InMsg t_InMsg;
@@ -844,7 +844,7 @@ struct OutMsg final : TLB_Complex {
     }
     return t;
   }
-  bool get_export_value(vm::CellBuilder& cb, vm::CellSlice& cs) const;
+  bool get_export_value(vm::CellBuilder& cb, vm::CellSlice& cs, int global_version) const;
   bool get_emitted_lt(vm::CellSlice& cs, unsigned long long& emitted_lt) const;
 };
 
@@ -853,18 +853,22 @@ extern const OutMsg t_OutMsg;
 // next: InMsgDescr, OutMsgDescr, OutMsgQueue, and their augmentations
 
 struct Aug_InMsgDescr final : AugmentationCheckData {
-  Aug_InMsgDescr() : AugmentationCheckData(t_InMsg, t_ImportFees) {
+  explicit Aug_InMsgDescr(int global_version)
+      : AugmentationCheckData(t_InMsg, t_ImportFees), global_version(global_version) {
   }
   bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override {
-    return t_InMsg.get_import_fees(cb, cs);
+    return t_InMsg.get_import_fees(cb, cs, global_version);
   }
+  int global_version;
 };
 
-extern const Aug_InMsgDescr aug_InMsgDescr;
+extern const Aug_InMsgDescr aug_InMsgDescrDefault;
 
 struct InMsgDescr final : TLB_Complex {
+  Aug_InMsgDescr aug;
   HashmapAugE dict_type;
-  InMsgDescr() : dict_type(256, aug_InMsgDescr){};
+  explicit InMsgDescr(int global_version) : aug(global_version), dict_type(256, aug) {
+  }
   bool skip(vm::CellSlice& cs) const override {
     return dict_type.skip(cs);
   }
@@ -873,21 +877,25 @@ struct InMsgDescr final : TLB_Complex {
   }
 };
 
-extern const InMsgDescr t_InMsgDescr;
+extern const InMsgDescr t_InMsgDescrDefault;
 
 struct Aug_OutMsgDescr final : AugmentationCheckData {
-  Aug_OutMsgDescr() : AugmentationCheckData(t_OutMsg, t_CurrencyCollection) {
+  explicit Aug_OutMsgDescr(int global_version)
+      : AugmentationCheckData(t_OutMsg, t_CurrencyCollection), global_version(global_version) {
   }
   bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override {
-    return t_OutMsg.get_export_value(cb, cs);
+    return t_OutMsg.get_export_value(cb, cs, global_version);
   }
+  int global_version;
 };
 
-extern const Aug_OutMsgDescr aug_OutMsgDescr;
+extern const Aug_OutMsgDescr aug_OutMsgDescrDefault;
 
 struct OutMsgDescr final : TLB_Complex {
+  Aug_OutMsgDescr aug;
   HashmapAugE dict_type;
-  OutMsgDescr() : dict_type(256, aug_OutMsgDescr){};
+  explicit OutMsgDescr(int global_version) : aug(global_version), dict_type(256, aug) {
+  }
   bool skip(vm::CellSlice& cs) const override {
     return dict_type.skip(cs);
   }
@@ -896,7 +904,7 @@ struct OutMsgDescr final : TLB_Complex {
   }
 };
 
-extern const OutMsgDescr t_OutMsgDescr;
+extern const OutMsgDescr t_OutMsgDescrDefault;
 
 struct EnqueuedMsg final : TLB_Complex {
   int get_size(const vm::CellSlice& cs) const override {
@@ -935,7 +943,7 @@ extern const Aug_DispatchQueue aug_DispatchQueue;
 
 struct OutMsgQueue final : TLB_Complex {
   HashmapAugE dict_type;
-  OutMsgQueue() : dict_type(32 + 64 + 256, aug_OutMsgQueue){};
+  OutMsgQueue() : dict_type(32 + 64 + 256, aug_OutMsgQueue) {};
   bool skip(vm::CellSlice& cs) const override {
     return dict_type.skip(cs);
   }
@@ -1138,8 +1146,8 @@ struct Aug_ShardFees final : AugmentationCheckData {
 extern const Aug_ShardFees aug_ShardFees;
 
 // Validate dict of libraries in message: used when sending and receiving message
-bool validate_message_libs(const td::Ref<vm::Cell> &cell);
-bool validate_message_relaxed_libs(const td::Ref<vm::Cell> &cell);
+bool validate_message_libs(const td::Ref<vm::Cell>& cell);
+bool validate_message_relaxed_libs(const td::Ref<vm::Cell>& cell);
 
 }  // namespace tlb
 }  // namespace block

crypto/block/block.tlb

@@ -125,7 +125,7 @@ currencies$_ grams:Grams other:ExtraCurrencyCollection
 //
 int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
   src:MsgAddressInt dest:MsgAddressInt 
-  value:CurrencyCollection ihr_fee:Grams fwd_fee:Grams
+  value:CurrencyCollection extra_flags:(VarUInteger 16) fwd_fee:Grams
   created_lt:uint64 created_at:uint32 = CommonMsgInfo;
 ext_in_msg_info$10 src:MsgAddressExt dest:MsgAddressInt 
   import_fee:Grams = CommonMsgInfo;
@@ -134,7 +134,7 @@ ext_out_msg_info$11 src:MsgAddressInt dest:MsgAddressExt
 
 int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
   src:MsgAddress dest:MsgAddressInt 
-  value:CurrencyCollection ihr_fee:Grams fwd_fee:Grams
+  value:CurrencyCollection extra_flags:(VarUInteger 16) fwd_fee:Grams
   created_lt:uint64 created_at:uint32 = CommonMsgInfoRelaxed;
 ext_out_msg_info$11 src:MsgAddress dest:MsgAddressExt
   created_lt:uint64 created_at:uint32 = CommonMsgInfoRelaxed;
@@ -162,6 +162,16 @@ message$_ {X:Type} info:CommonMsgInfoRelaxed
 
 _ (Message Any) = MessageAny;
 
+
+_ value:CurrencyCollection created_lt:uint64 created_at:uint32 = NewBounceOriginalInfo;
+_ gas_used:uint32 vm_steps:uint32 = NewBounceComputePhaseInfo;
+new_bounce_body#fffffffe
+    original_body:^Cell
+    original_info:^NewBounceOriginalInfo
+    bounced_by_phase:uint8 exit_code:int32
+    compute_phase:(Maybe NewBounceComputePhaseInfo)
+    = NewBounceBody;
+
 //
 interm_addr_regular$0 use_dest_bits:(#<= 96) 
   = IntermediateAddress;
@@ -796,9 +806,9 @@ _ 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;
 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_ext_msg_size:uint32 max_ext_msg_depth:uint16 max_acc_state_cells:uint32 max_mc_acc_state_cells:uint32
   max_acc_public_libraries:uint32 defer_out_queue_size_limit:uint32 max_msg_extra_currencies:uint32
-  max_acc_fixed_prefix_length:uint8 = SizeLimitsConfig;
+  max_acc_fixed_prefix_length:uint8 acc_state_cells_for_storage_dict:uint32 = SizeLimitsConfig;
 _ SizeLimitsConfig = ConfigParam 43;
 
 // key is [ wc:int32 addr:uint256 ]

crypto/block/mc-config.cpp

@@ -2034,12 +2034,13 @@ td::Result<SizeLimitsConfig> Config::do_get_size_limits_config(td::Ref<vm::CellS
 
   auto unpack_v2 = [&](auto& rec) {
     unpack_v1(rec);
-    limits.max_acc_state_bits = rec.max_acc_state_bits;
     limits.max_acc_state_cells = rec.max_acc_state_cells;
+    limits.max_mc_acc_state_cells = rec.max_mc_acc_state_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;
+    limits.acc_state_cells_for_storage_dict = rec.acc_state_cells_for_storage_dict;
   };
   gen::SizeLimitsConfig::Record_size_limits_config rec_v1;
   gen::SizeLimitsConfig::Record_size_limits_config_v2 rec_v2;

crypto/block/mc-config.h

@@ -398,11 +398,12 @@ struct SizeLimitsConfig {
   td::uint16 max_vm_data_depth = 512;
   ExtMsgLimits ext_msg_limits;
   td::uint32 max_acc_state_cells = 1 << 16;
-  td::uint32 max_acc_state_bits = (1 << 16) * 1023;
+  td::uint32 max_mc_acc_state_cells = 1 << 11;  // enabled in global version 12
   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;
+  td::uint32 acc_state_cells_for_storage_dict = 26;
 };
 
 struct CatchainValidatorsConfig {