mirror of
https://github.com/ton-blockchain/ton
synced 2025-02-13 11:42:18 +00:00
0daee1d887
* Deferred messages and msg metadata * Store out msg queue size in state * Add checks for queue processing 1. Collator must process at least one message from AccountDispatchQueue (unless block is full) 2. The first message from a transaction is not counted, it cannot be deferred (unless AccountDispatchQueue is not empty) * Return msg metadata from LS in listBlockTransactions[Ext] * Enable new features by capabilities * Changes in deferred messages * Process deferred messages via new_msgs in collator * Rework setting deferred_lt, bring back check_message_processing_order, check order of deferred_lt in validator * Use have_unprocessed_account_dispatch_queue_ in collator * Fix setting transaction lt for deferred messages * Fix lite-client compilation error * Changes in process_dispatch_queue, rename deferred_lt -> emitted_lt * Fix compilation error * Use uint64 for msg queue size * Add liteServer.getBlockOutMsgQueueSize * Fix compilation error * Fix typos in comments --------- Co-authored-by: SpyCheese <mikle98@yandex.ru>
962 lines
37 KiB
Text
962 lines
37 KiB
Text
unit$_ = Unit;
|
|
true$_ = True;
|
|
// EMPTY False;
|
|
bool_false$0 = Bool;
|
|
bool_true$1 = Bool;
|
|
bool_false$0 = BoolFalse;
|
|
bool_true$1 = BoolTrue;
|
|
nothing$0 {X:Type} = Maybe X;
|
|
just$1 {X:Type} value:X = Maybe X;
|
|
left$0 {X:Type} {Y:Type} value:X = Either X Y;
|
|
right$1 {X:Type} {Y:Type} value:Y = Either X Y;
|
|
pair$_ {X:Type} {Y:Type} first:X second:Y = Both X Y;
|
|
|
|
bit$_ (## 1) = Bit;
|
|
/*
|
|
*
|
|
* FROM hashmap.tlb
|
|
*
|
|
*/
|
|
// ordinary Hashmap / HashmapE, with fixed length keys
|
|
//
|
|
hm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l n)
|
|
{n = (~m) + l} node:(HashmapNode m X) = Hashmap n X;
|
|
|
|
hmn_leaf#_ {X:Type} value:X = HashmapNode 0 X;
|
|
hmn_fork#_ {n:#} {X:Type} left:^(Hashmap n X)
|
|
right:^(Hashmap n X) = HashmapNode (n + 1) X;
|
|
|
|
hml_short$0 {m:#} {n:#} len:(Unary ~n) {n <= m} s:(n * Bit) = HmLabel ~n m;
|
|
hml_long$10 {m:#} n:(#<= m) s:(n * Bit) = HmLabel ~n m;
|
|
hml_same$11 {m:#} v:Bit n:(#<= m) = HmLabel ~n m;
|
|
|
|
unary_zero$0 = Unary ~0;
|
|
unary_succ$1 {n:#} x:(Unary ~n) = Unary ~(n + 1);
|
|
|
|
hme_empty$0 {n:#} {X:Type} = HashmapE n X;
|
|
hme_root$1 {n:#} {X:Type} root:^(Hashmap n X) = HashmapE n X;
|
|
|
|
// true#_ = True;
|
|
_ {n:#} _:(Hashmap n True) = BitstringSet n;
|
|
|
|
// HashmapAug, hashmap with an extra value
|
|
// (augmentation) of type Y at every node
|
|
//
|
|
ahm_edge#_ {n:#} {X:Type} {Y:Type} {l:#} {m:#}
|
|
label:(HmLabel ~l n) {n = (~m) + l}
|
|
node:(HashmapAugNode m X Y) = HashmapAug n X Y;
|
|
ahmn_leaf#_ {X:Type} {Y:Type} extra:Y value:X = HashmapAugNode 0 X Y;
|
|
ahmn_fork#_ {n:#} {X:Type} {Y:Type} left:^(HashmapAug n X Y)
|
|
right:^(HashmapAug n X Y) extra:Y = HashmapAugNode (n + 1) X Y;
|
|
|
|
ahme_empty$0 {n:#} {X:Type} {Y:Type} extra:Y
|
|
= HashmapAugE n X Y;
|
|
ahme_root$1 {n:#} {X:Type} {Y:Type} root:^(HashmapAug n X Y)
|
|
extra:Y = HashmapAugE n X Y;
|
|
|
|
// VarHashmap / VarHashmapE, with variable-length keys
|
|
//
|
|
vhm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l n)
|
|
{n = (~m) + l} node:(VarHashmapNode m X)
|
|
= VarHashmap n X;
|
|
vhmn_leaf$00 {n:#} {X:Type} value:X = VarHashmapNode n X;
|
|
vhmn_fork$01 {n:#} {X:Type} left:^(VarHashmap n X)
|
|
right:^(VarHashmap n X) value:(Maybe X)
|
|
= VarHashmapNode (n + 1) X;
|
|
vhmn_cont$1 {n:#} {X:Type} branch:Bit child:^(VarHashmap n X)
|
|
value:X = VarHashmapNode (n + 1) X;
|
|
|
|
// nothing$0 {X:Type} = Maybe X;
|
|
// just$1 {X:Type} value:X = Maybe X;
|
|
|
|
vhme_empty$0 {n:#} {X:Type} = VarHashmapE n X;
|
|
vhme_root$1 {n:#} {X:Type} root:^(VarHashmap n X)
|
|
= VarHashmapE n X;
|
|
|
|
//
|
|
// PfxHashmap / PfxHashmapE, with variable-length keys
|
|
// constituting a prefix code
|
|
//
|
|
|
|
phm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l n)
|
|
{n = (~m) + l} node:(PfxHashmapNode m X)
|
|
= PfxHashmap n X;
|
|
|
|
phmn_leaf$0 {n:#} {X:Type} value:X = PfxHashmapNode n X;
|
|
phmn_fork$1 {n:#} {X:Type} left:^(PfxHashmap n X)
|
|
right:^(PfxHashmap n X) = PfxHashmapNode (n + 1) X;
|
|
|
|
phme_empty$0 {n:#} {X:Type} = PfxHashmapE n X;
|
|
phme_root$1 {n:#} {X:Type} root:^(PfxHashmap n X)
|
|
= PfxHashmapE n X;
|
|
/*
|
|
*
|
|
* END hashmap.tlb
|
|
*
|
|
*/
|
|
//
|
|
// TON BLOCK LAYOUT
|
|
//
|
|
addr_none$00 = MsgAddressExt;
|
|
addr_extern$01 len:(## 9) external_address:(bits len)
|
|
= MsgAddressExt;
|
|
anycast_info$_ depth:(#<= 30) { depth >= 1 }
|
|
rewrite_pfx:(bits depth) = Anycast;
|
|
addr_std$10 anycast:(Maybe Anycast)
|
|
workchain_id:int8 address:bits256 = MsgAddressInt;
|
|
addr_var$11 anycast:(Maybe Anycast) addr_len:(## 9)
|
|
workchain_id:int32 address:(bits addr_len) = MsgAddressInt;
|
|
_ _:MsgAddressInt = MsgAddress;
|
|
_ _:MsgAddressExt = MsgAddress;
|
|
//
|
|
var_uint$_ {n:#} len:(#< n) value:(uint (len * 8))
|
|
= VarUInteger n;
|
|
var_int$_ {n:#} len:(#< n) value:(int (len * 8))
|
|
= VarInteger n;
|
|
nanograms$_ amount:(VarUInteger 16) = Grams;
|
|
|
|
_ grams:Grams = Coins;
|
|
|
|
//
|
|
extra_currencies$_ dict:(HashmapE 32 (VarUInteger 32))
|
|
= ExtraCurrencyCollection;
|
|
currencies$_ grams:Grams other:ExtraCurrencyCollection
|
|
= CurrencyCollection;
|
|
//
|
|
int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
|
|
src:MsgAddressInt dest:MsgAddressInt
|
|
value:CurrencyCollection ihr_fee:Grams fwd_fee:Grams
|
|
created_lt:uint64 created_at:uint32 = CommonMsgInfo;
|
|
ext_in_msg_info$10 src:MsgAddressExt dest:MsgAddressInt
|
|
import_fee:Grams = CommonMsgInfo;
|
|
ext_out_msg_info$11 src:MsgAddressInt dest:MsgAddressExt
|
|
created_lt:uint64 created_at:uint32 = CommonMsgInfo;
|
|
|
|
int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
|
|
src:MsgAddress dest:MsgAddressInt
|
|
value:CurrencyCollection ihr_fee:Grams 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;
|
|
|
|
tick_tock$_ tick:Bool tock:Bool = TickTock;
|
|
|
|
_ split_depth:(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)
|
|
code:(Maybe ^Cell) data:(Maybe ^Cell)
|
|
library:(HashmapE 256 SimpleLib) = StateInitWithLibs;
|
|
|
|
simple_lib$_ public:Bool root:^Cell = SimpleLib;
|
|
|
|
message$_ {X:Type} info:CommonMsgInfo
|
|
init:(Maybe (Either StateInit ^StateInit))
|
|
body:(Either X ^X) = Message X;
|
|
|
|
message$_ {X:Type} info:CommonMsgInfoRelaxed
|
|
init:(Maybe (Either StateInit ^StateInit))
|
|
body:(Either X ^X) = MessageRelaxed X;
|
|
|
|
_ (Message Any) = MessageAny;
|
|
|
|
//
|
|
interm_addr_regular$0 use_dest_bits:(#<= 96)
|
|
= IntermediateAddress;
|
|
interm_addr_simple$10 workchain_id:int8 addr_pfx:uint64
|
|
= IntermediateAddress;
|
|
interm_addr_ext$11 workchain_id:int32 addr_pfx:uint64
|
|
= IntermediateAddress;
|
|
msg_envelope#4 cur_addr:IntermediateAddress
|
|
next_addr:IntermediateAddress fwd_fee_remaining:Grams
|
|
msg:^(Message Any) = MsgEnvelope;
|
|
msg_metadata#0 depth:uint32 initiator_addr:MsgAddressInt initiator_lt:uint64 = MsgMetadata;
|
|
msg_envelope_v2#5 cur_addr:IntermediateAddress
|
|
next_addr:IntermediateAddress fwd_fee_remaining:Grams
|
|
msg:^(Message Any)
|
|
emitted_lt:(Maybe uint64)
|
|
metadata:(Maybe MsgMetadata) = MsgEnvelope;
|
|
//
|
|
msg_import_ext$000 msg:^(Message Any) transaction:^Transaction
|
|
= InMsg;
|
|
msg_import_ihr$010 msg:^(Message Any) transaction:^Transaction
|
|
ihr_fee:Grams proof_created:^Cell = InMsg;
|
|
msg_import_imm$011 in_msg:^MsgEnvelope
|
|
transaction:^Transaction fwd_fee:Grams = InMsg;
|
|
msg_import_fin$100 in_msg:^MsgEnvelope
|
|
transaction:^Transaction fwd_fee:Grams = InMsg;
|
|
msg_import_tr$101 in_msg:^MsgEnvelope out_msg:^MsgEnvelope
|
|
transit_fee:Grams = InMsg;
|
|
msg_discard_fin$110 in_msg:^MsgEnvelope transaction_id:uint64
|
|
fwd_fee:Grams = InMsg;
|
|
msg_discard_tr$111 in_msg:^MsgEnvelope transaction_id:uint64
|
|
fwd_fee:Grams proof_delivered:^Cell = InMsg;
|
|
msg_import_deferred_fin$00100 in_msg:^MsgEnvelope
|
|
transaction:^Transaction fwd_fee:Grams = InMsg;
|
|
msg_import_deferred_tr$00101 in_msg:^MsgEnvelope out_msg:^MsgEnvelope = InMsg;
|
|
//
|
|
import_fees$_ fees_collected:Grams
|
|
value_imported:CurrencyCollection = ImportFees;
|
|
|
|
_ (HashmapAugE 256 InMsg ImportFees) = InMsgDescr;
|
|
|
|
msg_export_ext$000 msg:^(Message Any)
|
|
transaction:^Transaction = OutMsg;
|
|
msg_export_imm$010 out_msg:^MsgEnvelope
|
|
transaction:^Transaction reimport:^InMsg = OutMsg;
|
|
msg_export_new$001 out_msg:^MsgEnvelope
|
|
transaction:^Transaction = OutMsg;
|
|
msg_export_tr$011 out_msg:^MsgEnvelope
|
|
imported:^InMsg = OutMsg;
|
|
msg_export_deq$1100 out_msg:^MsgEnvelope
|
|
import_block_lt:uint63 = OutMsg;
|
|
msg_export_deq_short$1101 msg_env_hash:bits256
|
|
next_workchain:int32 next_addr_pfx:uint64
|
|
import_block_lt:uint64 = OutMsg;
|
|
msg_export_tr_req$111 out_msg:^MsgEnvelope
|
|
imported:^InMsg = OutMsg;
|
|
msg_export_deq_imm$100 out_msg:^MsgEnvelope
|
|
reimport:^InMsg = OutMsg;
|
|
msg_export_new_defer$10100 out_msg:^MsgEnvelope
|
|
transaction:^Transaction = OutMsg;
|
|
msg_export_deferred_tr$10101 out_msg:^MsgEnvelope
|
|
imported:^InMsg = OutMsg;
|
|
|
|
_ enqueued_lt:uint64 out_msg:^MsgEnvelope = EnqueuedMsg;
|
|
|
|
_ (HashmapAugE 256 OutMsg CurrencyCollection) = OutMsgDescr;
|
|
|
|
_ (HashmapAugE 352 EnqueuedMsg uint64) = OutMsgQueue;
|
|
|
|
processed_upto$_ last_msg_lt:uint64 last_msg_hash:bits256 = ProcessedUpto;
|
|
// key is [ shard:uint64 mc_seqno:uint32 ]
|
|
_ (HashmapE 96 ProcessedUpto) = ProcessedInfo;
|
|
|
|
ihr_pending$_ import_lt:uint64 = IhrPendingSince;
|
|
_ (HashmapE 320 IhrPendingSince) = IhrPendingInfo;
|
|
|
|
// key - created_lt
|
|
_ messages:(HashmapE 64 EnqueuedMsg) count:uint48 = AccountDispatchQueue;
|
|
// key - sender address, aug - min created_lt
|
|
_ (HashmapAugE 256 AccountDispatchQueue uint64) = DispatchQueue;
|
|
|
|
out_msg_queue_extra#0 dispatch_queue:DispatchQueue out_queue_size:(Maybe uint48) = OutMsgQueueExtra;
|
|
|
|
_ out_queue:OutMsgQueue proc_info:ProcessedInfo
|
|
extra:(Maybe OutMsgQueueExtra) = OutMsgQueueInfo;
|
|
//
|
|
storage_used$_ cells:(VarUInteger 7) bits:(VarUInteger 7)
|
|
public_cells:(VarUInteger 7) = StorageUsed;
|
|
|
|
storage_used_short$_ cells:(VarUInteger 7)
|
|
bits:(VarUInteger 7) = StorageUsedShort;
|
|
|
|
storage_info$_ used:StorageUsed last_paid:uint32
|
|
due_payment:(Maybe Grams) = StorageInfo;
|
|
|
|
account_none$0 = Account;
|
|
account$1 addr:MsgAddressInt storage_stat:StorageInfo
|
|
storage:AccountStorage = Account;
|
|
|
|
account_storage$_ last_trans_lt:uint64
|
|
balance:CurrencyCollection state:AccountState
|
|
= AccountStorage;
|
|
|
|
account_uninit$00 = AccountState;
|
|
account_active$1 _:StateInit = AccountState;
|
|
account_frozen$01 state_hash:bits256 = AccountState;
|
|
|
|
acc_state_uninit$00 = AccountStatus;
|
|
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;
|
|
|
|
depth_balance$_ split_depth:(#<= 30) balance:CurrencyCollection = DepthBalanceInfo;
|
|
|
|
_ (HashmapAugE 256 ShardAccount DepthBalanceInfo) = ShardAccounts;
|
|
|
|
transaction$0111 account_addr:bits256 lt:uint64
|
|
prev_trans_hash:bits256 prev_trans_lt:uint64 now:uint32
|
|
outmsg_cnt:uint15
|
|
orig_status:AccountStatus end_status:AccountStatus
|
|
^[ in_msg:(Maybe ^(Message Any)) out_msgs:(HashmapE 15 ^(Message Any)) ]
|
|
total_fees:CurrencyCollection state_update:^(HASH_UPDATE Account)
|
|
description:^TransactionDescr = Transaction;
|
|
|
|
!merkle_update#02 {X:Type} old_hash:bits256 new_hash:bits256
|
|
old:^X new:^X = MERKLE_UPDATE X;
|
|
update_hashes#72 {X:Type} old_hash:bits256 new_hash:bits256
|
|
= HASH_UPDATE X;
|
|
!merkle_proof#03 {X:Type} virtual_hash:bits256 depth:uint16 virtual_root:^X = MERKLE_PROOF X;
|
|
|
|
acc_trans#5 account_addr:bits256
|
|
transactions:(HashmapAug 64 ^Transaction CurrencyCollection)
|
|
state_update:^(HASH_UPDATE Account)
|
|
= AccountBlock;
|
|
|
|
_ (HashmapAugE 256 AccountBlock CurrencyCollection) = ShardAccountBlocks;
|
|
//
|
|
tr_phase_storage$_ storage_fees_collected:Grams
|
|
storage_fees_due:(Maybe Grams)
|
|
status_change:AccStatusChange
|
|
= TrStoragePhase;
|
|
|
|
acst_unchanged$0 = AccStatusChange; // x -> x
|
|
acst_frozen$10 = AccStatusChange; // init -> frozen
|
|
acst_deleted$11 = AccStatusChange; // frozen -> deleted
|
|
|
|
tr_phase_credit$_ due_fees_collected:(Maybe Grams)
|
|
credit:CurrencyCollection = TrCreditPhase;
|
|
|
|
tr_phase_compute_skipped$0 reason:ComputeSkipReason
|
|
= TrComputePhase;
|
|
tr_phase_compute_vm$1 success:Bool msg_state_used:Bool
|
|
account_activated:Bool gas_fees:Grams
|
|
^[ gas_used:(VarUInteger 7)
|
|
gas_limit:(VarUInteger 7) gas_credit:(Maybe (VarUInteger 3))
|
|
mode:int8 exit_code:int32 exit_arg:(Maybe int32)
|
|
vm_steps:uint32
|
|
vm_init_state_hash:bits256 vm_final_state_hash:bits256 ]
|
|
= TrComputePhase;
|
|
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
|
|
total_fwd_fees:(Maybe Grams) total_action_fees:(Maybe Grams)
|
|
result_code:int32 result_arg:(Maybe int32) tot_actions:uint16
|
|
spec_actions:uint16 skipped_actions:uint16 msgs_created:uint16
|
|
action_list_hash:bits256 tot_msg_size:StorageUsedShort
|
|
= TrActionPhase;
|
|
|
|
tr_phase_bounce_negfunds$00 = TrBouncePhase;
|
|
tr_phase_bounce_nofunds$01 msg_size:StorageUsedShort
|
|
req_fwd_fees:Grams = TrBouncePhase;
|
|
tr_phase_bounce_ok$1 msg_size:StorageUsedShort
|
|
msg_fees:Grams fwd_fees:Grams = TrBouncePhase;
|
|
//
|
|
trans_ord$0000 credit_first:Bool
|
|
storage_ph:(Maybe TrStoragePhase)
|
|
credit_ph:(Maybe TrCreditPhase)
|
|
compute_ph:TrComputePhase action:(Maybe ^TrActionPhase)
|
|
aborted:Bool bounce:(Maybe TrBouncePhase)
|
|
destroyed:Bool
|
|
= TransactionDescr;
|
|
|
|
trans_storage$0001 storage_ph:TrStoragePhase
|
|
= TransactionDescr;
|
|
|
|
trans_tick_tock$001 is_tock:Bool storage_ph:TrStoragePhase
|
|
compute_ph:TrComputePhase action:(Maybe ^TrActionPhase)
|
|
aborted:Bool destroyed:Bool = TransactionDescr;
|
|
//
|
|
split_merge_info$_ cur_shard_pfx_len:(## 6)
|
|
acc_split_depth:(## 6) this_addr:bits256 sibling_addr:bits256
|
|
= SplitMergeInfo;
|
|
trans_split_prepare$0100 split_info:SplitMergeInfo
|
|
storage_ph:(Maybe TrStoragePhase)
|
|
compute_ph:TrComputePhase action:(Maybe ^TrActionPhase)
|
|
aborted:Bool destroyed:Bool
|
|
= TransactionDescr;
|
|
trans_split_install$0101 split_info:SplitMergeInfo
|
|
prepare_transaction:^Transaction
|
|
installed:Bool = TransactionDescr;
|
|
|
|
trans_merge_prepare$0110 split_info:SplitMergeInfo
|
|
storage_ph:TrStoragePhase aborted:Bool
|
|
= TransactionDescr;
|
|
trans_merge_install$0111 split_info:SplitMergeInfo
|
|
prepare_transaction:^Transaction
|
|
storage_ph:(Maybe TrStoragePhase)
|
|
credit_ph:(Maybe TrCreditPhase)
|
|
compute_ph:TrComputePhase action:(Maybe ^TrActionPhase)
|
|
aborted:Bool destroyed:Bool
|
|
= TransactionDescr;
|
|
|
|
smc_info#076ef1ea actions:uint16 msgs_sent:uint16
|
|
unixtime:uint32 block_lt:uint64 trans_lt:uint64
|
|
rand_seed:bits256 balance_remaining:CurrencyCollection
|
|
myself:MsgAddressInt global_config:(Maybe Cell) = SmartContractInfo;
|
|
//
|
|
//
|
|
out_list_empty$_ = OutList 0;
|
|
out_list$_ {n:#} prev:^(OutList n) action:OutAction
|
|
= OutList (n + 1);
|
|
action_send_msg#0ec3c86d mode:(## 8)
|
|
out_msg:^(MessageRelaxed Any) = OutAction;
|
|
action_set_code#ad4de08e new_code:^Cell = OutAction;
|
|
action_reserve_currency#36e6b809 mode:(## 8)
|
|
currency:CurrencyCollection = OutAction;
|
|
libref_hash$0 lib_hash:bits256 = LibRef;
|
|
libref_ref$1 library:^Cell = LibRef;
|
|
action_change_library#26fa1dd4 mode:(## 7)
|
|
libref:LibRef = OutAction;
|
|
|
|
out_list_node$_ prev:^Cell action:OutAction = OutListNode;
|
|
//
|
|
//
|
|
shard_ident$00 shard_pfx_bits:(#<= 60)
|
|
workchain_id:int32 shard_prefix:uint64 = ShardIdent;
|
|
|
|
ext_blk_ref$_ end_lt:uint64
|
|
seq_no:uint32 root_hash:bits256 file_hash:bits256
|
|
= ExtBlkRef;
|
|
|
|
block_id_ext$_ shard_id:ShardIdent seq_no:uint32
|
|
root_hash:bits256 file_hash:bits256 = BlockIdExt;
|
|
|
|
master_info$_ master:ExtBlkRef = BlkMasterInfo;
|
|
|
|
shard_state#9023afe2 global_id:int32
|
|
shard_id:ShardIdent
|
|
seq_no:uint32 vert_seq_no:#
|
|
gen_utime:uint32 gen_lt:uint64
|
|
min_ref_mc_seqno:uint32
|
|
out_msg_queue_info:^OutMsgQueueInfo
|
|
before_split:(## 1)
|
|
accounts:^ShardAccounts
|
|
^[ overload_history:uint64 underload_history:uint64
|
|
total_balance:CurrencyCollection
|
|
total_validator_fees:CurrencyCollection
|
|
libraries:(HashmapE 256 LibDescr)
|
|
master_ref:(Maybe BlkMasterInfo) ]
|
|
custom:(Maybe ^McStateExtra)
|
|
= ShardStateUnsplit;
|
|
|
|
_ ShardStateUnsplit = ShardState;
|
|
split_state#5f327da5 left:^ShardStateUnsplit right:^ShardStateUnsplit = ShardState;
|
|
|
|
shared_lib_descr$00 lib:^Cell publishers:(Hashmap 256 True)
|
|
= LibDescr;
|
|
|
|
block_info#9bc7a987 version:uint32
|
|
not_master:(## 1)
|
|
after_merge:(## 1) before_split:(## 1)
|
|
after_split:(## 1)
|
|
want_split:Bool want_merge:Bool
|
|
key_block:Bool vert_seqno_incr:(## 1)
|
|
flags:(## 8) { flags <= 1 }
|
|
seq_no:# vert_seq_no:# { vert_seq_no >= vert_seqno_incr }
|
|
{ prev_seq_no:# } { ~prev_seq_no + 1 = seq_no }
|
|
shard:ShardIdent gen_utime:uint32
|
|
start_lt:uint64 end_lt:uint64
|
|
gen_validator_list_hash_short:uint32
|
|
gen_catchain_seqno:uint32
|
|
min_ref_mc_seqno:uint32
|
|
prev_key_block_seqno:uint32
|
|
gen_software:flags . 0?GlobalVersion
|
|
master_ref:not_master?^BlkMasterInfo
|
|
prev_ref:^(BlkPrevInfo after_merge)
|
|
prev_vert_ref:vert_seqno_incr?^(BlkPrevInfo 0)
|
|
= BlockInfo;
|
|
|
|
prev_blk_info$_ prev:ExtBlkRef = BlkPrevInfo 0;
|
|
prev_blks_info$_ prev1:^ExtBlkRef prev2:^ExtBlkRef = BlkPrevInfo 1;
|
|
|
|
block#11ef55aa global_id:int32
|
|
info:^BlockInfo value_flow:^ValueFlow
|
|
state_update:^(MERKLE_UPDATE ShardState)
|
|
extra:^BlockExtra = Block;
|
|
|
|
block_extra in_msg_descr:^InMsgDescr
|
|
out_msg_descr:^OutMsgDescr
|
|
account_blocks:^ShardAccountBlocks
|
|
rand_seed:bits256
|
|
created_by:bits256
|
|
custom:(Maybe ^McBlockExtra) = BlockExtra;
|
|
//
|
|
value_flow#b8e48dfb ^[ from_prev_blk:CurrencyCollection
|
|
to_next_blk:CurrencyCollection
|
|
imported:CurrencyCollection
|
|
exported:CurrencyCollection ]
|
|
fees_collected:CurrencyCollection
|
|
^[
|
|
fees_imported:CurrencyCollection
|
|
recovered:CurrencyCollection
|
|
created:CurrencyCollection
|
|
minted:CurrencyCollection
|
|
] = ValueFlow;
|
|
|
|
value_flow_v2#3ebf98b7 ^[ from_prev_blk:CurrencyCollection
|
|
to_next_blk:CurrencyCollection
|
|
imported:CurrencyCollection
|
|
exported:CurrencyCollection ]
|
|
fees_collected:CurrencyCollection
|
|
burned:CurrencyCollection
|
|
^[
|
|
fees_imported:CurrencyCollection
|
|
recovered:CurrencyCollection
|
|
created:CurrencyCollection
|
|
minted:CurrencyCollection
|
|
] = ValueFlow;
|
|
|
|
//
|
|
//
|
|
bt_leaf$0 {X:Type} leaf:X = BinTree X;
|
|
bt_fork$1 {X:Type} left:^(BinTree X) right:^(BinTree X)
|
|
= BinTree X;
|
|
|
|
fsm_none$0 = FutureSplitMerge;
|
|
fsm_split$10 split_utime:uint32 interval:uint32 = FutureSplitMerge;
|
|
fsm_merge$11 merge_utime:uint32 interval:uint32 = FutureSplitMerge;
|
|
|
|
shard_descr#b seq_no:uint32 reg_mc_seqno:uint32
|
|
start_lt:uint64 end_lt:uint64
|
|
root_hash:bits256 file_hash:bits256
|
|
before_split:Bool before_merge:Bool
|
|
want_split:Bool want_merge:Bool
|
|
nx_cc_updated:Bool flags:(## 3) { flags = 0 }
|
|
next_catchain_seqno:uint32 next_validator_shard:uint64
|
|
min_ref_mc_seqno:uint32 gen_utime:uint32
|
|
split_merge_at:FutureSplitMerge
|
|
fees_collected:CurrencyCollection
|
|
funds_created:CurrencyCollection = ShardDescr;
|
|
|
|
shard_descr_new#a seq_no:uint32 reg_mc_seqno:uint32
|
|
start_lt:uint64 end_lt:uint64
|
|
root_hash:bits256 file_hash:bits256
|
|
before_split:Bool before_merge:Bool
|
|
want_split:Bool want_merge:Bool
|
|
nx_cc_updated:Bool flags:(## 3) { flags = 0 }
|
|
next_catchain_seqno:uint32 next_validator_shard:uint64
|
|
min_ref_mc_seqno:uint32 gen_utime:uint32
|
|
split_merge_at:FutureSplitMerge
|
|
^[ fees_collected:CurrencyCollection
|
|
funds_created:CurrencyCollection ] = ShardDescr;
|
|
|
|
_ (HashmapE 32 ^(BinTree ShardDescr)) = ShardHashes;
|
|
|
|
bta_leaf$0 {X:Type} {Y:Type} extra:Y leaf:X = BinTreeAug X Y;
|
|
bta_fork$1 {X:Type} {Y:Type} left:^(BinTreeAug X Y)
|
|
right:^(BinTreeAug X Y) extra:Y = BinTreeAug X Y;
|
|
|
|
_ fees:CurrencyCollection create:CurrencyCollection = ShardFeeCreated;
|
|
_ (HashmapAugE 96 ShardFeeCreated ShardFeeCreated) = ShardFees;
|
|
|
|
_ config_addr:bits256 config:^(Hashmap 32 ^Cell)
|
|
= ConfigParams;
|
|
|
|
validator_info$_
|
|
validator_list_hash_short:uint32
|
|
catchain_seqno:uint32
|
|
nx_cc_updated:Bool
|
|
= ValidatorInfo;
|
|
|
|
validator_base_info$_
|
|
validator_list_hash_short:uint32
|
|
catchain_seqno:uint32
|
|
= ValidatorBaseInfo;
|
|
|
|
_ key:Bool max_end_lt:uint64 = KeyMaxLt;
|
|
_ key:Bool blk_ref:ExtBlkRef = KeyExtBlkRef;
|
|
|
|
_ (HashmapAugE 32 KeyExtBlkRef KeyMaxLt) = OldMcBlocksInfo;
|
|
|
|
|
|
counters#_ last_updated:uint32 total:uint64 cnt2048:uint64 cnt65536:uint64 = Counters;
|
|
creator_info#4 mc_blocks:Counters shard_blocks:Counters = CreatorStats;
|
|
block_create_stats#17 counters:(HashmapE 256 CreatorStats) = BlockCreateStats;
|
|
block_create_stats_ext#34 counters:(HashmapAugE 256 CreatorStats uint32) = BlockCreateStats;
|
|
|
|
masterchain_state_extra#cc26
|
|
shard_hashes:ShardHashes
|
|
config:ConfigParams
|
|
^[ flags:(## 16) { flags <= 1 }
|
|
validator_info:ValidatorInfo
|
|
prev_blocks:OldMcBlocksInfo
|
|
after_key_block:Bool
|
|
last_key_block:(Maybe ExtBlkRef)
|
|
block_create_stats:(flags . 0)?BlockCreateStats ]
|
|
global_balance:CurrencyCollection
|
|
= McStateExtra;
|
|
|
|
ed25519_pubkey#8e81278a pubkey:bits256 = SigPubKey; // 288 bits
|
|
ed25519_signature#5 R:bits256 s:bits256 = CryptoSignatureSimple; // 516 bits
|
|
_ CryptoSignatureSimple = CryptoSignature;
|
|
sig_pair$_ node_id_short:bits256 sign:CryptoSignature = CryptoSignaturePair; // 256+x ~ 772 bits
|
|
|
|
certificate#4 temp_key:SigPubKey valid_since:uint32 valid_until:uint32 = Certificate; // 356 bits
|
|
certificate_env#a419b7d certificate:Certificate = CertificateEnv; // 384 bits
|
|
signed_certificate$_ certificate:Certificate certificate_signature:CryptoSignature
|
|
= SignedCertificate; // 356+516 = 872 bits
|
|
// certificate_signature is the signature of CertificateEnv (with embedded certificate) with persistent key
|
|
chained_signature#f signed_cert:^SignedCertificate temp_key_signature:CryptoSignatureSimple
|
|
= CryptoSignature; // 4+(356+516)+516 = 520 bits+ref (1392 bits total)
|
|
// temp_key_signature is the signature of whatever was originally intended to be signed with temp_key from certificate
|
|
|
|
masterchain_block_extra#cca5
|
|
key_block:(## 1)
|
|
shard_hashes:ShardHashes
|
|
shard_fees:ShardFees
|
|
^[ prev_blk_signatures:(HashmapE 16 CryptoSignaturePair)
|
|
recover_create_msg:(Maybe ^InMsg)
|
|
mint_msg:(Maybe ^InMsg) ]
|
|
config:key_block?ConfigParams
|
|
= McBlockExtra;
|
|
|
|
//
|
|
// CONFIGURATION PARAMETERS
|
|
//
|
|
|
|
validator#53 public_key:SigPubKey weight:uint64 = ValidatorDescr;
|
|
validator_addr#73 public_key:SigPubKey weight:uint64 adnl_addr:bits256 = ValidatorDescr;
|
|
validators#11 utime_since:uint32 utime_until:uint32
|
|
total:(## 16) main:(## 16) { main <= total } { main >= 1 }
|
|
list:(Hashmap 16 ValidatorDescr) = ValidatorSet;
|
|
validators_ext#12 utime_since:uint32 utime_until:uint32
|
|
total:(## 16) main:(## 16) { main <= total } { main >= 1 }
|
|
total_weight:uint64 list:(HashmapE 16 ValidatorDescr) = ValidatorSet;
|
|
|
|
_ config_addr:bits256 = ConfigParam 0;
|
|
_ elector_addr:bits256 = ConfigParam 1;
|
|
_ minter_addr:bits256 = ConfigParam 2; // ConfigParam 0 is used if absent
|
|
_ fee_collector_addr:bits256 = ConfigParam 3; // ConfigParam 1 is used if absent
|
|
_ dns_root_addr:bits256 = ConfigParam 4; // root TON DNS resolver
|
|
|
|
burning_config#01
|
|
blackhole_addr:(Maybe bits256)
|
|
fee_burn_num:# fee_burn_denom:# { fee_burn_num <= fee_burn_denom } { fee_burn_denom >= 1 } = BurningConfig;
|
|
_ BurningConfig = ConfigParam 5;
|
|
|
|
_ mint_new_price:Grams mint_add_price:Grams = ConfigParam 6;
|
|
_ to_mint:ExtraCurrencyCollection = ConfigParam 7;
|
|
|
|
capabilities#c4 version:uint32 capabilities:uint64 = GlobalVersion;
|
|
_ GlobalVersion = ConfigParam 8; // all zero if absent
|
|
_ mandatory_params:(Hashmap 32 True) = ConfigParam 9;
|
|
_ critical_params:(Hashmap 32 True) = ConfigParam 10;
|
|
|
|
cfg_vote_cfg#36 min_tot_rounds:uint8 max_tot_rounds:uint8 min_wins:uint8 max_losses:uint8 min_store_sec:uint32 max_store_sec:uint32 bit_price:uint32 cell_price:uint32 = ConfigProposalSetup;
|
|
cfg_vote_setup#91 normal_params:^ConfigProposalSetup critical_params:^ConfigProposalSetup = ConfigVotingSetup;
|
|
_ ConfigVotingSetup = ConfigParam 11;
|
|
|
|
cfg_proposal#f3 param_id:int32 param_value:(Maybe ^Cell) if_hash_equal:(Maybe uint256)
|
|
= ConfigProposal;
|
|
cfg_proposal_status#ce expires:uint32 proposal:^ConfigProposal is_critical:Bool
|
|
voters:(HashmapE 16 True) remaining_weight:int64 validator_set_id:uint256
|
|
rounds_remaining:uint8 wins:uint8 losses:uint8 = ConfigProposalStatus;
|
|
|
|
wfmt_basic#1 vm_version:int32 vm_mode:uint64 = WorkchainFormat 1;
|
|
wfmt_ext#0 min_addr_len:(## 12) max_addr_len:(## 12) addr_len_step:(## 12)
|
|
{ min_addr_len >= 64 } { min_addr_len <= max_addr_len }
|
|
{ max_addr_len <= 1023 } { addr_len_step <= 1023 }
|
|
workchain_type_id:(## 32) { workchain_type_id >= 1 }
|
|
= WorkchainFormat 0;
|
|
|
|
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;
|
|
_ ComplaintPricing = ConfigParam 13;
|
|
|
|
block_grams_created#6b masterchain_block_fee:Grams basechain_block_fee:Grams
|
|
= BlockCreateFees;
|
|
_ BlockCreateFees = ConfigParam 14;
|
|
|
|
_ validators_elected_for:uint32 elections_start_before:uint32
|
|
elections_end_before:uint32 stake_held_for:uint32
|
|
= ConfigParam 15;
|
|
|
|
_ max_validators:(## 16) max_main_validators:(## 16) min_validators:(## 16)
|
|
{ max_validators >= max_main_validators }
|
|
{ max_main_validators >= min_validators }
|
|
{ min_validators >= 1 }
|
|
= ConfigParam 16;
|
|
|
|
_ min_stake:Grams max_stake:Grams min_total_stake:Grams max_stake_factor:uint32 = ConfigParam 17;
|
|
|
|
_#cc utime_since:uint32 bit_price_ps:uint64 cell_price_ps:uint64
|
|
mc_bit_price_ps:uint64 mc_cell_price_ps:uint64 = StoragePrices;
|
|
_ (Hashmap 32 StoragePrices) = ConfigParam 18;
|
|
|
|
_ global_id:int32 = ConfigParam 19;
|
|
|
|
gas_prices#dd gas_price:uint64 gas_limit:uint64 gas_credit:uint64
|
|
block_gas_limit:uint64 freeze_due_limit:uint64 delete_due_limit:uint64
|
|
= GasLimitsPrices;
|
|
|
|
gas_prices_ext#de gas_price:uint64 gas_limit:uint64 special_gas_limit:uint64 gas_credit:uint64
|
|
block_gas_limit:uint64 freeze_due_limit:uint64 delete_due_limit:uint64
|
|
= GasLimitsPrices;
|
|
|
|
gas_flat_pfx#d1 flat_gas_limit:uint64 flat_gas_price:uint64 other:GasLimitsPrices
|
|
= GasLimitsPrices;
|
|
|
|
config_mc_gas_prices#_ GasLimitsPrices = ConfigParam 20;
|
|
config_gas_prices#_ GasLimitsPrices = ConfigParam 21;
|
|
|
|
param_limits#c3 underload:# soft_limit:# { underload <= soft_limit }
|
|
hard_limit:# { soft_limit <= hard_limit } = ParamLimits;
|
|
block_limits#5d bytes:ParamLimits gas:ParamLimits lt_delta:ParamLimits
|
|
= BlockLimits;
|
|
|
|
config_mc_block_limits#_ BlockLimits = ConfigParam 22;
|
|
config_block_limits#_ BlockLimits = ConfigParam 23;
|
|
|
|
// msg_fwd_fees = (lump_price + ceil((bit_price * msg.bits + cell_price * msg.cells)/2^16)) nanograms
|
|
// ihr_fwd_fees = ceil((msg_fwd_fees * ihr_price_factor)/2^16) nanograms
|
|
// bits in the root cell of a message are not included in msg.bits (lump_price pays for them)
|
|
msg_forward_prices#ea lump_price:uint64 bit_price:uint64 cell_price:uint64
|
|
ihr_price_factor:uint32 first_frac:uint16 next_frac:uint16 = MsgForwardPrices;
|
|
|
|
// used for messages to/from masterchain
|
|
config_mc_fwd_prices#_ MsgForwardPrices = ConfigParam 24;
|
|
// used for all other messages
|
|
config_fwd_prices#_ MsgForwardPrices = ConfigParam 25;
|
|
|
|
catchain_config#c1 mc_catchain_lifetime:uint32 shard_catchain_lifetime:uint32
|
|
shard_validators_lifetime:uint32 shard_validators_num:uint32 = CatchainConfig;
|
|
|
|
catchain_config_new#c2 flags:(## 7) { flags = 0 } shuffle_mc_validators:Bool
|
|
mc_catchain_lifetime:uint32 shard_catchain_lifetime:uint32
|
|
shard_validators_lifetime:uint32 shard_validators_num:uint32 = CatchainConfig;
|
|
|
|
consensus_config#d6 round_candidates:# { round_candidates >= 1 }
|
|
next_candidate_delay_ms:uint32 consensus_timeout_ms:uint32
|
|
fast_attempts:uint32 attempt_duration:uint32 catchain_max_deps:uint32
|
|
max_block_bytes:uint32 max_collated_bytes:uint32 = ConsensusConfig;
|
|
|
|
consensus_config_new#d7 flags:(## 7) { flags = 0 } new_catchain_ids:Bool
|
|
round_candidates:(## 8) { round_candidates >= 1 }
|
|
next_candidate_delay_ms:uint32 consensus_timeout_ms:uint32
|
|
fast_attempts:uint32 attempt_duration:uint32 catchain_max_deps:uint32
|
|
max_block_bytes:uint32 max_collated_bytes:uint32 = ConsensusConfig;
|
|
|
|
consensus_config_v3#d8 flags:(## 7) { flags = 0 } new_catchain_ids:Bool
|
|
round_candidates:(## 8) { round_candidates >= 1 }
|
|
next_candidate_delay_ms:uint32 consensus_timeout_ms:uint32
|
|
fast_attempts:uint32 attempt_duration:uint32 catchain_max_deps:uint32
|
|
max_block_bytes:uint32 max_collated_bytes:uint32
|
|
proto_version:uint16 = ConsensusConfig;
|
|
|
|
consensus_config_v4#d9 flags:(## 7) { flags = 0 } new_catchain_ids:Bool
|
|
round_candidates:(## 8) { round_candidates >= 1 }
|
|
next_candidate_delay_ms:uint32 consensus_timeout_ms:uint32
|
|
fast_attempts:uint32 attempt_duration:uint32 catchain_max_deps:uint32
|
|
max_block_bytes:uint32 max_collated_bytes:uint32
|
|
proto_version:uint16 catchain_max_blocks_coeff:uint32 = ConsensusConfig;
|
|
|
|
_ CatchainConfig = ConfigParam 28;
|
|
_ ConsensusConfig = ConfigParam 29;
|
|
|
|
_ fundamental_smc_addr:(HashmapE 256 True) = ConfigParam 31;
|
|
_ prev_validators:ValidatorSet = ConfigParam 32;
|
|
_ prev_temp_validators:ValidatorSet = ConfigParam 33;
|
|
_ cur_validators:ValidatorSet = ConfigParam 34;
|
|
_ cur_temp_validators:ValidatorSet = ConfigParam 35;
|
|
_ next_validators:ValidatorSet = ConfigParam 36;
|
|
_ next_temp_validators:ValidatorSet = ConfigParam 37;
|
|
|
|
validator_temp_key#3 adnl_addr:bits256 temp_public_key:SigPubKey seqno:# valid_until:uint32 = ValidatorTempKey;
|
|
signed_temp_key#4 key:^ValidatorTempKey signature:CryptoSignature = ValidatorSignedTempKey;
|
|
_ (HashmapE 256 ValidatorSignedTempKey) = ConfigParam 39;
|
|
|
|
misbehaviour_punishment_config_v1#01
|
|
default_flat_fine:Grams default_proportional_fine:uint32
|
|
severity_flat_mult:uint16 severity_proportional_mult:uint16
|
|
unpunishable_interval:uint16
|
|
long_interval:uint16 long_flat_mult:uint16 long_proportional_mult:uint16
|
|
medium_interval:uint16 medium_flat_mult:uint16 medium_proportional_mult:uint16
|
|
= 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;
|
|
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 = 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;
|
|
|
|
precompiled_smc#b0 gas_usage:uint64 = PrecompiledSmc;
|
|
precompiled_contracts_config#c0 list:(HashmapE 256 PrecompiledSmc) = PrecompiledContractsConfig;
|
|
_ PrecompiledContractsConfig = ConfigParam 45;
|
|
|
|
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
|
|
_ OracleBridgeParams = ConfigParam 73; // Polygon bridge
|
|
|
|
// Note that chains in which bridge, minter and jetton-wallet operate are fixated
|
|
jetton_bridge_prices#_ bridge_burn_fee:Coins bridge_mint_fee:Coins
|
|
wallet_min_tons_for_storage:Coins
|
|
wallet_gas_consumption:Coins
|
|
minter_min_tons_for_storage:Coins
|
|
discover_gas_consumption:Coins = JettonBridgePrices;
|
|
|
|
jetton_bridge_params_v0#00 bridge_address:bits256 oracles_address:bits256 oracles:(HashmapE 256 uint256) state_flags:uint8 burn_bridge_fee:Coins = JettonBridgeParams;
|
|
jetton_bridge_params_v1#01 bridge_address:bits256 oracles_address:bits256 oracles:(HashmapE 256 uint256) state_flags:uint8 prices:^JettonBridgePrices external_chain_address:bits256 = JettonBridgeParams;
|
|
|
|
_ JettonBridgeParams = ConfigParam 79; // ETH->TON token bridge
|
|
_ JettonBridgeParams = ConfigParam 81; // BNB->TON token bridge
|
|
_ JettonBridgeParams = ConfigParam 82; // Polygon->TON token bridge
|
|
|
|
|
|
//
|
|
// PROOFS
|
|
//
|
|
block_signatures_pure#_ sig_count:uint32 sig_weight:uint64
|
|
signatures:(HashmapE 16 CryptoSignaturePair) = BlockSignaturesPure;
|
|
block_signatures#11 validator_info:ValidatorBaseInfo pure_signatures:BlockSignaturesPure = BlockSignatures;
|
|
block_proof#c3 proof_for:BlockIdExt root:^Cell signatures:(Maybe ^BlockSignatures) = BlockProof;
|
|
|
|
chain_empty$_ = ProofChain 0;
|
|
chain_link$_ {n:#} root:^Cell prev:n?^(ProofChain n) = ProofChain (n + 1);
|
|
top_block_descr#d5 proof_for:BlockIdExt signatures:(Maybe ^BlockSignatures)
|
|
len:(## 8) { len >= 1 } { len <= 8 } chain:(ProofChain len) = TopBlockDescr;
|
|
|
|
//
|
|
// COLLATED DATA
|
|
//
|
|
top_block_descr_set#4ac789f3 collection:(HashmapE 96 ^TopBlockDescr) = TopBlockDescrSet;
|
|
|
|
//
|
|
// VALIDATOR MISBEHAVIOR COMPLAINTS
|
|
//
|
|
prod_info#34 utime:uint32 mc_blk_ref:ExtBlkRef state_proof:^(MERKLE_PROOF Block)
|
|
prod_proof:^(MERKLE_PROOF ShardState) = ProducerInfo;
|
|
no_blk_gen from_utime:uint32 prod_info:^ProducerInfo = ComplaintDescr;
|
|
no_blk_gen_diff prod_info_old:^ProducerInfo prod_info_new:^ProducerInfo = ComplaintDescr;
|
|
validator_complaint#bc validator_pubkey:bits256 description:^ComplaintDescr created_at:uint32 severity:uint8 reward_addr:uint256 paid:Grams suggested_fine:Grams suggested_fine_part:uint32 = ValidatorComplaint;
|
|
complaint_status#2d complaint:^ValidatorComplaint voters:(HashmapE 16 True) vset_id:uint256 weight_remaining:int64 = ValidatorComplaintStatus;
|
|
|
|
//
|
|
// TVM REFLECTION
|
|
//
|
|
vm_stk_null#00 = VmStackValue;
|
|
vm_stk_tinyint#01 value:int64 = VmStackValue;
|
|
vm_stk_int#0201_ value:int257 = VmStackValue;
|
|
vm_stk_nan#02ff = VmStackValue;
|
|
vm_stk_cell#03 cell:^Cell = VmStackValue;
|
|
_ cell:^Cell st_bits:(## 10) end_bits:(## 10) { st_bits <= end_bits }
|
|
st_ref:(#<= 4) end_ref:(#<= 4) { st_ref <= end_ref } = VmCellSlice;
|
|
vm_stk_slice#04 _:VmCellSlice = VmStackValue;
|
|
vm_stk_builder#05 cell:^Cell = VmStackValue;
|
|
vm_stk_cont#06 cont:VmCont = VmStackValue;
|
|
vm_tupref_nil$_ = VmTupleRef 0;
|
|
vm_tupref_single$_ entry:^VmStackValue = VmTupleRef 1;
|
|
vm_tupref_any$_ {n:#} ref:^(VmTuple (n + 2)) = VmTupleRef (n + 2);
|
|
vm_tuple_nil$_ = VmTuple 0;
|
|
vm_tuple_tcons$_ {n:#} head:(VmTupleRef n) tail:^VmStackValue = VmTuple (n + 1);
|
|
vm_stk_tuple#07 len:(## 16) data:(VmTuple len) = VmStackValue;
|
|
|
|
vm_stack#_ depth:(## 24) stack:(VmStackList depth) = VmStack;
|
|
vm_stk_cons#_ {n:#} rest:^(VmStackList n) tos:VmStackValue = VmStackList (n + 1);
|
|
vm_stk_nil#_ = VmStackList 0;
|
|
|
|
_ cregs:(HashmapE 4 VmStackValue) = VmSaveList;
|
|
gas_limits#_ remaining:int64 _:^[ max_limit:int64 cur_limit:int64 credit:int64 ]
|
|
= VmGasLimits;
|
|
_ libraries:(HashmapE 256 ^Cell) = VmLibraries;
|
|
|
|
vm_ctl_data$_ nargs:(Maybe uint13) stack:(Maybe VmStack) save:VmSaveList
|
|
cp:(Maybe int16) = VmControlData;
|
|
vmc_std$00 cdata:VmControlData code:VmCellSlice = VmCont;
|
|
vmc_envelope$01 cdata:VmControlData next:^VmCont = VmCont;
|
|
vmc_quit$1000 exit_code:int32 = VmCont;
|
|
vmc_quit_exc$1001 = VmCont;
|
|
vmc_repeat$10100 count:uint63 body:^VmCont after:^VmCont = VmCont;
|
|
vmc_until$110000 body:^VmCont after:^VmCont = VmCont;
|
|
vmc_again$110001 body:^VmCont = VmCont;
|
|
vmc_while_cond$110010 cond:^VmCont body:^VmCont
|
|
after:^VmCont = VmCont;
|
|
vmc_while_body$110011 cond:^VmCont body:^VmCont
|
|
after:^VmCont = VmCont;
|
|
vmc_pushint$1111 value:int32 next:^VmCont = VmCont;
|
|
|
|
//
|
|
// DNS RECORDS
|
|
//
|
|
_ (HashmapE 256 ^DNSRecord) = DNS_RecordSet;
|
|
|
|
chunk_ref$_ {n:#} ref:^(TextChunks (n + 1)) = TextChunkRef (n + 1);
|
|
chunk_ref_empty$_ = TextChunkRef 0;
|
|
text_chunk$_ {n:#} len:(## 8) data:(bits (len * 8)) next:(TextChunkRef n) = TextChunks (n + 1);
|
|
text_chunk_empty$_ = TextChunks 0;
|
|
text$_ chunks:(## 8) rest:(TextChunks chunks) = Text;
|
|
dns_text#1eda _:Text = DNSRecord;
|
|
|
|
dns_next_resolver#ba93 resolver:MsgAddressInt = DNSRecord; // usually in record #-1
|
|
|
|
dns_adnl_address#ad01 adnl_addr:bits256 flags:(## 8) { flags <= 1 }
|
|
proto_list:flags . 0?ProtoList = DNSRecord; // often in record #2
|
|
proto_list_nil$0 = ProtoList;
|
|
proto_list_next$1 head:Protocol tail:ProtoList = ProtoList;
|
|
proto_http#4854 = Protocol;
|
|
|
|
dns_smc_address#9fd3 smc_addr:MsgAddressInt flags:(## 8) { flags <= 1 }
|
|
cap_list:flags . 0?SmcCapList = DNSRecord; // often in record #1
|
|
cap_list_nil$0 = SmcCapList;
|
|
cap_list_next$1 head:SmcCapability tail:SmcCapList = SmcCapList;
|
|
cap_method_seqno#5371 = SmcCapability;
|
|
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
|
|
//
|
|
|
|
chan_config$_ init_timeout:uint32 close_timeout:uint32 a_key:bits256 b_key:bits256
|
|
a_addr:^MsgAddressInt b_addr:^MsgAddressInt channel_id:uint64 min_A_extra:Grams = ChanConfig;
|
|
|
|
chan_state_init$000 signed_A:Bool signed_B:Bool min_A:Grams min_B:Grams expire_at:uint32 A:Grams B:Grams = ChanState;
|
|
chan_state_close$001 signed_A:Bool signed_B:Bool promise_A:Grams promise_B:Grams expire_at:uint32 A:Grams B:Grams = ChanState;
|
|
chan_state_payout$010 A:Grams B:Grams = ChanState;
|
|
|
|
chan_promise$_ channel_id:uint64 promise_A:Grams promise_B:Grams = ChanPromise;
|
|
chan_signed_promise#_ sig:(Maybe ^bits512) promise:ChanPromise = ChanSignedPromise;
|
|
|
|
chan_msg_init#27317822 inc_A:Grams inc_B:Grams min_A:Grams min_B:Grams channel_id:uint64 = ChanMsg;
|
|
chan_msg_close#f28ae183 extra_A:Grams extra_B:Grams promise:ChanSignedPromise = ChanMsg;
|
|
chan_msg_timeout#43278a28 = ChanMsg;
|
|
chan_msg_payout#37fe7810 = ChanMsg;
|
|
|
|
chan_signed_msg$_ sig_A:(Maybe ^bits512) sig_B:(Maybe ^bits512) msg:ChanMsg = ChanSignedMsg;
|
|
|
|
chan_op_cmd#912838d1 msg:ChanSignedMsg = ChanOp;
|
|
|
|
|
|
chan_data$_ config:^ChanConfig state:^ChanState = ChanData;
|