@aeternity/aepp-sdk 14.1.0 → 15.0.0

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

@@ -4,6 +4,7 @@
 import { Tag } from './constants.js';
 import SchemaTypes from './SchemaTypes.js';
 import coinAmount from './field-types/coin-amount.js';
+import { SerializeAsIsParams } from './field-types/interface.js';
 import { Encoded, Encoding } from '../../utils/encoder.js';
 import { EntryTag } from './entry/constants.js';
 import { EntParams, EntUnpacked } from './entry/schema.generated.js';
@@ -87,23 +88,22 @@ export declare const txSchema: readonly [{
         deserialize(value: Buffer): string;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -161,23 +161,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `cm_${string}`;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -223,30 +222,29 @@ export declare const txSchema: readonly [{
     readonly nameFee: {
         serializeAettos(_value: string | undefined, txFields: {
             name: import("./constants.js").AensName;
-        }): string;
+        } & SerializeAsIsParams): string;
         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;
+        } & SerializeAsIsParams & Parameters<(typeof coinAmount)["serialize"]>[1], parameters: Parameters<(typeof coinAmount)["serialize"]>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -286,13 +284,13 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly nameTtl: {
-        serialize: (value: number | undefined, params: unknown, options: unknown) => Buffer;
+        serialize: (value: number | undefined, params: SerializeAsIsParams, options: unknown) => Buffer;
         deserialize: (value: Buffer) => number;
     };
     readonly pointers: {
         serialize: (pointers: (import("../../apis/node/index.js").NamePointer & {
             id: Encoded.Generic<import("./field-types/address.js").AddressEncodings>;
-        })[]) => Buffer[][];
+        })[], params: SerializeAsIsParams) => Buffer[][];
         deserialize: (pointers: Array<[key: Buffer, id: Buffer]>) => (import("../../apis/node/index.js").NamePointer & {
             id: Encoded.Generic<import("./field-types/address.js").AddressEncodings>;
         })[];
@@ -302,23 +300,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -358,13 +355,13 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly nameTtl: {
-        serialize: (value: number | undefined, params: unknown, options: unknown) => Buffer;
+        serialize: (value: number | undefined, params: SerializeAsIsParams, options: unknown) => Buffer;
         deserialize: (value: Buffer) => number;
     };
     readonly pointers: {
         serialize: (pointers: (import("../../apis/node/index.js").NamePointer & {
             id: Encoded.Generic<import("./field-types/address.js").AddressEncodings | Encoding.Bytearray>;
-        })[]) => Buffer[][];
+        })[], params: SerializeAsIsParams) => 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>;
         })[];
@@ -374,23 +371,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -434,23 +430,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}` | `nm_${string}`;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -490,23 +485,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -556,23 +550,22 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): import("./field-types/ct-version.js").CtVersion;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -590,23 +583,23 @@ export declare const txSchema: readonly [{
         deserialize(value: Buffer): string;
     };
     readonly gasLimit: {
-        serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
+        serialize(_value: number | undefined, params: {
             tag: Tag;
             rebuildTx: (params: any) => any;
             unpackTx: typeof import("./index.js").unpackTx;
             buildTx: typeof import("./index.js").buildTx;
             _computingGasLimit?: number;
-        }, { gasMax }: {
+        } & SerializeAsIsParams, { gasMax, protocolParameters, }: {
             gasMax?: number;
-        }): Buffer;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Buffer;
         deserialize(value: Buffer): number;
     };
     readonly gasPrice: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, protocolParameters, }: {
             onNode?: import("../../Node.js").default;
             denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
-        }): Promise<import("./constants.js").Int | undefined>;
-        serializeAettos(value?: string | undefined): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(value: string | undefined, params: SerializeAsIsParams, { protocolParameters }: import("./protocol-parameters.js").ProtocolParametersOption): string;
         serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
@@ -667,23 +660,22 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): import("./constants.js").AbiVersion;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -695,23 +687,23 @@ export declare const txSchema: readonly [{
         deserialize(value: Buffer): string;
     };
     readonly gasLimit: {
-        serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
+        serialize(_value: number | undefined, params: {
             tag: Tag;
             rebuildTx: (params: any) => any;
             unpackTx: typeof import("./index.js").unpackTx;
             buildTx: typeof import("./index.js").buildTx;
             _computingGasLimit?: number;
-        }, { gasMax }: {
+        } & SerializeAsIsParams, { gasMax, protocolParameters, }: {
             gasMax?: number;
-        }): Buffer;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Buffer;
         deserialize(value: Buffer): number;
     };
     readonly gasPrice: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, protocolParameters, }: {
             onNode?: import("../../Node.js").default;
             denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
-        }): Promise<import("./constants.js").Int | undefined>;
-        serializeAettos(value?: string | undefined): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(value: string | undefined, params: SerializeAsIsParams, { protocolParameters }: import("./protocol-parameters.js").ProtocolParametersOption): string;
         serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
@@ -776,23 +768,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -851,23 +842,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -938,23 +928,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -1006,23 +995,22 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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;
     };
@@ -1065,23 +1053,22 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly initiatorDelegateIds: {
@@ -1141,23 +1128,22 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
@@ -1202,23 +1188,22 @@ export declare const txSchema: readonly [{
     readonly poi: EntryTreesPoi;
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
@@ -1263,23 +1248,22 @@ export declare const txSchema: readonly [{
     readonly poi: EntryTreesPoi;
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
@@ -1323,23 +1307,22 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly stateHash: {
@@ -1391,23 +1374,22 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly stateHash: {
@@ -1463,23 +1445,22 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
@@ -1539,23 +1520,22 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
@@ -1624,23 +1604,22 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly nonce: {
@@ -1707,44 +1686,43 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): import("./field-types/ct-version.js").CtVersion;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & 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 }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
             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, }: {
+        serialize(_value: number | undefined, params: {
             tag: Tag;
             rebuildTx: (params: any) => any;
             unpackTx: typeof import("./index.js").unpackTx;
             buildTx: typeof import("./index.js").buildTx;
             _computingGasLimit?: number;
-        }, { gasMax }: {
+        } & SerializeAsIsParams, { gasMax, protocolParameters, }: {
             gasMax?: number;
-        }): Buffer;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Buffer;
         deserialize(value: Buffer): number;
     };
     readonly gasPrice: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, protocolParameters, }: {
             onNode?: import("../../Node.js").default;
             denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
-        }): Promise<import("./constants.js").Int | undefined>;
-        serializeAettos(value?: string | undefined): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(value: string | undefined, params: SerializeAsIsParams, { protocolParameters }: import("./protocol-parameters.js").ProtocolParametersOption): string;
         serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
@@ -1791,35 +1769,35 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): import("./constants.js").AbiVersion;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly gasLimit: {
-        serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
+        serialize(_value: number | undefined, params: {
             tag: Tag;
             rebuildTx: (params: any) => any;
             unpackTx: typeof import("./index.js").unpackTx;
             buildTx: typeof import("./index.js").buildTx;
             _computingGasLimit?: number;
-        }, { gasMax }: {
+        } & SerializeAsIsParams, { gasMax, protocolParameters, }: {
             gasMax?: number;
-        }): Buffer;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Buffer;
         deserialize(value: Buffer): number;
     };
     readonly gasPrice: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, denomination, protocolParameters, }: {
             onNode?: import("../../Node.js").default;
             denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
-        }): Promise<import("./constants.js").Int | undefined>;
-        serializeAettos(value?: string | undefined): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(value: string | undefined, params: SerializeAsIsParams, { protocolParameters }: import("./protocol-parameters.js").ProtocolParametersOption): string;
         serialize(value: import("./constants.js").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../../index-browser.js").AE_AMOUNT_FORMATS;
         }): Buffer;
@@ -1858,15 +1836,15 @@ export declare const txSchema: readonly [{
         senderKey: string;
     };
     readonly fee: {
-        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode }: {
+        prepare(value: import("./constants.js").Int | undefined, params: {}, { onNode, protocolParameters }: {
             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 }: {
+        } & import("./protocol-parameters.js").ProtocolParametersOption): Promise<import("./constants.js").Int | undefined>;
+        serializeAettos(_value: string | undefined, params: import("./field-types/fee.js").SerializeAettosParams, { _canIncreaseFee, protocolParameters, }: {
             _canIncreaseFee?: boolean;
-        }): string;
+        } & import("./protocol-parameters.js").ProtocolParametersOption): string;
         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;
+        } & import("./protocol-parameters.js").ProtocolParametersOption & Parameters<typeof coinAmount.serialize>[2]): Buffer;
         deserialize(value: Buffer): string;
     };
     readonly tx: TransactionSignedTx;