@aeternity/aepp-sdk 13.2.2 → 13.3.1

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

@@ -9,22 +9,6 @@ export declare enum ORACLE_TTL_TYPES {
     delta = 0,
     block = 1
 }
-export declare const ORACLE_TTL: {
-    type: ORACLE_TTL_TYPES;
-    value: number;
-};
-export declare const QUERY_TTL: {
-    type: ORACLE_TTL_TYPES;
-    value: number;
-};
-export declare const RESPONSE_TTL: {
-    type: ORACLE_TTL_TYPES;
-    value: number;
-};
-export declare const DRY_RUN_ACCOUNT: {
-    readonly pub: "ak_11111111111111111111111111111111273Yts";
-    readonly amount: 100000000000000000000000000000000000n;
-};
 export declare enum CallReturnType {
     Ok = 0,
     Error = 1,
@@ -209,34 +193,39 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}`;
     };
     readonly recipientId: {
-        serialize: (value: `ak_${string}` | `nm_${string}`) => Buffer;
-        deserialize: (value: Buffer) => `ak_${string}` | `nm_${string}`;
+        serialize: (value: `ct_${string}` | `ak_${string}` | `nm_${string}`) => Buffer;
+        deserialize: (value: Buffer) => `ct_${string}` | `ak_${string}` | `nm_${string}`;
     };
     readonly amount: {
-        serializeAettos(value: string | undefined, params: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -247,6 +236,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -316,6 +306,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -325,23 +316,28 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `cm_${string}`;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -369,6 +365,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -393,23 +390,28 @@ export declare const txSchema: readonly [{
         deserialize(value: Buffer): string;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -437,6 +439,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -446,8 +449,8 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly nameTtl: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
+        serialize: (value: number | undefined, params: unknown, options: unknown) => Buffer;
+        deserialize: (value: Buffer) => number;
     };
     readonly pointers: {
         serialize(pointers: (import("../../apis/node").NamePointer & {
@@ -458,27 +461,107 @@ export declare const txSchema: readonly [{
         })[];
     };
     readonly clientTtl: {
-        serialize(value: number): Buffer;
+        serialize: (value: number | undefined, params: unknown) => Buffer;
+        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;
+        }): 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 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;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
+        }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
+}, {
+    readonly tag: {
+        serialize: (value: Tag.NameUpdateTx) => Buffer;
+        deserialize: (value: Buffer) => Tag.NameUpdateTx;
+        constValue: Tag.NameUpdateTx;
+        constValueOptional: boolean;
+    };
+    readonly version: {
+        serialize: (value: 2) => Buffer;
+        deserialize: (value: Buffer) => 2;
+        constValue: 2;
+        constValueOptional: boolean;
+    };
+    readonly accountId: {
+        serialize: (value: `ak_${string}`) => Buffer;
+        deserialize: (value: Buffer) => `ak_${string}`;
+    };
+    readonly nonce: {
+        serialize: (value: number) => Buffer;
+        prepare: (value: number | undefined, params: {}, options: {
+            accountId: string;
+        } & {
+            strategy?: import("../../apis/node").NextNonceStrategy | undefined;
+            onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
+        }) => Promise<number>;
+        deserialize: (value: Buffer) => number;
+        senderKey: string;
+    };
+    readonly nameId: {
+        serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
+        deserialize: (value: Buffer) => `nm_${string}`;
+    };
+    readonly nameTtl: {
+        serialize: (value: number | undefined, params: unknown, options: unknown) => 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}` | `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}`;
+        })[];
+    };
+    readonly clientTtl: {
+        serialize: (value: number | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => number;
+    };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -506,6 +589,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -519,23 +603,28 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `ak_${string}` | `nm_${string}`;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -563,6 +652,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -572,23 +662,28 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer) => `nm_${string}`;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -636,10 +731,10 @@ export declare const txSchema: readonly [{
         deserialize: (value: Buffer[], params: unknown) => `ak_${string}`[];
     };
     readonly deposit: {
-        serialize(value: import("./constants").Int | undefined, options: {}, parameters: {
+        serializeAettos(value: string | undefined, params: {}, options: {}): string;
+        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
         }): Buffer;
-        serializeAettos(value: string | undefined, params: {}): string;
         deserialize(value: Buffer): string;
     };
 }, {
@@ -666,6 +761,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -685,36 +781,40 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): import("./field-types/ct-version").CtVersion;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly deposit: {
-        serialize(value: import("./constants").Int | undefined, options: {}, parameters: {
+        serialize: (value: import("./constants").Int | undefined, params: {}, options: {
             denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
-        }): Buffer;
-        serializeAettos(value: string | undefined, params: {}): string;
-        deserialize(value: Buffer): string;
+        }) => Buffer;
+        deserialize: (value: Buffer) => string;
     };
     readonly amount: {
-        serializeAettos(value: string | undefined, params: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -732,8 +832,12 @@ export declare const txSchema: readonly [{
         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>;
         serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
         }): Buffer;
         deserialize(value: Buffer): string;
@@ -766,6 +870,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -790,29 +895,34 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): import("./constants").AbiVersion;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly amount: {
-        serializeAettos(value: string | undefined, params: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -830,8 +940,12 @@ export declare const txSchema: readonly [{
         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>;
         serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
         }): Buffer;
         deserialize(value: Buffer): string;
@@ -915,8 +1029,8 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): string;
     };
     readonly queryFee: {
-        serializeAettos(value: string | undefined, params: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -964,6 +1078,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -977,38 +1092,43 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): string;
     };
     readonly queryFee: {
-        serializeAettos(value: string | undefined, params: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 oracleTtlType: {
-        serialize: (value: ORACLE_TTL_TYPES) => Buffer;
-        deserialize: (value: Buffer) => ORACLE_TTL_TYPES;
+        serialize: (value: ORACLE_TTL_TYPES | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
     };
     readonly oracleTtlValue: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
+        serialize: (value: number | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -1051,36 +1171,42 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
     readonly oracleTtlType: {
-        serialize: (value: ORACLE_TTL_TYPES) => Buffer;
-        deserialize: (value: Buffer) => ORACLE_TTL_TYPES;
+        serialize: (value: ORACLE_TTL_TYPES | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
     };
     readonly oracleTtlValue: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
+        serialize: (value: number | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -1108,6 +1234,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1121,46 +1248,55 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): string;
     };
     readonly queryFee: {
-        serializeAettos(value: string | undefined, params: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        prepare(value: import("./constants").Int | undefined, params: {}, options: {
+            oracleId?: `ok_${string}` | undefined;
+            onNode?: import("../..").Node | undefined;
+        }): Promise<import("./constants").Int>;
+        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 queryTtlType: {
-        serialize: (value: ORACLE_TTL_TYPES) => Buffer;
-        deserialize: (value: Buffer) => ORACLE_TTL_TYPES;
+        serialize: (value: ORACLE_TTL_TYPES | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
     };
     readonly queryTtlValue: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
+        serialize: (value: number | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly responseTtlType: {
-        serialize: (value: ORACLE_TTL_TYPES) => Buffer;
-        deserialize: (value: Buffer) => ORACLE_TTL_TYPES;
+        serialize: (value: ORACLE_TTL_TYPES | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
     };
     readonly responseTtlValue: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
+        serialize: (value: number | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -1188,6 +1324,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1201,31 +1338,36 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): string;
     };
     readonly responseTtlType: {
-        serialize: (value: ORACLE_TTL_TYPES) => Buffer;
-        deserialize: (value: Buffer) => ORACLE_TTL_TYPES;
+        serialize: (value: ORACLE_TTL_TYPES | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
     };
     readonly responseTtlValue: {
-        serialize(value: number): Buffer;
-        deserialize(value: Buffer): number;
+        serialize: (value: number | undefined, params: unknown) => Buffer;
+        deserialize: (value: Buffer, params: unknown) => number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -1268,21 +1410,26 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1306,6 +1453,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1341,21 +1489,26 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1367,6 +1520,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1399,21 +1553,26 @@ export declare const txSchema: readonly [{
     readonly poi: EntryTreesPoi;
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1425,6 +1584,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1457,21 +1617,26 @@ export declare const txSchema: readonly [{
     readonly poi: EntryTreesPoi;
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1483,6 +1648,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1514,21 +1680,26 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1548,6 +1719,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1579,21 +1751,26 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1613,6 +1790,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1648,21 +1826,26 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1674,6 +1857,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1721,21 +1905,26 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1747,6 +1936,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -1876,21 +2066,26 @@ export declare const txSchema: readonly [{
     };
     readonly ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -1902,6 +2097,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -2061,8 +2257,12 @@ export declare const txSchema: readonly [{
         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 }: {
+        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
         }): Buffer;
         deserialize(value: Buffer): string;
@@ -2555,6 +2755,7 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
@@ -2578,23 +2779,28 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): import("./field-types/ct-version").CtVersion;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 ttl: {
         serialize(value: number | undefined): Buffer;
-        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+        prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
             onNode?: import("../..").Node | undefined;
             absoluteTtl?: boolean | undefined;
+            _isInternalBuild?: boolean | undefined;
+        } & {
+            _expectedMineRate?: number | undefined;
+            _microBlockCycle?: number | undefined;
         }): Promise<number | undefined>;
         deserialize(value: Buffer): number;
     };
@@ -2611,8 +2817,12 @@ export declare const txSchema: readonly [{
         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>;
         serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
         }): Buffer;
         deserialize(value: Buffer): string;
@@ -2658,14 +2868,15 @@ export declare const txSchema: readonly [{
         deserialize(buffer: Buffer): import("./constants").AbiVersion;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -2683,8 +2894,12 @@ export declare const txSchema: readonly [{
         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>;
         serializeAettos(value?: string | undefined): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
         }): Buffer;
         deserialize(value: Buffer): string;
@@ -2714,19 +2929,21 @@ export declare const txSchema: readonly [{
         } & {
             strategy?: import("../../apis/node").NextNonceStrategy | undefined;
             onNode?: import("../..").Node | undefined;
+            _isInternalBuild?: boolean | undefined;
         }) => Promise<number>;
         deserialize: (value: Buffer) => number;
         senderKey: string;
     };
     readonly fee: {
-        serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-            rebuildTx: (params: any) => `tx_${string}`;
-            unpackTx: typeof import(".").unpackTx;
-            buildTx: typeof import(".").buildTx;
-            _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-            _pickBiggerFee?: boolean | undefined;
+        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;
         }): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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;
@@ -2746,15 +2963,19 @@ export declare const txSchema: readonly [{
         constValueOptional: boolean;
     };
     readonly fee: {
-        serializeAettos(value: string | undefined, params: {}): string;
-        serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
+        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 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 }: {
+        serialize(value: import("./constants").Int | undefined, params: {}, { denomination, ...options }: {
             denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
         }): Buffer;
         deserialize(value: Buffer): string;