@aeternity/aepp-sdk 13.3.3 → 14.1.0

package/es/tx/builder/schema.d.ts

@@ -1,163 +1,46 @@
 /**
  * Transaction Schema for TxBuilder
  */
-/// <reference types="node" />
-import { Tag } from './constants';
-import SchemaTypes from './SchemaTypes';
-import { Encoded } from '../../utils/encoder';
+import { Tag } from './constants.js';
+import SchemaTypes from './SchemaTypes.js';
+import coinAmount from './field-types/coin-amount.js';
+import { Encoded, Encoding } from '../../utils/encoder.js';
+import { EntryTag } from './entry/constants.js';
+import { EntParams, EntUnpacked } from './entry/schema.generated.js';
+/**
+ * @category oracle
+ */
 export declare enum ORACLE_TTL_TYPES {
     delta = 0,
     block = 1
 }
-export declare enum CallReturnType {
-    Ok = 0,
-    Error = 1,
-    Revert = 2
-}
-interface EntryAny {
+interface TransactionAny {
     serialize: (value: TxParams | Uint8Array | Encoded.Transaction) => Buffer;
     deserialize: (value: Buffer) => TxUnpacked;
     recursiveType: true;
 }
-interface EntrySignedTx {
-    serialize: (value: TxParams & {
+interface TransactionSignedTx {
+    serialize: (value: (TxParams & {
         tag: Tag.SignedTx;
-    } | Uint8Array | Encoded.Transaction) => Buffer;
+    }) | Uint8Array | Encoded.Transaction) => Buffer;
     deserialize: (value: Buffer) => TxUnpacked & {
         tag: Tag.SignedTx;
     };
     recursiveType: true;
 }
-interface EntryMtreeValueArray {
-    serialize: (value: Array<TxParams & {
-        tag: Tag.MtreeValue;
-    } | Uint8Array | Encoded.Transaction>) => Buffer[];
-    deserialize: (value: Buffer[]) => Array<TxUnpacked & {
-        tag: Tag.MtreeValue;
-    }>;
-    recursiveType: true;
-}
 interface EntryTreesPoi {
-    serialize: (value: TxParams & {
-        tag: Tag.TreesPoi;
-    } | Uint8Array | Encoded.Transaction) => Buffer;
-    deserialize: (value: Buffer) => TxUnpacked & {
-        tag: Tag.TreesPoi;
+    serialize: (value: (EntParams & {
+        tag: EntryTag.TreesPoi;
+    }) | Uint8Array | Encoded.Transaction) => Buffer;
+    deserialize: (value: Buffer) => EntUnpacked & {
+        tag: EntryTag.TreesPoi;
     };
     recursiveType: true;
 }
-interface MapContracts {
-    serialize: (value: Record<Encoded.ContractAddress, TxParams & {
-        tag: Tag.Contract;
-    }>) => Buffer;
-    deserialize: (value: Buffer) => Record<Encoded.ContractAddress, TxUnpacked & {
-        tag: Tag.Contract;
-    }>;
-    recursiveType: true;
-}
-interface MapAccounts {
-    serialize: (value: Record<Encoded.AccountAddress, TxParams & {
-        tag: Tag.Account;
-    }>) => Buffer;
-    deserialize: (value: Buffer) => Record<Encoded.AccountAddress, TxUnpacked & {
-        tag: Tag.Account;
-    }>;
-    recursiveType: true;
-}
-interface MapCalls {
-    serialize: (value: Record<Encoded.Bytearray, TxParams & {
-        tag: Tag.ContractCall;
-    }>) => Buffer;
-    deserialize: (value: Buffer) => Record<Encoded.Bytearray, TxUnpacked & {
-        tag: Tag.ContractCall;
-    }>;
-    recursiveType: true;
-}
-interface MapChannels {
-    serialize: (value: Record<Encoded.Channel, TxParams & {
-        tag: Tag.Channel;
-    }>) => Buffer;
-    deserialize: (value: Buffer) => Record<Encoded.Channel, TxUnpacked & {
-        tag: Tag.Channel;
-    }>;
-    recursiveType: true;
-}
-interface MapNames {
-    serialize: (value: Record<Encoded.Name, TxParams & {
-        tag: Tag.Name;
-    }>) => Buffer;
-    deserialize: (value: Buffer) => Record<Encoded.Name, TxUnpacked & {
-        tag: Tag.Name;
-    }>;
-    recursiveType: true;
-}
-interface MapOracles {
-    serialize: (value: Record<Encoded.OracleAddress, TxParams & {
-        tag: Tag.Oracle;
-    }>) => Buffer;
-    deserialize: (value: Buffer) => Record<Encoded.OracleAddress, TxUnpacked & {
-        tag: Tag.Oracle;
-    }>;
-    recursiveType: true;
-}
 /**
  * @see {@link https://github.com/aeternity/protocol/blob/c007deeac4a01e401238412801ac7084ac72d60e/serializations.md#accounts-version-1-basic-accounts}
  */
 export declare const txSchema: readonly [{
-    readonly tag: {
-        serialize: (value: Tag.Account) => Buffer;
-        deserialize: (value: Buffer) => Tag.Account;
-        constValue: Tag.Account;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value: 1) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly nonce: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly balance: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.Account) => Buffer;
-        deserialize: (value: Buffer) => Tag.Account;
-        constValue: Tag.Account;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 2 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 2;
-        constValue: 2;
-        constValueOptional: boolean;
-    };
-    readonly flags: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly nonce: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly balance: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly gaContract: {
-        serialize: (value: `ct_${string}` | `nm_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ct_${string}` | `nm_${string}`;
-    };
-    readonly gaAuthFun: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
-}, {
     readonly tag: {
         serialize: (value: Tag.SignedTx) => Buffer;
         deserialize: (value: Buffer) => Tag.SignedTx;
@@ -174,7 +57,7 @@ export declare const txSchema: readonly [{
         serialize: (value: readonly Uint8Array[], params: unknown) => Buffer[];
         deserialize: (value: Buffer[], params: unknown) => Buffer[];
     };
-    readonly encodedTx: EntryAny;
+    readonly encodedTx: TransactionAny;
 }, {
     readonly tag: {
         serialize: (value: Tag.SpendTx) => Buffer;
@@ -198,46 +81,42 @@ export declare const txSchema: readonly [{
     };
     readonly amount: {
         serializeAettos(value: string | undefined, params: {}, options: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             senderId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -246,43 +125,6 @@ export declare const txSchema: readonly [{
         serialize: (value?: `ba_${string}` | undefined) => Buffer;
         deserialize: (value: Buffer) => `ba_${string}`;
     };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.Name) => Buffer;
-        deserialize: (value: Buffer) => Tag.Name;
-        constValue: Tag.Name;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly accountId: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly nameTtl: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly status: {
-        serialize(buffer: Uint8Array): Buffer;
-        deserialize(buffer: Buffer): Buffer;
-    };
-    readonly clientTtl: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly pointers: {
-        serialize(pointers: (import("../../apis/node").NamePointer & {
-            id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`;
-        })[]): Buffer[][];
-        deserialize(pointers: [key: Buffer, id: Buffer][]): (import("../../apis/node").NamePointer & {
-            id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`;
-        })[];
-    };
 }, {
     readonly tag: {
         serialize: (value: Tag.NamePreclaimTx) => Buffer;
@@ -301,13 +143,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             accountId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -317,30 +161,24 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `cm_${string}`;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
 }, {
@@ -361,61 +199,55 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             accountId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
     readonly name: {
-        serialize(value: `${string}.chain`): Buffer;
-        deserialize(value: Buffer): `${string}.chain`;
+        serialize(value: import("./constants.js").AensName): Buffer;
+        deserialize(value: Buffer): import("./constants.js").AensName;
     };
     readonly nameSalt: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
+        serialize: (value: import("./constants.js").Int | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => string;
     };
     readonly nameFee: {
         serializeAettos(_value: string | undefined, txFields: {
-            name: `${string}.chain`;
+            name: import("./constants.js").AensName;
         }): string;
-        serialize(value: import("./constants").Int | undefined, txFields: {
-            name: `${string}.chain`;
-        }, parameters: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: import("./constants.js").Int | undefined, txFields: {
+            name: import("./constants.js").AensName;
+        } & Parameters<(typeof coinAmount)["serialize"]>[1], parameters: Parameters<(typeof coinAmount)["serialize"]>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
 }, {
@@ -436,19 +268,21 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             accountId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
     readonly nameId: {
-        serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
+        serialize(value: import("./constants.js").AensName | Encoded.Name): Buffer;
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly nameTtl: {
@@ -456,11 +290,11 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => number;
     };
     readonly pointers: {
-        serialize(pointers: (import("../../apis/node").NamePointer & {
-            id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`;
-        })[]): Buffer[][];
-        deserialize(pointers: [key: Buffer, id: Buffer][]): (import("../../apis/node").NamePointer & {
-            id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`;
+        serialize: (pointers: (import("../../apis/node/index.js").NamePointer & {
+            id: Encoded.Generic<import("./field-types/address.js").AddressEncodings>;
+        })[]) => Buffer[][];
+        deserialize: (pointers: Array<[key: Buffer, id: Buffer]>) => (import("../../apis/node/index.js").NamePointer & {
+            id: Encoded.Generic<import("./field-types/address.js").AddressEncodings>;
         })[];
     };
     readonly clientTtl: {
@@ -468,30 +302,24 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
 }, {
@@ -512,19 +340,21 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             accountId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
     readonly nameId: {
-        serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
+        serialize(value: import("./constants.js").AensName | Encoded.Name): Buffer;
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly nameTtl: {
@@ -532,11 +362,11 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => number;
     };
     readonly pointers: {
-        serialize(pointers: (import("../../apis/node").NamePointer & {
-            id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}` | `ba_${string}`;
-        })[]): Buffer[][];
-        deserialize(pointers: [key: Buffer, id: Buffer][]): (import("../../apis/node").NamePointer & {
-            id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}` | `ba_${string}`;
+        serialize: (pointers: (import("../../apis/node/index.js").NamePointer & {
+            id: Encoded.Generic<import("./field-types/address.js").AddressEncodings | Encoding.Bytearray>;
+        })[]) => Buffer[][];
+        deserialize: (pointers: Array<[key: Buffer, id: Buffer]>) => (import("../../apis/node/index.js").NamePointer & {
+            id: Encoded.Generic<import("./field-types/address.js").AddressEncodings | Encoding.Bytearray>;
         })[];
     };
     readonly clientTtl: {
@@ -544,30 +374,24 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
 }, {
@@ -588,19 +412,21 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             accountId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
     readonly nameId: {
-        serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
+        serialize(value: import("./constants.js").AensName | Encoded.Name): Buffer;
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly recipientId: {
@@ -608,30 +434,24 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}` | `nm_${string}`;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
 }, {
@@ -652,98 +472,44 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             accountId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
     readonly nameId: {
-        serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
+        serialize(value: import("./constants.js").AensName | Encoded.Name): Buffer;
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.Contract) => Buffer;
-        deserialize: (value: Buffer) => Tag.Contract;
-        constValue: Tag.Contract;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly owner: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly ctVersion: {
-        serialize(value: import("./field-types/ct-version").CtVersion | undefined, params: {}, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-        }): Buffer;
-        prepare(value: import("./field-types/ct-version").CtVersion | undefined, params: {}, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./field-types/ct-version").CtVersion | undefined>;
-        deserialize(buffer: Buffer): import("./field-types/ct-version").CtVersion;
-    };
-    readonly code: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
-    readonly log: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
-    readonly active: {
-        serialize(value: boolean): Buffer;
-        deserialize(buffer: Buffer): boolean;
-    };
-    readonly referers: {
-        serialize: (value: readonly `ak_${string}`[], params: unknown) => Buffer[];
-        deserialize: (value: Buffer[], params: unknown) => `ak_${string}`[];
-    };
-    readonly deposit: {
-        serializeAettos(value: string | undefined, params: {}, options: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
-        deserialize(value: Buffer): string;
-    };
 }, {
     readonly tag: {
         serialize: (value: Tag.ContractCreateTx) => Buffer;
@@ -762,13 +528,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             ownerId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -778,52 +546,46 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `cb_${string}`;
     };
     readonly ctVersion: {
-        serialize(value: import("./field-types/ct-version").CtVersion | undefined, params: {}, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
+        serialize(value: import("./field-types/ct-version.js").CtVersion | undefined, params: {}, { consensusProtocolVersion, }: {
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
         }): Buffer;
-        prepare(value: import("./field-types/ct-version").CtVersion | undefined, params: {}, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./field-types/ct-version").CtVersion | undefined>;
-        deserialize(buffer: Buffer): import("./field-types/ct-version").CtVersion;
+        prepare(value: import("./field-types/ct-version.js").CtVersion | undefined, params: {}, options: {
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./field-types/ct-version.js").CtVersion | undefined>;
+        deserialize(buffer: Buffer): import("./field-types/ct-version.js").CtVersion;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly deposit: {
-        serialize: (value: import("./constants").Int | undefined, params: {}, options: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize: (value: import("./constants.js").Int | undefined, params: {}, options: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }) => Buffer;
         deserialize: (value: Buffer) => string;
     };
     readonly amount: {
         serializeAettos(value: string | undefined, params: {}, options: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
@@ -831,22 +593,22 @@ export declare const txSchema: readonly [{
         serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
             tag: Tag;
             rebuildTx: (params: any) => any;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingGasLimit?: number | undefined;
+            unpackTx: typeof import("./index.js").unpackTx;
+            buildTx: typeof import("./index.js").buildTx;
+            _computingGasLimit?: number;
         }, { gasMax }: {
-            gasMax?: number | undefined;
+            gasMax?: number;
         }): Buffer;
         deserialize(value: Buffer): number;
     };
     readonly gasPrice: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode, denomination }: {
-            onNode?: import("../..").Node | undefined;
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Promise<import("./constants").Int | undefined>;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, }: {
+            onNode?: import("../../Node.js").default;
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
+        }): Promise<import("./constants.js").Int | undefined>;
         serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
@@ -872,13 +634,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             callerId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -888,51 +652,45 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ct_${string}` | `nm_${string}`;
     };
     readonly abiVersion: {
-        _getProtocolDetails(c: import("./constants").ConsensusProtocolVersion, tag: Tag): import("./constants").AbiVersion;
-        serialize(value: import("./constants").AbiVersion | undefined, { tag }: {
+        _getProtocolDetails(c: import("./constants.js").ConsensusProtocolVersion, tag: Tag): import("./constants.js").AbiVersion;
+        serialize(value: import("./constants.js").AbiVersion | undefined, { tag }: {
             tag: Tag;
-        }, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
+        }, { consensusProtocolVersion, }: {
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
         }): Buffer;
-        prepare(value: import("./constants").AbiVersion | undefined, { tag }: {
+        prepare(value: import("./constants.js").AbiVersion | undefined, { tag }: {
             tag: Tag;
         }, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").AbiVersion | undefined>;
-        deserialize(buffer: Buffer): import("./constants").AbiVersion;
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").AbiVersion | undefined>;
+        deserialize(buffer: Buffer): import("./constants.js").AbiVersion;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly amount: {
         serializeAettos(value: string | undefined, params: {}, options: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
@@ -940,22 +698,22 @@ export declare const txSchema: readonly [{
         serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
             tag: Tag;
             rebuildTx: (params: any) => any;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingGasLimit?: number | undefined;
+            unpackTx: typeof import("./index.js").unpackTx;
+            buildTx: typeof import("./index.js").buildTx;
+            _computingGasLimit?: number;
         }, { gasMax }: {
-            gasMax?: number | undefined;
+            gasMax?: number;
         }): Buffer;
         deserialize(value: Buffer): number;
     };
     readonly gasPrice: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode, denomination }: {
-            onNode?: import("../..").Node | undefined;
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Promise<import("./constants").Int | undefined>;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, }: {
+            onNode?: import("../../Node.js").default;
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
+        }): Promise<import("./constants.js").Int | undefined>;
         serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
@@ -963,106 +721,6 @@ export declare const txSchema: readonly [{
         serialize: (value: `cb_${string}`) => Buffer;
         deserialize: (value: Buffer) => `cb_${string}`;
     };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ContractCall) => Buffer;
-        deserialize: (value: Buffer) => Tag.ContractCall;
-        constValue: Tag.ContractCall;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 2 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 2;
-        constValue: 2;
-        constValueOptional: boolean;
-    };
-    readonly callerId: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly callerNonce: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly height: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly contractId: {
-        serialize: (value: `ct_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ct_${string}`;
-    };
-    readonly gasPrice: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly gasUsed: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly returnValue: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
-    readonly returnType: {
-        serialize: (value: CallReturnType) => Buffer;
-        deserialize: (value: Buffer) => CallReturnType;
-    };
-    readonly log: {
-        serialize: (value: readonly Uint8Array[], params: unknown) => Buffer[];
-        deserialize: (value: Buffer[], params: unknown) => Buffer[];
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.Oracle) => Buffer;
-        deserialize: (value: Buffer) => Tag.Oracle;
-        constValue: Tag.Oracle;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly accountId: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly queryFormat: {
-        serialize(string: string): Buffer;
-        deserialize(buffer: Buffer): string;
-    };
-    readonly responseFormat: {
-        serialize(string: string): Buffer;
-        deserialize(buffer: Buffer): string;
-    };
-    readonly queryFee: {
-        serializeAettos(value: string | undefined, params: {}, options: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly oracleTtlValue: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly abiVersion: {
-        _getProtocolDetails(c: import("./constants").ConsensusProtocolVersion, tag: Tag): import("./constants").AbiVersion;
-        serialize(value: import("./constants").AbiVersion | undefined, { tag }: {
-            tag: Tag;
-        }, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-        }): Buffer;
-        prepare(value: import("./constants").AbiVersion | undefined, { tag }: {
-            tag: Tag;
-        }, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").AbiVersion | undefined>;
-        deserialize(buffer: Buffer): import("./constants").AbiVersion;
-    };
 }, {
     readonly tag: {
         serialize: (value: Tag.OracleRegisterTx) => Buffer;
@@ -1081,13 +739,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             accountId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1102,8 +762,8 @@ export declare const txSchema: readonly [{
     };
     readonly queryFee: {
         serializeAettos(value: string | undefined, params: {}, options: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
@@ -1116,46 +776,40 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly abiVersion: {
-        _getProtocolDetails(c: import("./constants").ConsensusProtocolVersion, tag: Tag): import("./constants").AbiVersion;
-        serialize(value: import("./constants").AbiVersion | undefined, { tag }: {
+        _getProtocolDetails(c: import("./constants.js").ConsensusProtocolVersion, tag: Tag): import("./constants.js").AbiVersion;
+        serialize(value: import("./constants.js").AbiVersion | undefined, { tag }: {
             tag: Tag;
-        }, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
+        }, { consensusProtocolVersion, }: {
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
         }): Buffer;
-        prepare(value: import("./constants").AbiVersion | undefined, { tag }: {
+        prepare(value: import("./constants.js").AbiVersion | undefined, { tag }: {
             tag: Tag;
         }, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").AbiVersion | undefined>;
-        deserialize(buffer: Buffer): import("./constants").AbiVersion;
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").AbiVersion | undefined>;
+        deserialize(buffer: Buffer): import("./constants.js").AbiVersion;
     };
 }, {
     readonly tag: {
@@ -1175,13 +829,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ok_${string}` | `nm_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             oracleId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1195,30 +851,24 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
 }, {
@@ -1239,13 +889,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             senderId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1259,13 +911,13 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): string;
     };
     readonly queryFee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, options: {
-            oracleId?: `ok_${string}` | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int>;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, options: {
+            oracleId?: Encoded.OracleAddress;
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int>;
         serializeAettos(value: string | undefined, params: {}, options: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
@@ -1286,30 +938,24 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
 }, {
@@ -1330,13 +976,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ok_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             oracleId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1358,30 +1006,24 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
 }, {
@@ -1402,7 +1044,7 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly initiatorAmount: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly responder: {
@@ -1410,42 +1052,36 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly responderAmount: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly channelReserve: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly lockPeriod: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly initiatorDelegateIds: {
@@ -1461,13 +1097,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `st_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             initiator: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1494,48 +1132,44 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly initiatorAmountFinal: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly responderAmountFinal: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             fromId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1569,38 +1203,34 @@ export declare const txSchema: readonly [{
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             fromId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1634,38 +1264,34 @@ export declare const txSchema: readonly [{
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
-        prepare: (value: number | undefined, params: {}, options: {
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
+        prepare: (value: number | undefined, params: {}, options: {
             fromId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1692,34 +1318,28 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly amount: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly stateHash: {
@@ -1731,13 +1351,15 @@ export declare const txSchema: readonly [{
         deserialize(value: Buffer): number;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             fromId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1764,34 +1386,28 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly amount: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly stateHash: {
@@ -1803,13 +1419,15 @@ export declare const txSchema: readonly [{
         deserialize(value: Buffer): number;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             fromId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1836,48 +1454,44 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly initiatorAmountFinal: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly responderAmountFinal: {
-        serialize(value: import("./constants").Int): Buffer;
+        serialize(value: import("./constants.js").Int): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             fromId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1926,38 +1540,34 @@ export declare const txSchema: readonly [{
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             fromId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1987,79 +1597,6 @@ export declare const txSchema: readonly [{
         serialize: (value: `st_${string}`) => Buffer;
         deserialize: (value: Buffer) => `st_${string}`;
     };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.Channel) => Buffer;
-        deserialize: (value: Buffer) => Tag.Channel;
-        constValue: Tag.Channel;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 3 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 3;
-        constValue: 3;
-        constValueOptional: boolean;
-    };
-    readonly initiator: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly responder: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly channelAmount: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly initiatorAmount: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly responderAmount: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly channelReserve: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly initiatorDelegateIds: {
-        serialize: (value: readonly (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[];
-        deserialize: (value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
-    };
-    readonly responderDelegateIds: {
-        serialize: (value: readonly (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[];
-        deserialize: (value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
-    };
-    readonly stateHash: {
-        serialize: (value: `st_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `st_${string}`;
-    };
-    readonly round: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly soloRound: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly lockPeriod: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly lockedUntil: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly initiatorAuth: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
-    readonly responderAuth: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
 }, {
     readonly tag: {
         serialize: (value: Tag.ChannelSnapshotSoloTx) => Buffer;
@@ -2088,671 +1625,38 @@ export declare const txSchema: readonly [{
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             fromId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ChannelOffChainUpdateTransfer) => Buffer;
-        deserialize: (value: Buffer) => Tag.ChannelOffChainUpdateTransfer;
-        constValue: Tag.ChannelOffChainUpdateTransfer;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly from: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly to: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly amount: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ChannelOffChainUpdateDeposit) => Buffer;
-        deserialize: (value: Buffer) => Tag.ChannelOffChainUpdateDeposit;
-        constValue: Tag.ChannelOffChainUpdateDeposit;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly from: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly amount: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ChannelOffChainUpdateWithdraw) => Buffer;
-        deserialize: (value: Buffer) => Tag.ChannelOffChainUpdateWithdraw;
-        constValue: Tag.ChannelOffChainUpdateWithdraw;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly from: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly amount: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ChannelOffChainUpdateCreateContract) => Buffer;
-        deserialize: (value: Buffer) => Tag.ChannelOffChainUpdateCreateContract;
-        constValue: Tag.ChannelOffChainUpdateCreateContract;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly owner: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly ctVersion: {
-        serialize(value: import("./field-types/ct-version").CtVersion | undefined, params: {}, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-        }): Buffer;
-        prepare(value: import("./field-types/ct-version").CtVersion | undefined, params: {}, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./field-types/ct-version").CtVersion | undefined>;
-        deserialize(buffer: Buffer): import("./field-types/ct-version").CtVersion;
-    };
-    readonly code: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
-    readonly deposit: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly callData: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ChannelOffChainUpdateCallContract) => Buffer;
-        deserialize: (value: Buffer) => Tag.ChannelOffChainUpdateCallContract;
-        constValue: Tag.ChannelOffChainUpdateCallContract;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly caller: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-    readonly contract: {
-        serialize: (value: `ct_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ct_${string}`;
-    };
-    readonly abiVersion: {
-        _getProtocolDetails(c: import("./constants").ConsensusProtocolVersion, tag: Tag): import("./constants").AbiVersion;
-        serialize(value: import("./constants").AbiVersion | undefined, { tag }: {
-            tag: Tag;
-        }, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-        }): Buffer;
-        prepare(value: import("./constants").AbiVersion | undefined, { tag }: {
-            tag: Tag;
-        }, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").AbiVersion | undefined>;
-        deserialize(buffer: Buffer): import("./constants").AbiVersion;
-    };
-    readonly amount: {
-        serialize(value: import("./constants").Int): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly callData: {
-        serialize: (value: `cb_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `cb_${string}`;
-    };
-    readonly callStack: {
-        serialize(buffer: Uint8Array): Buffer;
-        deserialize(buffer: Buffer): Buffer;
-    };
-    readonly gasPrice: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode, denomination }: {
-            onNode?: import("../..").Node | undefined;
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly gasLimit: {
-        serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
-            tag: Tag;
-            rebuildTx: (params: any) => any;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingGasLimit?: number | undefined;
-        }, { gasMax }: {
-            gasMax?: number | undefined;
-        }): Buffer;
-        deserialize(value: Buffer): number;
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ChannelClientReconnectTx) => Buffer;
-        deserialize: (value: Buffer) => Tag.ChannelClientReconnectTx;
-        constValue: Tag.ChannelClientReconnectTx;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly channelId: {
-        serialize: (value: `ch_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ch_${string}`;
-    };
-    readonly round: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
-    };
-    readonly role: {
-        serialize(string: string): Buffer;
-        deserialize(buffer: Buffer): string;
-    };
-    readonly pubkey: {
-        serialize: (value: `ak_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}`;
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.TreesPoi) => Buffer;
-        deserialize: (value: Buffer) => Tag.TreesPoi;
-        constValue: Tag.TreesPoi;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly accounts: {
-        serialize: (value: readonly {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.AccountAddress;
-            readonly "__#3@#tag": Tag.Account;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ak_${string}`): (import("./schema.generated").TxUnpackedAccount1 & {
-                tag: Tag.Account;
-            }) | (import("./schema.generated").TxUnpackedAccount2 & {
-                tag: Tag.Account;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ak_${string}`, (import("./schema.generated").TxUnpackedAccount1 & {
-                tag: Tag.Account;
-            }) | (import("./schema.generated").TxUnpackedAccount2 & {
-                tag: Tag.Account;
-            })>;
-        }[], params: unknown) => [Buffer, [Buffer, Buffer[]][]][];
-        deserialize: (value: [Buffer, [Buffer, Buffer[]][]][], params: unknown) => {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.AccountAddress;
-            readonly "__#3@#tag": Tag.Account;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ak_${string}`): (import("./schema.generated").TxUnpackedAccount1 & {
-                tag: Tag.Account;
-            }) | (import("./schema.generated").TxUnpackedAccount2 & {
-                tag: Tag.Account;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ak_${string}`, (import("./schema.generated").TxUnpackedAccount1 & {
-                tag: Tag.Account;
-            }) | (import("./schema.generated").TxUnpackedAccount2 & {
-                tag: Tag.Account;
-            })>;
-        }[];
-    };
-    readonly calls: {
-        serialize: (value: readonly {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.Bytearray;
-            readonly "__#3@#tag": Tag.ContractCall;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ba_${string}`): (import("./schema.generated").TxUnpackedContractCall2 & {
-                tag: Tag.ContractCall;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ba_${string}`, import("./schema.generated").TxUnpackedContractCall2 & {
-                tag: Tag.ContractCall;
-            }>;
-        }[], params: unknown) => [Buffer, [Buffer, Buffer[]][]][];
-        deserialize: (value: [Buffer, [Buffer, Buffer[]][]][], params: unknown) => {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.Bytearray;
-            readonly "__#3@#tag": Tag.ContractCall;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ba_${string}`): (import("./schema.generated").TxUnpackedContractCall2 & {
-                tag: Tag.ContractCall;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ba_${string}`, import("./schema.generated").TxUnpackedContractCall2 & {
-                tag: Tag.ContractCall;
-            }>;
-        }[];
-    };
-    readonly channels: {
-        serialize: (value: readonly {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.Channel;
-            readonly "__#3@#tag": Tag.Channel;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ch_${string}`): (import("./schema.generated").TxUnpackedChannel3 & {
-                tag: Tag.Channel;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ch_${string}`, import("./schema.generated").TxUnpackedChannel3 & {
-                tag: Tag.Channel;
-            }>;
-        }[], params: unknown) => [Buffer, [Buffer, Buffer[]][]][];
-        deserialize: (value: [Buffer, [Buffer, Buffer[]][]][], params: unknown) => {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.Channel;
-            readonly "__#3@#tag": Tag.Channel;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ch_${string}`): (import("./schema.generated").TxUnpackedChannel3 & {
-                tag: Tag.Channel;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ch_${string}`, import("./schema.generated").TxUnpackedChannel3 & {
-                tag: Tag.Channel;
-            }>;
-        }[];
-    };
-    readonly contracts: {
-        serialize: (value: readonly {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.ContractAddress;
-            readonly "__#3@#tag": Tag.Contract;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ct_${string}`): (import("./schema.generated").TxUnpackedContract1 & {
-                tag: Tag.Contract;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ct_${string}`, import("./schema.generated").TxUnpackedContract1 & {
-                tag: Tag.Contract;
-            }>;
-        }[], params: unknown) => [Buffer, [Buffer, Buffer[]][]][];
-        deserialize: (value: [Buffer, [Buffer, Buffer[]][]][], params: unknown) => {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.ContractAddress;
-            readonly "__#3@#tag": Tag.Contract;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ct_${string}`): (import("./schema.generated").TxUnpackedContract1 & {
-                tag: Tag.Contract;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ct_${string}`, import("./schema.generated").TxUnpackedContract1 & {
-                tag: Tag.Contract;
-            }>;
-        }[];
-    };
-    readonly ns: {
-        serialize: (value: readonly {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.Name;
-            readonly "__#3@#tag": Tag.Name;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `nm_${string}`): (import("./schema.generated").TxUnpackedName1 & {
-                tag: Tag.Name;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`nm_${string}`, import("./schema.generated").TxUnpackedName1 & {
-                tag: Tag.Name;
-            }>;
-        }[], params: unknown) => [Buffer, [Buffer, Buffer[]][]][];
-        deserialize: (value: [Buffer, [Buffer, Buffer[]][]][], params: unknown) => {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.Name;
-            readonly "__#3@#tag": Tag.Name;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `nm_${string}`): (import("./schema.generated").TxUnpackedName1 & {
-                tag: Tag.Name;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`nm_${string}`, import("./schema.generated").TxUnpackedName1 & {
-                tag: Tag.Name;
-            }>;
-        }[];
-    };
-    readonly oracles: {
-        serialize: (value: readonly {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.OracleAddress;
-            readonly "__#3@#tag": Tag.Oracle;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ok_${string}`): (import("./schema.generated").TxUnpackedOracle1 & {
-                tag: Tag.Oracle;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ok_${string}`, import("./schema.generated").TxUnpackedOracle1 & {
-                tag: Tag.Oracle;
-            }>;
-        }[], params: unknown) => [Buffer, [Buffer, Buffer[]][]][];
-        deserialize: (value: [Buffer, [Buffer, Buffer[]][]][], params: unknown) => {
-            readonly "__#3@#rootHash": string;
-            "__#3@#isComplete": boolean;
-            readonly isComplete: boolean;
-            readonly "__#3@#nodes": {
-                [key: string]: Buffer[];
-            };
-            readonly "__#3@#encoding": Encoded.Encoding.OracleAddress;
-            readonly "__#3@#tag": Tag.Oracle;
-            readonly "__#3@#unpackTx": typeof import(".").unpackTx;
-            isEqual(tree: any): boolean;
-            serialize(): [Buffer, [Buffer, Buffer[]][]];
-            "__#3@#getRaw"(_key: string): Buffer | undefined;
-            get(key: `ok_${string}`): (import("./schema.generated").TxUnpackedOracle1 & {
-                tag: Tag.Oracle;
-            }) | undefined;
-            "__#3@#entriesRaw"(): [string, Buffer][];
-            toObject(): Record<`ok_${string}`, import("./schema.generated").TxUnpackedOracle1 & {
-                tag: Tag.Oracle;
-            }>;
-        }[];
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.StateTrees) => Buffer;
-        deserialize: (value: Buffer) => Tag.StateTrees;
-        constValue: Tag.StateTrees;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 0 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 0;
-        constValue: 0;
-        constValueOptional: boolean;
-    };
-    readonly contracts: MapContracts;
-    readonly calls: MapCalls;
-    readonly channels: MapChannels;
-    readonly ns: MapNames;
-    readonly oracles: MapOracles;
-    readonly accounts: MapAccounts;
-}, {
-    readonly tag: {
-        serialize: (value: Tag.Mtree) => Buffer;
-        deserialize: (value: Buffer) => Tag.Mtree;
-        constValue: Tag.Mtree;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly values: EntryMtreeValueArray;
-}, {
-    readonly tag: {
-        serialize: (value: Tag.MtreeValue) => Buffer;
-        deserialize: (value: Buffer) => Tag.MtreeValue;
-        constValue: Tag.MtreeValue;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly key: {
-        serialize(buffer: Uint8Array): Buffer;
-        deserialize(buffer: Buffer): Buffer;
-    };
-    readonly value: {
-        serialize(buffer: Uint8Array): Buffer;
-        deserialize(buffer: Buffer): Buffer;
-    };
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ContractsMtree) => Buffer;
-        deserialize: (value: Buffer) => Tag.ContractsMtree;
-        constValue: Tag.ContractsMtree;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly payload: MapContracts;
-}, {
-    readonly tag: {
-        serialize: (value: Tag.CallsMtree) => Buffer;
-        deserialize: (value: Buffer) => Tag.CallsMtree;
-        constValue: Tag.CallsMtree;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly payload: MapCalls;
-}, {
-    readonly tag: {
-        serialize: (value: Tag.ChannelsMtree) => Buffer;
-        deserialize: (value: Buffer) => Tag.ChannelsMtree;
-        constValue: Tag.ChannelsMtree;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly payload: MapChannels;
-}, {
-    readonly tag: {
-        serialize: (value: Tag.NameserviceMtree) => Buffer;
-        deserialize: (value: Buffer) => Tag.NameserviceMtree;
-        constValue: Tag.NameserviceMtree;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly payload: MapNames;
-}, {
-    readonly tag: {
-        serialize: (value: Tag.OraclesMtree) => Buffer;
-        deserialize: (value: Buffer) => Tag.OraclesMtree;
-        constValue: Tag.OraclesMtree;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly payload: MapOracles;
-}, {
-    readonly tag: {
-        serialize: (value: Tag.AccountsMtree) => Buffer;
-        deserialize: (value: Buffer) => Tag.AccountsMtree;
-        constValue: Tag.AccountsMtree;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly payload: MapAccounts;
 }, {
     readonly tag: {
         serialize: (value: Tag.GaAttachTx) => Buffer;
@@ -2771,13 +1675,15 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             ownerId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -2791,62 +1697,56 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): Buffer;
     };
     readonly ctVersion: {
-        serialize(value: import("./field-types/ct-version").CtVersion | undefined, params: {}, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
+        serialize(value: import("./field-types/ct-version.js").CtVersion | undefined, params: {}, { consensusProtocolVersion, }: {
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
         }): Buffer;
-        prepare(value: import("./field-types/ct-version").CtVersion | undefined, params: {}, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./field-types/ct-version").CtVersion | undefined>;
-        deserialize(buffer: Buffer): import("./field-types/ct-version").CtVersion;
+        prepare(value: import("./field-types/ct-version.js").CtVersion | undefined, params: {}, options: {
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./field-types/ct-version.js").CtVersion | undefined>;
+        deserialize(buffer: Buffer): import("./field-types/ct-version.js").CtVersion;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
         prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
-            onNode?: import("../..").Node | undefined;
-            absoluteTtl?: boolean | undefined;
-            _isInternalBuild?: boolean | undefined;
-        } & Omit<{
-            _expectedMineRate?: number | undefined;
-            _microBlockCycle?: number | undefined;
-            onNode: import("../..").Node;
-        }, "onNode">): Promise<number | undefined>;
+            onNode?: import("../../Node.js").default;
+            absoluteTtl?: boolean;
+            _isInternalBuild?: boolean;
+        } & Omit<Parameters<typeof import("../../chain.js")._getPollInterval>[1], "onNode">): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly gasLimit: {
         serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
             tag: Tag;
             rebuildTx: (params: any) => any;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingGasLimit?: number | undefined;
+            unpackTx: typeof import("./index.js").unpackTx;
+            buildTx: typeof import("./index.js").buildTx;
+            _computingGasLimit?: number;
         }, { gasMax }: {
-            gasMax?: number | undefined;
+            gasMax?: number;
         }): Buffer;
         deserialize(value: Buffer): number;
     };
     readonly gasPrice: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode, denomination }: {
-            onNode?: import("../..").Node | undefined;
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Promise<import("./constants").Int | undefined>;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, }: {
+            onNode?: import("../../Node.js").default;
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
+        }): Promise<import("./constants.js").Int | undefined>;
         serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
@@ -2876,58 +1776,56 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `cb_${string}`;
     };
     readonly abiVersion: {
-        _getProtocolDetails(c: import("./constants").ConsensusProtocolVersion, tag: Tag): import("./constants").AbiVersion;
-        serialize(value: import("./constants").AbiVersion | undefined, { tag }: {
+        _getProtocolDetails(c: import("./constants.js").ConsensusProtocolVersion, tag: Tag): import("./constants.js").AbiVersion;
+        serialize(value: import("./constants.js").AbiVersion | undefined, { tag }: {
             tag: Tag;
-        }, { consensusProtocolVersion }: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
+        }, { consensusProtocolVersion, }: {
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
         }): Buffer;
-        prepare(value: import("./constants").AbiVersion | undefined, { tag }: {
+        prepare(value: import("./constants.js").AbiVersion | undefined, { tag }: {
             tag: Tag;
         }, options: {
-            consensusProtocolVersion?: import("./constants").ConsensusProtocolVersion | undefined;
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").AbiVersion | undefined>;
-        deserialize(buffer: Buffer): import("./constants").AbiVersion;
+            consensusProtocolVersion?: import("./constants.js").ConsensusProtocolVersion;
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").AbiVersion | undefined>;
+        deserialize(buffer: Buffer): import("./constants.js").AbiVersion;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly gasLimit: {
         serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
             tag: Tag;
             rebuildTx: (params: any) => any;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingGasLimit?: number | undefined;
+            unpackTx: typeof import("./index.js").unpackTx;
+            buildTx: typeof import("./index.js").buildTx;
+            _computingGasLimit?: number;
         }, { gasMax }: {
-            gasMax?: number | undefined;
+            gasMax?: number;
         }): Buffer;
         deserialize(value: Buffer): number;
     };
     readonly gasPrice: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode, denomination }: {
-            onNode?: import("../..").Node | undefined;
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Promise<import("./constants").Int | undefined>;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, }: {
+            onNode?: import("../../Node.js").default;
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
+        }): Promise<import("./constants.js").Int | undefined>;
         serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
+        serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
+            denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
         deserialize(value: Buffer): string;
     };
-    readonly tx: EntrySignedTx;
+    readonly tx: TransactionSignedTx;
 }, {
     readonly tag: {
         serialize: (value: Tag.PayingForTx) => Buffer;
@@ -2946,67 +1844,32 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly nonce: {
-        serialize: (value: number) => Buffer;
+        serialize: (value: number, params: {
+            tag: Tag;
+        }) => Buffer;
         prepare: (value: number | undefined, params: {}, options: {
             payerId: string;
         } & {
-            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
-            onNode?: import("../..").Node | undefined;
-            _isInternalBuild?: boolean | undefined;
+            strategy?: import("../../apis/node/index.js").Enum1;
+            onNode?: import("../../Node.js").default;
+            _isInternalBuild?: boolean;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
     readonly fee: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode }: {
-            onNode?: import("../..").Node | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: import("./field-types/fee").SerializeAettosParams, { _canIncreaseFee }: {
-            _canIncreaseFee?: boolean | undefined;
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+            onNode?: import("../../Node.js").default;
+        }): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee }: {
+            _canIncreaseFee?: boolean;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: import("./field-types/fee").SerializeAettosParams, options: {
-            _canIncreaseFee?: boolean | undefined;
-        } & {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly tx: EntrySignedTx;
-}, {
-    readonly tag: {
-        serialize: (value: Tag.GaMetaTxAuthData) => Buffer;
-        deserialize: (value: Buffer) => Tag.GaMetaTxAuthData;
-        constValue: Tag.GaMetaTxAuthData;
-        constValueOptional: boolean;
-    };
-    readonly version: {
-        serialize: (value?: 1 | undefined) => Buffer;
-        deserialize: (value: Buffer) => 1;
-        constValue: 1;
-        constValueOptional: boolean;
-    };
-    readonly fee: {
-        serializeAettos(value: string | undefined, params: {}, options: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
+        serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & import("./field-types/fee.js").SerializeAettosParams, options: {
+            _canIncreaseFee?: boolean;
+        } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
-    readonly gasPrice: {
-        prepare(value: import("./constants").Int | undefined, params: {}, { onNode, denomination }: {
-            onNode?: import("../..").Node | undefined;
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Promise<import("./constants").Int | undefined>;
-        serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
-            denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
-        deserialize(value: Buffer): string;
-    };
-    readonly txHash: {
-        serialize: (value: `th_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `th_${string}`;
-    };
+    readonly tx: TransactionSignedTx;
 }];
 type TxSchema = SchemaTypes<typeof txSchema>;
 export type TxParams = TxSchema['TxParams'];