@geeqdev/geeq-sdk 0.1.0 → 0.2.0

package/src/wasm/nodejs/geeq_core.d.ts

@@ -0,0 +1,753 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * `LogLevel` definition and methods can be found in this module
+ */
+export function configureErrorHandling(level: LogLevel): void;
+export function generateInitialCsvCapnp(genesis_block_buf: Uint8Array): ChainStateView;
+export function generateCsvCapnp(alb_buf: Uint8Array, vlb_buf: Uint8Array, all_buf: Uint8Array, vll_buf: Uint8Array, fork_data_buf: Uint8Array): ChainStateView;
+export function generateInitialCsvProto(genesis_block_buf: Uint8Array): ChainStateView;
+export function generateCsvProto(alb_buf: Uint8Array, vlb_buf: Uint8Array, all_buf: Uint8Array, vll_buf: Uint8Array, fork_data_buf: Uint8Array): ChainStateView;
+/**
+ * Returns key derivation path based on the logical hierarchy for deterministic wallets
+ * defined in Geeq `Wallet Address Proposal` specification. Returns error if `record_type`
+ * is `None`
+ *
+ * Note: this function may be not much of use because other functions exist for keypair
+ * derivation, which are specifically based on logical hierarchy defined for Geeq wallets.
+ */
+export function derivationPathGeeq(record_type: RecordType, coin_type: CoinType, account: number, address_index: number): Uint32Array;
+/**
+ * Generates a random 32-byte value to be used as an identifying number for proxy accounts.
+ *
+ * Proxy account default IRN is deterministically derived according to Geeq `Wallet Address
+ * Proposal` specification from public key that was used to create the record.
+ *
+ * ## Arguments
+ *
+ * `record_type` - enumeration defined in this library
+ * `pub_key` - 32-byte ed25519 key
+ * `mint_index` - sequential number tracked by wallet
+ */
+export function generateIrn(record_type: IrnRecordType, pub_key: Uint8Array, mint_index: number): Uint8Array;
+/**
+ * Parses a BIP-0039 mnemonic, detects the language from the enabled languages and converts to seed
+ * bytes. Supported number of words are 12, 15, 18, 21, and 24.
+ *
+ * ## Arguments
+ *
+ * `mnemonic` - string representing a wordlist
+ * `passphrase` - normalized UTF-8 passphrase or an empty string
+ */
+export function mnemonicToSeed(mnemonic: string, passphrase: string): Uint8Array;
+/**
+ * Generates a 2-byte value to sync full addresses across wallets that use the same seed phrase.
+ *
+ * Seed ID is derived from the public key with derivation path m/0’/0’/0’/0’/0’ according to Geeq
+ * `Wallet Address Proposal` specification.
+ *
+ * ## Arguments
+ *
+ * `seed` - BIP-0039 output
+ */
+export function generateSeedId(seed: Uint8Array): Uint8Array;
+export function verify(public_key: Uint8Array, signature: Uint8Array, data: Uint8Array): boolean;
+/**
+ * Available values for level 2 of keypair derivation path defined in Geeq `Wallet Address
+ * Proposal` specification. The intention is to conform with SLIP-0044 specification.
+ */
+export enum CoinType {
+  Testnet = 1,
+  Mainnet = 1019,
+}
+/**
+ * A subset of `RecordType` enum defined here.
+ */
+export enum IrnRecordType {
+  ProxyNftMint = 12,
+  ProxyFunding = 13,
+  ProxyMultisig = 14,
+  ProxyDce = 15,
+  ProxyTokenMint = 16,
+}
+/**
+ * The list of record types defined in Geeq `Wallet Address Proposal` specification.
+ * "None" is not a valid value.
+ */
+export enum RecordType {
+  None = 0,
+  AppCounterparty = 1,
+  AppDce = 2,
+  AppNft = 3,
+  AppStackable = 4,
+  CoinAsset = 5,
+  CoinHl = 6,
+  CoinMicro = 7,
+  GtNwa = 8,
+  ParamBoolean = 9,
+  ParamCount2 = 10,
+  ParamCount8 = 11,
+  ProxyNftMint = 12,
+  ProxyFunding = 13,
+  ProxyMultisig = 14,
+  ProxyDce = 15,
+  ProxyTokenMint = 16,
+  Sys = 17,
+}
+export class AlbMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class AllMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getThreeLb(): Uint8Array;
+  getThreeRb(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class AppLayBlock {
+  private constructor();
+  free(): void;
+  merkleTree(): AlbMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): AppLayBlock;
+  static fromAppLayBlockProto(bytes: Uint8Array): AppLayBlock;
+  static fromAppLayBlockCapnp(bytes: Uint8Array): AppLayBlock;
+}
+export class AppLayLedger {
+  private constructor();
+  free(): void;
+  merkleTree(): AllMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): AppLayLedger;
+  static fromAppLayLedgerProto(bytes: Uint8Array): AppLayLedger;
+  static fromAppLayLedgerCapnp(bytes: Uint8Array): AppLayLedger;
+}
+export class AppLayRec {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): AppLayRec;
+  static fromAppLayRecProto(bytes: Uint8Array): AppLayRec;
+  static fromAppLayRecCapnp(bytes: Uint8Array): AppLayRec;
+}
+export class AttestationSubgroup {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): AttestationSubgroup;
+  static fromAttestationSubgroupProto(bytes: Uint8Array): AttestationSubgroup;
+  static fromAttestationSubgroupCapnp(bytes: Uint8Array): AttestationSubgroup;
+}
+export class AttestationSubgroupData {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): AttestationSubgroupData;
+  static fromAttestationSubgroupDataProto(bytes: Uint8Array): AttestationSubgroupData;
+  static fromAttestationSubgroupProto(bytes: Uint8Array): AttestationSubgroupData;
+  static fromAttestationSubgroupCapnp(bytes: Uint8Array): AttestationSubgroupData;
+  static fromAttestationSubgroupDataCapnp(bytes: Uint8Array): AttestationSubgroupData;
+}
+export class AuditAdminNetTx {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): AuditAdminNetTx;
+  static fromAuditAdminNetTxProto(bytes: Uint8Array): AuditAdminNetTx;
+  static fromAuditAdminNetTxCapnp(bytes: Uint8Array): AuditAdminNetTx;
+}
+export class ChainStateView {
+  private constructor();
+  free(): void;
+  merkleTree(): CsvMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): ChainStateView;
+  static fromChainStateViewProto(bytes: Uint8Array): ChainStateView;
+  static fromChainStateViewCapnp(bytes: Uint8Array): ChainStateView;
+  getMerkleRootAlb(): Uint8Array;
+  getMerkleRootVlb(): Uint8Array;
+  getMerkleRootAll(): Uint8Array;
+  getMerkleRootVll(): Uint8Array;
+  getMerkleRootRcs(): Uint8Array;
+  getForkData(): Uint8Array;
+}
+export class CoinAcctRec {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): CoinAcctRec;
+  static fromCoinAcctRecProto(bytes: Uint8Array): CoinAcctRec;
+  static fromCoinAcctRecCapnp(bytes: Uint8Array): CoinAcctRec;
+}
+export class CsvMerkleTree {
+  private constructor();
+  free(): void;
+  getTwoLa(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getThreeLb(): Uint8Array;
+  getThreeRb(): Uint8Array;
+  getThreeLc(): Uint8Array;
+  getThreeRc(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getTwoLb(): Uint8Array;
+  getTwoRb(): Uint8Array;
+  getOneLa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class FeeDistAdminNetTx {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): FeeDistAdminNetTx;
+  static fromFeeDistAdminNetTxProto(bytes: Uint8Array): FeeDistAdminNetTx;
+  static fromFeeDistAdminNetTxCapnp(bytes: Uint8Array): FeeDistAdminNetTx;
+}
+export class GenesisBlock {
+  private constructor();
+  free(): void;
+  merkleTree(): GenesisBlockMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): GenesisBlock;
+  static fromGenesisBlockProto(bytes: Uint8Array): GenesisBlock;
+  static fromGenesisBlockCapnp(bytes: Uint8Array): GenesisBlock;
+}
+export class GenesisBlockData {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): GenesisBlockData;
+  static fromGenesisBlockDataProto(bytes: Uint8Array): GenesisBlockData;
+  static fromGenesisBlockProto(bytes: Uint8Array): GenesisBlockData;
+  static fromGenesisBlockDataCapnp(bytes: Uint8Array): GenesisBlockData;
+  static fromGenesisBlockCapnp(bytes: Uint8Array): GenesisBlockData;
+  chain_num: number;
+}
+export class GenesisBlockMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getFourLa(): Uint8Array;
+  getFourRa(): Uint8Array;
+  getFourLb(): Uint8Array;
+  getFourRb(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class HcsMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getFourLa(): Uint8Array;
+  getFourRa(): Uint8Array;
+  getFourLb(): Uint8Array;
+  getFourRb(): Uint8Array;
+  getThreeLb(): Uint8Array;
+  getThreeRb(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class HubContentStmt {
+  private constructor();
+  free(): void;
+  merkleTree(): HcsMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): HubContentStmt;
+  static fromHubContentStmtProto(bytes: Uint8Array): HubContentStmt;
+  static fromHubContentStmtCapnp(bytes: Uint8Array): HubContentStmt;
+}
+export class HubContentStmtData {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): HubContentStmtData;
+  static fromHubContentStmtDataProto(bytes: Uint8Array): HubContentStmtData;
+  static fromHubContentStmtProto(bytes: Uint8Array): HubContentStmtData;
+  static fromHubContentStmtDataCapnp(bytes: Uint8Array): HubContentStmtData;
+  static fromHubContentStmtCapnp(bytes: Uint8Array): HubContentStmtData;
+  block_num: number;
+  chain_num: number;
+  node_num: number;
+}
+export class Keypair {
+  private constructor();
+  free(): void;
+  static import(public_key: Uint8Array, secret_key: Uint8Array): Keypair;
+  static fromSecretKey(secret_key: Uint8Array): Keypair;
+  static generate(): Keypair;
+  /**
+   * Generates an ed25519 keypair from binary seed according to SLIP-0010 derivation scheme.
+   *
+   * The same function as `fromMnemonic()` except that the seed is precalculated.
+   */
+  static fromSeed(seed: Uint8Array, path: Uint32Array): Keypair;
+  /**
+   * Generates an ed25519 keypair from mnemonic code according to SLIP-0010 derivation scheme.
+   *
+   * Parses the wordlist generated according to BIP-0039 and converts the result into a binary
+   * seed using an optional passphrase, which is then used to generate the keypair.
+   *
+   * Only hardened key generation from private parent key to private child key is supported.
+   *
+   * ## Arguments
+   *
+   * `mnemonic` - string representing a wordlist
+   * `passphrase` - normalized UTF-8 passphrase or an empty string
+   * `path` - arbitrary array of indices 0 through 2^31-1
+   *
+   * Note: values out of this range will be considered indices for a hardened child key.
+   * Note: the derivation path is not expected to be based on a specific logical hierarchy.
+   */
+  static fromMnemonic(mnemonic: string, path: Uint32Array, passphrase: string): Keypair;
+  /**
+   * Generates an ed25519 keypair from binary seed according to SLIP-0010 derivation scheme.
+   *
+   * The same function as `tryFromMnemonicGeeqPath()` except that the seed is precalculated.
+   */
+  static tryFromSeedGeeqPath(seed: Uint8Array, record_type: RecordType, coin_type: CoinType, account: number, address_index: number): Keypair;
+  /**
+   * Generates an ed25519 keypair from mnemonic code according to SLIP-0010 derivation scheme.
+   *
+   * Parses the wordlist generated according to BIP-0039 and converts the result into a binary
+   * seed using an optional passphrase, which is then used to generate the keypair.
+   *
+   * Derivation path is based on the logical hierarchy for deterministic wallets defined in Geeq
+   * `Wallet Address Proposal` specification.
+   *
+   * Only hardened key generation from private parent key to private child key is supported.
+   *
+   * ## Arguments
+   *
+   * `mnemonic` - string representing a wordlist
+   * `passphrase` - normalized UTF-8 passphrase or an empty string
+   * `record_type`, `coin_type` - enumerations defined in this library
+   * `account`, `address_index` - indices 0 through 2^31-1
+   *
+   * Note: values out of this range will be considered indices for a hardened child key.
+   * Note: returns error if `record_type` is `None`.
+   */
+  static tryFromMnemonicGeeqPath(mnemonic: string, passphrase: string, record_type: RecordType, coin_type: CoinType, account: number, address_index: number): Keypair;
+  /**
+   * Generates a random 32-byte value to be used as an identifying number for proxy accounts.
+   *
+   * The same function as `generateIrn()` except that this one does not throw an error.
+   */
+  irn(record_type: IrnRecordType, mint_index: number): Uint8Array;
+  exportPublicKey(): Uint8Array;
+  exportSecretKey(): Uint8Array;
+  sign(data: Uint8Array): Uint8Array;
+}
+export class LogLevel {
+  private constructor();
+  free(): void;
+  /**
+   * Allowed values for `level` - ['OFF', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE']
+   */
+  static fromString(level: string): LogLevel;
+}
+/**
+ * A struct that represents the MerkleProof
+ *
+ * ### Fields
+ *
+ * * `nodes` - List of merkle proof nodes
+ * * `hash` - The hash, the proof was generated for
+ */
+export class MerkleProof {
+  private constructor();
+  free(): void;
+  getNodes(): any[];
+}
+/**
+ * A struct that represents a MerkleProof node
+ *
+ * ### Fields
+ *
+ * * `is_left` - A boolean value which indicates whether the node should be
+ * hashed on the left or the right of the hash state
+ *
+ * * `value` - Merkle proof node value (32 byte hash)
+ */
+export class MerkleProofNode {
+  private constructor();
+  free(): void;
+  getValue(): Uint8Array;
+}
+export class NalMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class NcsMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getFourLa(): Uint8Array;
+  getFourRa(): Uint8Array;
+  getFourLb(): Uint8Array;
+  getFourRb(): Uint8Array;
+  getThreeLb(): Uint8Array;
+  getThreeRb(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class NetActorList {
+  private constructor();
+  free(): void;
+  merkleTree(): NalMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): NetActorList;
+  static fromNetActorListProto(bytes: Uint8Array): NetActorList;
+  static fromNetActorListCapnp(bytes: Uint8Array): NetActorList;
+}
+export class NetActorRec {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): NetActorRec;
+  static fromNetActorRecProto(bytes: Uint8Array): NetActorRec;
+  static fromNetActorRecCapnp(bytes: Uint8Array): NetActorRec;
+}
+export class NodeContentStmt {
+  private constructor();
+  free(): void;
+  merkleTree(): NcsMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): NodeContentStmt;
+  static fromNodeContentStmtProto(bytes: Uint8Array): NodeContentStmt;
+  static fromNodeContentStmtCapnp(bytes: Uint8Array): NodeContentStmt;
+}
+export class NodeContentStmtData {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): NodeContentStmtData;
+  static fromNodeContentStmtDataProto(bytes: Uint8Array): NodeContentStmtData;
+  static fromNodeContentStmtProto(bytes: Uint8Array): NodeContentStmtData;
+  static fromNodeContentStmtDataCapnp(bytes: Uint8Array): NodeContentStmtData;
+  static fromNodeContentStmtCapnp(bytes: Uint8Array): NodeContentStmtData;
+  block_num: number;
+  chain_num: number;
+  node_num: number;
+}
+export class NodePayloadList {
+  private constructor();
+  free(): void;
+  merkleTree(): NplMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): NodePayloadList;
+  static fromNodePayloadListProto(bytes: Uint8Array): NodePayloadList;
+  static fromNodePayloadListCapnp(bytes: Uint8Array): NodePayloadList;
+  block_num: number;
+  chain_num: number;
+  node_num: number;
+}
+export class NodeTxList {
+  private constructor();
+  free(): void;
+  merkleTree(): NtlMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): NodeTxList;
+  static fromNodeTxListProto(bytes: Uint8Array): NodeTxList;
+  static fromNodeTxListCapnp(bytes: Uint8Array): NodeTxList;
+  block_num: number;
+  chain_num: number;
+  node_num: number;
+}
+export class NplMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class NtlMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getThreeLb(): Uint8Array;
+  getThreeRb(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class PalMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class ParamAcctList {
+  private constructor();
+  free(): void;
+  merkleTree(): PalMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): ParamAcctList;
+  static fromParamAcctListProto(bytes: Uint8Array): ParamAcctList;
+  static fromParamAcctListCapnp(bytes: Uint8Array): ParamAcctList;
+}
+export class ParamAcctRec {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): ParamAcctRec;
+  static fromParamAcctRecProto(bytes: Uint8Array): ParamAcctRec;
+  static fromParamAcctRecCapnp(bytes: Uint8Array): ParamAcctRec;
+}
+export class Payload {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): Payload;
+  static fromPayloadProto(bytes: Uint8Array): Payload;
+  static fromPayloadCapnp(bytes: Uint8Array): Payload;
+}
+export class ProxyAcctRec {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): ProxyAcctRec;
+  static fromProxyAcctRecProto(bytes: Uint8Array): ProxyAcctRec;
+  static fromProxyAcctRecCapnp(bytes: Uint8Array): ProxyAcctRec;
+}
+export class RcsMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getFourLa(): Uint8Array;
+  getFourRa(): Uint8Array | undefined;
+  getFourLb(): Uint8Array;
+  getFourRb(): Uint8Array;
+  getThreeLb(): Uint8Array;
+  getThreeRb(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+export class RelayContentStmt {
+  private constructor();
+  free(): void;
+  merkleTree(): RcsMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): RelayContentStmt;
+  static fromRelayContentStmtProto(bytes: Uint8Array): RelayContentStmt;
+  static fromRelayContentStmtCapnp(bytes: Uint8Array): RelayContentStmt;
+}
+export class RelayContentStmtData {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): RelayContentStmtData;
+  static fromRelayContentStmtDataProto(bytes: Uint8Array): RelayContentStmtData;
+  static fromRelayContentStmtProto(bytes: Uint8Array): RelayContentStmtData;
+  static fromRelayContentStmtDataCapnp(bytes: Uint8Array): RelayContentStmtData;
+  static fromRelayContentStmtCapnp(bytes: Uint8Array): RelayContentStmtData;
+  block_num: number;
+  chain_num: number;
+  node_num: number;
+}
+export class RfdAdminNetTx {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): RfdAdminNetTx;
+  static fromRfdAdminNetTxProto(bytes: Uint8Array): RfdAdminNetTx;
+  static fromRfdAdminNetTxCapnp(bytes: Uint8Array): RfdAdminNetTx;
+}
+export class SysAcctRec {
+  private constructor();
+  free(): void;
+  static fromSysAcctRecProto(bytes: Uint8Array): SysAcctRec;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): SysAcctRec;
+  static fromSysAcctRecCapnp(bytes: Uint8Array): SysAcctRec;
+  nonce: number;
+}
+export class UserAppTx {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): UserAppTx;
+  static fromUserAppTxProto(bytes: Uint8Array): UserAppTx;
+  static fromUserAppTxCapnp(bytes: Uint8Array): UserAppTx;
+}
+export class UserAppTxData {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): UserAppTxData;
+  static fromUserAppTxDataProto(bytes: Uint8Array): UserAppTxData;
+  static fromUserAppTxProto(bytes: Uint8Array): UserAppTxData;
+  static fromUserAppTxDataCapnp(bytes: Uint8Array): UserAppTxData;
+  static fromUserAppTxCapnp(bytes: Uint8Array): UserAppTxData;
+}
+export class UserValTx {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): UserValTx;
+  static fromUserValTxProto(bytes: Uint8Array): UserValTx;
+  static fromUserValTxCapnp(bytes: Uint8Array): UserValTx;
+}
+export class UserValTxData {
+  private constructor();
+  free(): void;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): UserValTxData;
+  static fromUserValTxDataProto(bytes: Uint8Array): UserValTxData;
+  static fromUserValTxProto(bytes: Uint8Array): UserValTxData;
+  static fromUserValTxDataCapnp(bytes: Uint8Array): UserValTxData;
+  static fromUserValTxCapnp(bytes: Uint8Array): UserValTxData;
+}
+export class ValLayBlock {
+  private constructor();
+  free(): void;
+  merkleTree(): VlbMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): ValLayBlock;
+  static fromValLayBlockProto(bytes: Uint8Array): ValLayBlock;
+  static fromValLayBlockCapnp(bytes: Uint8Array): ValLayBlock;
+}
+export class ValLayLedger {
+  private constructor();
+  free(): void;
+  merkleTree(): VllMerkleTree;
+  flatten(): Uint8Array;
+  static fromFlattenedBytes(bytes: Uint8Array): ValLayLedger;
+  static fromValLayLedgerProto(bytes: Uint8Array): ValLayLedger;
+  static fromValLayLedgerCapnp(bytes: Uint8Array): ValLayLedger;
+}
+export class VlbMerkleTree {
+  private constructor();
+  free(): void;
+  fiveRaProof(hash: Uint8Array): MerkleProof;
+  fourLaProof(hash: Uint8Array): MerkleProof;
+  fiveLaProof(hash: Uint8Array): MerkleProof;
+  sevenRaTxProof(hash: Uint8Array): MerkleProof;
+  oneLaProof(hash: Uint8Array): MerkleProof;
+  sevenRbTxProof(hash: Uint8Array): MerkleProof;
+  getSevenLa(): Uint8Array;
+  getSevenRa(): Uint8Array;
+  getSevenLb(): Uint8Array;
+  getSevenRb(): Uint8Array;
+  getSevenLc(): Uint8Array;
+  getSevenRc(): Uint8Array;
+  getSevenLd(): Uint8Array;
+  getSevenRd(): Uint8Array;
+  getSixLa(): Uint8Array;
+  getSixRa(): Uint8Array;
+  getSixLc(): Uint8Array;
+  getSixRc(): Uint8Array;
+  getFiveLa(): Uint8Array;
+  getFiveRa(): Uint8Array;
+  getFourLa(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getOneLa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getFourRa(): Uint8Array;
+  getFourLb(): Uint8Array;
+  getFourRb(): Uint8Array;
+  getFiveLb(): Uint8Array;
+  getFiveRb(): Uint8Array;
+  getFiveLc(): Uint8Array;
+  getFiveRc(): Uint8Array;
+  getSixLb(): Uint8Array;
+  getSixRb(): Uint8Array;
+  getSixLd(): Uint8Array;
+  getSixRd(): Uint8Array;
+  root(): Uint8Array;
+}
+export class VllMerkleTree {
+  private constructor();
+  free(): void;
+  getOneLa(): Uint8Array;
+  getThreeLa(): Uint8Array;
+  getFourLa(): Uint8Array;
+  getFourRa(): Uint8Array;
+  getFourLb(): Uint8Array;
+  getFourRb(): Uint8Array;
+  getFourLc(): Uint8Array;
+  getFourRc(): Uint8Array;
+  getThreeRa(): Uint8Array;
+  getThreeLb(): Uint8Array;
+  getThreeRb(): Uint8Array;
+  getTwoLa(): Uint8Array;
+  getTwoRa(): Uint8Array;
+  getOneRa(): Uint8Array;
+  root(): Uint8Array;
+}
+/**
+ * Wallet address based on Geeq `Wallet Address Proposal` specification.
+ */
+export class WalletAddress {
+  private constructor();
+  free(): void;
+  /**
+   * ## Arguments
+   *
+   * `chain_num` - chain instance containing the record
+   * `record_type` - enumeration defined in this library
+   * `acct_num` - 32-byte IRN of a ledger record
+   *
+   * Note: returns error if `record_type` is `None`.
+   */
+  static new(chain_num: number, record_type: RecordType, acct_num: Uint8Array): WalletAddress;
+  exportRecordType(): RecordType;
+  exportChainNum(): number;
+  exportAcctNum(): Uint8Array;
+  /**
+   * Returns a value in base58 format representing the wallet address of a ledger account.
+   */
+  encode(): string;
+  /**
+   * Returns a value from which the components of a given wallet address can be extracted.
+   *
+   * ## Arguments
+   *
+   * `s` - string representing a wallet address in base58 format
+   */
+  static decode(s: string): WalletAddress;
+}