tlb

package
v1.15.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 1, 2025 License: MIT Imports: 16 Imported by: 8

README

Serialization and deserialization of data described by TL-B schemas.

This library implements Marshaling and Unmarshaling for TL-B data and some primitives.

TL-B description you can find here:

Usage

Example

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrGramsOverflow = errors.New("grams overflow")
View Source 
var ErrInvalidTag = errors.New("invalid tag")

Functions

func Marshal 

func Marshal(c *boc.Cell, o any) error

func ProveKeyInHashmap 

func ProveKeyInHashmap[T any](prover *boc.MerkleProver, cell *boc.Cell, key boc.BitString) (T, []byte, error)

func Unmarshal 

func Unmarshal(c *boc.Cell, o any) error

Types

type AccStatusChange 

type AccStatusChange string

AccStatusChange acst_unchanged$0 = AccStatusChange; // x -> x acst_frozen$10 = AccStatusChange; // init -> frozen acst_deleted$11 = AccStatusChange; // frozen -> deleted 

const (
	AccStatusChangeUnchanged AccStatusChange = "acst_unchanged"
	AccStatusChangeFrozen    AccStatusChange = "acst_frozen"
	AccStatusChangeDeleted   AccStatusChange = "acst_deleted"
)

func (AccStatusChange) MarshalTLB 

func (a AccStatusChange) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*AccStatusChange) UnmarshalTLB 

func (a *AccStatusChange) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Account 

type Account struct {
	SumType
	AccountNone struct {
	} `tlbSumType:"account_none$0"`
	Account ExistedAccount `tlbSumType:"account$1"`
}

Account account_none$0 = Account;

func (Account) CurrencyCollection 

func (a Account) CurrencyCollection() (CurrencyCollection, bool)

func (Account) Status 

func (a Account) Status() AccountStatus

type AccountBlock 

type AccountBlock struct {
	Magic        Magic `tlb:"acc_trans#5"`
	AccountAddr  Bits256
	Transactions HashmapAug[Uint64, Ref[Transaction], CurrencyCollection]
	StateUpdate  HashUpdate `tlb:"^"`
}

acc_trans#5 account_addr:bits256 

  transactions:(HashmapAug 64 ^Transaction CurrencyCollection)
  state_update:^(HASH_UPDATE Account)
= AccountBlock;

type AccountDispatchQueue 

type AccountDispatchQueue struct {
	Messages HashmapE[Uint64, EnqueuedMsg]
	Count    Uint48
}

_ messages:(HashmapE 64 EnqueuedMsg) count:uint48 = AccountDispatchQueue;

type AccountState 

type AccountState struct {
	SumType
	AccountUninit struct {
	} `tlbSumType:"account_uninit$00"`
	AccountActive struct {
		StateInit StateInit
	} `tlbSumType:"account_active$1"`
	AccountFrozen struct {
		StateHash Bits256
	} `tlbSumType:"account_frozen$01"`
}

AccountState account_uninit$00 = AccountState; account_active$1 _:StateInit = AccountState; account_frozen$01 state_hash:bits256 = AccountState;

type AccountStatus 

type AccountStatus string

AccountStatus acc_state_uninit$00 = AccountStatus; acc_state_frozen$01 = AccountStatus; acc_state_active$10 = AccountStatus; acc_state_nonexist$11 = AccountStatus; 

const (
	//AccountEmpty  AccountStatus = "empty" // empty state from node
	AccountNone   AccountStatus = "nonexist"
	AccountUninit AccountStatus = "uninit"
	AccountActive AccountStatus = "active"
	AccountFrozen AccountStatus = "frozen"
)

func (AccountStatus) MarshalTLB 

func (a AccountStatus) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*AccountStatus) UnmarshalTLB 

func (a *AccountStatus) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type AccountStorage 

type AccountStorage struct {
	LastTransLt uint64
	Balance     CurrencyCollection
	State       AccountState
}

AccountStorage account_storage$_ last_trans_lt:uint64 balance:CurrencyCollection state:AccountState = AccountStorage;

type AddressWithWorkchain 

type AddressWithWorkchain struct {
	Workchain int8
	Address   Bits256
}

AddressWithWorkchain is a TL-B type that represents the key in "suspended_address_list.addresses": suspended_address_list#00 addresses:(HashmapE AddressWithWorkchain Unit) suspended_until:uint32 = SuspendedAddressList;

func (AddressWithWorkchain) Compare 

func (addr AddressWithWorkchain) Compare(other any) (int, bool)

Compare returns an integer comparing two addresses lexicographically. The result will be 0 if both are equal, -1 if addr < other, and +1 if addr > other.

func (AddressWithWorkchain) Equal 

func (addr AddressWithWorkchain) Equal(other any) bool

func (AddressWithWorkchain) FixedSize 

func (addr AddressWithWorkchain) FixedSize() int

func (AddressWithWorkchain) MarshalJSON 

func (addr AddressWithWorkchain) MarshalJSON() ([]byte, error)

func (*AddressWithWorkchain) UnmarshalTLB 

func (addr *AddressWithWorkchain) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type AllShardsInfo 

type AllShardsInfo struct {
	ShardHashes HashmapE[Uint32, Ref[ShardInfoBinTree]]
}

type Any 

type Any boc.Cell

func (Any) MarshalJSON 

func (a Any) MarshalJSON() ([]byte, error)

func (Any) MarshalTLB 

func (a Any) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Any) UnmarshalJSON 

func (a *Any) UnmarshalJSON(b []byte) error

func (*Any) UnmarshalTLB 

func (a *Any) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Anycast 

type Anycast struct {
	Depth      uint32
	RewritePfx uint32
}

Anycast anycast_info$_ depth:(#<= 30) { depth >= 1 } rewrite_pfx:(bits depth) = Anycast;

func (Anycast) MarshalTLB 

func (a Anycast) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Anycast) UnmarshalTLB 

func (a *Anycast) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type BinTree 

type BinTree[T any] struct {
	Values []T
}

func (BinTree[T]) MarshalTLB 

func (b BinTree[T]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*BinTree[T]) UnmarshalTLB 

func (b *BinTree[T]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Bits128 added in v1.15.0 

type Bits128 [16]byte

func (Bits128) Compare added in v1.15.0 

func (u Bits128) Compare(other any) (int, bool)

func (Bits128) Equal added in v1.15.0 

func (u Bits128) Equal(other any) bool

func (Bits128) FixedSize added in v1.15.0 

func (u Bits128) FixedSize() int

func (Bits128) MarshalJSON added in v1.15.0 

func (u Bits128) MarshalJSON() ([]byte, error)

func (*Bits128) UnmarshalJSON added in v1.15.0 

func (u *Bits128) UnmarshalJSON(b []byte) error

type Bits256 

type Bits256 [32]byte

func (Bits256) Compare 

func (u Bits256) Compare(other any) (int, bool)

func (Bits256) Equal 

func (u Bits256) Equal(other any) bool

func (Bits256) FixedSize 

func (u Bits256) FixedSize() int

func (Bits256) Hex 

func (b Bits256) Hex() string

func (Bits256) MarshalJSON 

func (u Bits256) MarshalJSON() ([]byte, error)

func (*Bits256) UnmarshalJSON 

func (u *Bits256) UnmarshalJSON(b []byte) error

type Bits264 

type Bits264 [33]byte

func (Bits264) Compare 

func (u Bits264) Compare(other any) (int, bool)

func (Bits264) Equal 

func (u Bits264) Equal(other any) bool

func (Bits264) FixedSize 

func (u Bits264) FixedSize() int

func (Bits264) MarshalJSON 

func (u Bits264) MarshalJSON() ([]byte, error)

func (*Bits264) UnmarshalJSON 

func (u *Bits264) UnmarshalJSON(b []byte) error

type Bits320 

type Bits320 [40]byte

func (Bits320) Compare 

func (u Bits320) Compare(other any) (int, bool)

func (Bits320) Equal 

func (u Bits320) Equal(other any) bool

func (Bits320) FixedSize 

func (u Bits320) FixedSize() int

func (Bits320) MarshalJSON 

func (u Bits320) MarshalJSON() ([]byte, error)

func (*Bits320) UnmarshalJSON 

func (u *Bits320) UnmarshalJSON(b []byte) error

type Bits352 

type Bits352 [44]byte

func (Bits352) Compare 

func (u Bits352) Compare(other any) (int, bool)

func (Bits352) Equal 

func (u Bits352) Equal(other any) bool

func (Bits352) FixedSize 

func (u Bits352) FixedSize() int

func (Bits352) MarshalJSON 

func (u Bits352) MarshalJSON() ([]byte, error)

func (*Bits352) UnmarshalJSON 

func (u *Bits352) UnmarshalJSON(b []byte) error

type Bits512 

type Bits512 [64]byte

func (Bits512) Compare 

func (u Bits512) Compare(other any) (int, bool)

func (Bits512) Equal 

func (u Bits512) Equal(other any) bool

func (Bits512) FixedSize 

func (u Bits512) FixedSize() int

func (Bits512) MarshalJSON 

func (u Bits512) MarshalJSON() ([]byte, error)

func (*Bits512) UnmarshalJSON 

func (u *Bits512) UnmarshalJSON(b []byte) error

type Bits80 

type Bits80 [10]byte

func (Bits80) Compare 

func (u Bits80) Compare(other any) (int, bool)

func (Bits80) Equal 

func (u Bits80) Equal(other any) bool

func (Bits80) FixedSize 

func (u Bits80) FixedSize() int

func (Bits80) MarshalJSON 

func (u Bits80) MarshalJSON() ([]byte, error)

func (*Bits80) UnmarshalJSON 

func (u *Bits80) UnmarshalJSON(b []byte) error

type Bits96 

type Bits96 [12]byte

func (Bits96) Compare 

func (u Bits96) Compare(other any) (int, bool)

func (Bits96) Equal 

func (u Bits96) Equal(other any) bool

func (Bits96) FixedSize 

func (u Bits96) FixedSize() int

func (Bits96) MarshalJSON 

func (u Bits96) MarshalJSON() ([]byte, error)

func (*Bits96) UnmarshalJSON 

func (u *Bits96) UnmarshalJSON(b []byte) error

type BlkMasterInfo 

type BlkMasterInfo struct {
	Master ExtBlkRef
}

BlkMasterInfo master_info$_ master:ExtBlkRef = BlkMasterInfo; ext_blk_ref$_ end_lt:uint64 seq_no:uint32 root_hash:bits256 file_hash:bits256 = ExtBlkRef;

type BlkPrevInfo 

type BlkPrevInfo struct {
	SumType
	PrevBlkInfo *struct {
		Prev ExtBlkRef
	} `tlbSumType:"prev_blk_info$_"`
	PrevBlksInfo *struct {
		Prev1 ExtBlkRef // ^ but decodes manually
		Prev2 ExtBlkRef // ^ but decodes manually
	} `tlbSumType:"prev_blks_info$_"`
}

BlkPrevInfo prev_blk_info$_ prev:ExtBlkRef = BlkPrevInfo 0; prev_blks_info$_ prev1:^ExtBlkRef prev2:^ExtBlkRef = BlkPrevInfo 1;

func (*BlkPrevInfo) UnmarshalTLB 

func (i *BlkPrevInfo) UnmarshalTLB(c *boc.Cell, isBlks bool, decoder *Decoder) error

type Block 

type Block struct {
	Magic       Magic `tlb:"block#11ef55aa"`
	GlobalId    int32
	Info        BlockInfo                `tlb:"^"`
	ValueFlow   ValueFlow                `tlb:"^"`
	StateUpdate MerkleUpdate[ShardState] `tlb:"^"`
	Extra       BlockExtra               `tlb:"^"`
}

Block block#11ef55aa global_id:int32 info:^BlockInfo value_flow:^ValueFlow state_update:^(MERKLE_UPDATE ShardState) extra:^BlockExtra = Block;

func (*Block) AllTransactions 

func (b *Block) AllTransactions() []*Transaction

AllTransactions returns all transactions in this block ordered by Lt.

func (*Block) TransactionsQuantity 

func (b *Block) TransactionsQuantity() int

TransactionsQuantity returns the number of transactions in this block.

type BlockCreateFees 

type BlockCreateFees struct {
	Magic               Magic `tlb:"#6b"`
	MasterchainBlockFee Grams
	BasechainBlockFee   Grams
}

type BlockCreateStats 

type BlockCreateStats struct {
	SumType
	BlockCreateStats struct {
		Counters HashmapE[Bits256, CreatorStats]
	} `tlbSumType:"block_create_stats#17"`
	BlockCreateStatsExt struct {
		Counters HashmapAugE[Bits256, CreatorStats, uint32]
	} `tlbSumType:"block_create_stats_ext#34"`
}

block_create_stats#17 counters:(HashmapE 256 CreatorStats) = BlockCreateStats; block_create_stats_ext#34 counters:(HashmapAugE 256 CreatorStats uint32) = BlockCreateStats;

type BlockExtra 

type BlockExtra struct {
	Magic           Magic                                                  `tlb:"block_extra#4a33f6fd"`
	InMsgDescrCell  boc.Cell                                               `tlb:"^"`
	OutMsgDescrCell boc.Cell                                               `tlb:"^"`
	AccountBlocks   HashmapAugE[Bits256, AccountBlock, CurrencyCollection] `tlb:"^"`
	RandSeed        Bits256
	CreatedBy       Bits256
	Custom          Maybe[Ref[McBlockExtra]]
}

BlockExtra block_extra in_msg_descr:^InMsgDescr out_msg_descr:^OutMsgDescr account_blocks:^ShardAccountBlocks rand_seed:bits256 created_by:bits256 custom:(Maybe ^McBlockExtra) = BlockExtra;

func (*BlockExtra) InMsgDescr 

func (extra *BlockExtra) InMsgDescr() (HashmapAugE[Bits256, InMsg, ImportFees], error)

func (*BlockExtra) InMsgDescrLength 

func (extra *BlockExtra) InMsgDescrLength() (int, error)

func (*BlockExtra) OutMsgDescr 

func (extra *BlockExtra) OutMsgDescr() (HashmapAugE[Bits256, OutMsg, CurrencyCollection], error)

func (*BlockExtra) OutMsgDescrLength 

func (extra *BlockExtra) OutMsgDescrLength() (int, error)

type BlockHeader 

type BlockHeader struct {
	Magic    Magic `tlb:"block#11ef55aa"`
	GlobalId int32
	Info     BlockInfo `tlb:"^"`
}

TODO: clarify the description of the structure

type BlockIdExt 

type BlockIdExt struct {
	ShardId  ShardIdent
	SeqNo    uint32
	RootHash Bits256
	FileHash Bits256
}

block_id_ext$_ shard_id:ShardIdent seq_no:uint32 root_hash:bits256 file_hash:bits256 = BlockIdExt;

type BlockInfo 

type BlockInfo struct {
	BlockInfoPart
	GenSoftware *GlobalVersion
	MasterRef   *BlkMasterInfo
	PrevRef     BlkPrevInfo
	PrevVertRef *BlkPrevInfo
}

BlockInfo 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;

func (*BlockInfo) UnmarshalTLB 

func (i *BlockInfo) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type BlockInfoPart 

type BlockInfoPart struct {
	Version                   uint32
	NotMaster                 bool
	AfterMerge                bool
	BeforeSplit               bool
	AfterSplit                bool
	WantSplit                 bool
	WantMerge                 bool
	KeyBlock                  bool
	VertSeqnoIncr             bool
	Flags                     uint8
	SeqNo                     uint32
	VertSeqNo                 uint32
	Shard                     ShardIdent
	GenUtime                  uint32
	StartLt                   uint64
	EndLt                     uint64
	GenValidatorListHashShort uint32
	GenCatchainSeqno          uint32
	MinRefMcSeqno             uint32
	PrevKeyBlockSeqno         uint32
}

type BlockLimits 

type BlockLimits struct {
	Magic   Magic `tlb:"#5d"`
	Bytes   ParamLimits
	Gas     ParamLimits
	LtDelta ParamLimits
}

type BlockProof 

type BlockProof struct {
	Magic      Magic `tlb:"block_proof#c3"`
	ProofFor   BlockIdExt
	Root       boc.Cell `tlb:"^"`
	Signatures Maybe[Ref[BlockSignatures]]
}

block_proof#c3 proof_for:BlockIdExt root:^Cell signatures:(Maybe ^BlockSignatures) = BlockProof;

type BlockSignatures 

type BlockSignatures struct {
	Magic          Magic `tlb:"block_signatures#11"`
	ValidatorInfo  ValidatorBaseInfo
	PureSignatures BlockSignaturesPure
}

block_signatures#11 validator_info:ValidatorBaseInfo pure_signatures:BlockSignaturesPure = BlockSignatures;

type BlockSignaturesPure 

type BlockSignaturesPure struct {
	SigCount   uint32
	SigWeight  uint64
	Signatures HashmapE[Uint16, CryptoSignaturePair]
}

type BurningConfig 

type BurningConfig struct {
	Magic         Magic    `tlb:"#01"`
	BlackholeAddr *Bits256 `tlb:"maybe"`
	FeeBurnNom    uint32
	FeeBurnDenom  uint32
}

type Bytes 

type Bytes []byte

func (Bytes) MarshalTLB 

func (b Bytes) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Bytes) UnmarshalTLB 

func (b *Bytes) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type CatchainConfig 

type CatchainConfig struct {
	SumType
	CatchainConfig struct {
		McCatchainLifetime      uint32
		ShardCatchainLifetime   uint32
		ShardValidatorsLifetime uint32
		ShardValidatorsNum      uint32
	} `tlbSumType:"#c1"`
	CatchainConfigNew struct {
		Flags                   Uint7
		ShuffleMcValidators     bool
		McCatchainLifetime      uint32
		ShardCatchainLifetime   uint32
		ShardValidatorsLifetime uint32
		ShardValidatorsNum      uint32
	} `tlbSumType:"#c2"`
}

func (*CatchainConfig) MarshalJSON 

func (t *CatchainConfig) MarshalJSON() ([]byte, error)

type Certificate 

type Certificate struct {
	Magic      Magic `tlb:"certificate#4"`
	TempKey    SigPubKey
	ValidSince uint32
	ValidUntil uint32
}

certificate#4 temp_key:SigPubKey valid_since:uint32 valid_until:uint32 = Certificate; // 356 bits

type ChunkedData 

type ChunkedData boc.BitString

ChunkedData chunked_data#_ data:(HashMapE 32 ^(SnakeData ~0)) = ChunkedData;

func (ChunkedData) MarshalTLB 

func (d ChunkedData) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*ChunkedData) UnmarshalTLB 

func (d *ChunkedData) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Coins 

type Coins = Grams

type CommonMsgInfo 

type CommonMsgInfo struct {
	SumType
	IntMsgInfo *struct {
		IhrDisabled bool
		Bounce      bool
		Bounced     bool
		Src         MsgAddress
		Dest        MsgAddress
		Value       CurrencyCollection
		IhrFee      Grams
		FwdFee      Grams
		CreatedLt   uint64
		CreatedAt   uint32
	} `tlbSumType:"int_msg_info$0"`
	ExtInMsgInfo *struct {
		Src       MsgAddress
		Dest      MsgAddress
		ImportFee VarUInteger16
	} `tlbSumType:"ext_in_msg_info$10"`
	ExtOutMsgInfo *struct {
		Src       MsgAddress
		Dest      MsgAddress
		CreatedLt uint64
		CreatedAt uint32
	} `tlbSumType:"ext_out_msg_info$11"`
}

CommonMsgInfo 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;

type ComplaintPricing 

type ComplaintPricing struct {
	Magic     Magic `tlb:"#1a"`
	Deposit   Grams
	BitPrice  Grams
	CellPrice Grams
}

type ComputeSkipReason 

type ComputeSkipReason string

ComputeSkipReason cskip_no_state$00 = ComputeSkipReason; cskip_bad_state$01 = ComputeSkipReason; cskip_no_gas$10 = ComputeSkipReason; cskip_suspended$110 = ComputeSkipReason; 

const (
	ComputeSkipReasonNoState  ComputeSkipReason = "cskip_no_state"
	ComputeSkipReasonBadState ComputeSkipReason = "cskip_bad_state"
	ComputeSkipReasonNoGas    ComputeSkipReason = "cskip_no_gas"
	ComputeSkipSuspended      ComputeSkipReason = "cskip_suspended"
)

func (ComputeSkipReason) MarshalTLB 

func (a ComputeSkipReason) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*ComputeSkipReason) UnmarshalTLB 

func (a *ComputeSkipReason) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type ConfigParam0 

type ConfigParam0 struct {
	ConfigAddr Bits256
}

type ConfigParam1 

type ConfigParam1 struct {
	ElectorAddr Bits256
}

type ConfigParam10 

type ConfigParam10 struct {
	CriticalParams Hashmap[Int32, struct{}]
}

type ConfigParam11 

type ConfigParam11 struct {
	ConfigVotingSetup ConfigVotingSetup
}

type ConfigParam12 

type ConfigParam12 struct {
	Workchains HashmapE[Uint32, WorkchainDescr]
}

type ConfigParam13 

type ConfigParam13 struct {
	ComplaintPricing ComplaintPricing
}

type ConfigParam14 

type ConfigParam14 struct {
	BlockCreateFees BlockCreateFees
}

type ConfigParam15 

type ConfigParam15 struct {
	ValidatorsElectedFor uint32
	ElectionsStartBefore uint32
	ElectionsEndBefore   uint32
	StakeHeldFor         uint32
}

type ConfigParam16 

type ConfigParam16 struct {
	MaxValidators     uint16
	MaxMainValidators uint16
	MinValidators     uint16
}

type ConfigParam17 

type ConfigParam17 struct {
	MinStake       Grams
	MaxStake       Grams
	MinTotalStake  Grams
	MaxStakeFactor uint32
}

type ConfigParam18 

type ConfigParam18 struct {
	Value Hashmap[Uint32, StoragePrices]
}

type ConfigParam2 

type ConfigParam2 struct {
	MinterAddr Bits256
}

type ConfigParam20 

type ConfigParam20 struct {
	GasLimitsPrices GasLimitsPrices
}

type ConfigParam21 

type ConfigParam21 struct {
	GasLimitsPrices GasLimitsPrices
}

type ConfigParam22 

type ConfigParam22 struct {
	BlockLimits BlockLimits
}

type ConfigParam23 

type ConfigParam23 struct {
	BlockLimits BlockLimits
}

type ConfigParam24 

type ConfigParam24 struct {
	MsgForwardPrices MsgForwardPrices
}

type ConfigParam25 

type ConfigParam25 struct {
	MsgForwardPrices MsgForwardPrices
}

type ConfigParam28 

type ConfigParam28 struct {
	CatchainConfig CatchainConfig
}

type ConfigParam29 

type ConfigParam29 struct {
	ConsensusConfig ConsensusConfig
}

type ConfigParam3 

type ConfigParam3 struct {
	FeeCollectorAddr Bits256
}

type ConfigParam31 

type ConfigParam31 struct {
	FundamentalSmcAddr HashmapE[Bits256, struct{}]
}

type ConfigParam32 

type ConfigParam32 struct {
	PrevValidators ValidatorSet
}

type ConfigParam33 

type ConfigParam33 struct {
	PrevTempValidators ValidatorSet
}

type ConfigParam34 

type ConfigParam34 struct {
	CurValidators ValidatorSet
}

type ConfigParam35 

type ConfigParam35 struct {
	CurTempValidators ValidatorSet
}

type ConfigParam36 

type ConfigParam36 struct {
	NextValidators ValidatorSet
}

type ConfigParam37 

type ConfigParam37 struct {
	NextTempValidators ValidatorSet
}

type ConfigParam39 

type ConfigParam39 struct {
	Value HashmapE[Bits256, ValidatorSignedTempKey]
}

type ConfigParam4 

type ConfigParam4 struct {
	DnsRootAddr Bits256
}

type ConfigParam40 

type ConfigParam40 struct {
	MisbehaviourPunishmentConfig MisbehaviourPunishmentConfig
}

type ConfigParam43 

type ConfigParam43 struct {
	SizeLimitsConfig SizeLimitsConfig
}

type ConfigParam44 

type ConfigParam44 struct {
	SuspendedAddressList SuspendedAddressList
}

type ConfigParam45 

type ConfigParam45 struct {
	PrecompiledContractsConfig PrecompiledContractsConfig
}

type ConfigParam5 

type ConfigParam5 struct {
	BurningConfig BurningConfig
}

type ConfigParam6 

type ConfigParam6 struct {
	MintNewPrice Grams
	MintAddPrice Grams
}

type ConfigParam7 

type ConfigParam7 struct {
	ToMint ExtraCurrencyCollection
}

type ConfigParam71 

type ConfigParam71 struct {
	OracleBridgeParams OracleBridgeParams
}

type ConfigParam72 

type ConfigParam72 struct {
	OracleBridgeParams OracleBridgeParams
}

type ConfigParam73 

type ConfigParam73 struct {
	OracleBridgeParams OracleBridgeParams
}

type ConfigParam79 

type ConfigParam79 struct {
	JettonBridgeParams JettonBridgeParams
}

type ConfigParam8 

type ConfigParam8 struct {
	GlobalVersion GlobalVersion
}

type ConfigParam81 

type ConfigParam81 struct {
	JettonBridgeParams JettonBridgeParams
}

type ConfigParam82 

type ConfigParam82 struct {
	JettonBridgeParams JettonBridgeParams
}

type ConfigParam9 

type ConfigParam9 struct {
	MandatoryParams Hashmap[Int32, struct{}]
}

type ConfigParams 

type ConfigParams struct {
	ConfigAddr Bits256
	Config     Hashmap[Uint32, Ref[boc.Cell]] `tlb:"^"`
}

ConfigParams _ config_addr:bits256 config:^(Hashmap 32 ^Cell) = ConfigParams;

func (*ConfigParams) CloneKeepingSubsetOfKeys 

func (params *ConfigParams) CloneKeepingSubsetOfKeys(keys []uint32) ConfigParams

CloneKeepingSubsetOfKeys returns a new ConfigParams with only the keys specified in the keys parameter.

type ConfigProposal 

type ConfigProposal struct {
	Magic       Magic `tlb:"#f3"`
	ParamId     int32
	ParamValue  *Any     `tlb:"maybe^"`
	IfHashEqual *Uint256 `tlb:"maybe"`
}

type ConfigProposalSetup 

type ConfigProposalSetup struct {
	Magic        Magic `tlb:"#36"`
	MinTotRounds uint8
	MaxTotRounds uint8
	MinWins      uint8
	MaxLosses    uint8
	MinStoreSec  uint32
	MaxStoreSec  uint32
	BitPrice     uint32
	CellPrice    uint32
}

type ConfigProposalStatus 

type ConfigProposalStatus struct {
	Magic           Magic `tlb:"#ce"`
	Expires         uint32
	Proposal        ConfigProposal `tlb:"^"`
	IsCritical      bool
	Voters          HashmapE[Uint16, struct{}]
	RemainingWeight int64
	ValidatorSetId  Uint256
	RoundsRemaining uint8
	Wins            uint8
	Losses          uint8
}

type ConfigVotingSetup 

type ConfigVotingSetup struct {
	Magic          Magic               `tlb:"#91"`
	NormalParams   ConfigProposalSetup `tlb:"^"`
	CriticalParams ConfigProposalSetup `tlb:"^"`
}

type ConsensusConfig 

type ConsensusConfig struct {
	SumType
	ConsensusConfig struct {
		RoundCandidates      uint32
		NextCandidateDelayMs uint32
		ConsensusTimeoutMs   uint32
		FastAttempts         uint32
		AttemptDuration      uint32
		CatchainMaxDeps      uint32
		MaxBlockBytes        uint32
		MaxCollatedBytes     uint32
	} `tlbSumType:"#d6"`
	ConsensusConfigNew struct {
		Flags                Uint7
		NewCatchainIds       bool
		RoundCandidates      uint8
		NextCandidateDelayMs uint32
		ConsensusTimeoutMs   uint32
		FastAttempts         uint32
		AttemptDuration      uint32
		CatchainMaxDeps      uint32
		MaxBlockBytes        uint32
		MaxCollatedBytes     uint32
	} `tlbSumType:"#d7"`
	ConsensusConfigV3 struct {
		Flags                Uint7
		NewCatchainIds       bool
		RoundCandidates      uint8
		NextCandidateDelayMs uint32
		ConsensusTimeoutMs   uint32
		FastAttempts         uint32
		AttemptDuration      uint32
		CatchainMaxDeps      uint32
		MaxBlockBytes        uint32
		MaxCollatedBytes     uint32
		ProtoVersion         uint16
	} `tlbSumType:"#d8"`
	ConsensusConfigV4 struct {
		Flags                  Uint7
		NewCatchainIds         bool
		RoundCandidates        uint8
		NextCandidateDelayMs   uint32
		ConsensusTimeoutMs     uint32
		FastAttempts           uint32
		AttemptDuration        uint32
		CatchainMaxDeps        uint32
		MaxBlockBytes          uint32
		MaxCollatedBytes       uint32
		ProtoVersion           uint16
		CatchainMaxBlocksCoeff uint32
	} `tlbSumType:"#d9"`
}

func (*ConsensusConfig) MarshalJSON 

func (t *ConsensusConfig) MarshalJSON() ([]byte, error)

type ContentData 

type ContentData struct {
	SumType
	Snake struct {
		Data SnakeData
	} `tlbSumType:"snake#00"`
	Chunks struct {
		Data ChunkedData
	} `tlbSumType:"chunks#01"`
}

ContentData snake#00 data:(SnakeData ~n) = ContentData; chunks#01 data:ChunkedData = ContentData;

func (ContentData) Bytes 

func (c ContentData) Bytes() ([]byte, error)

type Counters 

type Counters struct {
	LastUpdated uint32
	Total       uint64
	Cnt2048     uint64
	Cnt65536    uint64
}

type CreatorStats 

type CreatorStats struct {
	Magic       Magic `tlb:"creator_info#4"`
	McBlocks    Counters
	ShardBlocks Counters
}

creator_info#4 mc_blocks:Counters shard_blocks:Counters = CreatorStats;

type CryptoSignature 

type CryptoSignature struct {
	SumType
	CryptoSignatureSimple CryptoSignatureSimpleData `tlbSumType:"ed25519_signature#5"`
	CryptoSignature       struct {
		SignedCert       *SignedSertificate `tlb:"^"`
		TempKeySignature CryptoSignatureSimple
	} `tlbSumType:"chained_signature#f"`
}

func (*CryptoSignature) UnmarshalTLB 

func (cr *CryptoSignature) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type CryptoSignaturePair 

type CryptoSignaturePair struct {
	NodeIdShort Bits256
	Sign        CryptoSignature
}

sig_pair$_ node_id_short:bits256 sign:CryptoSignature = CryptoSignaturePair; // 256+x ~ 772 bits

type CryptoSignatureSimple 

type CryptoSignatureSimple struct {
	Magic                 Magic `tlb:"ed25519_signature#5"`
	CryptoSignatureSimple CryptoSignatureSimpleData
}

ed25519_signature#5 R:bits256 s:bits256 = CryptoSignatureSimple; // 516 bits _ CryptoSignatureSimple = CryptoSignature; chained_signature#f signed_cert:^SignedCertificate temp_key_signature:CryptoSignatureSimple 

= CryptoSignature;   // 4+(356+516)+516 = 520 bits+ref (1392 bits total)

type CryptoSignatureSimpleData 

type CryptoSignatureSimpleData struct {
	R Bits256
	S Bits256
}

type CurrencyCollection 

type CurrencyCollection struct {
	Grams Grams
	Other ExtraCurrencyCollection
}

CurrencyCollection currencies$_ grams:Grams other:ExtraCurrencyCollection = CurrencyCollection;

type DNSRecord 

type DNSRecord struct {
	SumType
	DNSText         DNSText    `tlbSumType:"dns_text#1eda"`
	DNSNextResolver MsgAddress `tlbSumType:"dns_next_resolver#ba93"`
	DNSAdnlAddress  struct {
		Address   [32]byte
		ProtoList []string
	} `tlbSumType:"dns_adnl_address#ad01"`
	DNSSmcAddress struct {
		Address       MsgAddress
		SmcCapability SmcCapabilities
	} `tlbSumType:"dns_smc_address#9fd3"`
	DNSStorageAddress Bits256   `tlbSumType:"dns_storage_address#7473"`
	NotStandard       *boc.Cell // only for custom unmarshaling
}

DNSRecord 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 dns_smc_address#9fd3 smc_addr:MsgAddressInt flags:(## 8) { flags <= 1 } cap_list:flags . 0?SmcCapList = DNSRecord; // often in record #1 dns_storage_address#7473 bag_id:bits256 = DNSRecord;

func (*DNSRecord) UnmarshalTLB 

func (r *DNSRecord) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type DNSRecordSet 

type DNSRecordSet struct {
	Records Hashmap[Bits256, Ref[DNSRecord]]
}

DNSRecordSet _ (HashmapE 256 DNSRecord) = DNS_RecordSet;

type DNSText 

type DNSText string

DNSText text$_ chunks:(## 8) rest:(TextChunks chunks) = Text;

func (*DNSText) UnmarshalTLB 

func (t *DNSText) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Decoder 

type Decoder struct {
	// contains filtered or unexported fields
}

Decoder unmarshals a cell into a golang type.

func NewDecoder 

func NewDecoder() *Decoder

NewDecoder returns a new Decoder.

func (*Decoder) Hasher 

func (dec *Decoder) Hasher() *boc.Hasher

Hasher returns boc.Hasher that is used to calculate hashes when decoding.

func (*Decoder) Unmarshal 

func (dec *Decoder) Unmarshal(c *boc.Cell, o any) error

Unmarshal decodes the give cell using TL-B schema and stores the result in the value pointed to by o.

func (*Decoder) WithDebug 

func (d *Decoder) WithDebug() *Decoder

func (*Decoder) WithLibraryResolver 

func (d *Decoder) WithLibraryResolver(resolveLib resolveLib) *Decoder

WithLibraryResolver provides a function which is used to fetch a library cell by its hash.

type DepthBalanceInfo 

type DepthBalanceInfo struct {
	SplitDepth Uint5
	Balance    CurrencyCollection
}

depth_balance$_ split_depth:(#<= 30) balance:CurrencyCollection = DepthBalanceInfo;

type Either 

type Either[M, N any] struct {
	IsRight bool
	Left    M
	Right   N
}

func (Either[_, _]) MarshalTLB 

func (m Either[_, _]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Either[_, _]) UnmarshalTLB 

func (m *Either[_, _]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type EitherRef 

type EitherRef[T any] struct {
	IsRight bool
	Value   T
}

func (EitherRef[_]) MarshalTLB 

func (m EitherRef[_]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*EitherRef[_]) UnmarshalTLB 

func (m *EitherRef[_]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Encoder 

type Encoder struct {
}

func (*Encoder) Marshal 

func (enc *Encoder) Marshal(c *boc.Cell, o any) error

type EnqueuedMsg 

type EnqueuedMsg struct {
	EnqueuedLt uint64
	OutMsg     MsgEnvelope `tlb:"^"`
}

_ enqueued_lt:uint64 out_msg:^MsgEnvelope = EnqueuedMsg;

type ExistedAccount 

type ExistedAccount struct {
	Addr        MsgAddress
	StorageStat StorageInfo
	Storage     AccountStorage
}

account$1 addr:MsgAddressInt storage_stat:StorageInfo storage:AccountStorage = Account;

type ExtBlkRef 

type ExtBlkRef struct {
	EndLt    uint64
	SeqNo    uint32
	RootHash Bits256
	FileHash Bits256
}

ExtBlkRef ext_blk_ref$_ end_lt:uint64 seq_no:uint32 root_hash:bits256 file_hash:bits256 = ExtBlkRef;

type ExtraCurrencyCollection 

type ExtraCurrencyCollection struct {
	Dict HashmapE[Uint32, VarUInteger32]
}

ExtraCurrencyCollection extra_currencies$_ dict:(HashmapE 32 (VarUInteger 32)) = ExtraCurrencyCollection;

func (ExtraCurrencyCollection) MarshalJSON 

func (f ExtraCurrencyCollection) MarshalJSON() ([]byte, error)

type FixedLengthText 

type FixedLengthText string

func (FixedLengthText) MarshalTLB 

func (t FixedLengthText) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*FixedLengthText) UnmarshalTLB 

func (t *FixedLengthText) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type FullContent 

type FullContent struct {
	SumType
	Onchain struct {
		Data HashmapE[Bits256, Ref[ContentData]]
	} `tlbSumType:"onchain#00"`
	Offchain struct {
		Uri SnakeData // Text
	} `tlbSumType:"offchain#01"`
}

FullContent onchain#00 data:(HashMapE 256 ^ContentData) = FullContent; offchain#01 uri:Text = FullContent; text#_ {n:#} data:(SnakeData ~n) = Text;

type GasLimitsPrices 

type GasLimitsPrices struct {
	SumType
	GasPrices struct {
		GasPrice       uint64
		GasLimit       uint64
		GasCredit      uint64
		BlockGasLimit  uint64
		FreezeDueLimit uint64
		DeleteDueLimit uint64
	} `tlbSumType:"#dd"`
	GasPricesExt struct {
		GasPrice        uint64
		GasLimit        uint64
		SpecialGasLimit uint64
		GasCredit       uint64
		BlockGasLimit   uint64
		FreezeDueLimit  uint64
		DeleteDueLimit  uint64
	} `tlbSumType:"#de"`
	GasFlatPfx struct {
		FlatGasLimit uint64
		FlatGasPrice uint64
		Other        *GasLimitsPrices
	} `tlbSumType:"#d1"`
}

func (*GasLimitsPrices) MarshalJSON 

func (t *GasLimitsPrices) MarshalJSON() ([]byte, error)

type GlobalVersion 

type GlobalVersion struct {
	Magic        Magic `tlb:"capabilities#c4"`
	Version      uint32
	Capabilities uint64
}

GlobalVersion capabilities#c4 version:uint32 capabilities:uint64 = GlobalVersion;

type Grams 

type Grams uint64 // total value fit to uint64

Grams nanograms$_ amount:(VarUInteger 16) = Grams;

func (Grams) MarshalJSON 

func (g Grams) MarshalJSON() ([]byte, error)

func (Grams) MarshalTLB 

func (g Grams) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Grams) UnmarshalJSON 

func (g *Grams) UnmarshalJSON(data []byte) error

func (*Grams) UnmarshalTLB 

func (g *Grams) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type HashMapAugExtraList 

type HashMapAugExtraList[T any] struct {
	Left  *HashMapAugExtraList[T]
	Right *HashMapAugExtraList[T]
	Data  T
}

type HashUpdate 

type HashUpdate struct {
	Magic   Magic `tlb:"update_hashes#72"`
	OldHash Bits256
	NewHash Bits256
}

HashUpdate update_hashes#72 {X:Type} old_hash:bits256 new_hash:bits256 = HASH_UPDATE X;

type Hashmap 

type Hashmap[keyT fixedSize, T any] struct {
	// contains filtered or unexported fields
}

func NewHashmap 

func NewHashmap[keyT fixedSize, T any](keys []keyT, values []T) Hashmap[keyT, T]

NewHashmap returns a new instance of Hashmap. Make sure that a key at index "i" corresponds to a value at the same index.

func (Hashmap[keyT, T]) Get 

func (h Hashmap[keyT, T]) Get(key keyT) (T, bool)

func (Hashmap[keyT, T]) Items 

func (h Hashmap[keyT, T]) Items() []HashmapItem[keyT, T]

func (Hashmap[keyT, T]) Keys 

func (h Hashmap[keyT, T]) Keys() []keyT

func (Hashmap[keyT, T]) MarshalJSON 

func (h Hashmap[keyT, T]) MarshalJSON() ([]byte, error)

func (Hashmap[keyT, T]) MarshalTLB 

func (h Hashmap[keyT, T]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Hashmap[keyT, T]) Put 

func (h *Hashmap[keyT, T]) Put(key keyT, value T)

func (*Hashmap[keyT, T]) UnmarshalTLB 

func (h *Hashmap[keyT, T]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

func (Hashmap[keyT, T]) Values 

func (h Hashmap[keyT, T]) Values() []T

type HashmapAug 

type HashmapAug[keyT fixedSize, T1, T2 any] struct {
	// contains filtered or unexported fields
}

func (HashmapAug[keyT, T1, T2]) MarshalTLB 

func (h HashmapAug[keyT, T1, T2]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*HashmapAug[keyT, T1, T2]) UnmarshalTLB 

func (h *HashmapAug[keyT, T1, T2]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

func (HashmapAug[_, T1, _]) Values 

func (h HashmapAug[_, T1, _]) Values() []T1

Values returns a list of value of this hashmap.

type HashmapAugE 

type HashmapAugE[keyT fixedSize, T1, T2 any] struct {
	// contains filtered or unexported fields
}

func (HashmapAugE[keyT, T1, T2]) Keys 

func (h HashmapAugE[keyT, T1, T2]) Keys() []keyT

func (HashmapAugE[keyT, T1, T2]) MarshalTLB 

func (h HashmapAugE[keyT, T1, T2]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*HashmapAugE[keyT, T1, T2]) UnmarshalTLB 

func (h *HashmapAugE[keyT, T1, T2]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

func (HashmapAugE[keyT, T1, T2]) Values 

func (h HashmapAugE[keyT, T1, T2]) Values() []T1

type HashmapE 

type HashmapE[keyT fixedSize, T any] struct {
	// contains filtered or unexported fields
}

func NewHashmapE 

func NewHashmapE[keyT fixedSize, T any](keys []keyT, values []T) HashmapE[keyT, T]

NewHashmapE returns a new instance of HashmapE. Make sure that a key at index "i" corresponds to a value at the same index.

func (HashmapE[keyT, T]) Get 

func (h HashmapE[keyT, T]) Get(key keyT) (T, bool)

func (HashmapE[keyT, T]) Items 

func (h HashmapE[keyT, T]) Items() []HashmapItem[keyT, T]

Items returns key-value pairs of this hashmap.

func (HashmapE[keyT, T]) Keys 

func (h HashmapE[keyT, T]) Keys() []keyT

func (HashmapE[keyT, T]) MarshalJSON 

func (h HashmapE[keyT, T]) MarshalJSON() ([]byte, error)

func (HashmapE[keyT, T]) MarshalTLB 

func (h HashmapE[keyT, T]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*HashmapE[keyT, T]) Put 

func (h *HashmapE[keyT, T]) Put(key keyT, value T)

func (*HashmapE[keyT, T]) UnmarshalTLB 

func (h *HashmapE[keyT, T]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

func (HashmapE[keyT, T]) Values 

func (h HashmapE[keyT, T]) Values() []T

type HashmapItem 

type HashmapItem[keyT fixedSize, T any] struct {
	Key   keyT
	Value T
}

HashmapItem represents a key-value pair stored in HashmapE[T].

type IhrPendingSince 

type IhrPendingSince struct {
	ImportLt uint64
}

ihr_pending$_ import_lt:uint64 = IhrPendingSince;

type ImportFees 

type ImportFees struct {
	FeesCollected Grams
	ValueImported CurrencyCollection
}

import_fees$_ fees_collected:Grams 

value_imported:CurrencyCollection = ImportFees;

type InMsg 

type InMsg struct {
	SumType
	MsgImportExt *struct {
		Msg         Message     `tlb:"^"`
		Transaction Transaction `tlb:"^"`
	} `tlbSumType:"msg_import_ext$000"`
	MsgImportIhr *struct {
		Msg          Message     `tlb:"^"`
		Transaction  Transaction `tlb:"^"`
		IhrFee       Grams
		ProofCreated boc.Cell `tlb:"^"`
	} `tlbSumType:"msg_import_ihr$010"`
	MsgImportImm *struct {
		InMsg       MsgEnvelope `tlb:"^"`
		Transaction Transaction `tlb:"^"`
		FwdFee      Grams
	} `tlbSumType:"msg_import_imm$011"`
	MsgImportFin *struct {
		InMsg       MsgEnvelope `tlb:"^"`
		Transaction Transaction `tlb:"^"`
		FwdFee      Grams
	} `tlbSumType:"msg_import_fin$100"`
	MsgImportTr *struct {
		InMsg      MsgEnvelope `tlb:"^"`
		OutMsg     MsgEnvelope `tlb:"^"`
		TransitFee Grams
	} `tlbSumType:"msg_import_tr$101"`
	MsgDiscardFin *struct {
		InMsg         MsgEnvelope `tlb:"^"`
		TransactionId uint64
		FwdFee        Grams
	} `tlbSumType:"msg_discard_fin$110"`
	MsgDiscardTr *struct {
		InMsg          MsgEnvelope `tlb:"^"`
		TransactionId  uint64
		FwdFee         Grams
		ProofDelivered boc.Cell `tlb:"^"`
	} `tlbSumType:"msg_discard_tr$111"`
	MsgImportDeferredFin *struct {
		InMsg         MsgEnvelope `tlb:"^"`
		TransactionId Transaction `tlb:"^"`
		FwdFee        Grams
	} `tlbSumType:"msg_import_deferred_fin$00100"`
	MsgImportDeferredTr *struct {
		InMsg  MsgEnvelope `tlb:"^"`
		OutMsg MsgEnvelope `tlb:"^"`
	} `tlbSumType:"msg_import_deferred_tr$00101"`
}

msg_import_deferred_tr$00101 in_msg:^MsgEnvelope out_msg:^MsgEnvelope = InMsg;

type Int1 

type Int1 int8

func (Int1) Compare 

func (u Int1) Compare(other any) (int, bool)

func (Int1) Equal 

func (u Int1) Equal(other any) bool

func (Int1) FixedSize 

func (u Int1) FixedSize() int

func (Int1) MarshalJSON 

func (u Int1) MarshalJSON() ([]byte, error)

func (Int1) MarshalTLB 

func (u Int1) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int1) UnmarshalJSON 

func (u *Int1) UnmarshalJSON(p []byte) error

func (*Int1) UnmarshalTLB 

func (u *Int1) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int10 

type Int10 int16

func (Int10) Compare 

func (u Int10) Compare(other any) (int, bool)

func (Int10) Equal 

func (u Int10) Equal(other any) bool

func (Int10) FixedSize 

func (u Int10) FixedSize() int

func (Int10) MarshalJSON 

func (u Int10) MarshalJSON() ([]byte, error)

func (Int10) MarshalTLB 

func (u Int10) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int10) UnmarshalJSON 

func (u *Int10) UnmarshalJSON(p []byte) error

func (*Int10) UnmarshalTLB 

func (u *Int10) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int11 

type Int11 int16

func (Int11) Compare 

func (u Int11) Compare(other any) (int, bool)

func (Int11) Equal 

func (u Int11) Equal(other any) bool

func (Int11) FixedSize 

func (u Int11) FixedSize() int

func (Int11) MarshalJSON 

func (u Int11) MarshalJSON() ([]byte, error)

func (Int11) MarshalTLB 

func (u Int11) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int11) UnmarshalJSON 

func (u *Int11) UnmarshalJSON(p []byte) error

func (*Int11) UnmarshalTLB 

func (u *Int11) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int12 

type Int12 int16

func (Int12) Compare 

func (u Int12) Compare(other any) (int, bool)

func (Int12) Equal 

func (u Int12) Equal(other any) bool

func (Int12) FixedSize 

func (u Int12) FixedSize() int

func (Int12) MarshalJSON 

func (u Int12) MarshalJSON() ([]byte, error)

func (Int12) MarshalTLB 

func (u Int12) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int12) UnmarshalJSON 

func (u *Int12) UnmarshalJSON(p []byte) error

func (*Int12) UnmarshalTLB 

func (u *Int12) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int128 

type Int128 big.Int

func (Int128) FixedSize 

func (u Int128) FixedSize() int

func (Int128) MarshalJSON 

func (u Int128) MarshalJSON() ([]byte, error)

func (Int128) MarshalTLB 

func (u Int128) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int128) UnmarshalJSON 

func (u *Int128) UnmarshalJSON(p []byte) error

func (*Int128) UnmarshalTLB 

func (u *Int128) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int13 

type Int13 int16

func (Int13) Compare 

func (u Int13) Compare(other any) (int, bool)

func (Int13) Equal 

func (u Int13) Equal(other any) bool

func (Int13) FixedSize 

func (u Int13) FixedSize() int

func (Int13) MarshalJSON 

func (u Int13) MarshalJSON() ([]byte, error)

func (Int13) MarshalTLB 

func (u Int13) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int13) UnmarshalJSON 

func (u *Int13) UnmarshalJSON(p []byte) error

func (*Int13) UnmarshalTLB 

func (u *Int13) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int14 

type Int14 int16

func (Int14) Compare 

func (u Int14) Compare(other any) (int, bool)

func (Int14) Equal 

func (u Int14) Equal(other any) bool

func (Int14) FixedSize 

func (u Int14) FixedSize() int

func (Int14) MarshalJSON 

func (u Int14) MarshalJSON() ([]byte, error)

func (Int14) MarshalTLB 

func (u Int14) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int14) UnmarshalJSON 

func (u *Int14) UnmarshalJSON(p []byte) error

func (*Int14) UnmarshalTLB 

func (u *Int14) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int15 

type Int15 int16

func (Int15) Compare 

func (u Int15) Compare(other any) (int, bool)

func (Int15) Equal 

func (u Int15) Equal(other any) bool

func (Int15) FixedSize 

func (u Int15) FixedSize() int

func (Int15) MarshalJSON 

func (u Int15) MarshalJSON() ([]byte, error)

func (Int15) MarshalTLB 

func (u Int15) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int15) UnmarshalJSON 

func (u *Int15) UnmarshalJSON(p []byte) error

func (*Int15) UnmarshalTLB 

func (u *Int15) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int16 

type Int16 int16

func (Int16) Compare 

func (u Int16) Compare(other any) (int, bool)

func (Int16) Equal 

func (u Int16) Equal(other any) bool

func (Int16) FixedSize 

func (u Int16) FixedSize() int

func (Int16) MarshalJSON 

func (u Int16) MarshalJSON() ([]byte, error)

func (Int16) MarshalTLB 

func (u Int16) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int16) UnmarshalJSON 

func (u *Int16) UnmarshalJSON(p []byte) error

func (*Int16) UnmarshalTLB 

func (u *Int16) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int17 

type Int17 int32

func (Int17) Compare 

func (u Int17) Compare(other any) (int, bool)

func (Int17) Equal 

func (u Int17) Equal(other any) bool

func (Int17) FixedSize 

func (u Int17) FixedSize() int

func (Int17) MarshalJSON 

func (u Int17) MarshalJSON() ([]byte, error)

func (Int17) MarshalTLB 

func (u Int17) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int17) UnmarshalJSON 

func (u *Int17) UnmarshalJSON(p []byte) error

func (*Int17) UnmarshalTLB 

func (u *Int17) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int18 

type Int18 int32

func (Int18) Compare 

func (u Int18) Compare(other any) (int, bool)

func (Int18) Equal 

func (u Int18) Equal(other any) bool

func (Int18) FixedSize 

func (u Int18) FixedSize() int

func (Int18) MarshalJSON 

func (u Int18) MarshalJSON() ([]byte, error)

func (Int18) MarshalTLB 

func (u Int18) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int18) UnmarshalJSON 

func (u *Int18) UnmarshalJSON(p []byte) error

func (*Int18) UnmarshalTLB 

func (u *Int18) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int19 

type Int19 int32

func (Int19) Compare 

func (u Int19) Compare(other any) (int, bool)

func (Int19) Equal 

func (u Int19) Equal(other any) bool

func (Int19) FixedSize 

func (u Int19) FixedSize() int

func (Int19) MarshalJSON 

func (u Int19) MarshalJSON() ([]byte, error)

func (Int19) MarshalTLB 

func (u Int19) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int19) UnmarshalJSON 

func (u *Int19) UnmarshalJSON(p []byte) error

func (*Int19) UnmarshalTLB 

func (u *Int19) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int2 

type Int2 int8

func (Int2) Compare 

func (u Int2) Compare(other any) (int, bool)

func (Int2) Equal 

func (u Int2) Equal(other any) bool

func (Int2) FixedSize 

func (u Int2) FixedSize() int

func (Int2) MarshalJSON 

func (u Int2) MarshalJSON() ([]byte, error)

func (Int2) MarshalTLB 

func (u Int2) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int2) UnmarshalJSON 

func (u *Int2) UnmarshalJSON(p []byte) error

func (*Int2) UnmarshalTLB 

func (u *Int2) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int20 

type Int20 int32

func (Int20) Compare 

func (u Int20) Compare(other any) (int, bool)

func (Int20) Equal 

func (u Int20) Equal(other any) bool

func (Int20) FixedSize 

func (u Int20) FixedSize() int

func (Int20) MarshalJSON 

func (u Int20) MarshalJSON() ([]byte, error)

func (Int20) MarshalTLB 

func (u Int20) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int20) UnmarshalJSON 

func (u *Int20) UnmarshalJSON(p []byte) error

func (*Int20) UnmarshalTLB 

func (u *Int20) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int21 

type Int21 int32

func (Int21) Compare 

func (u Int21) Compare(other any) (int, bool)

func (Int21) Equal 

func (u Int21) Equal(other any) bool

func (Int21) FixedSize 

func (u Int21) FixedSize() int

func (Int21) MarshalJSON 

func (u Int21) MarshalJSON() ([]byte, error)

func (Int21) MarshalTLB 

func (u Int21) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int21) UnmarshalJSON 

func (u *Int21) UnmarshalJSON(p []byte) error

func (*Int21) UnmarshalTLB 

func (u *Int21) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int22 

type Int22 int32

func (Int22) Compare 

func (u Int22) Compare(other any) (int, bool)

func (Int22) Equal 

func (u Int22) Equal(other any) bool

func (Int22) FixedSize 

func (u Int22) FixedSize() int

func (Int22) MarshalJSON 

func (u Int22) MarshalJSON() ([]byte, error)

func (Int22) MarshalTLB 

func (u Int22) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int22) UnmarshalJSON 

func (u *Int22) UnmarshalJSON(p []byte) error

func (*Int22) UnmarshalTLB 

func (u *Int22) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int23 

type Int23 int32

func (Int23) Compare 

func (u Int23) Compare(other any) (int, bool)

func (Int23) Equal 

func (u Int23) Equal(other any) bool

func (Int23) FixedSize 

func (u Int23) FixedSize() int

func (Int23) MarshalJSON 

func (u Int23) MarshalJSON() ([]byte, error)

func (Int23) MarshalTLB 

func (u Int23) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int23) UnmarshalJSON 

func (u *Int23) UnmarshalJSON(p []byte) error

func (*Int23) UnmarshalTLB 

func (u *Int23) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int24 

type Int24 int32

func (Int24) Compare 

func (u Int24) Compare(other any) (int, bool)

func (Int24) Equal 

func (u Int24) Equal(other any) bool

func (Int24) FixedSize 

func (u Int24) FixedSize() int

func (Int24) MarshalJSON 

func (u Int24) MarshalJSON() ([]byte, error)

func (Int24) MarshalTLB 

func (u Int24) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int24) UnmarshalJSON 

func (u *Int24) UnmarshalJSON(p []byte) error

func (*Int24) UnmarshalTLB 

func (u *Int24) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int25 

type Int25 int32

func (Int25) Compare 

func (u Int25) Compare(other any) (int, bool)

func (Int25) Equal 

func (u Int25) Equal(other any) bool

func (Int25) FixedSize 

func (u Int25) FixedSize() int

func (Int25) MarshalJSON 

func (u Int25) MarshalJSON() ([]byte, error)

func (Int25) MarshalTLB 

func (u Int25) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int25) UnmarshalJSON 

func (u *Int25) UnmarshalJSON(p []byte) error

func (*Int25) UnmarshalTLB 

func (u *Int25) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int256 

type Int256 big.Int

func (Int256) FixedSize 

func (u Int256) FixedSize() int

func (Int256) MarshalJSON 

func (u Int256) MarshalJSON() ([]byte, error)

func (Int256) MarshalTLB 

func (u Int256) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int256) UnmarshalJSON 

func (u *Int256) UnmarshalJSON(p []byte) error

func (*Int256) UnmarshalTLB 

func (u *Int256) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int257 

type Int257 big.Int

func Int257FromInt64 

func Int257FromInt64(i int64) Int257

func (Int257) FixedSize 

func (u Int257) FixedSize() int

func (Int257) MarshalJSON 

func (u Int257) MarshalJSON() ([]byte, error)

func (Int257) MarshalTLB 

func (u Int257) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int257) UnmarshalJSON 

func (u *Int257) UnmarshalJSON(p []byte) error

func (*Int257) UnmarshalTLB 

func (u *Int257) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int26 

type Int26 int32

func (Int26) Compare 

func (u Int26) Compare(other any) (int, bool)

func (Int26) Equal 

func (u Int26) Equal(other any) bool

func (Int26) FixedSize 

func (u Int26) FixedSize() int

func (Int26) MarshalJSON 

func (u Int26) MarshalJSON() ([]byte, error)

func (Int26) MarshalTLB 

func (u Int26) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int26) UnmarshalJSON 

func (u *Int26) UnmarshalJSON(p []byte) error

func (*Int26) UnmarshalTLB 

func (u *Int26) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int27 

type Int27 int32

func (Int27) Compare 

func (u Int27) Compare(other any) (int, bool)

func (Int27) Equal 

func (u Int27) Equal(other any) bool

func (Int27) FixedSize 

func (u Int27) FixedSize() int

func (Int27) MarshalJSON 

func (u Int27) MarshalJSON() ([]byte, error)

func (Int27) MarshalTLB 

func (u Int27) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int27) UnmarshalJSON 

func (u *Int27) UnmarshalJSON(p []byte) error

func (*Int27) UnmarshalTLB 

func (u *Int27) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int28 

type Int28 int32

func (Int28) Compare 

func (u Int28) Compare(other any) (int, bool)

func (Int28) Equal 

func (u Int28) Equal(other any) bool

func (Int28) FixedSize 

func (u Int28) FixedSize() int

func (Int28) MarshalJSON 

func (u Int28) MarshalJSON() ([]byte, error)

func (Int28) MarshalTLB 

func (u Int28) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int28) UnmarshalJSON 

func (u *Int28) UnmarshalJSON(p []byte) error

func (*Int28) UnmarshalTLB 

func (u *Int28) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int29 

type Int29 int32

func (Int29) Compare 

func (u Int29) Compare(other any) (int, bool)

func (Int29) Equal 

func (u Int29) Equal(other any) bool

func (Int29) FixedSize 

func (u Int29) FixedSize() int

func (Int29) MarshalJSON 

func (u Int29) MarshalJSON() ([]byte, error)

func (Int29) MarshalTLB 

func (u Int29) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int29) UnmarshalJSON 

func (u *Int29) UnmarshalJSON(p []byte) error

func (*Int29) UnmarshalTLB 

func (u *Int29) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int3 

type Int3 int8

func (Int3) Compare 

func (u Int3) Compare(other any) (int, bool)

func (Int3) Equal 

func (u Int3) Equal(other any) bool

func (Int3) FixedSize 

func (u Int3) FixedSize() int

func (Int3) MarshalJSON 

func (u Int3) MarshalJSON() ([]byte, error)

func (Int3) MarshalTLB 

func (u Int3) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int3) UnmarshalJSON 

func (u *Int3) UnmarshalJSON(p []byte) error

func (*Int3) UnmarshalTLB 

func (u *Int3) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int30 

type Int30 int32

func (Int30) Compare 

func (u Int30) Compare(other any) (int, bool)

func (Int30) Equal 

func (u Int30) Equal(other any) bool

func (Int30) FixedSize 

func (u Int30) FixedSize() int

func (Int30) MarshalJSON 

func (u Int30) MarshalJSON() ([]byte, error)

func (Int30) MarshalTLB 

func (u Int30) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int30) UnmarshalJSON 

func (u *Int30) UnmarshalJSON(p []byte) error

func (*Int30) UnmarshalTLB 

func (u *Int30) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int31 

type Int31 int32

func (Int31) Compare 

func (u Int31) Compare(other any) (int, bool)

func (Int31) Equal 

func (u Int31) Equal(other any) bool

func (Int31) FixedSize 

func (u Int31) FixedSize() int

func (Int31) MarshalJSON 

func (u Int31) MarshalJSON() ([]byte, error)

func (Int31) MarshalTLB 

func (u Int31) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int31) UnmarshalJSON 

func (u *Int31) UnmarshalJSON(p []byte) error

func (*Int31) UnmarshalTLB 

func (u *Int31) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int32 

type Int32 int32

func (Int32) Compare 

func (u Int32) Compare(other any) (int, bool)

func (Int32) Equal 

func (u Int32) Equal(other any) bool

func (Int32) FixedSize 

func (u Int32) FixedSize() int

func (Int32) MarshalJSON 

func (u Int32) MarshalJSON() ([]byte, error)

func (Int32) MarshalTLB 

func (u Int32) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int32) UnmarshalJSON 

func (u *Int32) UnmarshalJSON(p []byte) error

func (*Int32) UnmarshalTLB 

func (u *Int32) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int33 

type Int33 int64

func (Int33) Compare 

func (u Int33) Compare(other any) (int, bool)

func (Int33) Equal 

func (u Int33) Equal(other any) bool

func (Int33) FixedSize 

func (u Int33) FixedSize() int

func (Int33) MarshalJSON 

func (u Int33) MarshalJSON() ([]byte, error)

func (Int33) MarshalTLB 

func (u Int33) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int33) UnmarshalJSON 

func (u *Int33) UnmarshalJSON(p []byte) error

func (*Int33) UnmarshalTLB 

func (u *Int33) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int34 

type Int34 int64

func (Int34) Compare 

func (u Int34) Compare(other any) (int, bool)

func (Int34) Equal 

func (u Int34) Equal(other any) bool

func (Int34) FixedSize 

func (u Int34) FixedSize() int

func (Int34) MarshalJSON 

func (u Int34) MarshalJSON() ([]byte, error)

func (Int34) MarshalTLB 

func (u Int34) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int34) UnmarshalJSON 

func (u *Int34) UnmarshalJSON(p []byte) error

func (*Int34) UnmarshalTLB 

func (u *Int34) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int35 

type Int35 int64

func (Int35) Compare 

func (u Int35) Compare(other any) (int, bool)

func (Int35) Equal 

func (u Int35) Equal(other any) bool

func (Int35) FixedSize 

func (u Int35) FixedSize() int

func (Int35) MarshalJSON 

func (u Int35) MarshalJSON() ([]byte, error)

func (Int35) MarshalTLB 

func (u Int35) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int35) UnmarshalJSON 

func (u *Int35) UnmarshalJSON(p []byte) error

func (*Int35) UnmarshalTLB 

func (u *Int35) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int36 

type Int36 int64

func (Int36) Compare 

func (u Int36) Compare(other any) (int, bool)

func (Int36) Equal 

func (u Int36) Equal(other any) bool

func (Int36) FixedSize 

func (u Int36) FixedSize() int

func (Int36) MarshalJSON 

func (u Int36) MarshalJSON() ([]byte, error)

func (Int36) MarshalTLB 

func (u Int36) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int36) UnmarshalJSON 

func (u *Int36) UnmarshalJSON(p []byte) error

func (*Int36) UnmarshalTLB 

func (u *Int36) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int37 

type Int37 int64

func (Int37) Compare 

func (u Int37) Compare(other any) (int, bool)

func (Int37) Equal 

func (u Int37) Equal(other any) bool

func (Int37) FixedSize 

func (u Int37) FixedSize() int

func (Int37) MarshalJSON 

func (u Int37) MarshalJSON() ([]byte, error)

func (Int37) MarshalTLB 

func (u Int37) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int37) UnmarshalJSON 

func (u *Int37) UnmarshalJSON(p []byte) error

func (*Int37) UnmarshalTLB 

func (u *Int37) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int38 

type Int38 int64

func (Int38) Compare 

func (u Int38) Compare(other any) (int, bool)

func (Int38) Equal 

func (u Int38) Equal(other any) bool

func (Int38) FixedSize 

func (u Int38) FixedSize() int

func (Int38) MarshalJSON 

func (u Int38) MarshalJSON() ([]byte, error)

func (Int38) MarshalTLB 

func (u Int38) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int38) UnmarshalJSON 

func (u *Int38) UnmarshalJSON(p []byte) error

func (*Int38) UnmarshalTLB 

func (u *Int38) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int39 

type Int39 int64

func (Int39) Compare 

func (u Int39) Compare(other any) (int, bool)

func (Int39) Equal 

func (u Int39) Equal(other any) bool

func (Int39) FixedSize 

func (u Int39) FixedSize() int

func (Int39) MarshalJSON 

func (u Int39) MarshalJSON() ([]byte, error)

func (Int39) MarshalTLB 

func (u Int39) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int39) UnmarshalJSON 

func (u *Int39) UnmarshalJSON(p []byte) error

func (*Int39) UnmarshalTLB 

func (u *Int39) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int4 

type Int4 int8

func (Int4) Compare 

func (u Int4) Compare(other any) (int, bool)

func (Int4) Equal 

func (u Int4) Equal(other any) bool

func (Int4) FixedSize 

func (u Int4) FixedSize() int

func (Int4) MarshalJSON 

func (u Int4) MarshalJSON() ([]byte, error)

func (Int4) MarshalTLB 

func (u Int4) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int4) UnmarshalJSON 

func (u *Int4) UnmarshalJSON(p []byte) error

func (*Int4) UnmarshalTLB 

func (u *Int4) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int40 

type Int40 int64

func (Int40) Compare 

func (u Int40) Compare(other any) (int, bool)

func (Int40) Equal 

func (u Int40) Equal(other any) bool

func (Int40) FixedSize 

func (u Int40) FixedSize() int

func (Int40) MarshalJSON 

func (u Int40) MarshalJSON() ([]byte, error)

func (Int40) MarshalTLB 

func (u Int40) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int40) UnmarshalJSON 

func (u *Int40) UnmarshalJSON(p []byte) error

func (*Int40) UnmarshalTLB 

func (u *Int40) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int41 

type Int41 int64

func (Int41) Compare 

func (u Int41) Compare(other any) (int, bool)

func (Int41) Equal 

func (u Int41) Equal(other any) bool

func (Int41) FixedSize 

func (u Int41) FixedSize() int

func (Int41) MarshalJSON 

func (u Int41) MarshalJSON() ([]byte, error)

func (Int41) MarshalTLB 

func (u Int41) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int41) UnmarshalJSON 

func (u *Int41) UnmarshalJSON(p []byte) error

func (*Int41) UnmarshalTLB 

func (u *Int41) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int42 

type Int42 int64

func (Int42) Compare 

func (u Int42) Compare(other any) (int, bool)

func (Int42) Equal 

func (u Int42) Equal(other any) bool

func (Int42) FixedSize 

func (u Int42) FixedSize() int

func (Int42) MarshalJSON 

func (u Int42) MarshalJSON() ([]byte, error)

func (Int42) MarshalTLB 

func (u Int42) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int42) UnmarshalJSON 

func (u *Int42) UnmarshalJSON(p []byte) error

func (*Int42) UnmarshalTLB 

func (u *Int42) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int43 

type Int43 int64

func (Int43) Compare 

func (u Int43) Compare(other any) (int, bool)

func (Int43) Equal 

func (u Int43) Equal(other any) bool

func (Int43) FixedSize 

func (u Int43) FixedSize() int

func (Int43) MarshalJSON 

func (u Int43) MarshalJSON() ([]byte, error)

func (Int43) MarshalTLB 

func (u Int43) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int43) UnmarshalJSON 

func (u *Int43) UnmarshalJSON(p []byte) error

func (*Int43) UnmarshalTLB 

func (u *Int43) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int44 

type Int44 int64

func (Int44) Compare 

func (u Int44) Compare(other any) (int, bool)

func (Int44) Equal 

func (u Int44) Equal(other any) bool

func (Int44) FixedSize 

func (u Int44) FixedSize() int

func (Int44) MarshalJSON 

func (u Int44) MarshalJSON() ([]byte, error)

func (Int44) MarshalTLB 

func (u Int44) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int44) UnmarshalJSON 

func (u *Int44) UnmarshalJSON(p []byte) error

func (*Int44) UnmarshalTLB 

func (u *Int44) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int45 

type Int45 int64

func (Int45) Compare 

func (u Int45) Compare(other any) (int, bool)

func (Int45) Equal 

func (u Int45) Equal(other any) bool

func (Int45) FixedSize 

func (u Int45) FixedSize() int

func (Int45) MarshalJSON 

func (u Int45) MarshalJSON() ([]byte, error)

func (Int45) MarshalTLB 

func (u Int45) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int45) UnmarshalJSON 

func (u *Int45) UnmarshalJSON(p []byte) error

func (*Int45) UnmarshalTLB 

func (u *Int45) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int46 

type Int46 int64

func (Int46) Compare 

func (u Int46) Compare(other any) (int, bool)

func (Int46) Equal 

func (u Int46) Equal(other any) bool

func (Int46) FixedSize 

func (u Int46) FixedSize() int

func (Int46) MarshalJSON 

func (u Int46) MarshalJSON() ([]byte, error)

func (Int46) MarshalTLB 

func (u Int46) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int46) UnmarshalJSON 

func (u *Int46) UnmarshalJSON(p []byte) error

func (*Int46) UnmarshalTLB 

func (u *Int46) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int47 

type Int47 int64

func (Int47) Compare 

func (u Int47) Compare(other any) (int, bool)

func (Int47) Equal 

func (u Int47) Equal(other any) bool

func (Int47) FixedSize 

func (u Int47) FixedSize() int

func (Int47) MarshalJSON 

func (u Int47) MarshalJSON() ([]byte, error)

func (Int47) MarshalTLB 

func (u Int47) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int47) UnmarshalJSON 

func (u *Int47) UnmarshalJSON(p []byte) error

func (*Int47) UnmarshalTLB 

func (u *Int47) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int48 

type Int48 int64

func (Int48) Compare 

func (u Int48) Compare(other any) (int, bool)

func (Int48) Equal 

func (u Int48) Equal(other any) bool

func (Int48) FixedSize 

func (u Int48) FixedSize() int

func (Int48) MarshalJSON 

func (u Int48) MarshalJSON() ([]byte, error)

func (Int48) MarshalTLB 

func (u Int48) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int48) UnmarshalJSON 

func (u *Int48) UnmarshalJSON(p []byte) error

func (*Int48) UnmarshalTLB 

func (u *Int48) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int49 

type Int49 int64

func (Int49) Compare 

func (u Int49) Compare(other any) (int, bool)

func (Int49) Equal 

func (u Int49) Equal(other any) bool

func (Int49) FixedSize 

func (u Int49) FixedSize() int

func (Int49) MarshalJSON 

func (u Int49) MarshalJSON() ([]byte, error)

func (Int49) MarshalTLB 

func (u Int49) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int49) UnmarshalJSON 

func (u *Int49) UnmarshalJSON(p []byte) error

func (*Int49) UnmarshalTLB 

func (u *Int49) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int5 

type Int5 int8

func (Int5) Compare 

func (u Int5) Compare(other any) (int, bool)

func (Int5) Equal 

func (u Int5) Equal(other any) bool

func (Int5) FixedSize 

func (u Int5) FixedSize() int

func (Int5) MarshalJSON 

func (u Int5) MarshalJSON() ([]byte, error)

func (Int5) MarshalTLB 

func (u Int5) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int5) UnmarshalJSON 

func (u *Int5) UnmarshalJSON(p []byte) error

func (*Int5) UnmarshalTLB 

func (u *Int5) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int50 

type Int50 int64

func (Int50) Compare 

func (u Int50) Compare(other any) (int, bool)

func (Int50) Equal 

func (u Int50) Equal(other any) bool

func (Int50) FixedSize 

func (u Int50) FixedSize() int

func (Int50) MarshalJSON 

func (u Int50) MarshalJSON() ([]byte, error)

func (Int50) MarshalTLB 

func (u Int50) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int50) UnmarshalJSON 

func (u *Int50) UnmarshalJSON(p []byte) error

func (*Int50) UnmarshalTLB 

func (u *Int50) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int51 

type Int51 int64

func (Int51) Compare 

func (u Int51) Compare(other any) (int, bool)

func (Int51) Equal 

func (u Int51) Equal(other any) bool

func (Int51) FixedSize 

func (u Int51) FixedSize() int

func (Int51) MarshalJSON 

func (u Int51) MarshalJSON() ([]byte, error)

func (Int51) MarshalTLB 

func (u Int51) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int51) UnmarshalJSON 

func (u *Int51) UnmarshalJSON(p []byte) error

func (*Int51) UnmarshalTLB 

func (u *Int51) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int52 

type Int52 int64

func (Int52) Compare 

func (u Int52) Compare(other any) (int, bool)

func (Int52) Equal 

func (u Int52) Equal(other any) bool

func (Int52) FixedSize 

func (u Int52) FixedSize() int

func (Int52) MarshalJSON 

func (u Int52) MarshalJSON() ([]byte, error)

func (Int52) MarshalTLB 

func (u Int52) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int52) UnmarshalJSON 

func (u *Int52) UnmarshalJSON(p []byte) error

func (*Int52) UnmarshalTLB 

func (u *Int52) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int53 

type Int53 int64

func (Int53) Compare 

func (u Int53) Compare(other any) (int, bool)

func (Int53) Equal 

func (u Int53) Equal(other any) bool

func (Int53) FixedSize 

func (u Int53) FixedSize() int

func (Int53) MarshalJSON 

func (u Int53) MarshalJSON() ([]byte, error)

func (Int53) MarshalTLB 

func (u Int53) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int53) UnmarshalJSON 

func (u *Int53) UnmarshalJSON(p []byte) error

func (*Int53) UnmarshalTLB 

func (u *Int53) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int54 

type Int54 int64

func (Int54) Compare 

func (u Int54) Compare(other any) (int, bool)

func (Int54) Equal 

func (u Int54) Equal(other any) bool

func (Int54) FixedSize 

func (u Int54) FixedSize() int

func (Int54) MarshalJSON 

func (u Int54) MarshalJSON() ([]byte, error)

func (Int54) MarshalTLB 

func (u Int54) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int54) UnmarshalJSON 

func (u *Int54) UnmarshalJSON(p []byte) error

func (*Int54) UnmarshalTLB 

func (u *Int54) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int55 

type Int55 int64

func (Int55) Compare 

func (u Int55) Compare(other any) (int, bool)

func (Int55) Equal 

func (u Int55) Equal(other any) bool

func (Int55) FixedSize 

func (u Int55) FixedSize() int

func (Int55) MarshalJSON 

func (u Int55) MarshalJSON() ([]byte, error)

func (Int55) MarshalTLB 

func (u Int55) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int55) UnmarshalJSON 

func (u *Int55) UnmarshalJSON(p []byte) error

func (*Int55) UnmarshalTLB 

func (u *Int55) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int56 

type Int56 int64

func (Int56) Compare 

func (u Int56) Compare(other any) (int, bool)

func (Int56) Equal 

func (u Int56) Equal(other any) bool

func (Int56) FixedSize 

func (u Int56) FixedSize() int

func (Int56) MarshalJSON 

func (u Int56) MarshalJSON() ([]byte, error)

func (Int56) MarshalTLB 

func (u Int56) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int56) UnmarshalJSON 

func (u *Int56) UnmarshalJSON(p []byte) error

func (*Int56) UnmarshalTLB 

func (u *Int56) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int57 

type Int57 int64

func (Int57) Compare 

func (u Int57) Compare(other any) (int, bool)

func (Int57) Equal 

func (u Int57) Equal(other any) bool

func (Int57) FixedSize 

func (u Int57) FixedSize() int

func (Int57) MarshalJSON 

func (u Int57) MarshalJSON() ([]byte, error)

func (Int57) MarshalTLB 

func (u Int57) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int57) UnmarshalJSON 

func (u *Int57) UnmarshalJSON(p []byte) error

func (*Int57) UnmarshalTLB 

func (u *Int57) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int58 

type Int58 int64

func (Int58) Compare 

func (u Int58) Compare(other any) (int, bool)

func (Int58) Equal 

func (u Int58) Equal(other any) bool

func (Int58) FixedSize 

func (u Int58) FixedSize() int

func (Int58) MarshalJSON 

func (u Int58) MarshalJSON() ([]byte, error)

func (Int58) MarshalTLB 

func (u Int58) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int58) UnmarshalJSON 

func (u *Int58) UnmarshalJSON(p []byte) error

func (*Int58) UnmarshalTLB 

func (u *Int58) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int59 

type Int59 int64

func (Int59) Compare 

func (u Int59) Compare(other any) (int, bool)

func (Int59) Equal 

func (u Int59) Equal(other any) bool

func (Int59) FixedSize 

func (u Int59) FixedSize() int

func (Int59) MarshalJSON 

func (u Int59) MarshalJSON() ([]byte, error)

func (Int59) MarshalTLB 

func (u Int59) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int59) UnmarshalJSON 

func (u *Int59) UnmarshalJSON(p []byte) error

func (*Int59) UnmarshalTLB 

func (u *Int59) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int6 

type Int6 int8

func (Int6) Compare 

func (u Int6) Compare(other any) (int, bool)

func (Int6) Equal 

func (u Int6) Equal(other any) bool

func (Int6) FixedSize 

func (u Int6) FixedSize() int

func (Int6) MarshalJSON 

func (u Int6) MarshalJSON() ([]byte, error)

func (Int6) MarshalTLB 

func (u Int6) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int6) UnmarshalJSON 

func (u *Int6) UnmarshalJSON(p []byte) error

func (*Int6) UnmarshalTLB 

func (u *Int6) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int60 

type Int60 int64

func (Int60) Compare 

func (u Int60) Compare(other any) (int, bool)

func (Int60) Equal 

func (u Int60) Equal(other any) bool

func (Int60) FixedSize 

func (u Int60) FixedSize() int

func (Int60) MarshalJSON 

func (u Int60) MarshalJSON() ([]byte, error)

func (Int60) MarshalTLB 

func (u Int60) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int60) UnmarshalJSON 

func (u *Int60) UnmarshalJSON(p []byte) error

func (*Int60) UnmarshalTLB 

func (u *Int60) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int61 

type Int61 int64

func (Int61) Compare 

func (u Int61) Compare(other any) (int, bool)

func (Int61) Equal 

func (u Int61) Equal(other any) bool

func (Int61) FixedSize 

func (u Int61) FixedSize() int

func (Int61) MarshalJSON 

func (u Int61) MarshalJSON() ([]byte, error)

func (Int61) MarshalTLB 

func (u Int61) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int61) UnmarshalJSON 

func (u *Int61) UnmarshalJSON(p []byte) error

func (*Int61) UnmarshalTLB 

func (u *Int61) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int62 

type Int62 int64

func (Int62) Compare 

func (u Int62) Compare(other any) (int, bool)

func (Int62) Equal 

func (u Int62) Equal(other any) bool

func (Int62) FixedSize 

func (u Int62) FixedSize() int

func (Int62) MarshalJSON 

func (u Int62) MarshalJSON() ([]byte, error)

func (Int62) MarshalTLB 

func (u Int62) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int62) UnmarshalJSON 

func (u *Int62) UnmarshalJSON(p []byte) error

func (*Int62) UnmarshalTLB 

func (u *Int62) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int63 

type Int63 int64

func (Int63) Compare 

func (u Int63) Compare(other any) (int, bool)

func (Int63) Equal 

func (u Int63) Equal(other any) bool

func (Int63) FixedSize 

func (u Int63) FixedSize() int

func (Int63) MarshalJSON 

func (u Int63) MarshalJSON() ([]byte, error)

func (Int63) MarshalTLB 

func (u Int63) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int63) UnmarshalJSON 

func (u *Int63) UnmarshalJSON(p []byte) error

func (*Int63) UnmarshalTLB 

func (u *Int63) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int64 

type Int64 int64

func (Int64) Compare 

func (u Int64) Compare(other any) (int, bool)

func (Int64) Equal 

func (u Int64) Equal(other any) bool

func (Int64) FixedSize 

func (u Int64) FixedSize() int

func (Int64) MarshalJSON 

func (u Int64) MarshalJSON() ([]byte, error)

func (Int64) MarshalTLB 

func (u Int64) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int64) UnmarshalJSON 

func (u *Int64) UnmarshalJSON(p []byte) error

func (*Int64) UnmarshalTLB 

func (u *Int64) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int7 

type Int7 int8

func (Int7) Compare 

func (u Int7) Compare(other any) (int, bool)

func (Int7) Equal 

func (u Int7) Equal(other any) bool

func (Int7) FixedSize 

func (u Int7) FixedSize() int

func (Int7) MarshalJSON 

func (u Int7) MarshalJSON() ([]byte, error)

func (Int7) MarshalTLB 

func (u Int7) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int7) UnmarshalJSON 

func (u *Int7) UnmarshalJSON(p []byte) error

func (*Int7) UnmarshalTLB 

func (u *Int7) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int8 

type Int8 int8

func (Int8) Compare 

func (u Int8) Compare(other any) (int, bool)

func (Int8) Equal 

func (u Int8) Equal(other any) bool

func (Int8) FixedSize 

func (u Int8) FixedSize() int

func (Int8) MarshalJSON 

func (u Int8) MarshalJSON() ([]byte, error)

func (Int8) MarshalTLB 

func (u Int8) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int8) UnmarshalJSON 

func (u *Int8) UnmarshalJSON(p []byte) error

func (*Int8) UnmarshalTLB 

func (u *Int8) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Int9 

type Int9 int16

func (Int9) Compare 

func (u Int9) Compare(other any) (int, bool)

func (Int9) Equal 

func (u Int9) Equal(other any) bool

func (Int9) FixedSize 

func (u Int9) FixedSize() int

func (Int9) MarshalJSON 

func (u Int9) MarshalJSON() ([]byte, error)

func (Int9) MarshalTLB 

func (u Int9) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Int9) UnmarshalJSON 

func (u *Int9) UnmarshalJSON(p []byte) error

func (*Int9) UnmarshalTLB 

func (u *Int9) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type IntermediateAddress 

type IntermediateAddress struct {
	SumType
	IntermediateAddressRegular struct {
		UseDestBits Uint7
	} `tlbSumType:"interm_addr_regular$0"`
	IntermediateAddressSimple struct {
		WorkchainId   int8
		AddressPrefix uint64
	} `tlbSumType:"interm_addr_simple$10"`
	IntermediateAddressExt struct {
		WorkchainId   int32
		AddressPrefix uint64
	} `tlbSumType:"interm_addr_ext$11"`
}

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;

type JettonBridgeParams 

type JettonBridgeParams struct {
	SumType
	JettonBridgeParamsV0 struct {
		BridgeAddress  Bits256
		OraclesAddress Bits256
		Oracles        HashmapE[Bits256, Bits256]
		StateFlags     uint8
		BurnBridgeFee  Grams
	} `tlbSumType:"#00"`
	JettonBridgeParamsV1 struct {
		BridgeAddress        Bits256
		OraclesAddress       Bits256
		Oracles              HashmapE[Bits256, Bits256]
		StateFlags           uint8
		Prices               JettonBridgePrices `tlb:"^"`
		ExternalChainAddress Bits256
	} `tlbSumType:"#01"`
}

func (*JettonBridgeParams) MarshalJSON 

func (t *JettonBridgeParams) MarshalJSON() ([]byte, error)

type JettonBridgePrices 

type JettonBridgePrices struct {
	BridgeBurnFee           Grams
	BridgeMintFee           Grams
	WalletMinTonsForStorage Grams
	WalletGasConsumption    Grams
	MinterMinTonsForStorage Grams
	DiscoverGasConsumption  Grams
}

type KeyExtBlkRef 

type KeyExtBlkRef struct {
	Key    bool
	BlkRef ExtBlkRef
}

_ key:Bool blk_ref:ExtBlkRef = KeyExtBlkRef;

type KeyMaxLt 

type KeyMaxLt struct {
	Key      bool
	MaxEndLt uint64
}

_ key:Bool max_end_lt:uint64 = KeyMaxLt;

type LibDescr 

type LibDescr struct {
	Magic      Magic    `tlb:"shared_lib_descr$00"`
	Lib        boc.Cell `tlb:"^"`
	Publishers Hashmap[Bits256, struct{}]
}

shared_lib_descr$00 lib:^Cell publishers:(Hashmap 256 True) 

= LibDescr;

type Magic 

type Magic uint32

func (Magic) EncodeTag 

func (m Magic) EncodeTag(c *boc.Cell, tag string) error

func (Magic) MarshalJSON 

func (m Magic) MarshalJSON() ([]byte, error)

func (*Magic) UnmarshalJSON 

func (m *Magic) UnmarshalJSON(b []byte) error

func (*Magic) ValidateTag 

func (m *Magic) ValidateTag(c *boc.Cell, tag string) error

type MarshalerTLB 

type MarshalerTLB interface {
	MarshalTLB(c *boc.Cell, encoder *Encoder) error
}

type Maybe 

type Maybe[T any] struct {
	Exists bool
	Value  T
}

func (Maybe[T]) MarshalJSON 

func (m Maybe[T]) MarshalJSON() ([]byte, error)

func (Maybe[_]) MarshalTLB 

func (m Maybe[_]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (Maybe[T]) Pointer 

func (m Maybe[T]) Pointer() *T

func (*Maybe[T]) UnmarshalJSON 

func (m *Maybe[T]) UnmarshalJSON(b []byte) error

func (*Maybe[_]) UnmarshalTLB 

func (m *Maybe[_]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type McBlockExtra 

type McBlockExtra struct {
	Magic        Magic `tlb:"masterchain_block_extra#cca5"`
	KeyBlock     bool
	ShardHashes  HashmapE[Uint32, Ref[ShardInfoBinTree]]
	ShardFees    ShardFees
	McExtraOther struct {
		PrevBlkSignatures HashmapE[Uint16, CryptoSignaturePair]
		RecoverCreate     Maybe[Ref[InMsg]]
		MintMsg           Maybe[Ref[InMsg]]
	} `tlb:"^"`
	Config ConfigParams
}

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;

func (*McBlockExtra) UnmarshalTLB 

func (m *McBlockExtra) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type McStateExtra 

type McStateExtra struct {
	Magic         Magic `tlb:"masterchain_state_extra#cc26"`
	ShardHashes   HashmapE[Uint32, Ref[ShardInfoBinTree]]
	Config        ConfigParams
	Other         McStateExtraOther `tlb:"^"`
	GlobalBalance CurrencyCollection
}

McStateExtra 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;

type McStateExtraOther 

type McStateExtraOther struct {
	Flags            uint16
	ValidatorInfo    ValidatorInfo
	PrevBlocks       HashmapAugE[Uint32, KeyExtBlkRef, KeyMaxLt]
	AfterKeyBlock    bool
	LastKeyBlock     Maybe[ExtBlkRef]
	BlockCreateStats BlockCreateStats
}

^[ 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 ]

func (*McStateExtraOther) UnmarshalTLB 

func (m *McStateExtraOther) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type MerkleProof 

type MerkleProof[T any] struct {
	Magic       Magic `tlb:"!merkle_proof#03"`
	VirtualHash Bits256
	Depth       uint16
	VirtualRoot T `tlb:"^"`
}

MerkleProof !merkle_proof#03 {X:Type} virtual_hash:bits256 depth:uint16 virtual_root:^X = MERKLE_PROOF X;

type MerkleUpdate 

type MerkleUpdate[T any] struct {
	Magic     Magic `tlb:"!merkle_update#04"`
	FromHash  Bits256
	ToHash    Bits256
	FromDepth uint16
	ToDepth   uint16
	FromRoot  T `tlb:"^"`
	ToRoot    T `tlb:"^"`
}

type Message 

type Message struct {
	Info CommonMsgInfo
	Init Maybe[EitherRef[StateInit]]
	Body EitherRef[Any]
	// contains filtered or unexported fields
}

Message message$_ {X:Type} info:CommonMsgInfo init:(Maybe (Either StateInit ^StateInit)) body:(Either X ^X) = Message X;

func (*Message) Hash 

func (m *Message) Hash(normalizeExternal bool) Bits256

Hash returns a hash of this Message. it's strongly recommended to normalize hash

func (Message) MarshalTLB 

func (m Message) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Message) UnmarshalTLB 

func (m *Message) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type MisbehaviourPunishmentConfig 

type MisbehaviourPunishmentConfig struct {
	Magic                    Magic `tlb:"#01"`
	DefaultFlatFine          Grams
	DefaultProportionalFine  uint32
	SeverityFlatMult         uint16
	SeverityProportionalMult uint16
	UnpunishableInterval     uint16
	LongInterval             uint16
	LongFlatMult             uint16
	LongProportionalMult     uint16
	MediumInterval           uint16
	MediumFlatMult           uint16
	MediumProportionalMult   uint16
}

type MsgAddress 

type MsgAddress struct {
	SumType
	AddrNone struct {
	} `tlbSumType:"addr_none$00"`
	AddrExtern *boc.BitString `tlbSumType:"addr_extern$01"`
	AddrStd    struct {
		Anycast     Maybe[Anycast]
		WorkchainId int8
		Address     Bits256
	} `tlbSumType:"addr_std$10"`
	AddrVar *struct {
		Anycast     Maybe[Anycast]
		AddrLen     Uint9
		WorkchainId int32
		Address     boc.BitString
	} `tlbSumType:"addr_var$11"`
}

MsgAddress addr_none$00 = MsgAddressExt; addr_extern$01 len:(## 9) external_address:(bits len) = MsgAddressExt; 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;

func (MsgAddress) MarshalJSON 

func (a MsgAddress) MarshalJSON() ([]byte, error)

func (MsgAddress) MarshalTLB 

func (a MsgAddress) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*MsgAddress) UnmarshalJSON 

func (a *MsgAddress) UnmarshalJSON(b []byte) error

func (*MsgAddress) UnmarshalTLB 

func (a *MsgAddress) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type MsgEnvelope 

type MsgEnvelope struct {
	SumType SumType
	V1      struct {
		CurrentAddress  IntermediateAddress
		NextAddress     IntermediateAddress
		FwdFeeRemaining Grams
		Msg             Message `tlb:"^"`
	} `tlbSumType:"msg_envelope#4"`
	V2 struct {
		CurrentAddress  IntermediateAddress
		NextAddress     IntermediateAddress
		FwdFeeRemaining Grams
		Msg             Message      `tlb:"^"`
		EmittedLT       *uint64      `tlb:"maybe"`
		Metadata        *MsgMetadata `tlb:"maybe"`
	} `tlbSumType:"msg_envelope_v2#5"`
}
	msg_envelope#4 cur_addr:IntermediateAddress
 next_addr:IntermediateAddress fwd_fee_remaining:Grams
 msg:^(Message Any) = MsgEnvelope;

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;

type MsgForwardPrices 

type MsgForwardPrices struct {
	Magic          Magic `tlb:"#ea"`
	LumpPrice      uint64
	BitPrice       uint64
	CellPrice      uint64
	IhrPriceFactor uint32
	FirstFrac      uint16
	NextFrac       uint16
}

type MsgMetadata 

type MsgMetadata struct {
	Magic         Magic `tlb:"msg_metadata#0"`
	Depth         uint32
	InitiatorAddr MsgAddress
	InitiatorLT   uint64
}

msg_metadata#0 depth:uint32 initiator_addr:MsgAddressInt initiator_lt:uint64 = MsgMetadata;

type OracleBridgeParams 

type OracleBridgeParams struct {
	BridgeAddress         Bits256
	OracleMutlisigAddress Bits256
	Oracles               HashmapE[Bits256, Bits256]
	ExternalChainAddress  Bits256
}

type OutMsg 

type OutMsg struct {
	SumType
	MsgExportExt struct {
		Msg         Message     `tlb:"^"`
		Transaction Transaction `tlb:"^"`
	} `tlbSumType:"msg_export_ext$000"`
	MsgExportImm struct {
		OutMsg      MsgEnvelope `tlb:"^"`
		Transaction Transaction `tlb:"^"`
		Reimport    InMsg       `tlb:"^"`
	} `tlbSumType:"msg_export_imm$010"`
	MsgExportNew struct {
		OutMsg      MsgEnvelope `tlb:"^"`
		Transaction Transaction `tlb:"^"`
	} `tlbSumType:"msg_export_new$001"`
	MsgExportTr struct {
		OutMsg   MsgEnvelope `tlb:"^"`
		Imported InMsg       `tlb:"^"`
	} `tlbSumType:"msg_export_tr$011"`
	MsgExportDeq struct {
		OutMsg      MsgEnvelope `tlb:"^"`
		ImportBlock Uint63
	} `tlbSumType:"msg_export_deq$1100"`
	MsgExportDeqShort struct {
		MsgEnvHash     Bits256
		NextWorkchain  uint32
		NextAddrPrefix uint64
		ImportBlockLt  uint64
	} `tlbSumType:"msg_export_deq_short$1101"`
	MsgExportTrReq struct {
		OutMsg   MsgEnvelope `tlb:"^"`
		Imported InMsg       `tlb:"^"`
	} `tlbSumType:"msg_export_tr_req$111"`
	MsgExportDeqImm struct {
		OutMsg   MsgEnvelope `tlb:"^"`
		Reimport InMsg       `tlb:"^"`
	} `tlbSumType:"msg_export_deq_imm$100"`
	MsgExportNewDefer *struct {
		OutMsg      MsgEnvelope `tlb:"^"`
		Transaction Transaction `tlb:"^"`
	} `tlbSumType:"msg_export_new_defer$10100"`
	MsgExportDeferredTr *struct {
		OutMsg   MsgEnvelope `tlb:"^"`
		Imported InMsg       `tlb:"^"`
	} `tlbSumType:"msg_export_deferred_tr$10101"`
}

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;

type OutMsgQueueExtra 

type OutMsgQueueExtra struct {
	Magic Magic `tlb:"out_msg_queue_extra#0"`
	// key - sender address, aug - min created_lt
	DispatchQueue HashmapAugE[Bits256, AccountDispatchQueue, uint64]
	OutQueueSize  Maybe[Uint48]
}

dispatch_queue:DispatchQueue out_queue_size:(Maybe uint48) = OutMsgQueueExtra;

type OutMsgQueueInfo 

type OutMsgQueueInfo struct {
	OutQueue HashmapAugE[Bits352, EnqueuedMsg, uint64]
	ProcInfo HashmapE[Bits96, ProcessedUpto]
	Extra    Maybe[OutMsgQueueExtra]
}

_ out_queue:OutMsgQueue proc_info:ProcessedInfo ihr_pending:IhrPendingInfo = OutMsgQueueInfo;

type ParamLimits 

type ParamLimits struct {
	Magic     Magic `tlb:"#c3"`
	Underload uint32
	SoftLimit uint32
	HardLimit uint32
}

type PrecompiledContractsConfig 

type PrecompiledContractsConfig struct {
	Magic Magic `tlb:"#c0"`
	List  HashmapE[Bits256, PrecompiledSmc]
}

type PrecompiledSmc 

type PrecompiledSmc struct {
	Magic    Magic `tlb:"#b0"`
	GasUsage uint64
}

type ProcessedUpto 

type ProcessedUpto struct {
	LastMsgLt   uint64
	LastMsgHash Bits256
}

processed_upto$_ last_msg_lt:uint64 last_msg_hash:bits256 = ProcessedUpto;

type Ref 

type Ref[T any] struct {
	Value T
}

func (Ref[_]) MarshalTLB 

func (m Ref[_]) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Ref[T]) UnmarshalTLB 

func (m *Ref[T]) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type ShardAccount 

type ShardAccount struct {
	Account       Account `tlb:"^"`
	LastTransHash Bits256
	LastTransLt   uint64
}

ShardAccount account_descr$_ account:^Account last_trans_hash:bits256 last_trans_lt:uint64 = ShardAccount;

type ShardDesc 

type ShardDesc struct {
	SumType
	Old struct {
		SeqNo              uint32
		RegMcSeqno         uint32
		StartLT            uint64
		EndLT              uint64
		RootHash           Bits256
		FileHash           Bits256
		BeforeSplit        bool
		BeforeMerge        bool
		WantSplit          bool
		WantMerge          bool
		NXCCUpdated        bool
		Flags              Uint3
		NextCatchainSeqNo  uint32
		NextValidatorShard int64
		MinRefMcSeqNo      uint32
		GenUTime           uint32
	} `tlbSumType:"old#b"`
	New struct {
		SeqNo              uint32
		RegMcSeqno         uint32
		StartLT            uint64
		EndLT              uint64
		RootHash           Bits256
		FileHash           Bits256
		BeforeSplit        bool
		BeforeMerge        bool
		WantSplit          bool
		WantMerge          bool
		NXCCUpdated        bool
		Flags              Uint3
		NextCatchainSeqNo  uint32
		NextValidatorShard int64
		MinRefMcSeqNo      uint32
		GenUTime           uint32
	} `tlbSumType:"new#a"`
}

func (*ShardDesc) SeqNo 

func (d *ShardDesc) SeqNo() uint32

type ShardFeeCreated 

type ShardFeeCreated struct {
	Fees   CurrencyCollection
	Create CurrencyCollection
}

_ fees:CurrencyCollection create:CurrencyCollection = ShardFeeCreated;

type ShardFees 

type ShardFees struct {
	Hashmap HashmapAugE[Bits96, ShardFeeCreated, ShardFeeCreated]
}

_ (HashmapAugE 96 ShardFeeCreated ShardFeeCreated) = ShardFees;

type ShardIdent 

type ShardIdent struct {
	Magic        Magic `tlb:"shardident$00"`
	ShardPfxBits Uint6
	WorkchainID  int32
	ShardPrefix  uint64
}

ShardIdent shard_ident$00 shard_pfx_bits:(#<= 60) workchain_id:int32 shard_prefix:uint64 = ShardIdent;

type ShardInfoBinTree 

type ShardInfoBinTree struct {
	BinTree BinTree[ShardDesc]
}

type ShardState 

type ShardState struct {
	SumType
	UnsplitState struct {
		Value ShardStateUnsplit
	} `tlbSumType:"_"`
	SplitState struct {
		Left  ShardStateUnsplit `tlb:"^"` // ^ but decodes manually
		Right ShardStateUnsplit `tlb:"^"` // ^ but decodes manually
	} `tlbSumType:"split_state#5f327da5"`
}

ShardState _ ShardStateUnsplit = ShardState; split_state#5f327da5 left:^ShardStateUnsplit right:^ShardStateUnsplit = ShardState;

func (*ShardState) AccountBalances 

func (s *ShardState) AccountBalances() map[Bits256]CurrencyCollection

func (*ShardState) UnmarshalTLB 

func (s *ShardState) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type ShardStateUnsplit 

type ShardStateUnsplit struct {
	Magic             Magic `tlb:"shard_state#9023afe2"`
	ShardStateUnsplit ShardStateUnsplitData
}

ShardStateUnsplit 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;

type ShardStateUnsplitData 

type ShardStateUnsplitData struct {
	GlobalID        int32
	ShardID         ShardIdent
	SeqNo           uint32
	VertSeqNo       uint32
	GenUtime        uint32
	GenLt           uint64
	MinRefMcSeqno   uint32
	OutMsgQueueInfo OutMsgQueueInfo `tlb:"^"`
	BeforeSplit     bool
	Accounts        HashmapAugE[Bits256, ShardAccount, DepthBalanceInfo] `tlb:"^"`
	Other           ShardStateUnsplitOther                               `tlb:"^"`
	Custom          Maybe[Ref[McStateExtra]]
}

type ShardStateUnsplitOther 

type ShardStateUnsplitOther struct {
	OverloadHistory    uint64
	UnderloadHistory   uint64
	TotalBalance       CurrencyCollection
	TotalValidatorFees CurrencyCollection
	Libraries          HashmapE[Bits256, LibDescr]
	MasterRef          Maybe[BlkMasterInfo]
}

^[ overload_history:uint64 underload_history:uint64 total_balance:CurrencyCollection total_validator_fees:CurrencyCollection libraries:(HashmapE 256 LibDescr) master_ref:(Maybe BlkMasterInfo) ]

type SigPubKey 

type SigPubKey struct {
	Magic  Magic `tlb:"pubkey#8e81278a"`
	PubKey Bits256
}

type SignedCoins 

type SignedCoins int64

func (SignedCoins) MarshalJSON 

func (g SignedCoins) MarshalJSON() ([]byte, error)

func (SignedCoins) MarshalTLB 

func (g SignedCoins) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*SignedCoins) UnmarshalJSON 

func (g *SignedCoins) UnmarshalJSON(data []byte) error

func (*SignedCoins) UnmarshalTLB 

func (g *SignedCoins) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type SignedSertificate 

type SignedSertificate struct {
	Certificate          Certificate
	CertificateSignature CryptoSignature
}

signed_certificate$_ certificate:Certificate certificate_signature:CryptoSignature 

= SignedCertificate;  // 356+516 = 872 bits

type SimpleLib 

type SimpleLib struct {
	Public bool
	Root   boc.Cell `tlb:"^"`
}

SimpleLib simple_lib$_ public:Bool root:^Cell = SimpleLib;

type SizeLimitsConfig 

type SizeLimitsConfig struct {
	SumType
	SizeLimitsConfig struct {
		MaxMsgBits      uint32
		MaxMsgCells     uint32
		MaxLibraryCells uint32
		MaxVmDataDepth  uint16
		MaxExtMsgSize   uint32
		MaxExtMsgDepth  uint16
	} `tlbSumType:"#01"`
	SizeLimitsConfigV2 struct {
		MaxMsgBits       uint32
		MaxMsgCells      uint32
		MaxLibraryCells  uint32
		MaxVmDataDepth   uint16
		MaxExtMsgSize    uint32
		MaxExtMsgDepth   uint16
		MaxAccStateCells uint32
		MaxAccStateBits  uint32
	} `tlbSumType:"#02"`
}

func (*SizeLimitsConfig) MarshalJSON 

func (t *SizeLimitsConfig) MarshalJSON() ([]byte, error)

type SmcCapabilities 

type SmcCapabilities struct {
	Name       []string
	Interfaces []string
}

SmcCapabilities Reorganized SmcCapList type 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;

type SnakeData 

type SnakeData boc.BitString

SnakeData tail#_ {bn:#} b:(bits bn) = SnakeData ~0; cons#_ {bn:#} {n:#} b:(bits bn) next:^(SnakeData ~n) = SnakeData ~(n + 1);

func (SnakeData) MarshalTLB 

func (s SnakeData) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*SnakeData) UnmarshalTLB 

func (s *SnakeData) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type SplitMergeInfo 

type SplitMergeInfo struct {
	CurSHardPfxLen Uint6
	AccSplitDepth  Uint6
	ThisAddr       Bits256
	SiblingAddr    Bits256
}

split_merge_info$_ cur_shard_pfx_len:(## 6) 

acc_split_depth:(## 6) this_addr:bits256 sibling_addr:bits256
= SplitMergeInfo;

type StateInit 

type StateInit struct {
	SplitDepth Maybe[Uint5]
	Special    Maybe[TickTock]
	Code       Maybe[Ref[boc.Cell]]
	Data       Maybe[Ref[boc.Cell]]
	Library    HashmapE[Bits256, SimpleLib]
}

StateInit _ split_depth:(Maybe (## 5)) special:(Maybe TickTock) code:(Maybe ^Cell) data:(Maybe ^Cell) library:(HashmapE 256 SimpleLib) = StateInit;

type StorageExtraInfo added in v1.14.10 

type StorageExtraInfo struct {
	SumType
	StorageExtraNone struct {
	} `tlbSumType:"storage_extra_none$000"`
	StorageExtraInfo struct {
		DictHash Bits256
	} `tlbSumType:"storage_extra_info$001"`
}

storage_extra_none$000 = StorageExtraInfo; storage_extra_info$001 dict_hash:uint256 = StorageExtraInfo;

type StorageInfo 

type StorageInfo struct {
	Used         StorageUsed
	StorageExtra StorageExtraInfo
	LastPaid     uint32
	DuePayment   Maybe[Grams]
}

StorageInfo storage_info$_ used:StorageUsed storage_extra:StorageExtraInfo last_paid:uint32 due_payment:(Maybe Grams) = StorageInfo;

type StoragePrices 

type StoragePrices struct {
	Magic         Magic `tlb:"#cc"`
	UtimeSince    uint32
	BitPricePs    uint64
	CellPricePs   uint64
	McBitPricePs  uint64
	McCellPricePs uint64
}

type StorageUsed 

type StorageUsed struct {
	Cells VarUInteger7
	Bits  VarUInteger7
}

StorageUsed storage_used$_ cells:(VarUInteger 7) bits:(VarUInteger 7) = StorageUsed;

type SumType 

type SumType string

type SuspendedAddressList 

type SuspendedAddressList struct {
	Magic          Magic `tlb:"#00"`
	Addresses      HashmapE[AddressWithWorkchain, struct{}]
	SuspendedUntil uint32
}

type Tag 

type Tag struct {
	Name string
	Len  int
	Val  uint64
}

func ParseTag 

func ParseTag(tagString string) (Tag, error)

type Text 

type Text string

text#_ {n:#} data:(SnakeData ~n) = Text;

func (Text) MarshalTLB 

func (t Text) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Text) UnmarshalTLB 

func (t *Text) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type TickTock 

type TickTock struct {
	Tick bool
	Tock bool
}

TickTock tick_tock$_ tick:Bool tock:Bool = TickTock;

type TrActionPhase 

type TrActionPhase struct {
	Success         bool
	Valid           bool
	NoFunds         bool
	StatusChange    AccStatusChange
	TotalFwdFees    Maybe[Grams]
	TotalActionFees Maybe[Grams]
	ResultCode      int32
	ResultArg       Maybe[int32]
	TotActions      uint16
	SpecActions     uint16
	SkippedActions  uint16
	MsgsCreated     uint16
	ActionListHash  Bits256
	TotMsgSize      StorageUsed
}

TrActionPhase 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;

type TrBouncePhase 

type TrBouncePhase struct {
	SumType
	TrPhaseBounceNegfunds struct {
	} `tlbSumType:"tr_phase_bounce_negfunds$00"`
	TrPhaseBounceNofunds struct {
		MsgSize    StorageUsed
		ReqFwdFees Grams
	} `tlbSumType:"tr_phase_bounce_nofunds$01"`
	TrPhaseBounceOk struct {
		MsgSize StorageUsed
		MsgFees Grams
		FwdFees Grams
	} `tlbSumType:"tr_phase_bounce_ok$1"`
}

TrBouncePhase 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;

type TrComputePhase 

type TrComputePhase struct {
	SumType
	TrPhaseComputeSkipped struct {
		Reason ComputeSkipReason
	} `tlbSumType:"tr_phase_compute_skipped$0"`
	TrPhaseComputeVm struct {
		Success          bool
		MsgStateUsed     bool
		AccountActivated bool
		GasFees          Grams
		Vm               struct {
			GasUsed          VarUInteger7
			GasLimit         VarUInteger7
			GasCredit        Maybe[VarUInteger3]
			Mode             int8
			ExitCode         int32
			ExitArg          Maybe[int32]
			VmSteps          uint32
			VmInitStateHash  Bits256
			VmFinalStateHash Bits256
		} `tlb:"^"`
	} `tlbSumType:"tr_phase_compute_vm$1"`
}

TrComputePhase 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;

type TrCreditPhase 

type TrCreditPhase struct {
	DueFeesCollected Maybe[Grams]
	Credit           CurrencyCollection
}

TrCreditPhase tr_phase_credit$_ due_fees_collected:(Maybe Grams) credit:CurrencyCollection = TrCreditPhase;

type TrStoragePhase 

type TrStoragePhase struct {
	StorageFeesCollected Grams
	StorageFeesDue       Maybe[Grams]
	StatusChange         AccStatusChange
}

TrStoragePhase tr_phase_storage$_ storage_fees_collected:Grams storage_fees_due:(Maybe Grams) status_change:AccStatusChange = TrStoragePhase;

type Transaction 

type Transaction struct {
	Magic         Magic `tlb:"transaction$0111"`
	AccountAddr   Bits256
	Lt            uint64
	PrevTransHash Bits256
	PrevTransLt   uint64
	Now           uint32
	OutMsgCnt     Uint15
	OrigStatus    AccountStatus
	EndStatus     AccountStatus
	Msgs          struct {
		InMsg   Maybe[Ref[Message]]
		OutMsgs HashmapE[Uint15, Ref[Message]]
	} `tlb:"^"`
	TotalFees   CurrencyCollection
	StateUpdate HashUpdate       `tlb:"^"`
	Description TransactionDescr `tlb:"^"`
	// contains filtered or unexported fields
}

Transaction 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;

func (*Transaction) Hash 

func (tx *Transaction) Hash() Bits256

Hash returns a hash of this transaction.

func (Transaction) IsSuccess 

func (tx Transaction) IsSuccess() bool

func (*Transaction) SourceBoc 

func (tx *Transaction) SourceBoc() ([]byte, error)

SourceBoc returns a BOC of this transaction. It works only if the transaction was unmarshalled from a cell.

func (*Transaction) UnmarshalTLB 

func (tx *Transaction) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type TransactionDescr 

type TransactionDescr struct {
	SumType
	TransOrd struct {
		CreditFirst bool
		StoragePh   Maybe[TrStoragePhase]
		CreditPh    Maybe[TrCreditPhase]
		ComputePh   TrComputePhase
		Action      Maybe[Ref[TrActionPhase]]
		Aborted     bool
		Bounce      Maybe[TrBouncePhase]
		Destroyed   bool
	} `tlbSumType:"trans_ord$0000"`
	TransStorage struct {
		StoragePh TrStoragePhase
	} `tlbSumType:"trans_storage$0001"`
	TransTickTock struct {
		IsTock    bool
		StoragePh TrStoragePhase
		ComputePh TrComputePhase
		Action    Maybe[Ref[TrActionPhase]]
		Aborted   bool
		Destroyed bool
	} `tlbSumType:"trans_tick_tock$001"`
	TransSplitPrepare *struct {
		SplitInfo SplitMergeInfo
		StoragePh Maybe[TrStoragePhase]
		ComputePh TrComputePhase
		Action    Maybe[Ref[TrActionPhase]]
		Aborted   bool
		Destroyed bool
	} `tlbSumType:"trans_split_prepare$0100"`
	TransSplitInstall *struct {
		SplitInfo          SplitMergeInfo
		PrepareTransaction Any `tlb:"^"`
		Installed          bool
	} `tlbSumType:"trans_split_install$0101"`
	TransMergePrepare *struct {
		SplitInfo SplitMergeInfo
		StoragePh TrStoragePhase
		Aborted   bool
	} `tlbSumType:"trans_merge_prepare$0110"`
	TransMergeInstall *struct {
		SplitInfo          SplitMergeInfo
		PrepareTransaction Any `tlb:"^"` //Transaction]
		StoragePh          Maybe[TrStoragePhase]
		CreditPh           Maybe[TrCreditPhase]
		ComputePh          TrComputePhase
		Action             Maybe[Ref[TrActionPhase]]
		Aborted            bool
		Destroyed          bool
	} `tlbSumType:"trans_merge_install$0111"`
}

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;

type Uint1 

type Uint1 uint8

func (Uint1) Compare 

func (u Uint1) Compare(other any) (int, bool)

func (Uint1) Equal 

func (u Uint1) Equal(other any) bool

func (Uint1) FixedSize 

func (u Uint1) FixedSize() int

func (Uint1) MarshalJSON 

func (u Uint1) MarshalJSON() ([]byte, error)

func (Uint1) MarshalTLB 

func (u Uint1) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint1) UnmarshalJSON 

func (u *Uint1) UnmarshalJSON(p []byte) error

func (*Uint1) UnmarshalTLB 

func (u *Uint1) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint10 

type Uint10 uint16

func (Uint10) Compare 

func (u Uint10) Compare(other any) (int, bool)

func (Uint10) Equal 

func (u Uint10) Equal(other any) bool

func (Uint10) FixedSize 

func (u Uint10) FixedSize() int

func (Uint10) MarshalJSON 

func (u Uint10) MarshalJSON() ([]byte, error)

func (Uint10) MarshalTLB 

func (u Uint10) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint10) UnmarshalJSON 

func (u *Uint10) UnmarshalJSON(p []byte) error

func (*Uint10) UnmarshalTLB 

func (u *Uint10) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint11 

type Uint11 uint16

func (Uint11) Compare 

func (u Uint11) Compare(other any) (int, bool)

func (Uint11) Equal 

func (u Uint11) Equal(other any) bool

func (Uint11) FixedSize 

func (u Uint11) FixedSize() int

func (Uint11) MarshalJSON 

func (u Uint11) MarshalJSON() ([]byte, error)

func (Uint11) MarshalTLB 

func (u Uint11) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint11) UnmarshalJSON 

func (u *Uint11) UnmarshalJSON(p []byte) error

func (*Uint11) UnmarshalTLB 

func (u *Uint11) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint12 

type Uint12 uint16

func (Uint12) Compare 

func (u Uint12) Compare(other any) (int, bool)

func (Uint12) Equal 

func (u Uint12) Equal(other any) bool

func (Uint12) FixedSize 

func (u Uint12) FixedSize() int

func (Uint12) MarshalJSON 

func (u Uint12) MarshalJSON() ([]byte, error)

func (Uint12) MarshalTLB 

func (u Uint12) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint12) UnmarshalJSON 

func (u *Uint12) UnmarshalJSON(p []byte) error

func (*Uint12) UnmarshalTLB 

func (u *Uint12) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint128 

type Uint128 big.Int

func (Uint128) FixedSize 

func (u Uint128) FixedSize() int

func (Uint128) MarshalJSON 

func (u Uint128) MarshalJSON() ([]byte, error)

func (Uint128) MarshalTLB 

func (u Uint128) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint128) UnmarshalJSON 

func (u *Uint128) UnmarshalJSON(p []byte) error

func (*Uint128) UnmarshalTLB 

func (u *Uint128) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint13 

type Uint13 uint16

func (Uint13) Compare 

func (u Uint13) Compare(other any) (int, bool)

func (Uint13) Equal 

func (u Uint13) Equal(other any) bool

func (Uint13) FixedSize 

func (u Uint13) FixedSize() int

func (Uint13) MarshalJSON 

func (u Uint13) MarshalJSON() ([]byte, error)

func (Uint13) MarshalTLB 

func (u Uint13) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint13) UnmarshalJSON 

func (u *Uint13) UnmarshalJSON(p []byte) error

func (*Uint13) UnmarshalTLB 

func (u *Uint13) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint14 

type Uint14 uint16

func (Uint14) Compare 

func (u Uint14) Compare(other any) (int, bool)

func (Uint14) Equal 

func (u Uint14) Equal(other any) bool

func (Uint14) FixedSize 

func (u Uint14) FixedSize() int

func (Uint14) MarshalJSON 

func (u Uint14) MarshalJSON() ([]byte, error)

func (Uint14) MarshalTLB 

func (u Uint14) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint14) UnmarshalJSON 

func (u *Uint14) UnmarshalJSON(p []byte) error

func (*Uint14) UnmarshalTLB 

func (u *Uint14) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint15 

type Uint15 uint16

func (Uint15) Compare 

func (u Uint15) Compare(other any) (int, bool)

func (Uint15) Equal 

func (u Uint15) Equal(other any) bool

func (Uint15) FixedSize 

func (u Uint15) FixedSize() int

func (Uint15) MarshalJSON 

func (u Uint15) MarshalJSON() ([]byte, error)

func (Uint15) MarshalTLB 

func (u Uint15) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint15) UnmarshalJSON 

func (u *Uint15) UnmarshalJSON(p []byte) error

func (*Uint15) UnmarshalTLB 

func (u *Uint15) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint16 

type Uint16 uint16

func (Uint16) Compare 

func (u Uint16) Compare(other any) (int, bool)

func (Uint16) Equal 

func (u Uint16) Equal(other any) bool

func (Uint16) FixedSize 

func (u Uint16) FixedSize() int

func (Uint16) MarshalJSON 

func (u Uint16) MarshalJSON() ([]byte, error)

func (Uint16) MarshalTLB 

func (u Uint16) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint16) UnmarshalJSON 

func (u *Uint16) UnmarshalJSON(p []byte) error

func (*Uint16) UnmarshalTLB 

func (u *Uint16) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint17 

type Uint17 uint32

func (Uint17) Compare 

func (u Uint17) Compare(other any) (int, bool)

func (Uint17) Equal 

func (u Uint17) Equal(other any) bool

func (Uint17) FixedSize 

func (u Uint17) FixedSize() int

func (Uint17) MarshalJSON 

func (u Uint17) MarshalJSON() ([]byte, error)

func (Uint17) MarshalTLB 

func (u Uint17) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint17) UnmarshalJSON 

func (u *Uint17) UnmarshalJSON(p []byte) error

func (*Uint17) UnmarshalTLB 

func (u *Uint17) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint18 

type Uint18 uint32

func (Uint18) Compare 

func (u Uint18) Compare(other any) (int, bool)

func (Uint18) Equal 

func (u Uint18) Equal(other any) bool

func (Uint18) FixedSize 

func (u Uint18) FixedSize() int

func (Uint18) MarshalJSON 

func (u Uint18) MarshalJSON() ([]byte, error)

func (Uint18) MarshalTLB 

func (u Uint18) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint18) UnmarshalJSON 

func (u *Uint18) UnmarshalJSON(p []byte) error

func (*Uint18) UnmarshalTLB 

func (u *Uint18) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint19 

type Uint19 uint32

func (Uint19) Compare 

func (u Uint19) Compare(other any) (int, bool)

func (Uint19) Equal 

func (u Uint19) Equal(other any) bool

func (Uint19) FixedSize 

func (u Uint19) FixedSize() int

func (Uint19) MarshalJSON 

func (u Uint19) MarshalJSON() ([]byte, error)

func (Uint19) MarshalTLB 

func (u Uint19) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint19) UnmarshalJSON 

func (u *Uint19) UnmarshalJSON(p []byte) error

func (*Uint19) UnmarshalTLB 

func (u *Uint19) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint2 

type Uint2 uint8

func (Uint2) Compare 

func (u Uint2) Compare(other any) (int, bool)

func (Uint2) Equal 

func (u Uint2) Equal(other any) bool

func (Uint2) FixedSize 

func (u Uint2) FixedSize() int

func (Uint2) MarshalJSON 

func (u Uint2) MarshalJSON() ([]byte, error)

func (Uint2) MarshalTLB 

func (u Uint2) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint2) UnmarshalJSON 

func (u *Uint2) UnmarshalJSON(p []byte) error

func (*Uint2) UnmarshalTLB 

func (u *Uint2) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint20 

type Uint20 uint32

func (Uint20) Compare 

func (u Uint20) Compare(other any) (int, bool)

func (Uint20) Equal 

func (u Uint20) Equal(other any) bool

func (Uint20) FixedSize 

func (u Uint20) FixedSize() int

func (Uint20) MarshalJSON 

func (u Uint20) MarshalJSON() ([]byte, error)

func (Uint20) MarshalTLB 

func (u Uint20) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint20) UnmarshalJSON 

func (u *Uint20) UnmarshalJSON(p []byte) error

func (*Uint20) UnmarshalTLB 

func (u *Uint20) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint21 

type Uint21 uint32

func (Uint21) Compare 

func (u Uint21) Compare(other any) (int, bool)

func (Uint21) Equal 

func (u Uint21) Equal(other any) bool

func (Uint21) FixedSize 

func (u Uint21) FixedSize() int

func (Uint21) MarshalJSON 

func (u Uint21) MarshalJSON() ([]byte, error)

func (Uint21) MarshalTLB 

func (u Uint21) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint21) UnmarshalJSON 

func (u *Uint21) UnmarshalJSON(p []byte) error

func (*Uint21) UnmarshalTLB 

func (u *Uint21) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint22 

type Uint22 uint32

func (Uint22) Compare 

func (u Uint22) Compare(other any) (int, bool)

func (Uint22) Equal 

func (u Uint22) Equal(other any) bool

func (Uint22) FixedSize 

func (u Uint22) FixedSize() int

func (Uint22) MarshalJSON 

func (u Uint22) MarshalJSON() ([]byte, error)

func (Uint22) MarshalTLB 

func (u Uint22) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint22) UnmarshalJSON 

func (u *Uint22) UnmarshalJSON(p []byte) error

func (*Uint22) UnmarshalTLB 

func (u *Uint22) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint23 

type Uint23 uint32

func (Uint23) Compare 

func (u Uint23) Compare(other any) (int, bool)

func (Uint23) Equal 

func (u Uint23) Equal(other any) bool

func (Uint23) FixedSize 

func (u Uint23) FixedSize() int

func (Uint23) MarshalJSON 

func (u Uint23) MarshalJSON() ([]byte, error)

func (Uint23) MarshalTLB 

func (u Uint23) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint23) UnmarshalJSON 

func (u *Uint23) UnmarshalJSON(p []byte) error

func (*Uint23) UnmarshalTLB 

func (u *Uint23) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint24 

type Uint24 uint32

func (Uint24) Compare 

func (u Uint24) Compare(other any) (int, bool)

func (Uint24) Equal 

func (u Uint24) Equal(other any) bool

func (Uint24) FixedSize 

func (u Uint24) FixedSize() int

func (Uint24) MarshalJSON 

func (u Uint24) MarshalJSON() ([]byte, error)

func (Uint24) MarshalTLB 

func (u Uint24) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint24) UnmarshalJSON 

func (u *Uint24) UnmarshalJSON(p []byte) error

func (*Uint24) UnmarshalTLB 

func (u *Uint24) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint25 

type Uint25 uint32

func (Uint25) Compare 

func (u Uint25) Compare(other any) (int, bool)

func (Uint25) Equal 

func (u Uint25) Equal(other any) bool

func (Uint25) FixedSize 

func (u Uint25) FixedSize() int

func (Uint25) MarshalJSON 

func (u Uint25) MarshalJSON() ([]byte, error)

func (Uint25) MarshalTLB 

func (u Uint25) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint25) UnmarshalJSON 

func (u *Uint25) UnmarshalJSON(p []byte) error

func (*Uint25) UnmarshalTLB 

func (u *Uint25) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint256 

type Uint256 big.Int

func (Uint256) FixedSize 

func (u Uint256) FixedSize() int

func (Uint256) MarshalJSON 

func (u Uint256) MarshalJSON() ([]byte, error)

func (Uint256) MarshalTLB 

func (u Uint256) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint256) UnmarshalJSON 

func (u *Uint256) UnmarshalJSON(p []byte) error

func (*Uint256) UnmarshalTLB 

func (u *Uint256) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint257 

type Uint257 big.Int

func (Uint257) FixedSize 

func (u Uint257) FixedSize() int

func (Uint257) MarshalJSON 

func (u Uint257) MarshalJSON() ([]byte, error)

func (Uint257) MarshalTLB 

func (u Uint257) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint257) UnmarshalJSON 

func (u *Uint257) UnmarshalJSON(p []byte) error

func (*Uint257) UnmarshalTLB 

func (u *Uint257) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint26 

type Uint26 uint32

func (Uint26) Compare 

func (u Uint26) Compare(other any) (int, bool)

func (Uint26) Equal 

func (u Uint26) Equal(other any) bool

func (Uint26) FixedSize 

func (u Uint26) FixedSize() int

func (Uint26) MarshalJSON 

func (u Uint26) MarshalJSON() ([]byte, error)

func (Uint26) MarshalTLB 

func (u Uint26) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint26) UnmarshalJSON 

func (u *Uint26) UnmarshalJSON(p []byte) error

func (*Uint26) UnmarshalTLB 

func (u *Uint26) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint27 

type Uint27 uint32

func (Uint27) Compare 

func (u Uint27) Compare(other any) (int, bool)

func (Uint27) Equal 

func (u Uint27) Equal(other any) bool

func (Uint27) FixedSize 

func (u Uint27) FixedSize() int

func (Uint27) MarshalJSON 

func (u Uint27) MarshalJSON() ([]byte, error)

func (Uint27) MarshalTLB 

func (u Uint27) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint27) UnmarshalJSON 

func (u *Uint27) UnmarshalJSON(p []byte) error

func (*Uint27) UnmarshalTLB 

func (u *Uint27) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint28 

type Uint28 uint32

func (Uint28) Compare 

func (u Uint28) Compare(other any) (int, bool)

func (Uint28) Equal 

func (u Uint28) Equal(other any) bool

func (Uint28) FixedSize 

func (u Uint28) FixedSize() int

func (Uint28) MarshalJSON 

func (u Uint28) MarshalJSON() ([]byte, error)

func (Uint28) MarshalTLB 

func (u Uint28) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint28) UnmarshalJSON 

func (u *Uint28) UnmarshalJSON(p []byte) error

func (*Uint28) UnmarshalTLB 

func (u *Uint28) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint29 

type Uint29 uint32

func (Uint29) Compare 

func (u Uint29) Compare(other any) (int, bool)

func (Uint29) Equal 

func (u Uint29) Equal(other any) bool

func (Uint29) FixedSize 

func (u Uint29) FixedSize() int

func (Uint29) MarshalJSON 

func (u Uint29) MarshalJSON() ([]byte, error)

func (Uint29) MarshalTLB 

func (u Uint29) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint29) UnmarshalJSON 

func (u *Uint29) UnmarshalJSON(p []byte) error

func (*Uint29) UnmarshalTLB 

func (u *Uint29) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint3 

type Uint3 uint8

func (Uint3) Compare 

func (u Uint3) Compare(other any) (int, bool)

func (Uint3) Equal 

func (u Uint3) Equal(other any) bool

func (Uint3) FixedSize 

func (u Uint3) FixedSize() int

func (Uint3) MarshalJSON 

func (u Uint3) MarshalJSON() ([]byte, error)

func (Uint3) MarshalTLB 

func (u Uint3) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint3) UnmarshalJSON 

func (u *Uint3) UnmarshalJSON(p []byte) error

func (*Uint3) UnmarshalTLB 

func (u *Uint3) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint30 

type Uint30 uint32

func (Uint30) Compare 

func (u Uint30) Compare(other any) (int, bool)

func (Uint30) Equal 

func (u Uint30) Equal(other any) bool

func (Uint30) FixedSize 

func (u Uint30) FixedSize() int

func (Uint30) MarshalJSON 

func (u Uint30) MarshalJSON() ([]byte, error)

func (Uint30) MarshalTLB 

func (u Uint30) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint30) UnmarshalJSON 

func (u *Uint30) UnmarshalJSON(p []byte) error

func (*Uint30) UnmarshalTLB 

func (u *Uint30) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint31 

type Uint31 uint32

func (Uint31) Compare 

func (u Uint31) Compare(other any) (int, bool)

func (Uint31) Equal 

func (u Uint31) Equal(other any) bool

func (Uint31) FixedSize 

func (u Uint31) FixedSize() int

func (Uint31) MarshalJSON 

func (u Uint31) MarshalJSON() ([]byte, error)

func (Uint31) MarshalTLB 

func (u Uint31) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint31) UnmarshalJSON 

func (u *Uint31) UnmarshalJSON(p []byte) error

func (*Uint31) UnmarshalTLB 

func (u *Uint31) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint32 

type Uint32 uint32

func (Uint32) Compare 

func (u Uint32) Compare(other any) (int, bool)

func (Uint32) Equal 

func (u Uint32) Equal(other any) bool

func (Uint32) FixedSize 

func (u Uint32) FixedSize() int

func (Uint32) MarshalJSON 

func (u Uint32) MarshalJSON() ([]byte, error)

func (Uint32) MarshalTLB 

func (u Uint32) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint32) UnmarshalJSON 

func (u *Uint32) UnmarshalJSON(p []byte) error

func (*Uint32) UnmarshalTLB 

func (u *Uint32) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint33 

type Uint33 uint64

func (Uint33) Compare 

func (u Uint33) Compare(other any) (int, bool)

func (Uint33) Equal 

func (u Uint33) Equal(other any) bool

func (Uint33) FixedSize 

func (u Uint33) FixedSize() int

func (Uint33) MarshalJSON 

func (u Uint33) MarshalJSON() ([]byte, error)

func (Uint33) MarshalTLB 

func (u Uint33) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint33) UnmarshalJSON 

func (u *Uint33) UnmarshalJSON(p []byte) error

func (*Uint33) UnmarshalTLB 

func (u *Uint33) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint34 

type Uint34 uint64

func (Uint34) Compare 

func (u Uint34) Compare(other any) (int, bool)

func (Uint34) Equal 

func (u Uint34) Equal(other any) bool

func (Uint34) FixedSize 

func (u Uint34) FixedSize() int

func (Uint34) MarshalJSON 

func (u Uint34) MarshalJSON() ([]byte, error)

func (Uint34) MarshalTLB 

func (u Uint34) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint34) UnmarshalJSON 

func (u *Uint34) UnmarshalJSON(p []byte) error

func (*Uint34) UnmarshalTLB 

func (u *Uint34) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint35 

type Uint35 uint64

func (Uint35) Compare 

func (u Uint35) Compare(other any) (int, bool)

func (Uint35) Equal 

func (u Uint35) Equal(other any) bool

func (Uint35) FixedSize 

func (u Uint35) FixedSize() int

func (Uint35) MarshalJSON 

func (u Uint35) MarshalJSON() ([]byte, error)

func (Uint35) MarshalTLB 

func (u Uint35) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint35) UnmarshalJSON 

func (u *Uint35) UnmarshalJSON(p []byte) error

func (*Uint35) UnmarshalTLB 

func (u *Uint35) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint36 

type Uint36 uint64

func (Uint36) Compare 

func (u Uint36) Compare(other any) (int, bool)

func (Uint36) Equal 

func (u Uint36) Equal(other any) bool

func (Uint36) FixedSize 

func (u Uint36) FixedSize() int

func (Uint36) MarshalJSON 

func (u Uint36) MarshalJSON() ([]byte, error)

func (Uint36) MarshalTLB 

func (u Uint36) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint36) UnmarshalJSON 

func (u *Uint36) UnmarshalJSON(p []byte) error

func (*Uint36) UnmarshalTLB 

func (u *Uint36) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint37 

type Uint37 uint64

func (Uint37) Compare 

func (u Uint37) Compare(other any) (int, bool)

func (Uint37) Equal 

func (u Uint37) Equal(other any) bool

func (Uint37) FixedSize 

func (u Uint37) FixedSize() int

func (Uint37) MarshalJSON 

func (u Uint37) MarshalJSON() ([]byte, error)

func (Uint37) MarshalTLB 

func (u Uint37) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint37) UnmarshalJSON 

func (u *Uint37) UnmarshalJSON(p []byte) error

func (*Uint37) UnmarshalTLB 

func (u *Uint37) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint38 

type Uint38 uint64

func (Uint38) Compare 

func (u Uint38) Compare(other any) (int, bool)

func (Uint38) Equal 

func (u Uint38) Equal(other any) bool

func (Uint38) FixedSize 

func (u Uint38) FixedSize() int

func (Uint38) MarshalJSON 

func (u Uint38) MarshalJSON() ([]byte, error)

func (Uint38) MarshalTLB 

func (u Uint38) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint38) UnmarshalJSON 

func (u *Uint38) UnmarshalJSON(p []byte) error

func (*Uint38) UnmarshalTLB 

func (u *Uint38) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint39 

type Uint39 uint64

func (Uint39) Compare 

func (u Uint39) Compare(other any) (int, bool)

func (Uint39) Equal 

func (u Uint39) Equal(other any) bool

func (Uint39) FixedSize 

func (u Uint39) FixedSize() int

func (Uint39) MarshalJSON 

func (u Uint39) MarshalJSON() ([]byte, error)

func (Uint39) MarshalTLB 

func (u Uint39) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint39) UnmarshalJSON 

func (u *Uint39) UnmarshalJSON(p []byte) error

func (*Uint39) UnmarshalTLB 

func (u *Uint39) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint4 

type Uint4 uint8

func (Uint4) Compare 

func (u Uint4) Compare(other any) (int, bool)

func (Uint4) Equal 

func (u Uint4) Equal(other any) bool

func (Uint4) FixedSize 

func (u Uint4) FixedSize() int

func (Uint4) MarshalJSON 

func (u Uint4) MarshalJSON() ([]byte, error)

func (Uint4) MarshalTLB 

func (u Uint4) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint4) UnmarshalJSON 

func (u *Uint4) UnmarshalJSON(p []byte) error

func (*Uint4) UnmarshalTLB 

func (u *Uint4) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint40 

type Uint40 uint64

func (Uint40) Compare 

func (u Uint40) Compare(other any) (int, bool)

func (Uint40) Equal 

func (u Uint40) Equal(other any) bool

func (Uint40) FixedSize 

func (u Uint40) FixedSize() int

func (Uint40) MarshalJSON 

func (u Uint40) MarshalJSON() ([]byte, error)

func (Uint40) MarshalTLB 

func (u Uint40) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint40) UnmarshalJSON 

func (u *Uint40) UnmarshalJSON(p []byte) error

func (*Uint40) UnmarshalTLB 

func (u *Uint40) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint41 

type Uint41 uint64

func (Uint41) Compare 

func (u Uint41) Compare(other any) (int, bool)

func (Uint41) Equal 

func (u Uint41) Equal(other any) bool

func (Uint41) FixedSize 

func (u Uint41) FixedSize() int

func (Uint41) MarshalJSON 

func (u Uint41) MarshalJSON() ([]byte, error)

func (Uint41) MarshalTLB 

func (u Uint41) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint41) UnmarshalJSON 

func (u *Uint41) UnmarshalJSON(p []byte) error

func (*Uint41) UnmarshalTLB 

func (u *Uint41) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint42 

type Uint42 uint64

func (Uint42) Compare 

func (u Uint42) Compare(other any) (int, bool)

func (Uint42) Equal 

func (u Uint42) Equal(other any) bool

func (Uint42) FixedSize 

func (u Uint42) FixedSize() int

func (Uint42) MarshalJSON 

func (u Uint42) MarshalJSON() ([]byte, error)

func (Uint42) MarshalTLB 

func (u Uint42) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint42) UnmarshalJSON 

func (u *Uint42) UnmarshalJSON(p []byte) error

func (*Uint42) UnmarshalTLB 

func (u *Uint42) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint43 

type Uint43 uint64

func (Uint43) Compare 

func (u Uint43) Compare(other any) (int, bool)

func (Uint43) Equal 

func (u Uint43) Equal(other any) bool

func (Uint43) FixedSize 

func (u Uint43) FixedSize() int

func (Uint43) MarshalJSON 

func (u Uint43) MarshalJSON() ([]byte, error)

func (Uint43) MarshalTLB 

func (u Uint43) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint43) UnmarshalJSON 

func (u *Uint43) UnmarshalJSON(p []byte) error

func (*Uint43) UnmarshalTLB 

func (u *Uint43) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint44 

type Uint44 uint64

func (Uint44) Compare 

func (u Uint44) Compare(other any) (int, bool)

func (Uint44) Equal 

func (u Uint44) Equal(other any) bool

func (Uint44) FixedSize 

func (u Uint44) FixedSize() int

func (Uint44) MarshalJSON 

func (u Uint44) MarshalJSON() ([]byte, error)

func (Uint44) MarshalTLB 

func (u Uint44) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint44) UnmarshalJSON 

func (u *Uint44) UnmarshalJSON(p []byte) error

func (*Uint44) UnmarshalTLB 

func (u *Uint44) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint45 

type Uint45 uint64

func (Uint45) Compare 

func (u Uint45) Compare(other any) (int, bool)

func (Uint45) Equal 

func (u Uint45) Equal(other any) bool

func (Uint45) FixedSize 

func (u Uint45) FixedSize() int

func (Uint45) MarshalJSON 

func (u Uint45) MarshalJSON() ([]byte, error)

func (Uint45) MarshalTLB 

func (u Uint45) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint45) UnmarshalJSON 

func (u *Uint45) UnmarshalJSON(p []byte) error

func (*Uint45) UnmarshalTLB 

func (u *Uint45) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint46 

type Uint46 uint64

func (Uint46) Compare 

func (u Uint46) Compare(other any) (int, bool)

func (Uint46) Equal 

func (u Uint46) Equal(other any) bool

func (Uint46) FixedSize 

func (u Uint46) FixedSize() int

func (Uint46) MarshalJSON 

func (u Uint46) MarshalJSON() ([]byte, error)

func (Uint46) MarshalTLB 

func (u Uint46) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint46) UnmarshalJSON 

func (u *Uint46) UnmarshalJSON(p []byte) error

func (*Uint46) UnmarshalTLB 

func (u *Uint46) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint47 

type Uint47 uint64

func (Uint47) Compare 

func (u Uint47) Compare(other any) (int, bool)

func (Uint47) Equal 

func (u Uint47) Equal(other any) bool

func (Uint47) FixedSize 

func (u Uint47) FixedSize() int

func (Uint47) MarshalJSON 

func (u Uint47) MarshalJSON() ([]byte, error)

func (Uint47) MarshalTLB 

func (u Uint47) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint47) UnmarshalJSON 

func (u *Uint47) UnmarshalJSON(p []byte) error

func (*Uint47) UnmarshalTLB 

func (u *Uint47) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint48 

type Uint48 uint64

func (Uint48) Compare 

func (u Uint48) Compare(other any) (int, bool)

func (Uint48) Equal 

func (u Uint48) Equal(other any) bool

func (Uint48) FixedSize 

func (u Uint48) FixedSize() int

func (Uint48) MarshalJSON 

func (u Uint48) MarshalJSON() ([]byte, error)

func (Uint48) MarshalTLB 

func (u Uint48) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint48) UnmarshalJSON 

func (u *Uint48) UnmarshalJSON(p []byte) error

func (*Uint48) UnmarshalTLB 

func (u *Uint48) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint49 

type Uint49 uint64

func (Uint49) Compare 

func (u Uint49) Compare(other any) (int, bool)

func (Uint49) Equal 

func (u Uint49) Equal(other any) bool

func (Uint49) FixedSize 

func (u Uint49) FixedSize() int

func (Uint49) MarshalJSON 

func (u Uint49) MarshalJSON() ([]byte, error)

func (Uint49) MarshalTLB 

func (u Uint49) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint49) UnmarshalJSON 

func (u *Uint49) UnmarshalJSON(p []byte) error

func (*Uint49) UnmarshalTLB 

func (u *Uint49) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint5 

type Uint5 uint8

func (Uint5) Compare 

func (u Uint5) Compare(other any) (int, bool)

func (Uint5) Equal 

func (u Uint5) Equal(other any) bool

func (Uint5) FixedSize 

func (u Uint5) FixedSize() int

func (Uint5) MarshalJSON 

func (u Uint5) MarshalJSON() ([]byte, error)

func (Uint5) MarshalTLB 

func (u Uint5) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint5) UnmarshalJSON 

func (u *Uint5) UnmarshalJSON(p []byte) error

func (*Uint5) UnmarshalTLB 

func (u *Uint5) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint50 

type Uint50 uint64

func (Uint50) Compare 

func (u Uint50) Compare(other any) (int, bool)

func (Uint50) Equal 

func (u Uint50) Equal(other any) bool

func (Uint50) FixedSize 

func (u Uint50) FixedSize() int

func (Uint50) MarshalJSON 

func (u Uint50) MarshalJSON() ([]byte, error)

func (Uint50) MarshalTLB 

func (u Uint50) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint50) UnmarshalJSON 

func (u *Uint50) UnmarshalJSON(p []byte) error

func (*Uint50) UnmarshalTLB 

func (u *Uint50) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint51 

type Uint51 uint64

func (Uint51) Compare 

func (u Uint51) Compare(other any) (int, bool)

func (Uint51) Equal 

func (u Uint51) Equal(other any) bool

func (Uint51) FixedSize 

func (u Uint51) FixedSize() int

func (Uint51) MarshalJSON 

func (u Uint51) MarshalJSON() ([]byte, error)

func (Uint51) MarshalTLB 

func (u Uint51) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint51) UnmarshalJSON 

func (u *Uint51) UnmarshalJSON(p []byte) error

func (*Uint51) UnmarshalTLB 

func (u *Uint51) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint52 

type Uint52 uint64

func (Uint52) Compare 

func (u Uint52) Compare(other any) (int, bool)

func (Uint52) Equal 

func (u Uint52) Equal(other any) bool

func (Uint52) FixedSize 

func (u Uint52) FixedSize() int

func (Uint52) MarshalJSON 

func (u Uint52) MarshalJSON() ([]byte, error)

func (Uint52) MarshalTLB 

func (u Uint52) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint52) UnmarshalJSON 

func (u *Uint52) UnmarshalJSON(p []byte) error

func (*Uint52) UnmarshalTLB 

func (u *Uint52) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint53 

type Uint53 uint64

func (Uint53) Compare 

func (u Uint53) Compare(other any) (int, bool)

func (Uint53) Equal 

func (u Uint53) Equal(other any) bool

func (Uint53) FixedSize 

func (u Uint53) FixedSize() int

func (Uint53) MarshalJSON 

func (u Uint53) MarshalJSON() ([]byte, error)

func (Uint53) MarshalTLB 

func (u Uint53) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint53) UnmarshalJSON 

func (u *Uint53) UnmarshalJSON(p []byte) error

func (*Uint53) UnmarshalTLB 

func (u *Uint53) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint54 

type Uint54 uint64

func (Uint54) Compare 

func (u Uint54) Compare(other any) (int, bool)

func (Uint54) Equal 

func (u Uint54) Equal(other any) bool

func (Uint54) FixedSize 

func (u Uint54) FixedSize() int

func (Uint54) MarshalJSON 

func (u Uint54) MarshalJSON() ([]byte, error)

func (Uint54) MarshalTLB 

func (u Uint54) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint54) UnmarshalJSON 

func (u *Uint54) UnmarshalJSON(p []byte) error

func (*Uint54) UnmarshalTLB 

func (u *Uint54) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint55 

type Uint55 uint64

func (Uint55) Compare 

func (u Uint55) Compare(other any) (int, bool)

func (Uint55) Equal 

func (u Uint55) Equal(other any) bool

func (Uint55) FixedSize 

func (u Uint55) FixedSize() int

func (Uint55) MarshalJSON 

func (u Uint55) MarshalJSON() ([]byte, error)

func (Uint55) MarshalTLB 

func (u Uint55) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint55) UnmarshalJSON 

func (u *Uint55) UnmarshalJSON(p []byte) error

func (*Uint55) UnmarshalTLB 

func (u *Uint55) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint56 

type Uint56 uint64

func (Uint56) Compare 

func (u Uint56) Compare(other any) (int, bool)

func (Uint56) Equal 

func (u Uint56) Equal(other any) bool

func (Uint56) FixedSize 

func (u Uint56) FixedSize() int

func (Uint56) MarshalJSON 

func (u Uint56) MarshalJSON() ([]byte, error)

func (Uint56) MarshalTLB 

func (u Uint56) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint56) UnmarshalJSON 

func (u *Uint56) UnmarshalJSON(p []byte) error

func (*Uint56) UnmarshalTLB 

func (u *Uint56) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint57 

type Uint57 uint64

func (Uint57) Compare 

func (u Uint57) Compare(other any) (int, bool)

func (Uint57) Equal 

func (u Uint57) Equal(other any) bool

func (Uint57) FixedSize 

func (u Uint57) FixedSize() int

func (Uint57) MarshalJSON 

func (u Uint57) MarshalJSON() ([]byte, error)

func (Uint57) MarshalTLB 

func (u Uint57) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint57) UnmarshalJSON 

func (u *Uint57) UnmarshalJSON(p []byte) error

func (*Uint57) UnmarshalTLB 

func (u *Uint57) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint58 

type Uint58 uint64

func (Uint58) Compare 

func (u Uint58) Compare(other any) (int, bool)

func (Uint58) Equal 

func (u Uint58) Equal(other any) bool

func (Uint58) FixedSize 

func (u Uint58) FixedSize() int

func (Uint58) MarshalJSON 

func (u Uint58) MarshalJSON() ([]byte, error)

func (Uint58) MarshalTLB 

func (u Uint58) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint58) UnmarshalJSON 

func (u *Uint58) UnmarshalJSON(p []byte) error

func (*Uint58) UnmarshalTLB 

func (u *Uint58) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint59 

type Uint59 uint64

func (Uint59) Compare 

func (u Uint59) Compare(other any) (int, bool)

func (Uint59) Equal 

func (u Uint59) Equal(other any) bool

func (Uint59) FixedSize 

func (u Uint59) FixedSize() int

func (Uint59) MarshalJSON 

func (u Uint59) MarshalJSON() ([]byte, error)

func (Uint59) MarshalTLB 

func (u Uint59) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint59) UnmarshalJSON 

func (u *Uint59) UnmarshalJSON(p []byte) error

func (*Uint59) UnmarshalTLB 

func (u *Uint59) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint6 

type Uint6 uint8

func (Uint6) Compare 

func (u Uint6) Compare(other any) (int, bool)

func (Uint6) Equal 

func (u Uint6) Equal(other any) bool

func (Uint6) FixedSize 

func (u Uint6) FixedSize() int

func (Uint6) MarshalJSON 

func (u Uint6) MarshalJSON() ([]byte, error)

func (Uint6) MarshalTLB 

func (u Uint6) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint6) UnmarshalJSON 

func (u *Uint6) UnmarshalJSON(p []byte) error

func (*Uint6) UnmarshalTLB 

func (u *Uint6) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint60 

type Uint60 uint64

func (Uint60) Compare 

func (u Uint60) Compare(other any) (int, bool)

func (Uint60) Equal 

func (u Uint60) Equal(other any) bool

func (Uint60) FixedSize 

func (u Uint60) FixedSize() int

func (Uint60) MarshalJSON 

func (u Uint60) MarshalJSON() ([]byte, error)

func (Uint60) MarshalTLB 

func (u Uint60) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint60) UnmarshalJSON 

func (u *Uint60) UnmarshalJSON(p []byte) error

func (*Uint60) UnmarshalTLB 

func (u *Uint60) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint61 

type Uint61 uint64

func (Uint61) Compare 

func (u Uint61) Compare(other any) (int, bool)

func (Uint61) Equal 

func (u Uint61) Equal(other any) bool

func (Uint61) FixedSize 

func (u Uint61) FixedSize() int

func (Uint61) MarshalJSON 

func (u Uint61) MarshalJSON() ([]byte, error)

func (Uint61) MarshalTLB 

func (u Uint61) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint61) UnmarshalJSON 

func (u *Uint61) UnmarshalJSON(p []byte) error

func (*Uint61) UnmarshalTLB 

func (u *Uint61) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint62 

type Uint62 uint64

func (Uint62) Compare 

func (u Uint62) Compare(other any) (int, bool)

func (Uint62) Equal 

func (u Uint62) Equal(other any) bool

func (Uint62) FixedSize 

func (u Uint62) FixedSize() int

func (Uint62) MarshalJSON 

func (u Uint62) MarshalJSON() ([]byte, error)

func (Uint62) MarshalTLB 

func (u Uint62) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint62) UnmarshalJSON 

func (u *Uint62) UnmarshalJSON(p []byte) error

func (*Uint62) UnmarshalTLB 

func (u *Uint62) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint63 

type Uint63 uint64

func (Uint63) Compare 

func (u Uint63) Compare(other any) (int, bool)

func (Uint63) Equal 

func (u Uint63) Equal(other any) bool

func (Uint63) FixedSize 

func (u Uint63) FixedSize() int

func (Uint63) MarshalJSON 

func (u Uint63) MarshalJSON() ([]byte, error)

func (Uint63) MarshalTLB 

func (u Uint63) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint63) UnmarshalJSON 

func (u *Uint63) UnmarshalJSON(p []byte) error

func (*Uint63) UnmarshalTLB 

func (u *Uint63) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint64 

type Uint64 uint64

func (Uint64) Compare 

func (u Uint64) Compare(other any) (int, bool)

func (Uint64) Equal 

func (u Uint64) Equal(other any) bool

func (Uint64) FixedSize 

func (u Uint64) FixedSize() int

func (Uint64) MarshalJSON 

func (u Uint64) MarshalJSON() ([]byte, error)

func (Uint64) MarshalTLB 

func (u Uint64) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint64) UnmarshalJSON 

func (u *Uint64) UnmarshalJSON(p []byte) error

func (*Uint64) UnmarshalTLB 

func (u *Uint64) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint7 

type Uint7 uint8

func (Uint7) Compare 

func (u Uint7) Compare(other any) (int, bool)

func (Uint7) Equal 

func (u Uint7) Equal(other any) bool

func (Uint7) FixedSize 

func (u Uint7) FixedSize() int

func (Uint7) MarshalJSON 

func (u Uint7) MarshalJSON() ([]byte, error)

func (Uint7) MarshalTLB 

func (u Uint7) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint7) UnmarshalJSON 

func (u *Uint7) UnmarshalJSON(p []byte) error

func (*Uint7) UnmarshalTLB 

func (u *Uint7) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint8 

type Uint8 uint8

func (Uint8) Compare 

func (u Uint8) Compare(other any) (int, bool)

func (Uint8) Equal 

func (u Uint8) Equal(other any) bool

func (Uint8) FixedSize 

func (u Uint8) FixedSize() int

func (Uint8) MarshalJSON 

func (u Uint8) MarshalJSON() ([]byte, error)

func (Uint8) MarshalTLB 

func (u Uint8) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint8) UnmarshalJSON 

func (u *Uint8) UnmarshalJSON(p []byte) error

func (*Uint8) UnmarshalTLB 

func (u *Uint8) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Uint9 

type Uint9 uint16

func (Uint9) Compare 

func (u Uint9) Compare(other any) (int, bool)

func (Uint9) Equal 

func (u Uint9) Equal(other any) bool

func (Uint9) FixedSize 

func (u Uint9) FixedSize() int

func (Uint9) MarshalJSON 

func (u Uint9) MarshalJSON() ([]byte, error)

func (Uint9) MarshalTLB 

func (u Uint9) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Uint9) UnmarshalJSON 

func (u *Uint9) UnmarshalJSON(p []byte) error

func (*Uint9) UnmarshalTLB 

func (u *Uint9) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type Unary 

type Unary uint

func (Unary) MarshalTLB 

func (n Unary) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*Unary) UnmarshalTLB 

func (n *Unary) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type UnmarshalerTLB 

type UnmarshalerTLB interface {
	UnmarshalTLB(c *boc.Cell, decoder *Decoder) error
}

UnmarshalerTLB contains method UnmarshalTLB that must be implemented by a struct if it provides specific unmarshalling code.

type ValidatorBaseInfo 

type ValidatorBaseInfo struct {
	ValidatorListHashShort uint32
	CatchainSeqno          uint32
}

validator_base_info$_ 

validator_list_hash_short:uint32
catchain_seqno:uint32

= ValidatorBaseInfo;

type ValidatorDescr 

type ValidatorDescr struct {
	SumType
	// validator#53 public_key:SigPubKey weight:uint64 = ValidatorDescr;
	Validator *struct {
		PublicKey SigPubKey
		Weight    uint64
	} `tlbSumType:"validator#53"`
	// validator_addr#73 public_key:SigPubKey weight:uint64 adnl_addr:bits256 = ValidatorDescr;
	ValidatorAddr *struct {
		PublicKey SigPubKey
		Weight    uint64
		AdnlAddr  Bits256
	} `tlbSumType:"validatoraddr#73"`
}

func (ValidatorDescr) MarshalJSON 

func (vd ValidatorDescr) MarshalJSON() ([]byte, error)

func (ValidatorDescr) PubKey 

func (vd ValidatorDescr) PubKey() Bits256

type ValidatorInfo 

type ValidatorInfo struct {
	ValidatorListHashShort uint32
	CatchainSeqno          uint32
	NxCcUpdated            bool
}

validator_info$_ 

validator_list_hash_short:uint32
catchain_seqno:uint32
nx_cc_updated:Bool

= ValidatorInfo;

type ValidatorSet 

type ValidatorSet struct {
	SumType
	Validators struct {
		UtimeSince uint32
		UtimeUntil uint32
		Total      uint16
		Main       uint16
		List       Hashmap[Uint16, ValidatorDescr]
	} `tlbSumType:"#11"`
	ValidatorsExt struct {
		UtimeSince  uint32
		UtimeUntil  uint32
		Total       uint16
		Main        uint16
		TotalWeight uint64
		List        HashmapE[Uint16, ValidatorDescr]
	} `tlbSumType:"#12"`
}

func (*ValidatorSet) MarshalJSON 

func (t *ValidatorSet) MarshalJSON() ([]byte, error)

type ValidatorSetsCommon 

type ValidatorSetsCommon struct {
	UtimeSince uint32
	UtimeUntil uint32
	Total      uint16
	Main       uint16
}

type ValidatorSignedTempKey 

type ValidatorSignedTempKey struct {
	Magic     Magic            `tlb:"#4"`
	Key       ValidatorTempKey `tlb:"^"`
	Signature CryptoSignature
}

type ValidatorTempKey 

type ValidatorTempKey struct {
	Magic         Magic `tlb:"#3"`
	AdnlAddr      Bits256
	TempPublicKey SigPubKey
	Seqno         uint32
	ValidUntil    uint32
}

type ValidatorsSet 

type ValidatorsSet struct {
	SumType
	// validators#11 utime_since:uint32 utime_until:uint32
	//   total:(## 16) main:(## 16) { main <= total } { main >= 1 }
	//   list:(Hashmap 16 ValidatorDescr) = ValidatorSet;
	Validators *struct {
		ValidatorSetsCommon
		List Hashmap[Uint16, ValidatorDescr]
	} `tlbSumType:"validators#11"`
	// 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;
	ValidatorsExt *struct {
		ValidatorSetsCommon
		TotalWeight uint64
		List        HashmapE[Uint16, ValidatorDescr]
	} `tlbSumType:"validatorsext#12"`
}

func (ValidatorsSet) Common 

func (vs ValidatorsSet) Common() ValidatorSetsCommon

type ValueFlow 

type ValueFlow struct {
	Magic         Magic `json:"-"`
	FromPrevBlk   CurrencyCollection
	ToNextBlk     CurrencyCollection
	Imported      CurrencyCollection
	Exported      CurrencyCollection
	FeesCollected CurrencyCollection
	Burned        *CurrencyCollection
	FeesImported  CurrencyCollection
	Recovered     CurrencyCollection
	Created       CurrencyCollection
	Minted        CurrencyCollection
}

ValueFlow

v1: ^[ from_prev_blk:CurrencyCollection to_next_blk:CurrencyCollection imported:CurrencyCollection exported:CurrencyCollection ] fees_collected:CurrencyCollection ^[ fees_imported:CurrencyCollection recovered:CurrencyCollection created:CurrencyCollection minted:CurrencyCollection ];

v2: 

^[ 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 ]

func (*ValueFlow) UnmarshalTLB 

func (m *ValueFlow) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger1 

type VarUInteger1 big.Int

func (VarUInteger1) MarshalJSON 

func (u VarUInteger1) MarshalJSON() ([]byte, error)

func (VarUInteger1) MarshalTLB 

func (u VarUInteger1) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger1) UnmarshalJSON 

func (u *VarUInteger1) UnmarshalJSON(p []byte) error

func (*VarUInteger1) UnmarshalTLB 

func (u *VarUInteger1) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger10 

type VarUInteger10 big.Int

func (VarUInteger10) MarshalJSON 

func (u VarUInteger10) MarshalJSON() ([]byte, error)

func (VarUInteger10) MarshalTLB 

func (u VarUInteger10) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger10) UnmarshalJSON 

func (u *VarUInteger10) UnmarshalJSON(p []byte) error

func (*VarUInteger10) UnmarshalTLB 

func (u *VarUInteger10) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger11 

type VarUInteger11 big.Int

func (VarUInteger11) MarshalJSON 

func (u VarUInteger11) MarshalJSON() ([]byte, error)

func (VarUInteger11) MarshalTLB 

func (u VarUInteger11) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger11) UnmarshalJSON 

func (u *VarUInteger11) UnmarshalJSON(p []byte) error

func (*VarUInteger11) UnmarshalTLB 

func (u *VarUInteger11) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger12 

type VarUInteger12 big.Int

func (VarUInteger12) MarshalJSON 

func (u VarUInteger12) MarshalJSON() ([]byte, error)

func (VarUInteger12) MarshalTLB 

func (u VarUInteger12) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger12) UnmarshalJSON 

func (u *VarUInteger12) UnmarshalJSON(p []byte) error

func (*VarUInteger12) UnmarshalTLB 

func (u *VarUInteger12) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger13 

type VarUInteger13 big.Int

func (VarUInteger13) MarshalJSON 

func (u VarUInteger13) MarshalJSON() ([]byte, error)

func (VarUInteger13) MarshalTLB 

func (u VarUInteger13) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger13) UnmarshalJSON 

func (u *VarUInteger13) UnmarshalJSON(p []byte) error

func (*VarUInteger13) UnmarshalTLB 

func (u *VarUInteger13) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger14 

type VarUInteger14 big.Int

func (VarUInteger14) MarshalJSON 

func (u VarUInteger14) MarshalJSON() ([]byte, error)

func (VarUInteger14) MarshalTLB 

func (u VarUInteger14) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger14) UnmarshalJSON 

func (u *VarUInteger14) UnmarshalJSON(p []byte) error

func (*VarUInteger14) UnmarshalTLB 

func (u *VarUInteger14) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger15 

type VarUInteger15 big.Int

func (VarUInteger15) MarshalJSON 

func (u VarUInteger15) MarshalJSON() ([]byte, error)

func (VarUInteger15) MarshalTLB 

func (u VarUInteger15) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger15) UnmarshalJSON 

func (u *VarUInteger15) UnmarshalJSON(p []byte) error

func (*VarUInteger15) UnmarshalTLB 

func (u *VarUInteger15) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger16 

type VarUInteger16 big.Int

func VarUInteger16FromInt64 

func VarUInteger16FromInt64(i int64) VarUInteger16

func (VarUInteger16) MarshalJSON 

func (u VarUInteger16) MarshalJSON() ([]byte, error)

func (VarUInteger16) MarshalTLB 

func (u VarUInteger16) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger16) UnmarshalJSON 

func (u *VarUInteger16) UnmarshalJSON(p []byte) error

func (*VarUInteger16) UnmarshalTLB 

func (u *VarUInteger16) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger17 

type VarUInteger17 big.Int

func (VarUInteger17) MarshalJSON 

func (u VarUInteger17) MarshalJSON() ([]byte, error)

func (VarUInteger17) MarshalTLB 

func (u VarUInteger17) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger17) UnmarshalJSON 

func (u *VarUInteger17) UnmarshalJSON(p []byte) error

func (*VarUInteger17) UnmarshalTLB 

func (u *VarUInteger17) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger18 

type VarUInteger18 big.Int

func (VarUInteger18) MarshalJSON 

func (u VarUInteger18) MarshalJSON() ([]byte, error)

func (VarUInteger18) MarshalTLB 

func (u VarUInteger18) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger18) UnmarshalJSON 

func (u *VarUInteger18) UnmarshalJSON(p []byte) error

func (*VarUInteger18) UnmarshalTLB 

func (u *VarUInteger18) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger19 

type VarUInteger19 big.Int

func (VarUInteger19) MarshalJSON 

func (u VarUInteger19) MarshalJSON() ([]byte, error)

func (VarUInteger19) MarshalTLB 

func (u VarUInteger19) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger19) UnmarshalJSON 

func (u *VarUInteger19) UnmarshalJSON(p []byte) error

func (*VarUInteger19) UnmarshalTLB 

func (u *VarUInteger19) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger2 

type VarUInteger2 big.Int

func (VarUInteger2) MarshalJSON 

func (u VarUInteger2) MarshalJSON() ([]byte, error)

func (VarUInteger2) MarshalTLB 

func (u VarUInteger2) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger2) UnmarshalJSON 

func (u *VarUInteger2) UnmarshalJSON(p []byte) error

func (*VarUInteger2) UnmarshalTLB 

func (u *VarUInteger2) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger20 

type VarUInteger20 big.Int

func (VarUInteger20) MarshalJSON 

func (u VarUInteger20) MarshalJSON() ([]byte, error)

func (VarUInteger20) MarshalTLB 

func (u VarUInteger20) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger20) UnmarshalJSON 

func (u *VarUInteger20) UnmarshalJSON(p []byte) error

func (*VarUInteger20) UnmarshalTLB 

func (u *VarUInteger20) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger21 

type VarUInteger21 big.Int

func (VarUInteger21) MarshalJSON 

func (u VarUInteger21) MarshalJSON() ([]byte, error)

func (VarUInteger21) MarshalTLB 

func (u VarUInteger21) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger21) UnmarshalJSON 

func (u *VarUInteger21) UnmarshalJSON(p []byte) error

func (*VarUInteger21) UnmarshalTLB 

func (u *VarUInteger21) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger22 

type VarUInteger22 big.Int

func (VarUInteger22) MarshalJSON 

func (u VarUInteger22) MarshalJSON() ([]byte, error)

func (VarUInteger22) MarshalTLB 

func (u VarUInteger22) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger22) UnmarshalJSON 

func (u *VarUInteger22) UnmarshalJSON(p []byte) error

func (*VarUInteger22) UnmarshalTLB 

func (u *VarUInteger22) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger23 

type VarUInteger23 big.Int

func (VarUInteger23) MarshalJSON 

func (u VarUInteger23) MarshalJSON() ([]byte, error)

func (VarUInteger23) MarshalTLB 

func (u VarUInteger23) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger23) UnmarshalJSON 

func (u *VarUInteger23) UnmarshalJSON(p []byte) error

func (*VarUInteger23) UnmarshalTLB 

func (u *VarUInteger23) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger24 

type VarUInteger24 big.Int

func (VarUInteger24) MarshalJSON 

func (u VarUInteger24) MarshalJSON() ([]byte, error)

func (VarUInteger24) MarshalTLB 

func (u VarUInteger24) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger24) UnmarshalJSON 

func (u *VarUInteger24) UnmarshalJSON(p []byte) error

func (*VarUInteger24) UnmarshalTLB 

func (u *VarUInteger24) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger25 

type VarUInteger25 big.Int

func (VarUInteger25) MarshalJSON 

func (u VarUInteger25) MarshalJSON() ([]byte, error)

func (VarUInteger25) MarshalTLB 

func (u VarUInteger25) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger25) UnmarshalJSON 

func (u *VarUInteger25) UnmarshalJSON(p []byte) error

func (*VarUInteger25) UnmarshalTLB 

func (u *VarUInteger25) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger26 

type VarUInteger26 big.Int

func (VarUInteger26) MarshalJSON 

func (u VarUInteger26) MarshalJSON() ([]byte, error)

func (VarUInteger26) MarshalTLB 

func (u VarUInteger26) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger26) UnmarshalJSON 

func (u *VarUInteger26) UnmarshalJSON(p []byte) error

func (*VarUInteger26) UnmarshalTLB 

func (u *VarUInteger26) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger27 

type VarUInteger27 big.Int

func (VarUInteger27) MarshalJSON 

func (u VarUInteger27) MarshalJSON() ([]byte, error)

func (VarUInteger27) MarshalTLB 

func (u VarUInteger27) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger27) UnmarshalJSON 

func (u *VarUInteger27) UnmarshalJSON(p []byte) error

func (*VarUInteger27) UnmarshalTLB 

func (u *VarUInteger27) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger28 

type VarUInteger28 big.Int

func (VarUInteger28) MarshalJSON 

func (u VarUInteger28) MarshalJSON() ([]byte, error)

func (VarUInteger28) MarshalTLB 

func (u VarUInteger28) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger28) UnmarshalJSON 

func (u *VarUInteger28) UnmarshalJSON(p []byte) error

func (*VarUInteger28) UnmarshalTLB 

func (u *VarUInteger28) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger29 

type VarUInteger29 big.Int

func (VarUInteger29) MarshalJSON 

func (u VarUInteger29) MarshalJSON() ([]byte, error)

func (VarUInteger29) MarshalTLB 

func (u VarUInteger29) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger29) UnmarshalJSON 

func (u *VarUInteger29) UnmarshalJSON(p []byte) error

func (*VarUInteger29) UnmarshalTLB 

func (u *VarUInteger29) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger3 

type VarUInteger3 big.Int

func (VarUInteger3) MarshalJSON 

func (u VarUInteger3) MarshalJSON() ([]byte, error)

func (VarUInteger3) MarshalTLB 

func (u VarUInteger3) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger3) UnmarshalJSON 

func (u *VarUInteger3) UnmarshalJSON(p []byte) error

func (*VarUInteger3) UnmarshalTLB 

func (u *VarUInteger3) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger30 

type VarUInteger30 big.Int

func (VarUInteger30) MarshalJSON 

func (u VarUInteger30) MarshalJSON() ([]byte, error)

func (VarUInteger30) MarshalTLB 

func (u VarUInteger30) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger30) UnmarshalJSON 

func (u *VarUInteger30) UnmarshalJSON(p []byte) error

func (*VarUInteger30) UnmarshalTLB 

func (u *VarUInteger30) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger31 

type VarUInteger31 big.Int

func (VarUInteger31) MarshalJSON 

func (u VarUInteger31) MarshalJSON() ([]byte, error)

func (VarUInteger31) MarshalTLB 

func (u VarUInteger31) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger31) UnmarshalJSON 

func (u *VarUInteger31) UnmarshalJSON(p []byte) error

func (*VarUInteger31) UnmarshalTLB 

func (u *VarUInteger31) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger32 

type VarUInteger32 big.Int

func (VarUInteger32) MarshalJSON 

func (u VarUInteger32) MarshalJSON() ([]byte, error)

func (VarUInteger32) MarshalTLB 

func (u VarUInteger32) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger32) UnmarshalJSON 

func (u *VarUInteger32) UnmarshalJSON(p []byte) error

func (*VarUInteger32) UnmarshalTLB 

func (u *VarUInteger32) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger4 

type VarUInteger4 big.Int

func (VarUInteger4) MarshalJSON 

func (u VarUInteger4) MarshalJSON() ([]byte, error)

func (VarUInteger4) MarshalTLB 

func (u VarUInteger4) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger4) UnmarshalJSON 

func (u *VarUInteger4) UnmarshalJSON(p []byte) error

func (*VarUInteger4) UnmarshalTLB 

func (u *VarUInteger4) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger5 

type VarUInteger5 big.Int

func (VarUInteger5) MarshalJSON 

func (u VarUInteger5) MarshalJSON() ([]byte, error)

func (VarUInteger5) MarshalTLB 

func (u VarUInteger5) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger5) UnmarshalJSON 

func (u *VarUInteger5) UnmarshalJSON(p []byte) error

func (*VarUInteger5) UnmarshalTLB 

func (u *VarUInteger5) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger6 

type VarUInteger6 big.Int

func (VarUInteger6) MarshalJSON 

func (u VarUInteger6) MarshalJSON() ([]byte, error)

func (VarUInteger6) MarshalTLB 

func (u VarUInteger6) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger6) UnmarshalJSON 

func (u *VarUInteger6) UnmarshalJSON(p []byte) error

func (*VarUInteger6) UnmarshalTLB 

func (u *VarUInteger6) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger7 

type VarUInteger7 big.Int

func (VarUInteger7) MarshalJSON 

func (u VarUInteger7) MarshalJSON() ([]byte, error)

func (VarUInteger7) MarshalTLB 

func (u VarUInteger7) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger7) UnmarshalJSON 

func (u *VarUInteger7) UnmarshalJSON(p []byte) error

func (*VarUInteger7) UnmarshalTLB 

func (u *VarUInteger7) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger8 

type VarUInteger8 big.Int

func (VarUInteger8) MarshalJSON 

func (u VarUInteger8) MarshalJSON() ([]byte, error)

func (VarUInteger8) MarshalTLB 

func (u VarUInteger8) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger8) UnmarshalJSON 

func (u *VarUInteger8) UnmarshalJSON(p []byte) error

func (*VarUInteger8) UnmarshalTLB 

func (u *VarUInteger8) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VarUInteger9 

type VarUInteger9 big.Int

func (VarUInteger9) MarshalJSON 

func (u VarUInteger9) MarshalJSON() ([]byte, error)

func (VarUInteger9) MarshalTLB 

func (u VarUInteger9) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VarUInteger9) UnmarshalJSON 

func (u *VarUInteger9) UnmarshalJSON(p []byte) error

func (*VarUInteger9) UnmarshalTLB 

func (u *VarUInteger9) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VmCellSlice 

type VmCellSlice struct {
	// contains filtered or unexported fields
}

VmCellSlice _ cell:^Cell st_bits:(## 10) end_bits:(## 10) { st_bits <= end_bits } st_ref:(#<= 4) end_ref:(#<= 4) { st_ref <= end_ref } = VmCellSlice;

func (VmCellSlice) Cell 

func (s VmCellSlice) Cell() *boc.Cell

func (VmCellSlice) MarshalTLB 

func (s VmCellSlice) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VmCellSlice) UnmarshalTLB 

func (s *VmCellSlice) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

func (VmCellSlice) UnmarshalToTlbStruct 

func (s VmCellSlice) UnmarshalToTlbStruct(res any) error

type VmCont 

type VmCont struct {
}

VmCont _ cregs:(HashmapE 4 VmStackValue) = VmSaveList; 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;

func (VmCont) MarshalTLB 

func (ct VmCont) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VmCont) UnmarshalTLB 

func (ct *VmCont) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VmStack 

type VmStack []VmStackValue

VmStack 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;

func (VmStack) MarshalTL 

func (s VmStack) MarshalTL() ([]byte, error)

func (VmStack) MarshalTLB 

func (s VmStack) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VmStack) Put 

func (s *VmStack) Put(val VmStackValue)

func (VmStack) Unmarshal 

func (s VmStack) Unmarshal(dest any) error

func (*VmStack) UnmarshalTL 

func (s *VmStack) UnmarshalTL(r io.Reader) error

func (*VmStack) UnmarshalTLB 

func (s *VmStack) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VmStackValue 

type VmStackValue struct {
	SumType
	VmStkNull    struct{}      `tlbSumType:"vm_stk_null#00"`
	VmStkTinyInt int64         `tlbSumType:"vm_stk_tinyint#01"`
	VmStkInt     Int257        `tlbSumType:"vm_stk_int$000000100000000"` // vm_stk_int#0201_
	VmStkNan     struct{}      `tlbSumType:"vm_stk_nan#02ff"`
	VmStkCell    Ref[boc.Cell] `tlbSumType:"vm_stk_cell#03"`
	VmStkSlice   VmCellSlice   `tlbSumType:"vm_stk_slice#04"`
	VmStkBuilder Ref[boc.Cell] `tlbSumType:"vm_stk_builder#05"`
	VmStkCont    VmCont        `tlbSumType:"vm_stk_cont#06"`
	VmStkTuple   VmStkTuple    `tlbSumType:"vm_stk_tuple#07"`
}

VmStackValue 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; vm_stk_slice#04 _:VmCellSlice = VmStackValue; vm_stk_builder#05 cell:^Cell = VmStackValue; vm_stk_cont#06 cont:VmCont = VmStackValue; vm_stk_tuple#07 len:(## 16) data:(VmTuple len) = VmStackValue;

func CellToVmCellSlice 

func CellToVmCellSlice(cell *boc.Cell) (VmStackValue, error)

func TlbStructToVmCell 

func TlbStructToVmCell(s any) (VmStackValue, error)

func TlbStructToVmCellSlice 

func TlbStructToVmCellSlice(s any) (VmStackValue, error)

func (VmStackValue) Cell deprecated 

func (v VmStackValue) Cell() *boc.Cell

Deprecated: Cell is deprecated.

func (VmStackValue) CellSlice deprecated 

func (v VmStackValue) CellSlice() *boc.Cell

Deprecated: CellSlice is deprecated.

func (VmStackValue) Int257 deprecated 

func (v VmStackValue) Int257() Int257

Deprecated: Int is deprecated.

func (VmStackValue) Int64 deprecated 

func (v VmStackValue) Int64() int64

Deprecated: Int64 is deprecated.

func (VmStackValue) IsCell deprecated 

func (v VmStackValue) IsCell() bool

Deprecated: IsCell is deprecated.

func (VmStackValue) IsCellSlice deprecated 

func (v VmStackValue) IsCellSlice() bool

Deprecated: IsCellSlice is deprecated.

func (VmStackValue) IsInt deprecated 

func (v VmStackValue) IsInt() bool

Deprecated: IsInt is deprecated.

func (VmStackValue) IsNull deprecated 

func (v VmStackValue) IsNull() bool

Deprecated: IsNull is deprecated.

func (VmStackValue) IsTuple deprecated 

func (v VmStackValue) IsTuple() bool

Deprecated: IsTuple is deprecated.

func (VmStackValue) Uint64 deprecated 

func (v VmStackValue) Uint64() uint64

Deprecated: Uint64 is deprecated.

func (VmStackValue) Unmarshal 

func (v VmStackValue) Unmarshal(dest any) error

type VmStkTuple 

type VmStkTuple struct {
	Len  uint16
	Data *VmTuple
}

VmStkTuple Custom type: len:(## 16) data:(VmTuple len). Tag excluded. Use with VmStackValue type. 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;

func (VmStkTuple) MarshalTLB 

func (t VmStkTuple) MarshalTLB(c *boc.Cell, encoder *Encoder) error

func (*VmStkTuple) RecursiveToSlice 

func (t *VmStkTuple) RecursiveToSlice() ([]VmStackValue, error)

func (*VmStkTuple) Unmarshal 

func (t *VmStkTuple) Unmarshal(v any) error

func (*VmStkTuple) UnmarshalTLB 

func (t *VmStkTuple) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VmTuple 

type VmTuple struct {
	Head VmTupleRef
	Tail VmStackValue `tlb:"^"`
}

func (VmTuple) RecursiveToSlice 

func (t VmTuple) RecursiveToSlice(depth int) ([]VmStackValue, error)

func (*VmTuple) UnmarshalTLB 

func (t *VmTuple) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error

type VmTupleRef 

type VmTupleRef struct {
	Entry *VmStackValue `tlb:"^"`
	Ref   *VmTuple      `tlb:"^"`
}

type WcSplitMergeTimings 

type WcSplitMergeTimings struct {
	Magic                 Magic `tlb:"#0"`
	SplitMergeDelay       uint32
	SplitMergeInterval    uint32
	MinSplitMergeInterval uint32
	MaxSplitMergeDelay    uint32
}

type WorkchainDescr 

type WorkchainDescr struct {
	SumType
	Workchain struct {
		EnabledSince      uint32
		ActualMinSplit    uint8
		MinSplit          uint8
		MaxSplit          uint8
		Basic             Uint1
		Active            bool
		AcceptMsgs        bool
		Flags             Uint13
		ZerostateRootHash Bits256
		ZerostateFileHash Bits256
		Version           uint32
	} `tlbSumType:"#a6"`
	WorkchainV2 struct {
		EnabledSince      uint32
		ActualMinSplit    uint8
		MinSplit          uint8
		MaxSplit          uint8
		Basic             Uint1
		Active            bool
		AcceptMsgs        bool
		Flags             Uint13
		ZerostateRootHash Bits256
		ZerostateFileHash Bits256
		Version           uint32
	} `tlbSumType:"#a7"`
}

func (*WorkchainDescr) MarshalJSON 

func (t *WorkchainDescr) MarshalJSON() ([]byte, error)

type WorkchainFormat0 

type WorkchainFormat0 struct {
	Magic           Magic `tlb:"#0"`
	MinAddrLen      Uint12
	MaxAddrLen      Uint12
	AddrLenStep     Uint12
	WorkchainTypeId uint32
}

type WorkchainFormat1 

type WorkchainFormat1 struct {
	Magic     Magic `tlb:"#1"`
	VmVersion int32
	VmMode    uint64
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.