@aeternity/aepp-sdk 12.1.3 → 13.0.0-alpha.1

package/src/oracle.ts

@@ -40,7 +40,7 @@ import { RequestTimedOutError } from './utils/errors';
 import {
   decode, encode, Encoded, Encoding,
 } from './utils/encoder';
-import { _getPollInterval } from './chain';
+import { _getPollInterval, getHeight } from './chain';
 import { _buildTx, BuildTxOptions } from './tx';
 import Node from './Node';
 import AccountBase from './account/Base';
@@ -106,11 +106,11 @@ export async function pollForQueryResponse(
   let ttl;
   let response;
   do {
-    if (height != null) await pause(interval);
     ({ response, ttl } = await onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId));
     const responseBuffer = decode(response as Encoded.OracleResponse);
     if (responseBuffer.length > 0) return responseBuffer.toString();
-    height = await this.getHeight();
+    await pause(interval);
+    height = await getHeight({ onNode });
   } while (ttl >= height);
   throw new RequestTimedOutError(height);
 }
@@ -169,7 +169,7 @@ export async function postQueryToOracle(
   options: PostQueryToOracleOptions,
 ): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>> {
   options.queryFee ??= (await options.onNode.getOracleByPubkey(oracleId)).queryFee.toString();
-  const senderId = await options.onAccount.address(options);
+  const senderId = options.onAccount.address;
 
   const oracleQueryTx = await _buildTx(Tag.OracleQueryTx, {
     queryTtlType: QUERY_TTL.type,
@@ -181,7 +181,7 @@ export async function postQueryToOracle(
     senderId,
     query,
   });
-  const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx).tx;
+  const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx);
   const queryId = oracleQueryId(senderId, nonce, oracleId);
   return {
     ...await send(oracleQueryTx, options),
@@ -219,7 +219,7 @@ export async function extendOracleTtl(
     oracleTtlType: ORACLE_TTL.type,
     oracleTtlValue: ORACLE_TTL.value,
     ...options,
-    callerId: await options.onAccount.address(options),
+    callerId: options.onAccount.address,
     oracleId,
   });
   return {
@@ -256,7 +256,7 @@ export async function respondToQuery(
     responseTtlType: RESPONSE_TTL.type,
     responseTtlValue: RESPONSE_TTL.value,
     ...options,
-    callerId: await options.onAccount.address(options),
+    callerId: options.onAccount.address,
     oracleId,
     queryId,
     response,
@@ -338,7 +338,7 @@ export async function registerOracle(
   responseFormat: string,
   options: RegisterOracleOptions,
 ): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
-  const accountId = await options.onAccount.address(options);
+  const accountId = options.onAccount.address;
   const oracleRegisterTx = await _buildTx(Tag.OracleRegisterTx, {
     queryFee: QUERY_FEE,
     oracleTtlValue: ORACLE_TTL.value,

package/src/spend.ts

@@ -15,9 +15,7 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 import BigNumber from 'bignumber.js';
-import {
-  sendTransaction, getAccount, getBalance, resolveName,
-} from './chain';
+import { sendTransaction, getBalance, resolveName } from './chain';
 import { _buildTx, BuildTxOptions } from './tx';
 import { buildTxHash, unpackTx } from './tx/builder';
 import { ArgumentError } from './utils/errors';
@@ -38,15 +36,9 @@ export async function send(
   tx: Encoded.Transaction,
   options: SendOptions,
 ): Promise<SendReturnType> {
-  // TODO: detect authFun in AccountGa
-  const authFun = options.innerTx === true
-    ? undefined
-    : (await getAccount(await options.onAccount.address(options), options)).authFun;
-
   const signed = await options.onAccount.signTransaction(tx, {
     ...options,
-    authFun,
-    networkId: (await options.onNode.getStatus()).networkId,
+    networkId: await options.onNode.getNetworkId(),
   });
 
   return options.innerTx === true
@@ -75,7 +67,7 @@ export async function spend(
   return send(
     await _buildTx(Tag.SpendTx, {
       ...options,
-      senderId: await options.onAccount.address(options),
+      senderId: options.onAccount.address,
       recipientId: await resolveName<Encoding.AccountAddress>(
         recipientIdOrName,
         'account_pubkey',
@@ -113,12 +105,12 @@ export async function transferFunds(
     'account_pubkey',
     options,
   );
-  const senderId = await options.onAccount.address(options);
+  const senderId = options.onAccount.address;
   const balance = new BigNumber(
     await getBalance.bind(options.onAccount)(senderId, options),
   );
   const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
-  const { tx: { fee } } = unpackTx(
+  const { fee } = unpackTx(
     await _buildTx(Tag.SpendTx, {
       ...options, senderId, recipientId, amount: desiredAmount,
     }),
@@ -152,7 +144,7 @@ export async function payForTransaction(
   return send(
     await _buildTx(
       Tag.PayingForTx,
-      { ...options, payerId: await options.onAccount.address(options), tx: transaction },
+      { ...options, payerId: options.onAccount.address, tx: transaction },
     ),
     options,
   );

package/src/tx/builder/constants.ts

@@ -1,6 +1,8 @@
 import BigNumber from 'bignumber.js';
 import { mapObject } from '../../utils/other';
 
+export const MAX_AUTH_FUN_GAS = 50000;
+export type Int = number | string | BigNumber;
 // # AENS
 export type AensName = `${string}.chain`;
 export const NAME_TTL = 180000;
@@ -56,6 +58,34 @@ export const NAME_BID_RANGES = mapObject({
   1: 5702887,
 }, ([key, value]) => [key, new BigNumber(value).times(NAME_FEE_MULTIPLIER)]);
 
+export enum ConsensusProtocolVersion {
+  Iris = 5,
+}
+
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
+ */
+export enum VmVersion {
+  NoVm = 0,
+  Sophia = 1,
+  SophiaImprovementsMinerva = 3,
+  SophiaImprovementsFortuna = 4,
+  Fate = 5,
+  SophiaImprovementsLima = 6,
+  Fate2 = 7,
+}
+
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
+ */
+export enum AbiVersion {
+  NoAbi = 0,
+  Sophia = 1,
+  Fate = 3,
+}
+
 /**
  * Enum with tag types
  * @category transaction builder
@@ -67,13 +97,13 @@ export enum Tag {
   Account = 10,
   SignedTx = 11,
   SpendTx = 12,
-  // Oracle = 20,
+  Oracle = 20,
   // OracleQuery = 21,
   OracleRegisterTx = 22,
   OracleQueryTx = 23,
   OracleResponseTx = 24,
   OracleExtendTx = 25,
-  // Name = 30,
+  Name = 30,
   // NameCommitment = 31,
   NameClaimTx = 32,
   NamePreclaimTx = 33,
@@ -115,7 +145,7 @@ export enum Tag {
   NameserviceMtree = 624,
   OraclesMtree = 625,
   AccountsMtree = 626,
-  CompilerSophia = 70,
+  // CompilerSophia = 70,
   GaAttachTx = 80,
   GaMetaTx = 81,
   PayingForTx = 82,

package/src/tx/builder/field-types/abi-version.ts

@@ -0,0 +1,21 @@
+import { Tag, ConsensusProtocolVersion, AbiVersion } from '../constants';
+import { getProtocolDetails } from './ct-version';
+
+export default {
+  serialize(
+    value: AbiVersion | undefined,
+    { tag, consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
+    { tag: Tag; consensusProtocolVersion: ConsensusProtocolVersion },
+  ): Buffer {
+    const result = value ?? getProtocolDetails(
+      consensusProtocolVersion,
+      Tag.ContractCallTx === tag || Tag.GaMetaTx === tag ? 'contract-call' : 'oracle-call',
+    ).abiVersion;
+
+    return Buffer.from([result]);
+  },
+
+  deserialize(buffer: Buffer): AbiVersion {
+    return buffer[0];
+  },
+};

package/src/tx/builder/field-types/address.ts

@@ -0,0 +1,62 @@
+import { ArgumentError, PrefixNotFoundError, TagNotFoundError } from '../../../utils/errors';
+import { toBytes } from '../../../utils/bytes';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../../../utils/encoder';
+import { isItemOfArray } from '../../../utils/other';
+
+/**
+ * Map of prefix to ID tag constant
+ * @see {@link https://github.com/aeternity/protocol/blob/master/serializations.md#the-id-type}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_id.erl#L97-L102}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L163-L168}
+ */
+export const idTagToEncoding = [
+  Encoding.AccountAddress,
+  Encoding.Name,
+  Encoding.Commitment,
+  Encoding.OracleAddress,
+  Encoding.ContractAddress,
+  Encoding.Channel,
+] as const;
+
+export type AddressEncodings = typeof idTagToEncoding[number];
+
+export default function genAddressField<Encoding extends AddressEncodings>(
+  ...encodings: Encoding[]
+): {
+    serialize: (value: Encoded.Generic<Encoding>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+  } {
+  return {
+    /**
+     * Utility function to create and _id type
+     * @param hashId - Encoded hash
+     * @returns Buffer Buffer with ID tag and decoded HASh
+     */
+    serialize(hashId) {
+      const enc = hashId.slice(0, 2);
+      if (!isItemOfArray(enc, idTagToEncoding)) throw new TagNotFoundError(enc);
+      if (!isItemOfArray(enc, encodings)) {
+        throw new ArgumentError('Address encoding', encodings.join(', '), enc);
+      }
+      const idTag = idTagToEncoding.indexOf(enc) + 1;
+      return Buffer.from([...toBytes(idTag), ...decode(hashId)]);
+    },
+
+    /**
+     * Utility function to read and _id type
+     * @param buf - Data
+     * @returns Encoded hash string with prefix
+     */
+    deserialize(buf) {
+      const idTag = Buffer.from(buf).readUIntBE(0, 1);
+      const enc = idTagToEncoding[idTag - 1];
+      if (enc == null) throw new PrefixNotFoundError(idTag);
+      if (!isItemOfArray(enc, encodings)) {
+        throw new ArgumentError('Address encoding', encodings.join(', '), enc);
+      }
+      return encode(buf.subarray(1), enc) as Encoded.Generic<Encoding>;
+    },
+  };
+}

package/src/tx/builder/field-types/array.ts

@@ -0,0 +1,19 @@
+export default function genArrayField<Input, Output, Binary>(
+  itemHandler: {
+    serialize: (value: Input, params: unknown) => Binary;
+    deserialize: (value: Binary, params: unknown) => Output;
+  },
+): {
+    serialize: (value: Input[], params: unknown) => Binary[];
+    deserialize: (value: Binary[], params: unknown) => Output[];
+  } {
+  return {
+    serialize(items, params) {
+      return items.map((item) => itemHandler.serialize(item, params));
+    },
+
+    deserialize(buffers, params) {
+      return buffers.map((buffer) => itemHandler.deserialize(buffer, params));
+    },
+  };
+}

package/src/tx/builder/field-types/boolean.ts

@@ -0,0 +1,9 @@
+export default {
+  serialize(value: boolean): Buffer {
+    return Buffer.from([value ? 1 : 0]);
+  },
+
+  deserialize(buffer: Buffer): boolean {
+    return buffer[0] === 1;
+  },
+};

package/src/tx/builder/field-types/coin-amount.ts

@@ -1,6 +1,6 @@
-import uInt, { Int } from './u-int';
+import uInt from './u-int';
+import { Int } from '../constants';
 import { AE_AMOUNT_FORMATS, formatAmount } from '../../../utils/amount-formatter';
-import { ArgumentError } from '../../../utils/errors';
 
 export interface Options { denomination?: AE_AMOUNT_FORMATS }
 
@@ -8,11 +8,10 @@ export default {
   ...uInt,
 
   serializeAettos(value: string | undefined): string {
-    if (value == null) throw new ArgumentError('value', 'provided', value);
-    return value;
+    return value ?? '0';
   },
 
-  serializeOptional(value: Int | undefined, { denomination, ...options }: Options): Buffer {
+  serialize(value: Int | undefined, { denomination, ...options }: Options): Buffer {
     return uInt.serialize(
       this.serializeAettos(
         value != null ? formatAmount(value, { denomination }) : value,
@@ -20,8 +19,4 @@ export default {
       ),
     );
   },
-
-  serialize(value: Int, options: Options): Buffer {
-    return this.serializeOptional(value, options);
-  },
 };

package/src/tx/builder/field-types/ct-version.ts

@@ -0,0 +1,50 @@
+import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+
+// First abi/vm by default
+export const ProtocolToVmAbi = {
+  [ConsensusProtocolVersion.Iris]: {
+    'contract-create': {
+      vmVersion: [VmVersion.Fate2], abiVersion: [AbiVersion.Fate],
+    },
+    // TODO: Ensure that AEVM (Sophia?) is still available here
+    'contract-call': {
+      vmVersion: [], abiVersion: [AbiVersion.Fate, AbiVersion.Sophia],
+    },
+    'oracle-call': {
+      vmVersion: [], abiVersion: [AbiVersion.NoAbi, AbiVersion.Sophia],
+    },
+  },
+} as const;
+
+export interface CtVersion {
+  vmVersion: VmVersion;
+  abiVersion: AbiVersion;
+}
+
+export function getProtocolDetails(
+  protocolVersion: ConsensusProtocolVersion,
+  type: 'contract-create' | 'contract-call' | 'oracle-call',
+): CtVersion {
+  const protocol = ProtocolToVmAbi[protocolVersion][type];
+  return {
+    vmVersion: protocol.vmVersion[0] ?? VmVersion.Fate2,
+    abiVersion: protocol.abiVersion[0],
+  };
+}
+
+export default {
+  serialize(
+    value: CtVersion | undefined,
+    { consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
+    { consensusProtocolVersion: ConsensusProtocolVersion },
+  ): Buffer {
+    value ??= getProtocolDetails(consensusProtocolVersion, 'contract-create');
+
+    return Buffer.from([value.vmVersion, 0, value.abiVersion]);
+  },
+
+  deserialize(buffer: Buffer): CtVersion {
+    const [vm, , abi] = buffer;
+    return { vmVersion: +vm, abiVersion: +abi };
+  },
+};

package/src/tx/builder/field-types/deposit.ts

@@ -1,5 +1,5 @@
 import coinAmount from './coin-amount';
-import { Int } from './u-int';
+import { Int } from '../constants';
 import { IllegalArgumentError } from '../../../utils/errors';
 
 export default {

package/src/tx/builder/field-types/encoded.ts

@@ -0,0 +1,27 @@
+import {
+  decode, encode, Encoded, Encoding,
+} from '../../../utils/encoder';
+import { ArgumentError } from '../../../utils/errors';
+
+export default function genEncodedField<E extends Encoding, Optional extends boolean = false>(
+  encoding: E,
+  optional?: Optional,
+): {
+    serialize: Optional extends true
+      ? (value?: Encoded.Generic<E>) => Buffer : (value: Encoded.Generic<E>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+  } {
+  return {
+    serialize(encodedData?: Encoded.Generic<E>) {
+      if (encodedData == null) {
+        if (optional === true) return Buffer.from([]);
+        throw new ArgumentError('Encoded data', 'provided', encodedData);
+      }
+      return decode(encodedData);
+    },
+
+    deserialize(buffer) {
+      return encode(buffer, encoding);
+    },
+  };
+}

package/src/tx/builder/field-types/entry.ts

@@ -0,0 +1,31 @@
+import { decode, encode, Encoding } from '../../../utils/encoder';
+import { Tag } from '../constants';
+import { ArgumentError } from '../../../utils/errors';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+
+export default function genEntryField<T extends Tag = Tag>(tag?: T): {
+  serialize: (
+    // TODO: replace with `Parameters<typeof buildTxType<T>>[0]`,
+    //  but fix TS2502 value is referenced directly or indirectly in its own type annotation
+    value: any,
+    options: { buildTx: typeof buildTxType },
+  ) => Buffer;
+  deserialize: (
+    value: Buffer, options: { unpackTx: typeof unpackTxType },
+    // TODO: replace with `ReturnType<typeof unpackTxType<T>>`,
+    //  TS2577 Return type annotation circularly references itself
+  ) => any;
+} {
+  return {
+    serialize(txParams, { buildTx }) {
+      if (ArrayBuffer.isView(txParams)) return Buffer.from(txParams as any);
+      return decode(buildTx({ ...txParams, ...tag != null && { tag } }));
+    },
+
+    deserialize(buf, { unpackTx }) {
+      const tx = unpackTx(encode(buf, Encoding.Transaction));
+      if (tag != null && tx.tag !== tag) throw new ArgumentError('Tag', tag, tx.tag);
+      return tx;
+    },
+  };
+}

package/src/tx/builder/field-types/enumeration.ts

@@ -0,0 +1,32 @@
+import { ArgumentError } from '../../../utils/errors';
+import { isItemOfArray } from '../../../utils/other';
+
+export default function genEnumerationField<
+  Enum extends { [key: string]: number | string },
+>(enm: Enum): {
+  serialize: (value: Enum[keyof Enum]) => Buffer;
+  deserialize: (value: Buffer) => Enum[keyof Enum];
+} {
+  const values = Object.values(enm).filter((v) => typeof v === 'number');
+  return {
+    serialize(value) {
+      if (typeof value !== 'number') throw new ArgumentError('value', 'to be a number', value);
+      if (value > 0xff) throw new ArgumentError('value', 'to be less than 256', value);
+      if (!isItemOfArray(value, values)) {
+        throw new ArgumentError('value', 'to be a value of Enum', value);
+      }
+      return Buffer.from([value]);
+    },
+
+    deserialize(buffer) {
+      if (buffer.length !== 1) {
+        throw new ArgumentError('buffer', 'to have single element', buffer.length);
+      }
+      const value = buffer[0];
+      if (!isItemOfArray(value, values)) {
+        throw new ArgumentError('value', 'to be a value of Enum', value);
+      }
+      return value as Enum[keyof Enum];
+    },
+  };
+}

package/src/tx/builder/field-types/fee.ts

@@ -3,6 +3,8 @@ import { IllegalArgumentError } from '../../../utils/errors';
 import { MIN_GAS_PRICE, Tag } from '../constants';
 import coinAmount from './coin-amount';
 import { isKeyOfObject } from '../../../utils/other';
+import { decode, Encoded } from '../../../utils/encoder';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 
 const BASE_GAS = 15000;
 const GAS_PER_BYTE = 20;
@@ -75,7 +77,7 @@ const TX_FEE_OTHER_GAS = (
   }
 };
 
-function getOracleRelativeTtl(params: any, txType: Tag): number {
+function getOracleRelativeTtl(params: any): number {
   const ttlKeys = {
     [Tag.OracleRegisterTx]: 'oracleTtlValue',
     [Tag.OracleExtendTx]: 'oracleTtlValue',
@@ -83,21 +85,27 @@ function getOracleRelativeTtl(params: any, txType: Tag): number {
     [Tag.OracleResponseTx]: 'responseTtlValue',
   } as const;
 
-  if (!isKeyOfObject(txType, ttlKeys)) return 1;
-  return params[ttlKeys[txType]];
+  const { tag } = params;
+  if (!isKeyOfObject(tag, ttlKeys)) return 1;
+  return params[ttlKeys[tag]];
 }
 
 /**
  * Calculate fee based on tx type and params
  */
-export function buildFee(txType: Tag, buildTx: any): BigNumber {
-  const { rlpEncoded: { length }, txObject } = buildTx;
+export function buildFee(
+  builtTx: Encoded.Transaction,
+  unpackTx: typeof unpackTxType,
+  buildTx: typeof buildTxType,
+): BigNumber {
+  const { length } = decode(builtTx);
+  const txObject = unpackTx(builtTx);
 
-  return TX_FEE_BASE_GAS(txType)
-    .plus(TX_FEE_OTHER_GAS(txType, length, {
-      relativeTtl: getOracleRelativeTtl(txObject, txType),
-      innerTxSize: [Tag.GaMetaTx, Tag.PayingForTx].includes(txType)
-        ? txObject.tx.tx.encodedTx.rlpEncoded.length
+  return TX_FEE_BASE_GAS(txObject.tag)
+    .plus(TX_FEE_OTHER_GAS(txObject.tag, length, {
+      relativeTtl: getOracleRelativeTtl(txObject),
+      innerTxSize: txObject.tag === Tag.GaMetaTx || txObject.tag === Tag.PayingForTx
+        ? decode(buildTx(txObject.tx.encodedTx)).length
         : 0,
     }))
     .times(MIN_GAS_PRICE);
@@ -106,18 +114,18 @@ export function buildFee(txType: Tag, buildTx: any): BigNumber {
 /**
  * Calculate min fee
  * @category transaction builder
- * @param txType - Transaction type
  * @param rebuildTx - Callback to get built transaction with specific fee
  */
-export function calculateMinFee(
-  txType: Tag,
-  rebuildTx: (value: BigNumber) => any,
+function calculateMinFee(
+  rebuildTx: (value: BigNumber) => Encoded.Transaction,
+  unpackTx: typeof unpackTxType,
+  buildTx: typeof buildTxType,
 ): BigNumber {
   let fee = new BigNumber(0);
   let previousFee;
   do {
     previousFee = fee;
-    fee = buildFee(txType, rebuildTx(fee));
+    fee = buildFee(rebuildTx(fee), unpackTx, buildTx);
   } while (!fee.eq(previousFee));
   return fee;
 }
@@ -127,17 +135,27 @@ export default {
 
   serializeAettos(
     _value: string | undefined,
-    { txType, rebuildTx, _computingMinFee }:
-    { txType: Tag; rebuildTx: (params: any) => any; _computingMinFee?: string },
+    {
+      rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee,
+    }: {
+      rebuildTx: (params: any) => Encoded.Transaction;
+      unpackTx: typeof unpackTxType;
+      buildTx: typeof buildTxType;
+      _computingMinFee?: BigNumber;
+      _pickBiggerFee?: boolean;
+    },
   ): string {
-    if (_computingMinFee != null) return _computingMinFee;
-    const minFee = calculateMinFee(txType, (fee) => rebuildTx({ _computingMinFee: fee }));
+    if (_computingMinFee != null) return _computingMinFee.toFixed();
+    const minFee = calculateMinFee(
+      (fee) => rebuildTx({ _computingMinFee: fee }),
+      unpackTx,
+      buildTx,
+    );
     const value = new BigNumber(_value ?? minFee);
     if (minFee.gt(value)) {
+      if (_pickBiggerFee === true) return minFee.toFixed();
       throw new IllegalArgumentError(`Fee ${value.toString()} must be bigger then ${minFee}`);
     }
     return value.toFixed();
   },
-
-  serialize: coinAmount.serializeOptional,
 };

package/src/tx/builder/field-types/gas-limit.ts

@@ -1,14 +1,16 @@
 import { IllegalArgumentError } from '../../../utils/errors';
-import { MIN_GAS_PRICE, Tag } from '../constants';
+import { MIN_GAS_PRICE, Tag, MAX_AUTH_FUN_GAS } from '../constants';
 import shortUInt from './short-u-int';
 import { buildFee } from './fee';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 
 function calculateGasLimitMax(
-  txType: Tag,
   gasMax: number,
   rebuildTx: (value: number) => any,
+  unpackTx: typeof unpackTxType,
+  buildTx: typeof buildTxType,
 ): number {
-  return gasMax - +buildFee(txType, rebuildTx(gasMax)).dividedBy(MIN_GAS_PRICE);
+  return gasMax - +buildFee(rebuildTx(gasMax), unpackTx, buildTx).dividedBy(MIN_GAS_PRICE);
 }
 
 export default {
@@ -17,20 +19,23 @@ export default {
   serialize(
     _value: number | undefined,
     {
-      txType, rebuildTx, gasMax = 6e6, _computingGasLimit,
+      tag, rebuildTx, unpackTx, buildTx, gasMax = 6e6, _computingGasLimit,
     }: {
-      txType: Tag;
+      tag: Tag;
       rebuildTx: (params: any) => any;
+      unpackTx: typeof unpackTxType;
+      buildTx: typeof buildTxType;
       gasMax: number;
       _computingGasLimit?: number;
     },
   ): Buffer {
     if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);
 
-    const gasLimitMax = calculateGasLimitMax(
-      txType,
+    const gasLimitMax = tag === Tag.GaMetaTx ? MAX_AUTH_FUN_GAS : calculateGasLimitMax(
       gasMax,
-      (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit }),
+      (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit, _pickBiggerFee: true }),
+      unpackTx,
+      buildTx,
     );
     const value = _value ?? gasLimitMax;
     if (value > gasLimitMax) {

package/src/tx/builder/field-types/gas-price.ts

@@ -11,6 +11,4 @@ export default {
     }
     return value;
   },
-
-  serialize: coinAmount.serializeOptional,
 };