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

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

@@ -1,25 +1,8 @@
-import { sendTransaction, resolveName } from './chain';
-import { BuildTxOptions } from './tx';
+import { sendTransaction, resolveName, SendTransactionOptions } from './chain';
+import { BuildTxOptions } from './tx/builder';
 import { Encoded } from './utils/encoder';
 import { Tag, AensName } from './tx/builder/constants';
 import AccountBase from './account/Base';
-/**
- * Sign and post a transaction to the chain
- * @category chain
- * @param tx - Transaction
- * @param options - Options
- * @param options.verify - Verify transaction before broadcast, throw error if not
- * valid
- * @returns Transaction
- */
-export declare function send(tx: Encoded.Transaction, options: SendOptions): Promise<SendReturnType>;
-type SendOptionsType = Parameters<AccountBase['signTransaction']>[1] & Parameters<typeof sendTransaction>[1] & {
-    onAccount: AccountBase;
-};
-export interface SendOptions extends SendOptionsType {
-}
-interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {
-}
 /**
  * Send coins to another account
  * @category chain
@@ -28,24 +11,33 @@ interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {
  * @param options - Options
  * @returns Transaction
  */
-export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | AensName, options: SpendOptions): ReturnType<typeof send>;
+export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | AensName, options: SpendOptions): ReturnType<typeof sendTransaction>;
 type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
     onAccount: AccountBase;
-} & SendOptions;
+} & SendTransactionOptions;
 interface SpendOptions extends SpendOptionsType {
 }
 /**
- * Send a fraction of coin balance to another account
+ * Spend a fraction of coin balance to another account. Useful if needed to drain account balance
+ * completely, sending funds to another account (with fraction set to 1).
  * @category chain
  * @param fraction - Fraction of balance to spend (between 0 and 1)
  * @param recipientIdOrName - Address or name of recipient account
  * @param options - Options
- * @returns Transaction
+ * @example
+ * ```js
+ * // `fraction` * 100 = % of AE to be transferred (e.g. `0.42` for 42% or `1` for 100%)
+ * const { blockHeight } = await aeSdk.transferFunds(
+ *   0.42,
+ *   'ak_21A27UVVt3hDkBE5J7rhhqnH5YNb4Y1dqo4PnSybrH85pnWo7E',
+ * );
+ * console.log('Transaction mined at', blockHeight);
+ * ```
  */
-export declare function transferFunds(fraction: number | string, recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof send>;
+export declare function transferFunds(fraction: number | string, recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof sendTransaction>;
 type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
     onAccount: AccountBase;
-} & SendOptions;
+} & SendTransactionOptions;
 interface TransferFundsOptions extends TransferFundsOptionsType {
 }
 /**
@@ -55,8 +47,8 @@ interface TransferFundsOptions extends TransferFundsOptionsType {
  * @param options - Options
  * @returns Object Transaction
  */
-export declare function payForTransaction(transaction: Encoded.Transaction, options: PayForTransactionOptions): ReturnType<typeof send>;
-interface PayForTransactionOptions extends BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx'>, SendOptions {
+export declare function payForTransaction(transaction: Encoded.Transaction, options: PayForTransactionOptions): ReturnType<typeof sendTransaction>;
+interface PayForTransactionOptions extends BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx' | 'onNode'>, SendTransactionOptions {
     onAccount: AccountBase;
 }
 export {};

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

@@ -0,0 +1,37 @@
+import { Field as OriginalField } from './field-types';
+import { UnionToIntersection } from '../../utils/other';
+export interface Field extends OriginalField {
+    serialize: (...args: any[]) => any;
+}
+type NullablePartial<T, NK extends keyof T = {
+    [K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T]> = Partial<Pick<T, NK>> & Omit<T, NK>;
+type Or<A, B> = A extends undefined ? B : A;
+type TxParamsBySchemaInternal<SchemaItem> = {
+    -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field ? Parameters<SchemaItem[key]['serialize']>[0] : never;
+};
+type TxParamsBySchemaInternalParams<SchemaItem, SchemaItemValues = SchemaItem[keyof SchemaItem]> = UnionToIntersection<SchemaItemValues extends Field ? Or<Parameters<SchemaItemValues['serialize']>[2], {}> : never>;
+type PickIsRec<SchemaItem, Recursive extends boolean> = {
+    [Key in keyof SchemaItem as SchemaItem[Key] extends Field & {
+        recursiveType: true;
+    } ? (Recursive extends true ? Key : never) : (Recursive extends true ? never : Key)]: SchemaItem[Key];
+};
+type TxParamsBySchema<SchemaItem> = SchemaItem extends Object ? TxParamsBySchemaInternal<PickIsRec<SchemaItem, true>> & NullablePartial<TxParamsBySchemaInternal<PickIsRec<SchemaItem, false>>> & TxParamsBySchemaInternalParams<PickIsRec<SchemaItem, false>> : never;
+type TxParamsAsyncBySchemaInternal<SchemaItem> = {
+    -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field & {
+        prepare: Function;
+    } ? Parameters<SchemaItem[key]['prepare']>[0] : SchemaItem[key] extends Field ? Parameters<SchemaItem[key]['serialize']>[0] : never;
+};
+type TxParamsAsyncBySchemaInternalParams<SchemaItem, SchemaItemValues = SchemaItem[keyof SchemaItem]> = UnionToIntersection<SchemaItemValues extends Field & {
+    prepare: Function;
+} ? Or<Parameters<SchemaItemValues['prepare']>[2], {}> : {}>;
+type TxParamsAsyncBySchema<SchemaItem> = SchemaItem extends Object ? TxParamsAsyncBySchemaInternal<PickIsRec<SchemaItem, true>> & NullablePartial<TxParamsAsyncBySchemaInternal<PickIsRec<SchemaItem, false>>> & TxParamsAsyncBySchemaInternalParams<PickIsRec<SchemaItem, false>> & TxParamsBySchemaInternalParams<PickIsRec<SchemaItem, false>> : never;
+type TxUnpackedBySchema<SchemaItem> = {
+    -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field ? ReturnType<SchemaItem[key]['deserialize']> : never;
+};
+export default interface SchemaTypes<Schema extends readonly any[], SchemaItems = Schema[number]> {
+    TxParams: TxParamsBySchema<SchemaItems>;
+    TxParamsAsync: TxParamsAsyncBySchema<SchemaItems>;
+    TxUnpacked: TxUnpackedBySchema<SchemaItems>;
+}
+export {};

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

@@ -16,7 +16,8 @@ export declare const NAME_BID_RANGES: {
     [k: string]: BigNumber;
 };
 export declare enum ConsensusProtocolVersion {
-    Iris = 5
+    Iris = 5,
+    Ceres = 6
 }
 /**
  * @category transaction builder
@@ -94,5 +95,6 @@ export declare enum Tag {
     AccountsMtree = 626,
     GaAttachTx = 80,
     GaMetaTx = 81,
-    PayingForTx = 82
+    PayingForTx = 82,
+    GaMetaTxAuthData = 810
 }

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

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

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

@@ -2,6 +2,6 @@ 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[];
+    serialize: (value: readonly Input[], params: unknown) => Binary[];
     deserialize: (value: Binary[], params: unknown) => Output[];
 };

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

@@ -1,12 +1,11 @@
 /// <reference types="node" />
 import { Int } from '../constants';
 import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
-export interface Options {
-    denomination?: AE_AMOUNT_FORMATS;
-}
 declare const _default: {
     serializeAettos(value: string | undefined): string;
-    serialize(value: Int | undefined, { denomination, ...options }: Options): Buffer;
+    serialize(value: Int | undefined, params: {}, { denomination }: {
+        denomination?: AE_AMOUNT_FORMATS | undefined;
+    }): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

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

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+import Node from '../../../Node';
 export declare const ProtocolToVmAbi: {
     readonly 5: {
         readonly 'contract-create': {
@@ -23,7 +24,32 @@ export declare const ProtocolToVmAbi: {
             ];
             readonly abiVersion: readonly [
                 AbiVersion.NoAbi,
-                AbiVersion.Sophia
+                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
             ];
         };
     };
@@ -34,9 +60,13 @@ export interface CtVersion {
 }
 export declare function getProtocolDetails(protocolVersion: ConsensusProtocolVersion, type: 'contract-create' | 'contract-call' | 'oracle-call'): CtVersion;
 declare const _default: {
-    serialize(value: CtVersion | undefined, { consensusProtocolVersion }: {
-        consensusProtocolVersion: ConsensusProtocolVersion;
+    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

@@ -5,9 +5,10 @@ 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

@@ -2,5 +2,5 @@
 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>;
+    deserialize: (value: Buffer) => Encoded.Generic<E>;
 };

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

@@ -14,7 +14,9 @@ declare const _default: {
         _computingMinFee?: BigNumber | undefined;
         _pickBiggerFee?: boolean | undefined;
     }): string;
-    serialize(value: import("../constants").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

@@ -2,13 +2,14 @@
 import { Tag } from '../constants';
 import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 declare const _default: {
-    serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, gasMax, _computingGasLimit, }: {
+    serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
         tag: Tag;
         rebuildTx: (params: any) => any;
         unpackTx: typeof unpackTxType;
         buildTx: typeof buildTxType;
-        gasMax: number;
         _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("../constants").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

@@ -4,13 +4,24 @@ import _array from './array';
 import _encoded from './encoded';
 import _entry from './entry';
 import _enumeration from './enumeration';
+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: {
-    serialize(value: import("../constants").AbiVersion | undefined, { tag, consensusProtocolVersion }: {
+    _getProtocolDetails(c: import("../constants").ConsensusProtocolVersion, tag: import("../constants").Tag): import("../constants").AbiVersion;
+    serialize(value: import("../constants").AbiVersion | undefined, { tag }: {
         tag: import("../constants").Tag;
-        consensusProtocolVersion: import("../constants").ConsensusProtocolVersion;
+    }, { 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 address: typeof _address;
@@ -21,17 +32,25 @@ declare const boolean: {
 };
 declare const coinAmount: {
     serializeAettos(value: string | undefined): string;
-    serialize(value: import("../constants").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 ctVersion: {
-    serialize(value: import("./ct-version").CtVersion | undefined, { consensusProtocolVersion }: {
-        consensusProtocolVersion: import("../constants").ConsensusProtocolVersion;
+    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("../constants").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;
 };
@@ -46,7 +65,9 @@ declare const fee: {
         _computingMinFee?: import("bignumber.js").BigNumber | undefined;
         _pickBiggerFee?: boolean | undefined;
     }): string;
-    serialize(value: import("../constants").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: {
@@ -54,21 +75,25 @@ declare const field: {
     deserialize(value: Buffer): string;
 };
 declare const gasLimit: {
-    serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, gasMax, _computingGasLimit, }: {
+    serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
         tag: import("../constants").Tag;
         rebuildTx: (params: any) => any;
         unpackTx: typeof import("..").unpackTx;
         buildTx: typeof import("..").buildTx;
-        gasMax: number;
         _computingGasLimit?: number | undefined;
+    }, { gasMax }: {
+        gasMax?: number | undefined;
     }): Buffer;
     deserialize(value: Buffer): number;
 };
 declare const gasPrice: {
     serializeAettos(value?: string | undefined): string;
-    serialize(value: import("../constants").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;
@@ -80,13 +105,16 @@ declare const nameFee: {
     }): string;
     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: `${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}`;
@@ -111,10 +139,19 @@ 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<[
@@ -123,7 +160,9 @@ export type BinaryData = Buffer | Buffer[] | Buffer[][] | Array<[
     ]>
 ]>;
 export interface Field {
-    serialize: (value: any, options: any) => BinaryData;
+    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 { abiVersion, address, array, boolean, coinAmount, ctVersion, deposit, encoded, entry, enumeration, fee, field, gasLimit, gasPrice, mptree, name, nameFee, nameId, pointers, raw, shortUInt, shortUIntConst, string, uInt, };
+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

@@ -2,6 +2,7 @@
 import { Tag } from '../constants';
 import { Encoded, Encoding } from '../../../utils/encoder';
 import type { unpackTx } from '..';
+import type { TxUnpacked } from '../schema.generated';
 type MPTreeBinary = [
     Buffer,
     Array<[
@@ -31,8 +32,12 @@ declare class MPTree<E extends Encoding, T extends Tag> {
      * @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>>;
+    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;

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

@@ -12,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/short-u-int-const.d.ts

@@ -1,5 +1,7 @@
 /// <reference types="node" />
-export default function genShortUIntConstField<Value extends number>(value: Value): {
-    serialize: (value?: Value) => Buffer;
+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/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/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,39 +1,42 @@
 import { Encoded, Encoding } from '../../utils/encoder';
-import { AE_AMOUNT_FORMATS } from '../../utils/amount-formatter';
-import { RawTxObject, TxTypeSchemas } from './schema';
+import { Field } from './field-types';
+import { TxUnpacked, TxParams, TxParamsAsync } from './schema.generated';
 import { Tag } from './constants';
+/**
+ * JavaScript-based Transaction builder
+ */
+export declare function getSchema(tag: Tag, version?: number): Array<[
+    string,
+    Field
+]>;
 /**
  * Build transaction hash
  * @category transaction builder
  * @param params - Object with tx params
  * @param options - options
- * @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, E extends Encoding = Encoding.Transaction>(params: {
-    tag: TxType;
-    version?: number;
-} & Omit<TxTypeSchemas[TxType], 'tag' | 'version'> & (TxType extends Tag.ContractCreateTx | Tag.ContractCallTx | Tag.ChannelOffChainUpdateCallContract | Tag.GaAttachTx | Tag.GaMetaTx ? {
-    gasMax?: number;
-} : {}), { prefix, denomination, }?: {
+export declare function buildTx<E extends Encoding = Encoding.Transaction>(params: TxParams, { prefix, }?: {
     prefix?: E;
-    denomination?: AE_AMOUNT_FORMATS;
 }): Encoded.Generic<E>;
+export type BuildTxOptions<TxType extends Tag, OmitFields extends string> = Omit<TxParamsAsync & {
+    tag: TxType;
+}, 'tag' | OmitFields>;
 /**
- * Unpack transaction hash
+ * @category transaction builder
+ */
+export declare function buildTxAsync(params: TxParamsAsync): Promise<Encoded.Transaction>;
+/**
+ * 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): RawTxObject<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