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

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

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+import Node from '../../../Node';
+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.Fate
+            ];
+        };
+    };
+    readonly 6: {
+        readonly 'contract-create': {
+            readonly vmVersion: readonly [
+                VmVersion.Fate2
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.Fate
+            ];
+        };
+        readonly 'contract-call': {
+            readonly vmVersion: readonly [
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.Fate
+            ];
+        };
+        readonly 'oracle-call': {
+            readonly vmVersion: readonly [
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.NoAbi,
+                AbiVersion.Fate
+            ];
+        };
+    };
+};
+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, params: {}, { consensusProtocolVersion }: {
+        consensusProtocolVersion?: ConsensusProtocolVersion | undefined;
+    }): Buffer;
+    prepare(value: CtVersion | undefined, params: {}, options: {
+        consensusProtocolVersion?: ConsensusProtocolVersion;
+        onNode?: Node;
+    }): Promise<CtVersion | undefined>;
+    deserialize(buffer: Buffer): CtVersion;
+};
+export default _default;

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

@@ -1,13 +1,14 @@
 /// <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'.
      * @param options - Options
+     * @param parameters - Parameters
      * @returns Deposit value Buffer.
      */
-    serialize(value: Int | undefined, options: Parameters<(typeof coinAmount)['serialize']>[1]): Buffer;
+    serialize(value: Int | undefined, options: Parameters<(typeof coinAmount)['serialize']>[1], parameters: Parameters<(typeof coinAmount)['serialize']>[2]): Buffer;
     serializeAettos(value: string | undefined): string;
     deserialize(value: Buffer): string;
 };

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<E>;
+};

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,22 @@
 /// <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, params: {}, { denomination }: {
+        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    }): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

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

@@ -1,11 +1,15 @@
 /// <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, _computingGasLimit, }: {
+        tag: Tag;
         rebuildTx: (params: any) => any;
-        gasMax: number;
+        unpackTx: typeof unpackTxType;
+        buildTx: typeof buildTxType;
         _computingGasLimit?: number | undefined;
+    }, { gasMax }: {
+        gasMax?: number | undefined;
     }): Buffer;
     deserialize(value: Buffer): number;
 };

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

@@ -1,7 +1,9 @@
 /// <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, params: {}, { denomination }: {
+        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    }): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

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

@@ -1,55 +1,100 @@
 /// <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 _map from './map';
+import _mptree from './mptree';
+import _nonce from './nonce';
+import _shortUIntConst from './short-u-int-const';
+import _wrapped from './wrapped';
+declare const abiVersion: {
+    _getProtocolDetails(c: import("../constants").ConsensusProtocolVersion, tag: import("../constants").Tag): import("../constants").AbiVersion;
+    serialize(value: import("../constants").AbiVersion | undefined, { tag }: {
+        tag: import("../constants").Tag;
+    }, { consensusProtocolVersion }: {
+        consensusProtocolVersion?: import("../constants").ConsensusProtocolVersion | undefined;
+    }): Buffer;
+    prepare(value: import("../constants").AbiVersion | undefined, { tag }: {
+        tag: import("../constants").Tag;
+    }, options: {
+        consensusProtocolVersion?: import("../constants").ConsensusProtocolVersion | undefined;
+        onNode?: import("../../..").Node | undefined;
+    }): Promise<import("../constants").AbiVersion | undefined>;
+    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, params: {}, { denomination }: {
+        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    }): 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, params: {}, { consensusProtocolVersion }: {
+        consensusProtocolVersion?: import("../constants").ConsensusProtocolVersion | undefined;
+    }): Buffer;
+    prepare(value: import("./ct-version").CtVersion | undefined, params: {}, options: {
+        consensusProtocolVersion?: import("../constants").ConsensusProtocolVersion | undefined;
+        onNode?: import("../../..").Node | undefined;
+    }): Promise<import("./ct-version").CtVersion | undefined>;
+    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: {}, parameters: {
+        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    }): 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, params: {}, { denomination }: {
+        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    }): 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, _computingGasLimit, }: {
+        tag: import("../constants").Tag;
         rebuildTx: (params: any) => any;
-        gasMax: number;
+        unpackTx: typeof import("..").unpackTx;
+        buildTx: typeof import("..").buildTx;
         _computingGasLimit?: number | undefined;
+    }, { gasMax }: {
+        gasMax?: number | undefined;
     }): Buffer;
     deserialize(value: Buffer): number;
 };
 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, params: {}, { denomination }: {
+        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    }): Buffer;
     deserialize(value: Buffer): string;
 };
+declare const map: typeof _map;
+declare const mptree: typeof _mptree;
 declare const name: {
     serialize(value: `${string}.chain`): Buffer;
     deserialize(value: Buffer): `${string}.chain`;
@@ -58,15 +103,18 @@ 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;
+    }, parameters: {
+        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    }): 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 nonce: typeof _nonce;
 declare const pointers: {
     serialize(pointers: (import("../../../apis/node").NamePointer & {
         id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`;
@@ -78,8 +126,43 @@ 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 ttl: {
+    serialize(value: number | undefined): Buffer;
+    prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        onNode?: import("../../..").Node | undefined;
+        absoluteTtl?: boolean | undefined;
+    }): Promise<number | undefined>;
+    deserialize(value: Buffer): number;
+};
+declare const uInt: {
+    serialize(value: import("../constants").Int): Buffer;
+    deserialize(value: Buffer): string;
+};
+declare const wrapped: typeof _wrapped;
+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, parameters: any) => BinaryData;
+    prepare?: (value: any, options: any, parameters: any) => Promise<any>;
+    deserialize: (value: BinaryData, options: any) => any;
+    recursiveType?: boolean;
 }
-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, map, mptree, name, nameFee, nameId, nonce, pointers, raw, shortUInt, shortUIntConst, string, ttl, uInt, wrapped, };

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+import { Encoding, Encoded } from '../../../utils/encoder';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+export default function genMapField<E extends Encoding, T extends Tag>(encoding: E, tag: T): {
+    serialize: (value: Record<Encoded.Generic<E>, any>, options: {
+        buildTx: typeof buildTxType;
+    }) => Buffer;
+    deserialize: (value: Buffer, options: {
+        unpackTx: typeof unpackTxType;
+    }) => Record<Encoded.Generic<E>, any>;
+    recursiveType: true;
+};

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

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+import { Encoded, Encoding } from '../../../utils/encoder';
+import type { unpackTx } from '..';
+import type { TxUnpacked } from '../schema.generated';
+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>): TxUnpacked & {
+        tag: T;
+    } | undefined;
+    toObject(): Record<Encoded.Generic<E>, TxUnpacked & {
+        tag: T;
+    }>;
+}
+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;
@@ -13,7 +12,7 @@ declare const _default: {
      */
     serialize(value: Int | undefined, txFields: {
         name: AensName;
-    } & Parameters<(typeof coinAmount)['serialize']>[1]): Buffer;
+    } & Parameters<(typeof coinAmount)['serialize']>[1], parameters: Parameters<(typeof coinAmount)['serialize']>[2]): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

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

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import Node from '../../../Node';
+import { NextNonceStrategy } from '../../../apis/node';
+export default function genNonceField<SenderKey extends string>(senderKey: SenderKey): {
+    serialize: (value: number) => Buffer;
+    prepare: (value: number | undefined, params: {}, options: {
+        [key in SenderKey]: string;
+    } & {
+        strategy?: NextNonceStrategy;
+        onNode?: Node;
+    }) => Promise<number>;
+    deserialize: (value: Buffer) => number;
+    senderKey: string;
+};

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,7 @@
+/// <reference types="node" />
+export default function genShortUIntConstField<Value extends number, Optional extends boolean = false>(constValue: Value, optional?: Optional): {
+    serialize: Optional extends true ? (value?: Value) => Buffer : (value: Value) => Buffer;
+    deserialize: (value: Buffer) => Value;
+    constValue: Value;
+    constValueOptional: boolean;
+};

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/ttl.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import Node from '../../../Node';
+declare const _default: {
+    serialize(value: number | undefined): Buffer;
+    prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        onNode?: Node | undefined;
+        absoluteTtl?: boolean | undefined;
+    }): Promise<number | undefined>;
+    deserialize(value: Buffer): number;
+};
+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;

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

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+type TagWrapping = Tag.AccountsMtree | Tag.CallsMtree | Tag.ChannelsMtree | Tag.ContractsMtree | Tag.NameserviceMtree | Tag.OraclesMtree;
+export default function genWrappedField<T extends TagWrapping>(tag: T): {
+    serialize: (value: any, options: {
+        buildTx: typeof buildTxType;
+    }) => Buffer;
+    deserialize: (value: Buffer, options: {
+        unpackTx: typeof unpackTxType;
+    }) => any;
+    recursiveType: true;
+};
+export {};

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

@@ -1,57 +1,42 @@
 import { Encoded, Encoding } from '../../utils/encoder';
-import { AE_AMOUNT_FORMATS } from '../../utils/amount-formatter';
-import { RawTxObject, TxSchema, TxTypeSchemas } from './schema';
+import { Field } from './field-types';
+import { TxUnpacked, TxParams, TxParamsAsync } from './schema.generated';
 import { Tag } from './constants';
 /**
- * @category transaction builder
+ * JavaScript-based Transaction builder
  */
-export interface BuiltTx<Tx extends TxSchema, Prefix extends Encoding> {
-    tx: Encoded.Generic<Prefix>;
-    rlpEncoded: Uint8Array;
-    binary: Uint8Array;
-    txObject: RawTxObject<Tx>;
-}
+export declare function getSchema(tag: Tag, version?: number): Array<[
+    string,
+    Field
+]>;
 /**
  * Build transaction hash
  * @category transaction builder
- * @param _params - Object with tx params
- * @param type - Transaction type
+ * @param params - Object with tx params
  * @param options - options
- * @param options.excludeKeys - Array of keys to exclude for validation and build
- * @param options.denomination - Denomination of amounts
  * @param options.prefix - Prefix of transaction
- * @throws {@link InvalidTxParamsError}
- * @returns object
- * @returns object.tx Base64Check transaction hash with 'tx_' prefix
- * @returns object.rlpEncoded rlp encoded transaction
- * @returns object.binary binary transaction
+ * @returns object Base64Check transaction hash with 'tx_' prefix
  */
-export declare function buildTx<TxType extends Tag, Prefix>(_params: Omit<TxTypeSchemas[TxType], 'tag' | 'VSN'> & {
-    VSN?: number;
-}, type: TxType, { excludeKeys, prefix, vsn, denomination, }?: {
-    excludeKeys?: string[];
-    prefix?: Encoding;
-    vsn?: number;
-    denomination?: AE_AMOUNT_FORMATS;
-}): BuiltTx<TxSchema, Prefix extends Encoding ? Prefix : Encoding.Transaction>;
+export declare function buildTx<E extends Encoding = Encoding.Transaction>(params: TxParams, { prefix, }?: {
+    prefix?: E;
+}): Encoded.Generic<E>;
+export type BuildTxOptions<TxType extends Tag, OmitFields extends string> = Omit<TxParamsAsync & {
+    tag: TxType;
+}, 'tag' | OmitFields>;
 /**
  * @category transaction builder
  */
-export interface TxUnpacked<Tx extends TxSchema> {
-    txType: Tag;
-    tx: RawTxObject<Tx>;
-    rlpEncoded: Uint8Array;
-}
+export declare function buildTxAsync(params: TxParamsAsync): Promise<Encoded.Transaction>;
 /**
- * Unpack transaction hash
+ * Unpack transaction encoded as string
  * @category transaction builder
  * @param encodedTx - Transaction to unpack
  * @param txType - Expected transaction type
- * @returns object
- * @returns object.tx Object with transaction param's
- * @returns object.txType Transaction type
+ * @returns Object with transaction param's
  */
-export declare function unpackTx<TxType extends Tag>(encodedTx: Encoded.Transaction | Encoded.Poi, txType?: TxType): TxUnpacked<TxTypeSchemas[TxType]>;
+export declare function unpackTx<TxType extends Tag>(encodedTx: Encoded.Transaction | Encoded.Poi | Encoded.StateTrees | Encoded.CallStateTree, txType?: TxType): TxUnpacked & {
+    tag: TxType;
+};
 /**
  * Build a transaction hash
  * @category transaction builder