#ifndef _BLOCKCHAIN_API2_H_
#define _BLOCKCHAIN_API2_H_
#include "molecule2_reader.h"
#ifdef __cplusplus
extern "C" {
#endif
struct Uint32Type;
struct Uint32VTable;
struct Uint32VTable *GetUint32VTable(void);
struct Uint32Type make_Uint32(mol2_cursor_t *cur);
uint32_t Uint32_len_impl(struct Uint32Type *);
uint8_t Uint32_get_impl(struct Uint32Type *, uint32_t, bool *);
struct Uint64Type;
struct Uint64VTable;
struct Uint64VTable *GetUint64VTable(void);
struct Uint64Type make_Uint64(mol2_cursor_t *cur);
uint32_t Uint64_len_impl(struct Uint64Type *);
uint8_t Uint64_get_impl(struct Uint64Type *, uint32_t, bool *);
struct Uint128Type;
struct Uint128VTable;
struct Uint128VTable *GetUint128VTable(void);
struct Uint128Type make_Uint128(mol2_cursor_t *cur);
uint32_t Uint128_len_impl(struct Uint128Type *);
uint8_t Uint128_get_impl(struct Uint128Type *, uint32_t, bool *);
struct Byte32Type;
struct Byte32VTable;
struct Byte32VTable *GetByte32VTable(void);
struct Byte32Type make_Byte32(mol2_cursor_t *cur);
uint32_t Byte32_len_impl(struct Byte32Type *);
uint8_t Byte32_get_impl(struct Byte32Type *, uint32_t, bool *);
struct Uint256Type;
struct Uint256VTable;
struct Uint256VTable *GetUint256VTable(void);
struct Uint256Type make_Uint256(mol2_cursor_t *cur);
uint32_t Uint256_len_impl(struct Uint256Type *);
uint8_t Uint256_get_impl(struct Uint256Type *, uint32_t, bool *);
struct BytesType;
struct BytesVTable;
struct BytesVTable *GetBytesVTable(void);
struct BytesType make_Bytes(mol2_cursor_t *cur);
uint32_t Bytes_len_impl(struct BytesType *);
uint8_t Bytes_get_impl(struct BytesType *, uint32_t, bool *);
struct BytesOptType;
struct BytesOptVTable;
struct BytesOptVTable *GetBytesOptVTable(void);
struct BytesOptType make_BytesOpt(mol2_cursor_t *cur);
bool BytesOpt_is_none_impl(struct BytesOptType *);
bool BytesOpt_is_some_impl(struct BytesOptType *);
mol2_cursor_t BytesOpt_unwrap_impl(struct BytesOptType *);
struct BytesVecType;
struct BytesVecVTable;
struct BytesVecVTable *GetBytesVecVTable(void);
struct BytesVecType make_BytesVec(mol2_cursor_t *cur);
uint32_t BytesVec_len_impl(struct BytesVecType *);
mol2_cursor_t BytesVec_get_impl(struct BytesVecType *, uint32_t, bool *);
struct Byte32VecType;
struct Byte32VecVTable;
struct Byte32VecVTable *GetByte32VecVTable(void);
struct Byte32VecType make_Byte32Vec(mol2_cursor_t *cur);
uint32_t Byte32Vec_len_impl(struct Byte32VecType *);
mol2_cursor_t Byte32Vec_get_impl(struct Byte32VecType *, uint32_t, bool *);
struct ScriptOptType;
struct ScriptOptVTable;
struct ScriptOptVTable *GetScriptOptVTable(void);
struct ScriptOptType make_ScriptOpt(mol2_cursor_t *cur);
bool ScriptOpt_is_none_impl(struct ScriptOptType *);
bool ScriptOpt_is_some_impl(struct ScriptOptType *);
struct ScriptType ScriptOpt_unwrap_impl(struct ScriptOptType *);
struct ProposalShortIdType;
struct ProposalShortIdVTable;
struct ProposalShortIdVTable *GetProposalShortIdVTable(void);
struct ProposalShortIdType make_ProposalShortId(mol2_cursor_t *cur);
uint32_t ProposalShortId_len_impl(struct ProposalShortIdType *);
uint8_t ProposalShortId_get_impl(struct ProposalShortIdType *, uint32_t,
bool *);
struct UncleBlockVecType;
struct UncleBlockVecVTable;
struct UncleBlockVecVTable *GetUncleBlockVecVTable(void);
struct UncleBlockVecType make_UncleBlockVec(mol2_cursor_t *cur);
uint32_t UncleBlockVec_len_impl(struct UncleBlockVecType *);
struct UncleBlockType UncleBlockVec_get_impl(struct UncleBlockVecType *,
uint32_t, bool *);
struct TransactionVecType;
struct TransactionVecVTable;
struct TransactionVecVTable *GetTransactionVecVTable(void);
struct TransactionVecType make_TransactionVec(mol2_cursor_t *cur);
uint32_t TransactionVec_len_impl(struct TransactionVecType *);
struct TransactionType TransactionVec_get_impl(struct TransactionVecType *,
uint32_t, bool *);
struct ProposalShortIdVecType;
struct ProposalShortIdVecVTable;
struct ProposalShortIdVecVTable *GetProposalShortIdVecVTable(void);
struct ProposalShortIdVecType make_ProposalShortIdVec(mol2_cursor_t *cur);
uint32_t ProposalShortIdVec_len_impl(struct ProposalShortIdVecType *);
mol2_cursor_t ProposalShortIdVec_get_impl(struct ProposalShortIdVecType *,
uint32_t, bool *);
struct CellDepVecType;
struct CellDepVecVTable;
struct CellDepVecVTable *GetCellDepVecVTable(void);
struct CellDepVecType make_CellDepVec(mol2_cursor_t *cur);
uint32_t CellDepVec_len_impl(struct CellDepVecType *);
struct CellDepType CellDepVec_get_impl(struct CellDepVecType *, uint32_t,
bool *);
struct CellInputVecType;
struct CellInputVecVTable;
struct CellInputVecVTable *GetCellInputVecVTable(void);
struct CellInputVecType make_CellInputVec(mol2_cursor_t *cur);
uint32_t CellInputVec_len_impl(struct CellInputVecType *);
struct CellInputType CellInputVec_get_impl(struct CellInputVecType *, uint32_t,
bool *);
struct CellOutputVecType;
struct CellOutputVecVTable;
struct CellOutputVecVTable *GetCellOutputVecVTable(void);
struct CellOutputVecType make_CellOutputVec(mol2_cursor_t *cur);
uint32_t CellOutputVec_len_impl(struct CellOutputVecType *);
struct CellOutputType CellOutputVec_get_impl(struct CellOutputVecType *,
uint32_t, bool *);
struct ScriptType;
struct ScriptVTable;
struct ScriptVTable *GetScriptVTable(void);
struct ScriptType make_Script(mol2_cursor_t *cur);
mol2_cursor_t Script_get_code_hash_impl(struct ScriptType *);
uint8_t Script_get_hash_type_impl(struct ScriptType *);
mol2_cursor_t Script_get_args_impl(struct ScriptType *);
struct OutPointType;
struct OutPointVTable;
struct OutPointVTable *GetOutPointVTable(void);
struct OutPointType make_OutPoint(mol2_cursor_t *cur);
mol2_cursor_t OutPoint_get_tx_hash_impl(struct OutPointType *);
uint32_t OutPoint_get_index_impl(struct OutPointType *);
struct CellInputType;
struct CellInputVTable;
struct CellInputVTable *GetCellInputVTable(void);
struct CellInputType make_CellInput(mol2_cursor_t *cur);
uint64_t CellInput_get_since_impl(struct CellInputType *);
struct OutPointType CellInput_get_previous_output_impl(struct CellInputType *);
struct CellOutputType;
struct CellOutputVTable;
struct CellOutputVTable *GetCellOutputVTable(void);
struct CellOutputType make_CellOutput(mol2_cursor_t *cur);
uint64_t CellOutput_get_capacity_impl(struct CellOutputType *);
struct ScriptType CellOutput_get_lock_impl(struct CellOutputType *);
struct ScriptOptType CellOutput_get_type__impl(struct CellOutputType *);
struct CellDepType;
struct CellDepVTable;
struct CellDepVTable *GetCellDepVTable(void);
struct CellDepType make_CellDep(mol2_cursor_t *cur);
struct OutPointType CellDep_get_out_point_impl(struct CellDepType *);
uint8_t CellDep_get_dep_type_impl(struct CellDepType *);
struct RawTransactionType;
struct RawTransactionVTable;
struct RawTransactionVTable *GetRawTransactionVTable(void);
struct RawTransactionType make_RawTransaction(mol2_cursor_t *cur);
uint32_t RawTransaction_get_version_impl(struct RawTransactionType *);
struct CellDepVecType RawTransaction_get_cell_deps_impl(
struct RawTransactionType *);
struct Byte32VecType RawTransaction_get_header_deps_impl(
struct RawTransactionType *);
struct CellInputVecType RawTransaction_get_inputs_impl(
struct RawTransactionType *);
struct CellOutputVecType RawTransaction_get_outputs_impl(
struct RawTransactionType *);
struct BytesVecType RawTransaction_get_outputs_data_impl(
struct RawTransactionType *);
struct TransactionType;
struct TransactionVTable;
struct TransactionVTable *GetTransactionVTable(void);
struct TransactionType make_Transaction(mol2_cursor_t *cur);
struct RawTransactionType Transaction_get_raw_impl(struct TransactionType *);
struct BytesVecType Transaction_get_witnesses_impl(struct TransactionType *);
struct RawHeaderType;
struct RawHeaderVTable;
struct RawHeaderVTable *GetRawHeaderVTable(void);
struct RawHeaderType make_RawHeader(mol2_cursor_t *cur);
uint32_t RawHeader_get_version_impl(struct RawHeaderType *);
uint32_t RawHeader_get_compact_target_impl(struct RawHeaderType *);
uint64_t RawHeader_get_timestamp_impl(struct RawHeaderType *);
uint64_t RawHeader_get_number_impl(struct RawHeaderType *);
uint64_t RawHeader_get_epoch_impl(struct RawHeaderType *);
mol2_cursor_t RawHeader_get_parent_hash_impl(struct RawHeaderType *);
mol2_cursor_t RawHeader_get_transactions_root_impl(struct RawHeaderType *);
mol2_cursor_t RawHeader_get_proposals_hash_impl(struct RawHeaderType *);
mol2_cursor_t RawHeader_get_uncles_hash_impl(struct RawHeaderType *);
mol2_cursor_t RawHeader_get_dao_impl(struct RawHeaderType *);
struct HeaderType;
struct HeaderVTable;
struct HeaderVTable *GetHeaderVTable(void);
struct HeaderType make_Header(mol2_cursor_t *cur);
struct RawHeaderType Header_get_raw_impl(struct HeaderType *);
mol2_cursor_t Header_get_nonce_impl(struct HeaderType *);
struct UncleBlockType;
struct UncleBlockVTable;
struct UncleBlockVTable *GetUncleBlockVTable(void);
struct UncleBlockType make_UncleBlock(mol2_cursor_t *cur);
struct HeaderType UncleBlock_get_header_impl(struct UncleBlockType *);
struct ProposalShortIdVecType UncleBlock_get_proposals_impl(
struct UncleBlockType *);
struct BlockType;
struct BlockVTable;
struct BlockVTable *GetBlockVTable(void);
struct BlockType make_Block(mol2_cursor_t *cur);
struct HeaderType Block_get_header_impl(struct BlockType *);
struct UncleBlockVecType Block_get_uncles_impl(struct BlockType *);
struct TransactionVecType Block_get_transactions_impl(struct BlockType *);
struct ProposalShortIdVecType Block_get_proposals_impl(struct BlockType *);
struct CellbaseWitnessType;
struct CellbaseWitnessVTable;
struct CellbaseWitnessVTable *GetCellbaseWitnessVTable(void);
struct CellbaseWitnessType make_CellbaseWitness(mol2_cursor_t *cur);
struct ScriptType CellbaseWitness_get_lock_impl(struct CellbaseWitnessType *);
mol2_cursor_t CellbaseWitness_get_message_impl(struct CellbaseWitnessType *);
struct WitnessArgsType;
struct WitnessArgsVTable;
struct WitnessArgsVTable *GetWitnessArgsVTable(void);
struct WitnessArgsType make_WitnessArgs(mol2_cursor_t *cur);
struct BytesOptType WitnessArgs_get_lock_impl(struct WitnessArgsType *);
struct BytesOptType WitnessArgs_get_input_type_impl(struct WitnessArgsType *);
struct BytesOptType WitnessArgs_get_output_type_impl(struct WitnessArgsType *);
typedef struct Uint32VTable {
uint32_t (*len)(struct Uint32Type *);
uint8_t (*get)(struct Uint32Type *, uint32_t, bool *);
} Uint32VTable;
typedef struct Uint32Type {
mol2_cursor_t cur;
Uint32VTable *t;
} Uint32Type;
typedef struct Uint64VTable {
uint32_t (*len)(struct Uint64Type *);
uint8_t (*get)(struct Uint64Type *, uint32_t, bool *);
} Uint64VTable;
typedef struct Uint64Type {
mol2_cursor_t cur;
Uint64VTable *t;
} Uint64Type;
typedef struct Uint128VTable {
uint32_t (*len)(struct Uint128Type *);
uint8_t (*get)(struct Uint128Type *, uint32_t, bool *);
} Uint128VTable;
typedef struct Uint128Type {
mol2_cursor_t cur;
Uint128VTable *t;
} Uint128Type;
typedef struct Byte32VTable {
uint32_t (*len)(struct Byte32Type *);
uint8_t (*get)(struct Byte32Type *, uint32_t, bool *);
} Byte32VTable;
typedef struct Byte32Type {
mol2_cursor_t cur;
Byte32VTable *t;
} Byte32Type;
typedef struct Uint256VTable {
uint32_t (*len)(struct Uint256Type *);
uint8_t (*get)(struct Uint256Type *, uint32_t, bool *);
} Uint256VTable;
typedef struct Uint256Type {
mol2_cursor_t cur;
Uint256VTable *t;
} Uint256Type;
typedef struct BytesVTable {
uint32_t (*len)(struct BytesType *);
uint8_t (*get)(struct BytesType *, uint32_t, bool *);
} BytesVTable;
typedef struct BytesType {
mol2_cursor_t cur;
BytesVTable *t;
} BytesType;
typedef struct BytesOptVTable {
bool (*is_none)(struct BytesOptType *);
bool (*is_some)(struct BytesOptType *);
mol2_cursor_t (*unwrap)(struct BytesOptType *);
} BytesOptVTable;
typedef struct BytesOptType {
mol2_cursor_t cur;
BytesOptVTable *t;
} BytesOptType;
typedef struct BytesVecVTable {
uint32_t (*len)(struct BytesVecType *);
mol2_cursor_t (*get)(struct BytesVecType *, uint32_t, bool *);
} BytesVecVTable;
typedef struct BytesVecType {
mol2_cursor_t cur;
BytesVecVTable *t;
} BytesVecType;
typedef struct Byte32VecVTable {
uint32_t (*len)(struct Byte32VecType *);
mol2_cursor_t (*get)(struct Byte32VecType *, uint32_t, bool *);
} Byte32VecVTable;
typedef struct Byte32VecType {
mol2_cursor_t cur;
Byte32VecVTable *t;
} Byte32VecType;
typedef struct ScriptOptVTable {
bool (*is_none)(struct ScriptOptType *);
bool (*is_some)(struct ScriptOptType *);
struct ScriptType (*unwrap)(struct ScriptOptType *);
} ScriptOptVTable;
typedef struct ScriptOptType {
mol2_cursor_t cur;
ScriptOptVTable *t;
} ScriptOptType;
typedef struct ProposalShortIdVTable {
uint32_t (*len)(struct ProposalShortIdType *);
uint8_t (*get)(struct ProposalShortIdType *, uint32_t, bool *);
} ProposalShortIdVTable;
typedef struct ProposalShortIdType {
mol2_cursor_t cur;
ProposalShortIdVTable *t;
} ProposalShortIdType;
typedef struct UncleBlockVecVTable {
uint32_t (*len)(struct UncleBlockVecType *);
struct UncleBlockType (*get)(struct UncleBlockVecType *, uint32_t, bool *);
} UncleBlockVecVTable;
typedef struct UncleBlockVecType {
mol2_cursor_t cur;
UncleBlockVecVTable *t;
} UncleBlockVecType;
typedef struct TransactionVecVTable {
uint32_t (*len)(struct TransactionVecType *);
struct TransactionType (*get)(struct TransactionVecType *, uint32_t, bool *);
} TransactionVecVTable;
typedef struct TransactionVecType {
mol2_cursor_t cur;
TransactionVecVTable *t;
} TransactionVecType;
typedef struct ProposalShortIdVecVTable {
uint32_t (*len)(struct ProposalShortIdVecType *);
mol2_cursor_t (*get)(struct ProposalShortIdVecType *, uint32_t, bool *);
} ProposalShortIdVecVTable;
typedef struct ProposalShortIdVecType {
mol2_cursor_t cur;
ProposalShortIdVecVTable *t;
} ProposalShortIdVecType;
typedef struct CellDepVecVTable {
uint32_t (*len)(struct CellDepVecType *);
struct CellDepType (*get)(struct CellDepVecType *, uint32_t, bool *);
} CellDepVecVTable;
typedef struct CellDepVecType {
mol2_cursor_t cur;
CellDepVecVTable *t;
} CellDepVecType;
typedef struct CellInputVecVTable {
uint32_t (*len)(struct CellInputVecType *);
struct CellInputType (*get)(struct CellInputVecType *, uint32_t, bool *);
} CellInputVecVTable;
typedef struct CellInputVecType {
mol2_cursor_t cur;
CellInputVecVTable *t;
} CellInputVecType;
typedef struct CellOutputVecVTable {
uint32_t (*len)(struct CellOutputVecType *);
struct CellOutputType (*get)(struct CellOutputVecType *, uint32_t, bool *);
} CellOutputVecVTable;
typedef struct CellOutputVecType {
mol2_cursor_t cur;
CellOutputVecVTable *t;
} CellOutputVecType;
typedef struct ScriptVTable {
mol2_cursor_t (*code_hash)(struct ScriptType *);
uint8_t (*hash_type)(struct ScriptType *);
mol2_cursor_t (*args)(struct ScriptType *);
} ScriptVTable;
typedef struct ScriptType {
mol2_cursor_t cur;
ScriptVTable *t;
} ScriptType;
typedef struct OutPointVTable {
mol2_cursor_t (*tx_hash)(struct OutPointType *);
uint32_t (*index)(struct OutPointType *);
} OutPointVTable;
typedef struct OutPointType {
mol2_cursor_t cur;
OutPointVTable *t;
} OutPointType;
typedef struct CellInputVTable {
uint64_t (*since)(struct CellInputType *);
struct OutPointType (*previous_output)(struct CellInputType *);
} CellInputVTable;
typedef struct CellInputType {
mol2_cursor_t cur;
CellInputVTable *t;
} CellInputType;
typedef struct CellOutputVTable {
uint64_t (*capacity)(struct CellOutputType *);
struct ScriptType (*lock)(struct CellOutputType *);
struct ScriptOptType (*type_)(struct CellOutputType *);
} CellOutputVTable;
typedef struct CellOutputType {
mol2_cursor_t cur;
CellOutputVTable *t;
} CellOutputType;
typedef struct CellDepVTable {
struct OutPointType (*out_point)(struct CellDepType *);
uint8_t (*dep_type)(struct CellDepType *);
} CellDepVTable;
typedef struct CellDepType {
mol2_cursor_t cur;
CellDepVTable *t;
} CellDepType;
typedef struct RawTransactionVTable {
uint32_t (*version)(struct RawTransactionType *);
struct CellDepVecType (*cell_deps)(struct RawTransactionType *);
struct Byte32VecType (*header_deps)(struct RawTransactionType *);
struct CellInputVecType (*inputs)(struct RawTransactionType *);
struct CellOutputVecType (*outputs)(struct RawTransactionType *);
struct BytesVecType (*outputs_data)(struct RawTransactionType *);
} RawTransactionVTable;
typedef struct RawTransactionType {
mol2_cursor_t cur;
RawTransactionVTable *t;
} RawTransactionType;
typedef struct TransactionVTable {
struct RawTransactionType (*raw)(struct TransactionType *);
struct BytesVecType (*witnesses)(struct TransactionType *);
} TransactionVTable;
typedef struct TransactionType {
mol2_cursor_t cur;
TransactionVTable *t;
} TransactionType;
typedef struct RawHeaderVTable {
uint32_t (*version)(struct RawHeaderType *);
uint32_t (*compact_target)(struct RawHeaderType *);
uint64_t (*timestamp)(struct RawHeaderType *);
uint64_t (*number)(struct RawHeaderType *);
uint64_t (*epoch)(struct RawHeaderType *);
mol2_cursor_t (*parent_hash)(struct RawHeaderType *);
mol2_cursor_t (*transactions_root)(struct RawHeaderType *);
mol2_cursor_t (*proposals_hash)(struct RawHeaderType *);
mol2_cursor_t (*uncles_hash)(struct RawHeaderType *);
mol2_cursor_t (*dao)(struct RawHeaderType *);
} RawHeaderVTable;
typedef struct RawHeaderType {
mol2_cursor_t cur;
RawHeaderVTable *t;
} RawHeaderType;
typedef struct HeaderVTable {
struct RawHeaderType (*raw)(struct HeaderType *);
mol2_cursor_t (*nonce)(struct HeaderType *);
} HeaderVTable;
typedef struct HeaderType {
mol2_cursor_t cur;
HeaderVTable *t;
} HeaderType;
typedef struct UncleBlockVTable {
struct HeaderType (*header)(struct UncleBlockType *);
struct ProposalShortIdVecType (*proposals)(struct UncleBlockType *);
} UncleBlockVTable;
typedef struct UncleBlockType {
mol2_cursor_t cur;
UncleBlockVTable *t;
} UncleBlockType;
typedef struct BlockVTable {
struct HeaderType (*header)(struct BlockType *);
struct UncleBlockVecType (*uncles)(struct BlockType *);
struct TransactionVecType (*transactions)(struct BlockType *);
struct ProposalShortIdVecType (*proposals)(struct BlockType *);
} BlockVTable;
typedef struct BlockType {
mol2_cursor_t cur;
BlockVTable *t;
} BlockType;
typedef struct CellbaseWitnessVTable {
struct ScriptType (*lock)(struct CellbaseWitnessType *);
mol2_cursor_t (*message)(struct CellbaseWitnessType *);
} CellbaseWitnessVTable;
typedef struct CellbaseWitnessType {
mol2_cursor_t cur;
CellbaseWitnessVTable *t;
} CellbaseWitnessType;
typedef struct WitnessArgsVTable {
struct BytesOptType (*lock)(struct WitnessArgsType *);
struct BytesOptType (*input_type)(struct WitnessArgsType *);
struct BytesOptType (*output_type)(struct WitnessArgsType *);
} WitnessArgsVTable;
typedef struct WitnessArgsType {
mol2_cursor_t cur;
WitnessArgsVTable *t;
} WitnessArgsType;
#ifndef MOLECULEC_C2_DECLARATION_ONLY
struct Uint32Type make_Uint32(mol2_cursor_t *cur) {
Uint32Type ret;
ret.cur = *cur;
ret.t = GetUint32VTable();
return ret;
}
struct Uint32VTable *GetUint32VTable(void) {
static Uint32VTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = Uint32_len_impl;
s_vtable.get = Uint32_get_impl;
return &s_vtable;
}
uint32_t Uint32_len_impl(Uint32Type *this) { return 4; }
uint8_t Uint32_get_impl(Uint32Type *this, uint32_t index, bool *existing) {
uint8_t ret = {0};
mol2_cursor_res_t res = mol2_slice_by_offset2(&this->cur, 1 * index, 1);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_Uint8(&res.cur);
return ret;
}
struct Uint64Type make_Uint64(mol2_cursor_t *cur) {
Uint64Type ret;
ret.cur = *cur;
ret.t = GetUint64VTable();
return ret;
}
struct Uint64VTable *GetUint64VTable(void) {
static Uint64VTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = Uint64_len_impl;
s_vtable.get = Uint64_get_impl;
return &s_vtable;
}
uint32_t Uint64_len_impl(Uint64Type *this) { return 8; }
uint8_t Uint64_get_impl(Uint64Type *this, uint32_t index, bool *existing) {
uint8_t ret = {0};
mol2_cursor_res_t res = mol2_slice_by_offset2(&this->cur, 1 * index, 1);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_Uint8(&res.cur);
return ret;
}
struct Uint128Type make_Uint128(mol2_cursor_t *cur) {
Uint128Type ret;
ret.cur = *cur;
ret.t = GetUint128VTable();
return ret;
}
struct Uint128VTable *GetUint128VTable(void) {
static Uint128VTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = Uint128_len_impl;
s_vtable.get = Uint128_get_impl;
return &s_vtable;
}
uint32_t Uint128_len_impl(Uint128Type *this) { return 16; }
uint8_t Uint128_get_impl(Uint128Type *this, uint32_t index, bool *existing) {
uint8_t ret = {0};
mol2_cursor_res_t res = mol2_slice_by_offset2(&this->cur, 1 * index, 1);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_Uint8(&res.cur);
return ret;
}
struct Byte32Type make_Byte32(mol2_cursor_t *cur) {
Byte32Type ret;
ret.cur = *cur;
ret.t = GetByte32VTable();
return ret;
}
struct Byte32VTable *GetByte32VTable(void) {
static Byte32VTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = Byte32_len_impl;
s_vtable.get = Byte32_get_impl;
return &s_vtable;
}
uint32_t Byte32_len_impl(Byte32Type *this) { return 32; }
uint8_t Byte32_get_impl(Byte32Type *this, uint32_t index, bool *existing) {
uint8_t ret = {0};
mol2_cursor_res_t res = mol2_slice_by_offset2(&this->cur, 1 * index, 1);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_Uint8(&res.cur);
return ret;
}
struct Uint256Type make_Uint256(mol2_cursor_t *cur) {
Uint256Type ret;
ret.cur = *cur;
ret.t = GetUint256VTable();
return ret;
}
struct Uint256VTable *GetUint256VTable(void) {
static Uint256VTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = Uint256_len_impl;
s_vtable.get = Uint256_get_impl;
return &s_vtable;
}
uint32_t Uint256_len_impl(Uint256Type *this) { return 32; }
uint8_t Uint256_get_impl(Uint256Type *this, uint32_t index, bool *existing) {
uint8_t ret = {0};
mol2_cursor_res_t res = mol2_slice_by_offset2(&this->cur, 1 * index, 1);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_Uint8(&res.cur);
return ret;
}
struct BytesType make_Bytes(mol2_cursor_t *cur) {
BytesType ret;
ret.cur = *cur;
ret.t = GetBytesVTable();
return ret;
}
struct BytesVTable *GetBytesVTable(void) {
static BytesVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = Bytes_len_impl;
s_vtable.get = Bytes_get_impl;
return &s_vtable;
}
uint32_t Bytes_len_impl(BytesType *this) {
return mol2_fixvec_length(&this->cur);
}
uint8_t Bytes_get_impl(BytesType *this, uint32_t index, bool *existing) {
uint8_t ret = {0};
mol2_cursor_res_t res = mol2_fixvec_slice_by_index(&this->cur, 1, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_Uint8(&res.cur);
return ret;
}
struct BytesOptType make_BytesOpt(mol2_cursor_t *cur) {
BytesOptType ret;
ret.cur = *cur;
ret.t = GetBytesOptVTable();
return ret;
}
struct BytesOptVTable *GetBytesOptVTable(void) {
static BytesOptVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.is_none = BytesOpt_is_none_impl;
s_vtable.is_some = BytesOpt_is_some_impl;
s_vtable.unwrap = BytesOpt_unwrap_impl;
return &s_vtable;
}
bool BytesOpt_is_none_impl(BytesOptType *this) {
return mol2_option_is_none(&this->cur);
}
bool BytesOpt_is_some_impl(BytesOptType *this) {
return !mol2_option_is_none(&this->cur);
}
mol2_cursor_t BytesOpt_unwrap_impl(BytesOptType *this) {
mol2_cursor_t ret;
ret = convert_to_rawbytes(&this->cur);
return ret;
}
struct BytesVecType make_BytesVec(mol2_cursor_t *cur) {
BytesVecType ret;
ret.cur = *cur;
ret.t = GetBytesVecVTable();
return ret;
}
struct BytesVecVTable *GetBytesVecVTable(void) {
static BytesVecVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = BytesVec_len_impl;
s_vtable.get = BytesVec_get_impl;
return &s_vtable;
}
uint32_t BytesVec_len_impl(BytesVecType *this) {
return mol2_dynvec_length(&this->cur);
}
mol2_cursor_t BytesVec_get_impl(BytesVecType *this, uint32_t index,
bool *existing) {
mol2_cursor_t ret = {0};
mol2_cursor_res_t res = mol2_dynvec_slice_by_index(&this->cur, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
return convert_to_rawbytes(&res.cur);
}
struct Byte32VecType make_Byte32Vec(mol2_cursor_t *cur) {
Byte32VecType ret;
ret.cur = *cur;
ret.t = GetByte32VecVTable();
return ret;
}
struct Byte32VecVTable *GetByte32VecVTable(void) {
static Byte32VecVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = Byte32Vec_len_impl;
s_vtable.get = Byte32Vec_get_impl;
return &s_vtable;
}
uint32_t Byte32Vec_len_impl(Byte32VecType *this) {
return mol2_fixvec_length(&this->cur);
}
mol2_cursor_t Byte32Vec_get_impl(Byte32VecType *this, uint32_t index,
bool *existing) {
mol2_cursor_t ret = {0};
mol2_cursor_res_t res = mol2_fixvec_slice_by_index(&this->cur, 32, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_array(&res.cur);
return ret;
}
struct ScriptOptType make_ScriptOpt(mol2_cursor_t *cur) {
ScriptOptType ret;
ret.cur = *cur;
ret.t = GetScriptOptVTable();
return ret;
}
struct ScriptOptVTable *GetScriptOptVTable(void) {
static ScriptOptVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.is_none = ScriptOpt_is_none_impl;
s_vtable.is_some = ScriptOpt_is_some_impl;
s_vtable.unwrap = ScriptOpt_unwrap_impl;
return &s_vtable;
}
bool ScriptOpt_is_none_impl(ScriptOptType *this) {
return mol2_option_is_none(&this->cur);
}
bool ScriptOpt_is_some_impl(ScriptOptType *this) {
return !mol2_option_is_none(&this->cur);
}
ScriptType ScriptOpt_unwrap_impl(ScriptOptType *this) {
ScriptType ret;
mol2_cursor_t cur = this->cur;
ret.cur = cur;
ret.t = GetScriptVTable();
return ret;
}
struct ProposalShortIdType make_ProposalShortId(mol2_cursor_t *cur) {
ProposalShortIdType ret;
ret.cur = *cur;
ret.t = GetProposalShortIdVTable();
return ret;
}
struct ProposalShortIdVTable *GetProposalShortIdVTable(void) {
static ProposalShortIdVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = ProposalShortId_len_impl;
s_vtable.get = ProposalShortId_get_impl;
return &s_vtable;
}
uint32_t ProposalShortId_len_impl(ProposalShortIdType *this) { return 10; }
uint8_t ProposalShortId_get_impl(ProposalShortIdType *this, uint32_t index,
bool *existing) {
uint8_t ret = {0};
mol2_cursor_res_t res = mol2_slice_by_offset2(&this->cur, 1 * index, 1);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_Uint8(&res.cur);
return ret;
}
struct UncleBlockVecType make_UncleBlockVec(mol2_cursor_t *cur) {
UncleBlockVecType ret;
ret.cur = *cur;
ret.t = GetUncleBlockVecVTable();
return ret;
}
struct UncleBlockVecVTable *GetUncleBlockVecVTable(void) {
static UncleBlockVecVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = UncleBlockVec_len_impl;
s_vtable.get = UncleBlockVec_get_impl;
return &s_vtable;
}
uint32_t UncleBlockVec_len_impl(UncleBlockVecType *this) {
return mol2_dynvec_length(&this->cur);
}
UncleBlockType UncleBlockVec_get_impl(UncleBlockVecType *this, uint32_t index,
bool *existing) {
UncleBlockType ret = {0};
mol2_cursor_res_t res = mol2_dynvec_slice_by_index(&this->cur, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret.cur = res.cur;
ret.t = GetUncleBlockVTable();
return ret;
}
struct TransactionVecType make_TransactionVec(mol2_cursor_t *cur) {
TransactionVecType ret;
ret.cur = *cur;
ret.t = GetTransactionVecVTable();
return ret;
}
struct TransactionVecVTable *GetTransactionVecVTable(void) {
static TransactionVecVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = TransactionVec_len_impl;
s_vtable.get = TransactionVec_get_impl;
return &s_vtable;
}
uint32_t TransactionVec_len_impl(TransactionVecType *this) {
return mol2_dynvec_length(&this->cur);
}
TransactionType TransactionVec_get_impl(TransactionVecType *this,
uint32_t index, bool *existing) {
TransactionType ret = {0};
mol2_cursor_res_t res = mol2_dynvec_slice_by_index(&this->cur, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret.cur = res.cur;
ret.t = GetTransactionVTable();
return ret;
}
struct ProposalShortIdVecType make_ProposalShortIdVec(mol2_cursor_t *cur) {
ProposalShortIdVecType ret;
ret.cur = *cur;
ret.t = GetProposalShortIdVecVTable();
return ret;
}
struct ProposalShortIdVecVTable *GetProposalShortIdVecVTable(void) {
static ProposalShortIdVecVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = ProposalShortIdVec_len_impl;
s_vtable.get = ProposalShortIdVec_get_impl;
return &s_vtable;
}
uint32_t ProposalShortIdVec_len_impl(ProposalShortIdVecType *this) {
return mol2_fixvec_length(&this->cur);
}
mol2_cursor_t ProposalShortIdVec_get_impl(ProposalShortIdVecType *this,
uint32_t index, bool *existing) {
mol2_cursor_t ret = {0};
mol2_cursor_res_t res = mol2_fixvec_slice_by_index(&this->cur, 10, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret = convert_to_array(&res.cur);
return ret;
}
struct CellDepVecType make_CellDepVec(mol2_cursor_t *cur) {
CellDepVecType ret;
ret.cur = *cur;
ret.t = GetCellDepVecVTable();
return ret;
}
struct CellDepVecVTable *GetCellDepVecVTable(void) {
static CellDepVecVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = CellDepVec_len_impl;
s_vtable.get = CellDepVec_get_impl;
return &s_vtable;
}
uint32_t CellDepVec_len_impl(CellDepVecType *this) {
return mol2_fixvec_length(&this->cur);
}
CellDepType CellDepVec_get_impl(CellDepVecType *this, uint32_t index,
bool *existing) {
CellDepType ret = {0};
mol2_cursor_res_t res = mol2_fixvec_slice_by_index(&this->cur, 37, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret.cur = res.cur;
ret.t = GetCellDepVTable();
return ret;
}
struct CellInputVecType make_CellInputVec(mol2_cursor_t *cur) {
CellInputVecType ret;
ret.cur = *cur;
ret.t = GetCellInputVecVTable();
return ret;
}
struct CellInputVecVTable *GetCellInputVecVTable(void) {
static CellInputVecVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = CellInputVec_len_impl;
s_vtable.get = CellInputVec_get_impl;
return &s_vtable;
}
uint32_t CellInputVec_len_impl(CellInputVecType *this) {
return mol2_fixvec_length(&this->cur);
}
CellInputType CellInputVec_get_impl(CellInputVecType *this, uint32_t index,
bool *existing) {
CellInputType ret = {0};
mol2_cursor_res_t res = mol2_fixvec_slice_by_index(&this->cur, 44, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret.cur = res.cur;
ret.t = GetCellInputVTable();
return ret;
}
struct CellOutputVecType make_CellOutputVec(mol2_cursor_t *cur) {
CellOutputVecType ret;
ret.cur = *cur;
ret.t = GetCellOutputVecVTable();
return ret;
}
struct CellOutputVecVTable *GetCellOutputVecVTable(void) {
static CellOutputVecVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.len = CellOutputVec_len_impl;
s_vtable.get = CellOutputVec_get_impl;
return &s_vtable;
}
uint32_t CellOutputVec_len_impl(CellOutputVecType *this) {
return mol2_dynvec_length(&this->cur);
}
CellOutputType CellOutputVec_get_impl(CellOutputVecType *this, uint32_t index,
bool *existing) {
CellOutputType ret = {0};
mol2_cursor_res_t res = mol2_dynvec_slice_by_index(&this->cur, index);
if (res.errno != MOL2_OK) {
*existing = false;
return ret;
} else {
*existing = true;
}
ret.cur = res.cur;
ret.t = GetCellOutputVTable();
return ret;
}
struct ScriptType make_Script(mol2_cursor_t *cur) {
ScriptType ret;
ret.cur = *cur;
ret.t = GetScriptVTable();
return ret;
}
struct ScriptVTable *GetScriptVTable(void) {
static ScriptVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.code_hash = Script_get_code_hash_impl;
s_vtable.hash_type = Script_get_hash_type_impl;
s_vtable.args = Script_get_args_impl;
return &s_vtable;
}
mol2_cursor_t Script_get_code_hash_impl(ScriptType *this) {
mol2_cursor_t ret;
mol2_cursor_t ret2 = mol2_table_slice_by_index(&this->cur, 0);
ret = convert_to_array(&ret2);
return ret;
}
uint8_t Script_get_hash_type_impl(ScriptType *this) {
uint8_t ret;
mol2_cursor_t ret2 = mol2_table_slice_by_index(&this->cur, 1);
ret = convert_to_Uint8(&ret2);
return ret;
}
mol2_cursor_t Script_get_args_impl(ScriptType *this) {
mol2_cursor_t ret;
mol2_cursor_t re2 = mol2_table_slice_by_index(&this->cur, 2);
ret = convert_to_rawbytes(&re2);
return ret;
}
struct OutPointType make_OutPoint(mol2_cursor_t *cur) {
OutPointType ret;
ret.cur = *cur;
ret.t = GetOutPointVTable();
return ret;
}
struct OutPointVTable *GetOutPointVTable(void) {
static OutPointVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.tx_hash = OutPoint_get_tx_hash_impl;
s_vtable.index = OutPoint_get_index_impl;
return &s_vtable;
}
mol2_cursor_t OutPoint_get_tx_hash_impl(OutPointType *this) {
mol2_cursor_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 0, 32);
ret = convert_to_array(&ret2);
return ret;
}
uint32_t OutPoint_get_index_impl(OutPointType *this) {
uint32_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 32, 4);
ret = convert_to_Uint32(&ret2);
return ret;
}
struct CellInputType make_CellInput(mol2_cursor_t *cur) {
CellInputType ret;
ret.cur = *cur;
ret.t = GetCellInputVTable();
return ret;
}
struct CellInputVTable *GetCellInputVTable(void) {
static CellInputVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.since = CellInput_get_since_impl;
s_vtable.previous_output = CellInput_get_previous_output_impl;
return &s_vtable;
}
uint64_t CellInput_get_since_impl(CellInputType *this) {
uint64_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 0, 8);
ret = convert_to_Uint64(&ret2);
return ret;
}
OutPointType CellInput_get_previous_output_impl(CellInputType *this) {
OutPointType ret;
mol2_cursor_t cur = mol2_slice_by_offset(&this->cur, 8, 36);
ret.cur = cur;
ret.t = GetOutPointVTable();
return ret;
}
struct CellOutputType make_CellOutput(mol2_cursor_t *cur) {
CellOutputType ret;
ret.cur = *cur;
ret.t = GetCellOutputVTable();
return ret;
}
struct CellOutputVTable *GetCellOutputVTable(void) {
static CellOutputVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.capacity = CellOutput_get_capacity_impl;
s_vtable.lock = CellOutput_get_lock_impl;
s_vtable.type_ = CellOutput_get_type__impl;
return &s_vtable;
}
uint64_t CellOutput_get_capacity_impl(CellOutputType *this) {
uint64_t ret;
mol2_cursor_t ret2 = mol2_table_slice_by_index(&this->cur, 0);
ret = convert_to_Uint64(&ret2);
return ret;
}
ScriptType CellOutput_get_lock_impl(CellOutputType *this) {
ScriptType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 1);
ret.cur = cur;
ret.t = GetScriptVTable();
return ret;
}
ScriptOptType CellOutput_get_type__impl(CellOutputType *this) {
ScriptOptType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 2);
ret.cur = cur;
ret.t = GetScriptOptVTable();
return ret;
}
struct CellDepType make_CellDep(mol2_cursor_t *cur) {
CellDepType ret;
ret.cur = *cur;
ret.t = GetCellDepVTable();
return ret;
}
struct CellDepVTable *GetCellDepVTable(void) {
static CellDepVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.out_point = CellDep_get_out_point_impl;
s_vtable.dep_type = CellDep_get_dep_type_impl;
return &s_vtable;
}
OutPointType CellDep_get_out_point_impl(CellDepType *this) {
OutPointType ret;
mol2_cursor_t cur = mol2_slice_by_offset(&this->cur, 0, 36);
ret.cur = cur;
ret.t = GetOutPointVTable();
return ret;
}
uint8_t CellDep_get_dep_type_impl(CellDepType *this) {
uint8_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 36, 1);
ret = convert_to_Uint8(&ret2);
return ret;
}
struct RawTransactionType make_RawTransaction(mol2_cursor_t *cur) {
RawTransactionType ret;
ret.cur = *cur;
ret.t = GetRawTransactionVTable();
return ret;
}
struct RawTransactionVTable *GetRawTransactionVTable(void) {
static RawTransactionVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.version = RawTransaction_get_version_impl;
s_vtable.cell_deps = RawTransaction_get_cell_deps_impl;
s_vtable.header_deps = RawTransaction_get_header_deps_impl;
s_vtable.inputs = RawTransaction_get_inputs_impl;
s_vtable.outputs = RawTransaction_get_outputs_impl;
s_vtable.outputs_data = RawTransaction_get_outputs_data_impl;
return &s_vtable;
}
uint32_t RawTransaction_get_version_impl(RawTransactionType *this) {
uint32_t ret;
mol2_cursor_t ret2 = mol2_table_slice_by_index(&this->cur, 0);
ret = convert_to_Uint32(&ret2);
return ret;
}
CellDepVecType RawTransaction_get_cell_deps_impl(RawTransactionType *this) {
CellDepVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 1);
ret.cur = cur;
ret.t = GetCellDepVecVTable();
return ret;
}
Byte32VecType RawTransaction_get_header_deps_impl(RawTransactionType *this) {
Byte32VecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 2);
ret.cur = cur;
ret.t = GetByte32VecVTable();
return ret;
}
CellInputVecType RawTransaction_get_inputs_impl(RawTransactionType *this) {
CellInputVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 3);
ret.cur = cur;
ret.t = GetCellInputVecVTable();
return ret;
}
CellOutputVecType RawTransaction_get_outputs_impl(RawTransactionType *this) {
CellOutputVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 4);
ret.cur = cur;
ret.t = GetCellOutputVecVTable();
return ret;
}
BytesVecType RawTransaction_get_outputs_data_impl(RawTransactionType *this) {
BytesVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 5);
ret.cur = cur;
ret.t = GetBytesVecVTable();
return ret;
}
struct TransactionType make_Transaction(mol2_cursor_t *cur) {
TransactionType ret;
ret.cur = *cur;
ret.t = GetTransactionVTable();
return ret;
}
struct TransactionVTable *GetTransactionVTable(void) {
static TransactionVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.raw = Transaction_get_raw_impl;
s_vtable.witnesses = Transaction_get_witnesses_impl;
return &s_vtable;
}
RawTransactionType Transaction_get_raw_impl(TransactionType *this) {
RawTransactionType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 0);
ret.cur = cur;
ret.t = GetRawTransactionVTable();
return ret;
}
BytesVecType Transaction_get_witnesses_impl(TransactionType *this) {
BytesVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 1);
ret.cur = cur;
ret.t = GetBytesVecVTable();
return ret;
}
struct RawHeaderType make_RawHeader(mol2_cursor_t *cur) {
RawHeaderType ret;
ret.cur = *cur;
ret.t = GetRawHeaderVTable();
return ret;
}
struct RawHeaderVTable *GetRawHeaderVTable(void) {
static RawHeaderVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.version = RawHeader_get_version_impl;
s_vtable.compact_target = RawHeader_get_compact_target_impl;
s_vtable.timestamp = RawHeader_get_timestamp_impl;
s_vtable.number = RawHeader_get_number_impl;
s_vtable.epoch = RawHeader_get_epoch_impl;
s_vtable.parent_hash = RawHeader_get_parent_hash_impl;
s_vtable.transactions_root = RawHeader_get_transactions_root_impl;
s_vtable.proposals_hash = RawHeader_get_proposals_hash_impl;
s_vtable.uncles_hash = RawHeader_get_uncles_hash_impl;
s_vtable.dao = RawHeader_get_dao_impl;
return &s_vtable;
}
uint32_t RawHeader_get_version_impl(RawHeaderType *this) {
uint32_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 0, 4);
ret = convert_to_Uint32(&ret2);
return ret;
}
uint32_t RawHeader_get_compact_target_impl(RawHeaderType *this) {
uint32_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 4, 4);
ret = convert_to_Uint32(&ret2);
return ret;
}
uint64_t RawHeader_get_timestamp_impl(RawHeaderType *this) {
uint64_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 8, 8);
ret = convert_to_Uint64(&ret2);
return ret;
}
uint64_t RawHeader_get_number_impl(RawHeaderType *this) {
uint64_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 16, 8);
ret = convert_to_Uint64(&ret2);
return ret;
}
uint64_t RawHeader_get_epoch_impl(RawHeaderType *this) {
uint64_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 24, 8);
ret = convert_to_Uint64(&ret2);
return ret;
}
mol2_cursor_t RawHeader_get_parent_hash_impl(RawHeaderType *this) {
mol2_cursor_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 32, 32);
ret = convert_to_array(&ret2);
return ret;
}
mol2_cursor_t RawHeader_get_transactions_root_impl(RawHeaderType *this) {
mol2_cursor_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 64, 32);
ret = convert_to_array(&ret2);
return ret;
}
mol2_cursor_t RawHeader_get_proposals_hash_impl(RawHeaderType *this) {
mol2_cursor_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 96, 32);
ret = convert_to_array(&ret2);
return ret;
}
mol2_cursor_t RawHeader_get_uncles_hash_impl(RawHeaderType *this) {
mol2_cursor_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 128, 32);
ret = convert_to_array(&ret2);
return ret;
}
mol2_cursor_t RawHeader_get_dao_impl(RawHeaderType *this) {
mol2_cursor_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 160, 32);
ret = convert_to_array(&ret2);
return ret;
}
struct HeaderType make_Header(mol2_cursor_t *cur) {
HeaderType ret;
ret.cur = *cur;
ret.t = GetHeaderVTable();
return ret;
}
struct HeaderVTable *GetHeaderVTable(void) {
static HeaderVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.raw = Header_get_raw_impl;
s_vtable.nonce = Header_get_nonce_impl;
return &s_vtable;
}
RawHeaderType Header_get_raw_impl(HeaderType *this) {
RawHeaderType ret;
mol2_cursor_t cur = mol2_slice_by_offset(&this->cur, 0, 192);
ret.cur = cur;
ret.t = GetRawHeaderVTable();
return ret;
}
mol2_cursor_t Header_get_nonce_impl(HeaderType *this) {
mol2_cursor_t ret;
mol2_cursor_t ret2 = mol2_slice_by_offset(&this->cur, 192, 16);
ret = convert_to_array(&ret2);
return ret;
}
struct UncleBlockType make_UncleBlock(mol2_cursor_t *cur) {
UncleBlockType ret;
ret.cur = *cur;
ret.t = GetUncleBlockVTable();
return ret;
}
struct UncleBlockVTable *GetUncleBlockVTable(void) {
static UncleBlockVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.header = UncleBlock_get_header_impl;
s_vtable.proposals = UncleBlock_get_proposals_impl;
return &s_vtable;
}
HeaderType UncleBlock_get_header_impl(UncleBlockType *this) {
HeaderType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 0);
ret.cur = cur;
ret.t = GetHeaderVTable();
return ret;
}
ProposalShortIdVecType UncleBlock_get_proposals_impl(UncleBlockType *this) {
ProposalShortIdVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 1);
ret.cur = cur;
ret.t = GetProposalShortIdVecVTable();
return ret;
}
struct BlockType make_Block(mol2_cursor_t *cur) {
BlockType ret;
ret.cur = *cur;
ret.t = GetBlockVTable();
return ret;
}
struct BlockVTable *GetBlockVTable(void) {
static BlockVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.header = Block_get_header_impl;
s_vtable.uncles = Block_get_uncles_impl;
s_vtable.transactions = Block_get_transactions_impl;
s_vtable.proposals = Block_get_proposals_impl;
return &s_vtable;
}
HeaderType Block_get_header_impl(BlockType *this) {
HeaderType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 0);
ret.cur = cur;
ret.t = GetHeaderVTable();
return ret;
}
UncleBlockVecType Block_get_uncles_impl(BlockType *this) {
UncleBlockVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 1);
ret.cur = cur;
ret.t = GetUncleBlockVecVTable();
return ret;
}
TransactionVecType Block_get_transactions_impl(BlockType *this) {
TransactionVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 2);
ret.cur = cur;
ret.t = GetTransactionVecVTable();
return ret;
}
ProposalShortIdVecType Block_get_proposals_impl(BlockType *this) {
ProposalShortIdVecType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 3);
ret.cur = cur;
ret.t = GetProposalShortIdVecVTable();
return ret;
}
struct CellbaseWitnessType make_CellbaseWitness(mol2_cursor_t *cur) {
CellbaseWitnessType ret;
ret.cur = *cur;
ret.t = GetCellbaseWitnessVTable();
return ret;
}
struct CellbaseWitnessVTable *GetCellbaseWitnessVTable(void) {
static CellbaseWitnessVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.lock = CellbaseWitness_get_lock_impl;
s_vtable.message = CellbaseWitness_get_message_impl;
return &s_vtable;
}
ScriptType CellbaseWitness_get_lock_impl(CellbaseWitnessType *this) {
ScriptType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 0);
ret.cur = cur;
ret.t = GetScriptVTable();
return ret;
}
mol2_cursor_t CellbaseWitness_get_message_impl(CellbaseWitnessType *this) {
mol2_cursor_t ret;
mol2_cursor_t re2 = mol2_table_slice_by_index(&this->cur, 1);
ret = convert_to_rawbytes(&re2);
return ret;
}
struct WitnessArgsType make_WitnessArgs(mol2_cursor_t *cur) {
WitnessArgsType ret;
ret.cur = *cur;
ret.t = GetWitnessArgsVTable();
return ret;
}
struct WitnessArgsVTable *GetWitnessArgsVTable(void) {
static WitnessArgsVTable s_vtable;
static int inited = 0;
if (inited) return &s_vtable;
s_vtable.lock = WitnessArgs_get_lock_impl;
s_vtable.input_type = WitnessArgs_get_input_type_impl;
s_vtable.output_type = WitnessArgs_get_output_type_impl;
return &s_vtable;
}
BytesOptType WitnessArgs_get_lock_impl(WitnessArgsType *this) {
BytesOptType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 0);
ret.cur = cur;
ret.t = GetBytesOptVTable();
return ret;
}
BytesOptType WitnessArgs_get_input_type_impl(WitnessArgsType *this) {
BytesOptType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 1);
ret.cur = cur;
ret.t = GetBytesOptVTable();
return ret;
}
BytesOptType WitnessArgs_get_output_type_impl(WitnessArgsType *this) {
BytesOptType ret;
mol2_cursor_t cur = mol2_table_slice_by_index(&this->cur, 2);
ret.cur = cur;
ret.t = GetBytesOptVTable();
return ret;
}
#endif
#ifdef __cplusplus
}
#endif
#endif