danog/ton
1
0
Fork 0
mirror of https://github.com/danog/ton.git synced 2024-12-02 17:38:33 +01:00
Code Issues Projects Releases Wiki Activity
bfa166d66c
ton/crypto/block/block-parse.h

1082 lines
36 KiB
C
Raw Normal View History

initial commit
2019-09-07 12:03:22 +02:00
/*
This file is part of TON Blockchain Library.
TON Blockchain Library is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
TON Blockchain Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
Copyright 2017-2019 Telegram Systems LLP
*/
#pragma once
#include "common/refcnt.hpp"
#include "vm/cells.h"
#include "vm/cellslice.h"
#include "vm/dict.h"
#include "vm/boc.h"
#include "block/block.h"
#include <ostream>
#include "tl/tlblib.hpp"
#include "td/utils/bits.h"
#include "td/utils/StringBuilder.h"
#include "ton/ton-types.h"
namespace block {
using td::Ref;
namespace tlb {
using namespace ::tlb;
struct Anycast final : TLB {
int get_size(const vm::CellSlice& cs) const override {
return cs.have(5) ? 5 + (int)cs.prefetch_ulong(5) : -1;
}
bool skip_get_depth(vm::CellSlice& cs, int& depth) const {
return cs.fetch_uint_leq(30, depth) && cs.advance(depth);
}
};
extern const Anycast t_Anycast;
struct Maybe_Anycast final : public Maybe<Anycast> {
bool skip_get_depth(vm::CellSlice& cs, int& depth) const;
};
extern const Maybe_Anycast t_Maybe_Anycast;
struct VarUInteger final : TLB_Complex {
int n, ln;
VarUInteger(int _n) : n(_n) {
ln = 32 - td::count_leading_zeroes32(n - 1);
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
td::RefInt256 as_integer_skip(vm::CellSlice& cs) const override;
unsigned long long as_uint(const vm::CellSlice& cs) const override;
bool null_value(vm::CellBuilder& cb) const override {
return cb.store_zeroes_bool(ln);
}
bool store_integer_value(vm::CellBuilder& cb, const td::BigInt256& value) const override;
unsigned precompute_integer_size(const td::BigInt256& value) const;
unsigned precompute_integer_size(td::RefInt256 value) const;
};
extern const VarUInteger t_VarUInteger_3, t_VarUInteger_7, t_VarUInteger_16, t_VarUInteger_32;
struct VarUIntegerPos final : TLB_Complex {
int n, ln;
VarUIntegerPos(int _n) : n(_n) {
ln = 32 - td::count_leading_zeroes32(n - 1);
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
td::RefInt256 as_integer_skip(vm::CellSlice& cs) const override;
unsigned long long as_uint(const vm::CellSlice& cs) const override;
bool store_integer_value(vm::CellBuilder& cb, const td::BigInt256& value) const override;
};
extern const VarUIntegerPos t_VarUIntegerPos_16, t_VarUIntegerPos_32;
struct VarInteger final : TLB_Complex {
int n, ln;
VarInteger(int _n) : n(_n) {
ln = 32 - td::count_leading_zeroes32(n - 1);
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
td::RefInt256 as_integer_skip(vm::CellSlice& cs) const override;
long long as_int(const vm::CellSlice& cs) const override;
bool null_value(vm::CellBuilder& cb) const override {
return cb.store_zeroes_bool(ln);
}
bool store_integer_value(vm::CellBuilder& cb, const td::BigInt256& value) const override;
};
struct VarIntegerNz final : TLB_Complex {
int n, ln;
VarIntegerNz(int _n) : n(_n) {
ln = 32 - td::count_leading_zeroes32(n - 1);
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
td::RefInt256 as_integer_skip(vm::CellSlice& cs) const override;
long long as_int(const vm::CellSlice& cs) const override;
bool store_integer_value(vm::CellBuilder& cb, const td::BigInt256& value) const override;
};
struct Unary final : TLB {
int get_size(const vm::CellSlice& cs) const override {
return cs.count_leading(1) + 1;
}
bool validate_skip(vm::CellSlice& cs, bool weak, int& n) const {
return cs.advance((n = cs.count_leading(1)) + 1);
}
bool skip(vm::CellSlice& cs, int& n) const {
return validate_skip(cs, false, n);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
return cs.advance(get_size(cs));
}
bool skip(vm::CellSlice& cs) const override {
return validate_skip(cs);
}
bool validate(const vm::CellSlice& cs, bool weak = false) const override {
return cs.have(get_size(cs));
}
};
extern const Unary t_Unary;
struct HmLabel final : TLB_Complex {
enum { hml_short = 0, hml_long = 2, hml_same = 3 };
int m; // max size
HmLabel(int _m) : m(_m) {
}
bool validate_skip(vm::CellSlice& cs, bool weak, int& n) const;
bool skip(vm::CellSlice& cs, int& n) const {
return validate_skip(cs, false, n);
}
bool skip(vm::CellSlice& cs) const override {
int n;
return skip(cs, n);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
int n;
return validate_skip(cs, weak, n);
}
int get_tag(const vm::CellSlice& cs) const override;
};
struct Hashmap final : TLB_Complex {
const TLB& value_type;
int n;
Hashmap(int _n, const TLB& _val_type) : value_type(_val_type), n(_n) {
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
struct HashmapNode final : TLB_Complex {
enum { hmn_leaf = 0, hmn_fork = 1 };
const TLB& value_type;
int n;
HashmapNode(int _n, const TLB& _val_type) : value_type(_val_type), n(_n) {
}
int get_size(const vm::CellSlice& cs) const override;
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return n > 0 ? hmn_fork : n;
}
};
struct HashmapE final : TLB {
enum { hme_empty = 0, hme_root = 1 };
Hashmap root_type;
HashmapE(int _n, const TLB& _val_type) : root_type(_n, _val_type) {
}
int get_size(const vm::CellSlice& cs) const override;
bool validate(const vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(1);
}
bool null_value(vm::CellBuilder& cb) const override {
return cb.store_zeroes_bool(1);
}
bool add_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override;
int sub_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override;
bool add_values_ref(Ref<vm::Cell>& res, Ref<vm::Cell> arg1, Ref<vm::Cell> arg2) const;
int sub_values_ref(Ref<vm::Cell>& res, Ref<vm::Cell> arg1, Ref<vm::Cell> arg2) const;
bool store_ref(vm::CellBuilder& cb, Ref<vm::Cell> arg) const;
};
struct AugmentationCheckData : vm::dict::AugmentationData {
const TLB& value_type;
const TLB& extra_type;
AugmentationCheckData(const TLB& val_type, const TLB& ex_type) : value_type(val_type), extra_type(ex_type) {
}
bool skip_extra(vm::CellSlice& cs) const override {
return extra_type.skip(cs);
}
bool eval_fork(vm::CellBuilder& cb, vm::CellSlice& left_cs, vm::CellSlice& right_cs) const override {
return extra_type.add_values(cb, left_cs, right_cs);
}
bool eval_empty(vm::CellBuilder& cb) const override {
return extra_type.null_value(cb);
}
};
struct HashmapAug final : TLB_Complex {
const AugmentationCheckData& aug;
int n;
HashmapAug(int _n, const AugmentationCheckData& _aug) : aug(_aug), n(_n) {
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool extract_extra(vm::CellSlice& cs) const;
};
struct HashmapAugNode final : TLB_Complex {
enum { ahmn_leaf = 0, ahmn_fork = 1 };
const AugmentationCheckData& aug;
int n;
HashmapAugNode(int _n, const AugmentationCheckData& _aug) : aug(_aug), n(_n) {
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return n > 0 ? ahmn_fork : n;
}
};
struct HashmapAugE final : TLB_Complex {
enum { ahme_empty = 0, ahme_root = 1 };
HashmapAug root_type;
HashmapAugE(int _n, const AugmentationCheckData& _aug) : root_type(_n, std::move(_aug)) {
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool extract_extra(vm::CellSlice& cs) const;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(1);
}
};
struct Grams final : TLB_Complex {
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
td::RefInt256 as_integer_skip(vm::CellSlice& cs) const override;
bool null_value(vm::CellBuilder& cb) const override;
bool store_integer_value(vm::CellBuilder& cb, const td::BigInt256& value) const override;
unsigned precompute_size(const td::BigInt256& value) const;
unsigned precompute_size(td::RefInt256 value) const;
};
extern const Grams t_Grams;
struct MsgAddressInt final : TLB_Complex {
enum { addr_std = 2, addr_var = 3 };
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(2);
}
static ton::AccountIdPrefixFull get_prefix(vm::CellSlice&& cs);
static ton::AccountIdPrefixFull get_prefix(const vm::CellSlice& cs);
static ton::AccountIdPrefixFull get_prefix(Ref<vm::CellSlice> cs_ref);
static bool get_prefix_to(vm::CellSlice&& cs, ton::AccountIdPrefixFull& pfx) {
return (pfx = get_prefix(std::move(cs))).is_valid();
}
static bool get_prefix_to(const vm::CellSlice& cs, ton::AccountIdPrefixFull& pfx) {
return (pfx = get_prefix(cs)).is_valid();
}
static bool get_prefix_to(Ref<vm::CellSlice> cs_ref, ton::AccountIdPrefixFull& pfx) {
return cs_ref.not_null() && (pfx = get_prefix(std::move(cs_ref))).is_valid();
}
bool skip_get_depth(vm::CellSlice& cs, int& depth) const;
bool extract_std_address(Ref<vm::CellSlice> cs_ref, ton::WorkchainId& workchain, ton::StdSmcAddress& addr,
bool rewrite = true) const;
bool extract_std_address(vm::CellSlice& cs, ton::WorkchainId& workchain, ton::StdSmcAddress& addr,
bool rewrite = true) const;
};
extern const MsgAddressInt t_MsgAddressInt;
struct MsgAddressExt final : TLB {
enum { addr_none = 0, addr_ext = 1 };
int get_size(const vm::CellSlice& cs) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(2);
}
};
extern const MsgAddressExt t_MsgAddressExt;
struct MsgAddress final : TLB_Complex {
enum { addr_none = 0, addr_ext = 1, addr_std = 2, addr_var = 3 };
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(2);
}
};
extern const MsgAddress t_MsgAddress;
struct ExtraCurrencyCollection final : TLB {
HashmapE dict_type;
ExtraCurrencyCollection() : dict_type(32, t_VarUIntegerPos_32) {
}
int get_size(const vm::CellSlice& cs) const override {
return dict_type.get_size(cs);
}
bool validate(const vm::CellSlice& cs, bool weak) const override {
return dict_type.validate(cs, weak);
}
bool null_value(vm::CellBuilder& cb) const override {
return cb.store_zeroes_bool(1);
}
bool add_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override {
return dict_type.add_values(cb, cs1, cs2);
}
int sub_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override {
return dict_type.sub_values(cb, cs1, cs2);
}
bool add_values_ref(Ref<vm::Cell>& res, Ref<vm::Cell> arg1, Ref<vm::Cell> arg2) const {
return dict_type.add_values_ref(res, std::move(arg1), std::move(arg2));
}
int sub_values_ref(Ref<vm::Cell>& res, Ref<vm::Cell> arg1, Ref<vm::Cell> arg2) const {
return dict_type.sub_values_ref(res, std::move(arg1), std::move(arg2));
}
bool store_ref(vm::CellBuilder& cb, Ref<vm::Cell> arg) const {
return dict_type.store_ref(cb, std::move(arg));
}
unsigned precompute_size(Ref<vm::Cell> arg) const {
return arg.is_null() ? 1 : 0x10001;
}
};
extern const ExtraCurrencyCollection t_ExtraCurrencyCollection;
struct CurrencyCollection final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
td::RefInt256 as_integer_skip(vm::CellSlice& cs) const override;
bool null_value(vm::CellBuilder& cb) const override {
return cb.store_bits_same_bool(1 + 4, false);
}
bool add_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override;
bool unpack_special(vm::CellSlice& cs, td::RefInt256& balance, Ref<vm::Cell>& extra, bool inexact = false) const;
bool unpack_special(vm::CellSlice& cs, block::CurrencyCollection& value, bool inexact = false) const;
bool pack_special(vm::CellBuilder& cb, td::RefInt256 balance, Ref<vm::Cell> extra) const;
bool pack_special(vm::CellBuilder& cb, const block::CurrencyCollection& value) const;
bool pack_special(vm::CellBuilder& cb, block::CurrencyCollection&& value) const;
bool unpack(vm::CellSlice& cs, block::CurrencyCollection& res) const;
bool pack(vm::CellBuilder& cb, const block::CurrencyCollection& res) const;
unsigned precompute_size(td::RefInt256 balance, Ref<vm::Cell> extra) const {
return t_Grams.precompute_size(std::move(balance)) + t_ExtraCurrencyCollection.precompute_size(std::move(extra));
}
};
extern const CurrencyCollection t_CurrencyCollection;
struct CommonMsgInfo final : TLB_Complex {
enum { int_msg_info = 0, ext_in_msg_info = 2, ext_out_msg_info = 3 };
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
int v = (int)cs.prefetch_ulong(2);
return v == 1 ? int_msg_info : v;
}
struct Record_int_msg_info;
bool unpack(vm::CellSlice& cs, Record_int_msg_info& data) const;
bool get_created_lt(vm::CellSlice& cs, unsigned long long& created_lt) const;
bool is_internal(const vm::CellSlice& cs) const {
return get_tag(cs) == int_msg_info;
}
};
struct CommonMsgInfo::Record_int_msg_info {
bool ihr_disabled, bounce, bounced;
Ref<vm::CellSlice> src, dest, value, ihr_fee, fwd_fee;
unsigned long long created_lt;
unsigned created_at;
};
extern const CommonMsgInfo t_CommonMsgInfo;
struct TickTock final : TLB {
int get_size(const vm::CellSlice& cs) const override {
return 2;
}
};
extern const TickTock t_TickTock;
struct StateInit final : TLB_Complex {
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool get_ticktock(vm::CellSlice& cs, int& ticktock) const;
};
extern const StateInit t_StateInit;
struct Message final : TLB_Complex {
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool extract_info(vm::CellSlice& cs) const;
bool get_created_lt(vm::CellSlice& cs, unsigned long long& created_lt) const;
bool is_internal(const vm::CellSlice& cs) const {
return t_CommonMsgInfo.is_internal(cs);
}
bool is_internal(Ref<vm::Cell> ref) const;
};
extern const Message t_Message;
extern const RefTo<Message> t_Ref_Message;
struct IntermediateAddress final : TLB_Complex {
enum { interm_addr_regular = 0, interm_addr_simple = 2, interm_addr_ext = 3 };
int get_size(const vm::CellSlice& cs) const override;
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool fetch_regular(vm::CellSlice& cs, int& use_dst_bits) const {
return cs.fetch_uint_to(8, use_dst_bits) && use_dst_bits <= 96;
}
int get_tag(const vm::CellSlice& cs) const override {
int v = (int)cs.prefetch_ulong(2);
return v == 1 ? interm_addr_regular : v;
}
};
extern const IntermediateAddress t_IntermediateAddress;
struct MsgEnvelope final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool extract_fwd_fees_remaining(vm::CellSlice& cs) const;
struct Record {
typedef MsgEnvelope type_class;
Ref<vm::CellSlice> cur_addr, next_addr, fwd_fee_remaining;
Ref<vm::Cell> msg;
};
struct Record_std {
typedef MsgEnvelope type_class;
int cur_addr, next_addr;
td::RefInt256 fwd_fee_remaining;
Ref<vm::Cell> msg;
};
bool unpack(vm::CellSlice& cs, Record& data) const;
bool unpack(vm::CellSlice& cs, Record_std& data) const;
bool unpack_std(vm::CellSlice& cs, int& cur_a, int& nhop_a, Ref<vm::Cell>& msg) const;
bool get_created_lt(const vm::CellSlice& cs, unsigned long long& created_lt) const;
};
extern const MsgEnvelope t_MsgEnvelope;
extern const RefTo<MsgEnvelope> t_Ref_MsgEnvelope;
struct StorageUsed final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const StorageUsed t_StorageUsed;
struct StorageUsedShort final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const StorageUsedShort t_StorageUsedShort;
struct StorageInfo final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const StorageInfo t_StorageInfo;
struct AccountState final : TLB_Complex {
enum { account_uninit = 0, account_frozen = 1, account_active = 2 };
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
int t = (int)cs.prefetch_ulong(2);
return t == 3 ? account_active : t;
}
bool get_ticktock(vm::CellSlice& cs, int& ticktock) const;
};
extern const AccountState t_AccountState;
struct AccountStorage final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool skip_copy_balance(vm::CellBuilder& cb, vm::CellSlice& cs) const;
};
extern const AccountStorage t_AccountStorage;
struct Account final : TLB_Complex {
enum { account_none = 0, account = 1 };
bool allow_empty;
Account(bool _allow_empty = false) : allow_empty(_allow_empty) {
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
// Ref<vm::CellSlice> get_balance(const vm::CellSlice& cs) const;
bool skip_copy_balance(vm::CellBuilder& cb, vm::CellSlice& cs) const;
bool skip_copy_depth_balance(vm::CellBuilder& cb, vm::CellSlice& cs) const;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(1);
}
};
extern const Account t_Account, t_AccountE;
extern const RefTo<Account> t_Ref_Account;
struct AccountStatus final : TLB {
enum { acc_state_uninit, acc_state_frozen, acc_state_active, acc_state_nonexist };
int get_size(const vm::CellSlice& cs) const override {
return 2;
}
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(2);
}
};
extern const AccountStatus t_AccountStatus;
struct ShardAccount final : TLB_Complex {
struct Record {
using Type = ShardAccount;
Ref<vm::Cell> account;
ton::LogicalTime last_trans_lt;
ton::Bits256 last_trans_hash;
bool valid{false};
bool is_zero{false};
bool reset();
bool unpack(vm::CellSlice& cs);
bool unpack(Ref<vm::CellSlice> cs_ref);
bool invalidate() {
return valid = false;
}
};
int get_size(const vm::CellSlice& cs) const override {
return 0x10140;
}
bool skip(vm::CellSlice& cs) const override {
return cs.advance_ext(0x140, 1);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
return cs.advance(0x140) && t_Ref_Account.validate_skip(cs, weak);
}
static bool unpack(vm::CellSlice& cs, Record& info) {
return info.unpack(cs);
}
static bool unpack(Ref<vm::CellSlice> cs_ref, Record& info) {
return info.unpack(std::move(cs_ref));
}
static bool extract_account_state(Ref<vm::CellSlice> cs_ref, Ref<vm::Cell>& acc_state);
};
extern const ShardAccount t_ShardAccount;
struct DepthBalanceInfo final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool null_value(vm::CellBuilder& cb) const override;
bool add_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override;
};
extern const DepthBalanceInfo t_DepthBalanceInfo;
struct Aug_ShardAccounts final : AugmentationCheckData {
Aug_ShardAccounts() : AugmentationCheckData(t_ShardAccount, t_DepthBalanceInfo) {
}
bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override;
};
extern const Aug_ShardAccounts aug_ShardAccounts;
struct ShardAccounts final : TLB_Complex {
HashmapAugE dict_type;
ShardAccounts() : dict_type(256, aug_ShardAccounts){};
bool skip(vm::CellSlice& cs) const override {
return dict_type.skip(cs);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
return dict_type.validate_skip(cs, weak);
}
};
extern const ShardAccounts t_ShardAccounts;
struct AccStatusChange final : TLB {
enum { acst_unchanged = 0, acst_frozen = 2, acst_deleted = 3 };
int get_size(const vm::CellSlice& cs) const override {
return cs.prefetch_ulong(1) ? 2 : 1;
}
int get_tag(const vm::CellSlice& cs) const override {
if (cs.size() == 1) {
return (int)cs.prefetch_ulong(1) ? -1 : acst_unchanged;
}
int v = (int)cs.prefetch_ulong(2);
return v == 1 ? acst_unchanged : v;
}
};
extern const AccStatusChange t_AccStatusChange;
struct TrStoragePhase final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const TrStoragePhase t_TrStoragePhase;
struct TrCreditPhase final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const TrCreditPhase t_TrCreditPhase;
struct TrComputeInternal1 final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
struct ComputeSkipReason final : TLB {
enum { cskip_no_state = 0, cskip_bad_state = 1, cskip_no_gas = 2 };
int get_size(const vm::CellSlice& cs) const override {
return 2;
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
return get_tag(cs) >= 0 && cs.advance(2);
}
int get_tag(const vm::CellSlice& cs) const override {
int t = (int)cs.prefetch_ulong(2);
return t < 3 ? t : -1;
}
};
extern const ComputeSkipReason t_ComputeSkipReason;
struct TrComputePhase final : TLB_Complex {
enum { tr_phase_compute_skipped = 0, tr_phase_compute_vm = 1 };
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(1);
}
};
extern const TrComputePhase t_TrComputePhase;
struct TrActionPhase final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const TrActionPhase t_TrActionPhase;
struct TrBouncePhase final : TLB_Complex {
enum { tr_phase_bounce_negfunds = 0, tr_phase_bounce_nofunds = 1, tr_phase_bounce_ok = 2 };
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override;
};
extern const TrBouncePhase t_TrBouncePhase;
struct SplitMergeInfo final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const SplitMergeInfo t_SplitMergeInfo;
struct TransactionDescr final : TLB_Complex {
enum {
trans_ord = 0,
trans_storage = 1,
trans_tick_tock = 2,
trans_split_prepare = 4,
trans_split_install = 5,
trans_merge_prepare = 6,
trans_merge_install = 7
};
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override;
};
extern const TransactionDescr t_TransactionDescr;
struct Transaction_aux final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const Transaction_aux t_Transaction_aux;
struct Transaction final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool get_total_fees(vm::CellSlice&& cs, block::CurrencyCollection& total_fees) const;
};
extern const Transaction t_Transaction;
extern const RefTo<Transaction> t_Ref_Transaction;
struct Aug_AccountTransactions final : AugmentationCheckData {
Aug_AccountTransactions() : AugmentationCheckData(t_Ref_Transaction, t_CurrencyCollection) {
}
bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override;
};
extern const Aug_AccountTransactions aug_AccountTransactions;
extern const HashmapAug t_AccountTransactions; // (HashmapAug 64 ^Transaction CurrencyCollection)
struct HashUpdate final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override {
return cs.advance(8 + 256 * 2);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
return cs.fetch_ulong(8) == 0x72 && cs.advance(256 * 2);
}
};
extern const HashUpdate t_HashUpdate;
extern const RefTo<HashUpdate> t_Ref_HashUpdate;
struct AccountBlock final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool get_total_fees(vm::CellSlice&& cs, block::CurrencyCollection& total_fees) const;
};
extern const AccountBlock t_AccountBlock;
struct Aug_ShardAccountBlocks final : AugmentationCheckData {
Aug_ShardAccountBlocks() : AugmentationCheckData(t_AccountBlock, t_CurrencyCollection) {
}
bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override;
};
extern const Aug_ShardAccountBlocks aug_ShardAccountBlocks;
extern const HashmapAugE t_ShardAccountBlocks; // (HashmapAugE 256 AccountBlock CurrencyCollection)
struct ImportFees final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool null_value(vm::CellBuilder& cb) const override {
return cb.store_bits_same_bool(4 + 4 + 1, false);
}
bool add_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override;
};
extern const ImportFees t_ImportFees;
struct InMsg final : TLB_Complex {
enum {
msg_import_ext = 0,
msg_import_ihr = 2,
msg_import_imm = 3,
msg_import_fin = 4,
msg_import_tr = 5,
msg_discard_fin = 6,
msg_discard_tr = 7
};
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(3);
}
bool get_import_fees(vm::CellBuilder& cb, vm::CellSlice& cs) const;
};
extern const InMsg t_InMsg;
struct OutMsg final : TLB_Complex {
enum {
msg_export_ext = 0,
msg_export_new = 1,
msg_export_imm = 2,
msg_export_tr = 3,
msg_export_deq_imm = 4,
msg_export_deq = 6,
msg_export_tr_req = 7
};
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(3);
}
bool get_export_value(vm::CellBuilder& cb, vm::CellSlice& cs) const;
bool get_created_lt(vm::CellSlice& cs, unsigned long long& created_lt) const;
};
extern const OutMsg t_OutMsg;
// next: InMsgDescr, OutMsgDescr, OutMsgQueue, and their augmentations
struct Aug_InMsgDescr final : AugmentationCheckData {
Aug_InMsgDescr() : AugmentationCheckData(t_InMsg, t_ImportFees) {
}
bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override {
return t_InMsg.get_import_fees(cb, cs);
}
};
extern const Aug_InMsgDescr aug_InMsgDescr;
struct InMsgDescr final : TLB_Complex {
HashmapAugE dict_type;
InMsgDescr() : dict_type(256, aug_InMsgDescr){};
bool skip(vm::CellSlice& cs) const override {
return dict_type.skip(cs);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
return dict_type.validate_skip(cs, weak);
}
};
extern const InMsgDescr t_InMsgDescr;
struct Aug_OutMsgDescr final : AugmentationCheckData {
Aug_OutMsgDescr() : AugmentationCheckData(t_OutMsg, t_CurrencyCollection) {
}
bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override {
return t_OutMsg.get_export_value(cb, cs);
}
};
extern const Aug_OutMsgDescr aug_OutMsgDescr;
struct OutMsgDescr final : TLB_Complex {
HashmapAugE dict_type;
OutMsgDescr() : dict_type(256, aug_OutMsgDescr){};
bool skip(vm::CellSlice& cs) const override {
return dict_type.skip(cs);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
return dict_type.validate_skip(cs, weak);
}
};
extern const OutMsgDescr t_OutMsgDescr;
struct EnqueuedMsg final : TLB_Complex {
int get_size(const vm::CellSlice& cs) const override {
return 0x10040;
}
bool skip(vm::CellSlice& cs) const override {
return cs.advance_ext(0x10040);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool unpack(vm::CellSlice& cs, EnqueuedMsgDescr& descr) const {
return descr.unpack(cs);
}
};
extern const EnqueuedMsg t_EnqueuedMsg;
struct Aug_OutMsgQueue final : AugmentationCheckData {
Aug_OutMsgQueue() : AugmentationCheckData(t_EnqueuedMsg, t_uint64) {
}
bool eval_fork(vm::CellBuilder& cb, vm::CellSlice& left_cs, vm::CellSlice& right_cs) const override;
bool eval_empty(vm::CellBuilder& cb) const override;
bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override;
};
extern const Aug_OutMsgQueue aug_OutMsgQueue;
struct OutMsgQueue final : TLB_Complex {
HashmapAugE dict_type;
OutMsgQueue() : dict_type(32 + 64 + 256, aug_OutMsgQueue){};
bool skip(vm::CellSlice& cs) const override {
return dict_type.skip(cs);
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override {
return dict_type.validate_skip(cs, weak);
}
};
extern const OutMsgQueue t_OutMsgQueue;
struct ProcessedUpto final : TLB {
int get_size(const vm::CellSlice& cs) const override {
return 64 + 256;
}
};
extern const ProcessedUpto t_ProcessedUpto;
extern const HashmapE t_ProcessedInfo;
extern const HashmapE t_IhrPendingInfo;
struct OutMsgQueueInfo final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const OutMsgQueueInfo t_OutMsgQueueInfo;
extern const RefTo<OutMsgQueueInfo> t_Ref_OutMsgQueueInfo;
struct ExtBlkRef final : TLB {
enum { fixed_size = 64 + 32 + 256 * 2 };
int get_size(const vm::CellSlice& cs) const override {
return fixed_size;
}
bool unpack(vm::CellSlice& cs, ton::BlockIdExt& blkid, ton::LogicalTime* end_lt = nullptr) const;
bool unpack(Ref<vm::CellSlice> cs_ref, ton::BlockIdExt& blkid, ton::LogicalTime* end_lt = nullptr) const;
};
extern const ExtBlkRef t_ExtBlkRef;
struct BlkMasterInfo final : TLB {
int get_size(const vm::CellSlice& cs) const override {
return t_ExtBlkRef.get_size(cs);
}
};
extern const BlkMasterInfo t_BlkMasterInfo;
struct ShardIdent final : TLB_Complex {
struct Record;
int get_size(const vm::CellSlice& cs) const override {
return 2 + 6 + 32 + 64;
}
bool skip(vm::CellSlice& cs) const override {
return cs.advance(get_size(cs));
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return 0;
}
bool unpack(vm::CellSlice& cs, Record& data) const;
bool pack(vm::CellBuilder& cb, const Record& data) const;
bool unpack(vm::CellSlice& cs, ton::ShardIdFull& data) const;
bool pack(vm::CellBuilder& cb, ton::ShardIdFull data) const;
bool unpack(vm::CellSlice& cs, ton::WorkchainId& workchain, ton::ShardId& shard) const;
bool pack(vm::CellBuilder& cb, ton::WorkchainId workchain, ton::ShardId shard) const;
};
struct ShardIdent::Record {
int shard_pfx_bits;
int workchain_id;
unsigned long long shard_prefix;
Record() : shard_pfx_bits(-1) {
}
Record(int _pfxlen, int _wcid, unsigned long long _pfx)
: shard_pfx_bits(_pfxlen), workchain_id(_wcid), shard_prefix(_pfx) {
}
bool check() const;
bool is_valid() const {
return shard_pfx_bits >= 0;
}
void invalidate() {
shard_pfx_bits = -1;
}
};
extern const ShardIdent t_ShardIdent;
struct BlockIdExt final : TLB_Complex {
int get_size(const vm::CellSlice& cs) const override {
return 2 + 6 + 32 + 64 + 32 + 256 * 2;
}
bool skip(vm::CellSlice& cs) const override {
return cs.advance(get_size(cs));
}
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool unpack(vm::CellSlice& cs, ton::BlockIdExt& data) const;
bool pack(vm::CellBuilder& cb, const ton::BlockIdExt& data) const;
};
extern const BlockIdExt t_BlockIdExt;
struct ShardState final : TLB_Complex {
enum { shard_state = (int)0x9023afe2, split_state = 0x5f327da5 };
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(32) == shard_state ? shard_state : -1;
}
};
extern const ShardState t_ShardState;
struct ShardState_aux final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return 0;
}
};
extern const ShardState_aux t_ShardState_aux;
struct LibDescr final : TLB_Complex {
enum { shared_lib_descr = 0 };
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
int get_tag(const vm::CellSlice& cs) const override {
return (int)cs.prefetch_ulong(2);
}
};
extern const LibDescr t_LibDescr;
struct BlkPrevInfo final : TLB_Complex {
bool merged;
BlkPrevInfo(bool _merged) : merged(_merged) {
}
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const BlkPrevInfo t_BlkPrevInfo_0;
struct McStateExtra final : TLB_Complex {
enum { masterchain_state_extra = 0xcc26 };
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
};
extern const McStateExtra t_McStateExtra;
struct KeyExtBlkRef final : TLB {
enum { fixed_size = 1 + ExtBlkRef::fixed_size };
int get_size(const vm::CellSlice& cs) const override {
return fixed_size;
}
};
extern const KeyExtBlkRef t_KeyExtBlkRef;
struct KeyMaxLt final : TLB {
enum { fixed_size = 1 + 64 };
int get_size(const vm::CellSlice& cs) const override {
return fixed_size;
}
bool null_value(vm::CellBuilder& cb) const override {
return cb.store_bits_same_bool(fixed_size, false);
}
bool add_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override;
};
extern const KeyMaxLt t_KeyMaxLt;
struct Aug_OldMcBlocksInfo final : AugmentationCheckData {
Aug_OldMcBlocksInfo() : AugmentationCheckData(t_KeyExtBlkRef, t_KeyMaxLt) {
}
bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override;
};
extern const Aug_OldMcBlocksInfo aug_OldMcBlocksInfo;
struct ShardFeeCreated final : TLB_Complex {
bool skip(vm::CellSlice& cs) const override;
bool validate_skip(vm::CellSlice& cs, bool weak = false) const override;
bool null_value(vm::CellBuilder& cb) const override;
bool add_values(vm::CellBuilder& cb, vm::CellSlice& cs1, vm::CellSlice& cs2) const override;
};
extern const ShardFeeCreated t_ShardFeeCreated;
struct Aug_ShardFees final : AugmentationCheckData {
Aug_ShardFees() : AugmentationCheckData(t_ShardFeeCreated, t_ShardFeeCreated) {
}
bool eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const override;
};
extern const Aug_ShardFees aug_ShardFees;
} // namespace tlb
} // namespace block
Reference in New Issue Copy Permalink