@aeternity/aepp-sdk 13.2.2 → 13.3.1

package/types-legacy/ts4.2/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,
@@ -213,34 +197,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;
         };
@@ -251,6 +240,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,6 +315,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;
@@ -334,23 +325,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;
         };
@@ -379,6 +375,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;
@@ -403,23 +400,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;
         };
@@ -448,6 +450,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;
@@ -457,8 +460,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 & {
@@ -472,27 +475,111 @@ 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;
         };
@@ -521,6 +608,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;
@@ -534,23 +622,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;
         };
@@ -579,6 +672,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;
@@ -588,23 +682,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;
         };
@@ -653,10 +752,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;
         };
     },
@@ -684,6 +783,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;
@@ -703,36 +803,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;
@@ -750,8 +854,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;
@@ -785,6 +893,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;
@@ -809,29 +918,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;
@@ -849,8 +963,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;
@@ -936,8 +1054,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;
@@ -986,6 +1104,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;
@@ -999,38 +1118,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;
         };
@@ -1074,36 +1198,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;
         };
@@ -1132,6 +1262,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;
@@ -1145,46 +1276,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;
         };
@@ -1213,6 +1353,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;
@@ -1226,31 +1367,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;
         };
@@ -1294,21 +1440,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;
@@ -1332,6 +1483,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;
@@ -1368,21 +1520,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;
@@ -1394,6 +1551,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;
@@ -1427,21 +1585,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;
@@ -1453,6 +1616,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;
@@ -1486,21 +1650,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;
@@ -1512,6 +1681,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;
@@ -1544,21 +1714,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;
@@ -1578,6 +1753,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;
@@ -1610,21 +1786,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;
@@ -1644,6 +1825,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;
@@ -1680,21 +1862,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;
@@ -1706,6 +1893,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;
@@ -1754,21 +1942,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;
@@ -1780,6 +1973,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;
@@ -1912,21 +2106,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;
@@ -1938,6 +2137,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;
@@ -2102,8 +2302,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;
@@ -2788,6 +2992,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;
@@ -2811,23 +3016,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;
         };
@@ -2844,8 +3054,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;
@@ -2892,14 +3106,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;
@@ -2917,8 +3132,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;
@@ -2949,19 +3168,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;
@@ -2982,15 +3203,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;