@aeternity/aepp-sdk 13.0.0-alpha.0 → 13.0.0-alpha.1

package/types-legacy/ts4.5/contract/ga.d.ts

@@ -5,9 +5,10 @@ import { Tag } from '../tx/builder/constants';
 import { BuildTxOptions } from '../tx';
 import { Encoded } from '../utils/encoder';
 import AccountBase from '../account/Base';
+import Contract from './Contract';
 import { SendOptions } from '../spend';
 import Node from '../Node';
-import CompilerHttp from './CompilerHttp';
+import CompilerBase from './compiler/Base';
 /**
  * Convert current account to GA
  * @category contract
@@ -17,15 +18,15 @@ import CompilerHttp from './CompilerHttp';
  * @param options - Options
  * @returns General Account Object
  */
-export declare function createGeneralizedAccount(authFnName: string, sourceCode: string, args: any[], { onAccount, onCompiler, onNode, ...options }: CreateGeneralizedAccountOptions): Promise<Readonly<{
+export declare function createGeneralizedAccount(authFnName: string, args: any[], { onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem, ...options }: CreateGeneralizedAccountOptions): Promise<Readonly<{
     owner: Encoded.AccountAddress;
     transaction: Encoded.TxHash;
     rawTx: Encoded.Transaction;
     gaContractId: Encoded.ContractAddress;
 }>>;
-interface CreateGeneralizedAccountOptions extends BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>, SendOptions {
+interface CreateGeneralizedAccountOptions extends BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>, SendOptions, Pick<Parameters<typeof Contract.initialize>[0], 'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'> {
     onAccount: AccountBase;
-    onCompiler: CompilerHttp;
+    onCompiler: CompilerBase;
     onNode: Node;
     gasLimit?: number;
 }

package/types-legacy/ts4.5/index-browser.d.ts

@@ -0,0 +1,39 @@
+export * from './chain';
+export * from './utils/crypto';
+export * from './utils/keystore';
+export * from './utils/bytes';
+export * from './tx';
+export * from './tx/builder';
+export * from './tx/builder/helpers';
+export * from './tx/builder/constants';
+export * from './tx/builder/schema';
+export * from './utils/amount-formatter';
+export * from './utils/hd-wallet';
+export { encode, decode, Encoding } from './utils/encoder';
+export * from './aens';
+export { default as Contract } from './contract/Contract';
+export type { ContractMethodsBase } from './contract/Contract';
+export * from './oracle';
+export * from './spend';
+export * from './contract/ga';
+export { default as AeSdkMethods } from './AeSdkMethods';
+export { default as AeSdkBase } from './AeSdkBase';
+export { default as AeSdk } from './AeSdk';
+export { default as AeSdkAepp } from './AeSdkAepp';
+export { default as AeSdkWallet } from './AeSdkWallet';
+export { default as Node } from './Node';
+export { default as verifyTransaction } from './tx/validator';
+export { default as AccountBase } from './account/Base';
+export { default as MemoryAccount } from './account/Memory';
+export { default as AccountGeneralized } from './account/Generalized';
+export { default as AccountLedger } from './account/Ledger';
+export { default as AccountLedgerFactory } from './account/LedgerFactory';
+export { default as CompilerBase } from './contract/compiler/Base';
+export { default as CompilerHttp } from './contract/compiler/Http';
+export { default as Channel } from './channel/Contract';
+export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
+export * from './aepp-wallet-communication/schema';
+export { default as walletDetector } from './aepp-wallet-communication/wallet-detector';
+export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime';
+export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage';
+export * from './utils/errors';

package/types-legacy/ts4.5/index.d.ts

@@ -1,38 +1,4 @@
-export * from './chain';
-export * from './utils/crypto';
-export * from './utils/keystore';
-export * from './utils/bytes';
-export * from './tx';
-export * from './tx/builder';
-export * from './tx/builder/helpers';
-export * from './tx/builder/constants';
-export * from './tx/builder/schema';
-export * from './utils/amount-formatter';
-export * from './utils/hd-wallet';
-export { encode, decode, Encoding } from './utils/encoder';
-export * from './aens';
-export { default as Contract } from './contract/Contract';
-export type { ContractMethodsBase } from './contract/Contract';
-export * from './oracle';
-export * from './spend';
-export * from './contract/ga';
-export { default as AeSdkMethods } from './AeSdkMethods';
-export { default as AeSdkBase } from './AeSdkBase';
-export { default as AeSdk } from './AeSdk';
-export { default as AeSdkAepp } from './AeSdkAepp';
-export { default as AeSdkWallet } from './AeSdkWallet';
-export { default as Node } from './Node';
-export { default as verifyTransaction } from './tx/validator';
-export { default as AccountBase } from './account/Base';
-export { default as MemoryAccount } from './account/Memory';
-export { default as AccountGeneralized } from './account/Generalized';
-export { default as AccountLedger } from './account/Ledger';
-export { default as AccountLedgerFactory } from './account/LedgerFactory';
-export { default as CompilerHttp } from './contract/CompilerHttp';
-export { default as Channel } from './channel/Contract';
-export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
-export * from './aepp-wallet-communication/schema';
-export { default as walletDetector } from './aepp-wallet-communication/wallet-detector';
-export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime';
-export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage';
-export * from './utils/errors';
+export * from './index-browser';
+export { default as CompilerCli } from './contract/compiler/Cli';
+export { default as getFileSystem } from './contract/compiler/getFileSystem';
+export { default as CompilerHttpNode } from './contract/compiler/HttpNode';

package/types-legacy/ts4.5/tx/builder/constants.d.ts

@@ -1,5 +1,6 @@
 import BigNumber from 'bignumber.js';
 export declare const MAX_AUTH_FUN_GAS = 50000;
+export type Int = number | string | BigNumber;
 export type AensName = `${string}.chain`;
 export declare const NAME_TTL = 180000;
 export declare const NAME_MAX_TTL = 36000;
@@ -14,6 +15,31 @@ export declare const NAME_BID_MAX_LENGTH = 12;
 export declare const NAME_BID_RANGES: {
     [k: string]: BigNumber;
 };
+export declare enum ConsensusProtocolVersion {
+    Iris = 5
+}
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
+ */
+export declare enum VmVersion {
+    NoVm = 0,
+    Sophia = 1,
+    SophiaImprovementsMinerva = 3,
+    SophiaImprovementsFortuna = 4,
+    Fate = 5,
+    SophiaImprovementsLima = 6,
+    Fate2 = 7
+}
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
+ */
+export declare enum AbiVersion {
+    NoAbi = 0,
+    Sophia = 1,
+    Fate = 3
+}
 /**
  * Enum with tag types
  * @category transaction builder
@@ -24,10 +50,12 @@ export declare enum Tag {
     Account = 10,
     SignedTx = 11,
     SpendTx = 12,
+    Oracle = 20,
     OracleRegisterTx = 22,
     OracleQueryTx = 23,
     OracleResponseTx = 24,
     OracleExtendTx = 25,
+    Name = 30,
     NameClaimTx = 32,
     NamePreclaimTx = 33,
     NameUpdateTx = 34,
@@ -64,7 +92,6 @@ export declare enum Tag {
     NameserviceMtree = 624,
     OraclesMtree = 625,
     AccountsMtree = 626,
-    CompilerSophia = 70,
     GaAttachTx = 80,
     GaMetaTx = 81,
     PayingForTx = 82

package/types-legacy/ts4.5/tx/builder/field-types/abi-version.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Tag, ConsensusProtocolVersion, AbiVersion } from '../constants';
+declare const _default: {
+    serialize(value: AbiVersion | undefined, { tag, consensusProtocolVersion }: {
+        tag: Tag;
+        consensusProtocolVersion: ConsensusProtocolVersion;
+    }): Buffer;
+    deserialize(buffer: Buffer): AbiVersion;
+};
+export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/address.d.ts

@@ -1,22 +1,21 @@
 /// <reference types="node" />
-import { Encoding } from '../../../utils/encoder';
+import { Encoded } from '../../../utils/encoder';
 /**
  * Map of prefix to ID tag constant
  * @see {@link https://github.com/aeternity/protocol/blob/master/serializations.md#the-id-type}
  * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_id.erl#L97-L102}
  * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L163-L168}
  */
-declare const idTagToEncoding: readonly [
-    Encoding.AccountAddress,
-    Encoding.Name,
-    Encoding.Commitment,
-    Encoding.OracleAddress,
-    Encoding.ContractAddress,
-    Encoding.Channel
+export declare const idTagToEncoding: readonly [
+    Encoded.Encoding.AccountAddress,
+    Encoded.Encoding.Name,
+    Encoded.Encoding.Commitment,
+    Encoded.Encoding.OracleAddress,
+    Encoded.Encoding.ContractAddress,
+    Encoded.Encoding.Channel
 ];
 export type AddressEncodings = typeof idTagToEncoding[number];
-export default function genAddressField<Encoding extends AddressEncodings>(): {
-    serialize: (value: `${Encoding}_${string}`) => Buffer;
-    deserialize: (value: Buffer) => `${Encoding}_${string}`;
+export default function genAddressField<Encoding extends AddressEncodings>(...encodings: Encoding[]): {
+    serialize: (value: Encoded.Generic<Encoding>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
 };
-export {};

package/types-legacy/ts4.5/tx/builder/field-types/array.d.ts

@@ -0,0 +1,7 @@
+export default function genArrayField<Input, Output, Binary>(itemHandler: {
+    serialize: (value: Input, params: unknown) => Binary;
+    deserialize: (value: Binary, params: unknown) => Output;
+}): {
+    serialize: (value: Input[], params: unknown) => Binary[];
+    deserialize: (value: Binary[], params: unknown) => Output[];
+};

package/types-legacy/ts4.5/tx/builder/field-types/boolean.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+declare const _default: {
+    serialize(value: boolean): Buffer;
+    deserialize(buffer: Buffer): boolean;
+};
+export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/coin-amount.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Int } from './u-int';
+import { Int } from '../constants';
 import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
 export interface Options {
     denomination?: AE_AMOUNT_FORMATS;

package/types-legacy/ts4.5/tx/builder/field-types/ct-version.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+export declare const ProtocolToVmAbi: {
+    readonly 5: {
+        readonly 'contract-create': {
+            readonly vmVersion: readonly [
+                VmVersion.Fate2
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.Fate
+            ];
+        };
+        readonly 'contract-call': {
+            readonly vmVersion: readonly [
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.Fate,
+                AbiVersion.Sophia
+            ];
+        };
+        readonly 'oracle-call': {
+            readonly vmVersion: readonly [
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.NoAbi,
+                AbiVersion.Sophia
+            ];
+        };
+    };
+};
+export interface CtVersion {
+    vmVersion: VmVersion;
+    abiVersion: AbiVersion;
+}
+export declare function getProtocolDetails(protocolVersion: ConsensusProtocolVersion, type: 'contract-create' | 'contract-call' | 'oracle-call'): CtVersion;
+declare const _default: {
+    serialize(value: CtVersion | undefined, { consensusProtocolVersion }: {
+        consensusProtocolVersion: ConsensusProtocolVersion;
+    }): Buffer;
+    deserialize(buffer: Buffer): CtVersion;
+};
+export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/deposit.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import coinAmount from './coin-amount';
-import { Int } from './u-int';
+import { Int } from '../constants';
 declare const _default: {
     /**
      * @param value - Deposit value in string format. Should be equal to '0'.

package/types-legacy/ts4.5/tx/builder/field-types/encoded.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { Encoded, Encoding } from '../../../utils/encoder';
+export default function genEncodedField<E extends Encoding, Optional extends boolean = false>(encoding: E, optional?: Optional): {
+    serialize: Optional extends true ? (value?: Encoded.Generic<E>) => Buffer : (value: Encoded.Generic<E>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+};

package/types-legacy/ts4.5/tx/builder/field-types/entry.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+export default function genEntryField<T extends Tag = Tag>(tag?: T): {
+    serialize: (value: any, options: {
+        buildTx: typeof buildTxType;
+    }) => Buffer;
+    deserialize: (value: Buffer, options: {
+        unpackTx: typeof unpackTxType;
+    }) => any;
+};

package/types-legacy/ts4.5/tx/builder/field-types/enumeration.d.ts

@@ -1,5 +1,7 @@
 /// <reference types="node" />
-export default function genEnumerationField<Enum extends number>(): {
-    serialize: (value: Enum) => Buffer;
-    deserialize: (value: Buffer) => Enum;
+export default function genEnumerationField<Enum extends {
+    [key: string]: number | string;
+}>(enm: Enum): {
+    serialize: (value: Enum[keyof Enum]) => Buffer;
+    deserialize: (value: Buffer) => Enum[keyof Enum];
 };

package/types-legacy/ts4.5/tx/builder/field-types/fee.d.ts

@@ -1,17 +1,20 @@
 /// <reference types="node" />
 import BigNumber from 'bignumber.js';
-import { Tag } from '../constants';
+import { Encoded } from '../../../utils/encoder';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 /**
  * Calculate fee based on tx type and params
  */
-export declare function buildFee(txType: Tag, buildTx: any): BigNumber;
+export declare function buildFee(builtTx: Encoded.Transaction, unpackTx: typeof unpackTxType, buildTx: typeof buildTxType): BigNumber;
 declare const _default: {
-    serializeAettos(_value: string | undefined, { txType, rebuildTx, _computingMinFee }: {
-        txType: Tag;
-        rebuildTx: (params: any) => any;
-        _computingMinFee?: string | undefined;
+    serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
+        rebuildTx: (params: any) => Encoded.Transaction;
+        unpackTx: typeof unpackTxType;
+        buildTx: typeof buildTxType;
+        _computingMinFee?: BigNumber | undefined;
+        _pickBiggerFee?: boolean | undefined;
     }): string;
-    serialize(value: import("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/gas-limit.d.ts

@@ -1,9 +1,12 @@
 /// <reference types="node" />
 import { Tag } from '../constants';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 declare const _default: {
-    serialize(_value: number | undefined, { txType, rebuildTx, gasMax, _computingGasLimit, }: {
-        txType: Tag;
+    serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, gasMax, _computingGasLimit, }: {
+        tag: Tag;
         rebuildTx: (params: any) => any;
+        unpackTx: typeof unpackTxType;
+        buildTx: typeof buildTxType;
         gasMax: number;
         _computingGasLimit?: number | undefined;
     }): Buffer;

package/types-legacy/ts4.5/tx/builder/field-types/gas-price.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 declare const _default: {
     serializeAettos(value?: string | undefined): string;
-    serialize(value: import("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/index.d.ts

@@ -1,45 +1,64 @@
 /// <reference types="node" />
 import _address from './address';
-import _addresses from './addresses';
+import _array from './array';
+import _encoded from './encoded';
+import _entry from './entry';
 import _enumeration from './enumeration';
-declare const field: {
-    serialize(value: string): Buffer;
-    deserialize(value: Buffer): string;
-};
-declare const uInt: {
-    serialize(value: import("./u-int").Int): Buffer;
-    deserialize(value: Buffer): string;
+import _mptree from './mptree';
+import _shortUIntConst from './short-u-int-const';
+declare const abiVersion: {
+    serialize(value: import("../constants").AbiVersion | undefined, { tag, consensusProtocolVersion }: {
+        tag: import("../constants").Tag;
+        consensusProtocolVersion: import("../constants").ConsensusProtocolVersion;
+    }): Buffer;
+    deserialize(buffer: Buffer): import("../constants").AbiVersion;
 };
-declare const shortUInt: {
-    serialize(value: number): Buffer;
-    deserialize(value: Buffer): number;
+declare const address: typeof _address;
+declare const array: typeof _array;
+declare const boolean: {
+    serialize(value: boolean): Buffer;
+    deserialize(buffer: Buffer): boolean;
 };
 declare const coinAmount: {
     serializeAettos(value: string | undefined): string;
-    serialize(value: import("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
     deserialize(value: Buffer): string;
 };
-declare const address: typeof _address;
-declare const addresses: typeof _addresses;
+declare const ctVersion: {
+    serialize(value: import("./ct-version").CtVersion | undefined, { consensusProtocolVersion }: {
+        consensusProtocolVersion: import("../constants").ConsensusProtocolVersion;
+    }): Buffer;
+    deserialize(buffer: Buffer): import("./ct-version").CtVersion;
+};
 declare const deposit: {
-    serialize(value: import("./u-int").Int | undefined, options: import("./coin-amount").Options): Buffer;
+    serialize(value: import("../constants").Int | undefined, options: import("./coin-amount").Options): Buffer;
     serializeAettos(value: string | undefined): string;
     deserialize(value: Buffer): string;
 };
+declare const encoded: typeof _encoded;
+declare const entry: typeof _entry;
 declare const enumeration: typeof _enumeration;
 declare const fee: {
-    serializeAettos(_value: string | undefined, { txType, rebuildTx, _computingMinFee }: {
-        txType: import("../constants").Tag;
-        rebuildTx: (params: any) => any;
-        _computingMinFee?: string | undefined;
+    serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
+        rebuildTx: (params: any) => `tx_${string}`;
+        unpackTx: typeof import("..").unpackTx;
+        buildTx: typeof import("..").buildTx;
+        _computingMinFee?: import("bignumber.js").BigNumber | undefined;
+        _pickBiggerFee?: boolean | undefined;
     }): string;
-    serialize(value: import("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+declare const field: {
+    serialize(value: string): Buffer;
     deserialize(value: Buffer): string;
 };
 declare const gasLimit: {
-    serialize(_value: number | undefined, { txType, rebuildTx, gasMax, _computingGasLimit, }: {
-        txType: import("../constants").Tag;
+    serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, gasMax, _computingGasLimit, }: {
+        tag: import("../constants").Tag;
         rebuildTx: (params: any) => any;
+        unpackTx: typeof import("..").unpackTx;
+        buildTx: typeof import("..").buildTx;
         gasMax: number;
         _computingGasLimit?: number | undefined;
     }): Buffer;
@@ -47,9 +66,10 @@ declare const gasLimit: {
 };
 declare const gasPrice: {
     serializeAettos(value?: string | undefined): string;
-    serialize(value: import("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
     deserialize(value: Buffer): string;
 };
+declare const mptree: typeof _mptree;
 declare const name: {
     serialize(value: `${string}.chain`): Buffer;
     deserialize(value: Buffer): `${string}.chain`;
@@ -58,13 +78,13 @@ declare const nameFee: {
     serializeAettos(_value: string | undefined, txFields: {
         name: `${string}.chain`;
     }): string;
-    serialize(value: import("./u-int").Int | undefined, txFields: {
+    serialize(value: import("../constants").Int | undefined, txFields: {
         name: `${string}.chain`;
     } & import("./coin-amount").Options): Buffer;
     deserialize(value: Buffer): string;
 };
 declare const nameId: {
-    serialize(value: `nm_${string}` | `${string}.chain`): Buffer;
+    serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
     deserialize: (value: Buffer) => `nm_${string}`;
 };
 declare const pointers: {
@@ -78,8 +98,32 @@ declare const pointers: {
         id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`;
     })[];
 };
+declare const raw: {
+    serialize(buffer: Uint8Array): Buffer;
+    deserialize(buffer: Buffer): Buffer;
+};
+declare const shortUInt: {
+    serialize(value: number): Buffer;
+    deserialize(value: Buffer): number;
+};
+declare const shortUIntConst: typeof _shortUIntConst;
+declare const string: {
+    serialize(string: string): Buffer;
+    deserialize(buffer: Buffer): string;
+};
+declare const uInt: {
+    serialize(value: import("../constants").Int): Buffer;
+    deserialize(value: Buffer): string;
+};
+export type BinaryData = Buffer | Buffer[] | Buffer[][] | Array<[
+    Buffer,
+    Array<[
+        Buffer,
+        Buffer[]
+    ]>
+]>;
 export interface Field {
-    serialize: (value: any, options: any) => Buffer | Buffer[] | Buffer[][];
-    deserialize: (value: Buffer | Buffer[] | Buffer[][]) => any;
+    serialize: (value: any, options: any) => BinaryData;
+    deserialize: (value: BinaryData, options: any) => any;
 }
-export { field, uInt, shortUInt, coinAmount, address, addresses, deposit, enumeration, fee, gasLimit, gasPrice, name, nameFee, nameId, pointers, };
+export { abiVersion, address, array, boolean, coinAmount, ctVersion, deposit, encoded, entry, enumeration, fee, field, gasLimit, gasPrice, mptree, name, nameFee, nameId, pointers, raw, shortUInt, shortUIntConst, string, uInt, };

package/types-legacy/ts4.5/tx/builder/field-types/mptree.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+import { Encoded, Encoding } from '../../../utils/encoder';
+import type { unpackTx } from '..';
+type MPTreeBinary = [
+    Buffer,
+    Array<[
+        Buffer,
+        Buffer[]
+    ]>
+];
+declare class MPTree<E extends Encoding, T extends Tag> {
+    #private;
+    get isComplete(): boolean;
+    /**
+     * Deserialize Merkle Patricia Tree
+     * @param binary - Binary
+     * @param tag - Tag to use to decode value
+     * @param unpTx - Implementation of unpackTx use to decode values
+     * @returns Merkle Patricia Tree
+     */
+    constructor(binary: MPTreeBinary, encoding: E, tag: T, unpTx: typeof unpackTx);
+    isEqual(tree: MPTree<E, T>): boolean;
+    /**
+     * Serialize Merkle Patricia Tree
+     * @returns Binary
+     */
+    serialize(): MPTreeBinary;
+    /**
+     * Retrieve value from Merkle Patricia Tree
+     * @param key - The key of the element to retrieve
+     * @returns Value associated to the specified key
+     */
+    get(key: Encoded.Generic<E>): ReturnType<any> | undefined;
+    toObject(): Record<Encoded.Any, ReturnType<any>>;
+}
+export default function genMPTreeField<E extends Encoding, T extends Tag>(encoding: E, tag: T): {
+    serialize: (value: MPTree<E, T>) => MPTreeBinary;
+    deserialize: (value: MPTreeBinary, o: {
+        unpackTx: typeof unpackTx;
+    }) => MPTree<E, T>;
+};
+export {};

package/types-legacy/ts4.5/tx/builder/field-types/name-fee.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
-import { Int } from './u-int';
 import coinAmount from './coin-amount';
-import { AensName } from '../constants';
+import { AensName, Int } from '../constants';
 declare const _default: {
     serializeAettos(_value: string | undefined, txFields: {
         name: AensName;

package/types-legacy/ts4.5/tx/builder/field-types/raw.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+declare const _default: {
+    serialize(buffer: Uint8Array): Buffer;
+    deserialize(buffer: Buffer): Buffer;
+};
+export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/short-u-int-const.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export default function genShortUIntConstField<Value extends number>(value: Value): {
+    serialize: (value?: Value) => Buffer;
+    deserialize: (value: Buffer) => Value;
+};

package/types-legacy/ts4.5/tx/builder/field-types/string.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+declare const _default: {
+    serialize(string: string): Buffer;
+    deserialize(buffer: Buffer): string;
+};
+export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/u-int.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
-import BigNumber from 'bignumber.js';
-export type Int = number | string | BigNumber;
+import { Int } from '../constants';
 declare const _default: {
     serialize(value: Int): Buffer;
     deserialize(value: Buffer): string;