@aeternity/aepp-sdk 12.0.0 → 12.1.2

package/src/spend.ts

@@ -14,139 +14,151 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import { sendTransaction, getAccount, getBalance, resolveName } from './chain'
-import { _buildTx, BuildTxOptions } from './tx'
-import { buildTxHash, unpackTx } from './tx/builder'
-import BigNumber from 'bignumber.js'
-import { ArgumentError } from './utils/errors'
-import { EncodedData } from './utils/encoder'
-import { createMetaTx } from './contract/ga'
-import { TX_TYPE, AensName } from './tx/builder/schema'
-import AccountBase from './account/Base'
+import BigNumber from 'bignumber.js';
+import {
+  sendTransaction, getAccount, getBalance, resolveName,
+} from './chain';
+import { _buildTx, BuildTxOptions } from './tx';
+import { buildTxHash, unpackTx } from './tx/builder';
+import { ArgumentError } from './utils/errors';
+import { Encoded, Encoding } from './utils/encoder';
+import { Tag, AensName } from './tx/builder/constants';
+import AccountBase from './account/Base';
 
 /**
  * Sign and post a transaction to the chain
+ * @category chain
  * @param tx - Transaction
  * @param options - Options
  * @param options.verify - Verify transaction before broadcast, throw error if not
  * valid
  * @returns Transaction
  */
-export async function send (tx: EncodedData<'tx'>, options: SendOptions): Promise<SendReturnType> {
-  const { contractId, authFun = undefined } = options.innerTx === true
-    ? { contractId: null }
-    : await getAccount(await options.onAccount.address(options), options)
+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 = contractId != null
-    // TODO: not required arguments become required depending on account type, can ga be extracted?
-    ? await signUsingGA(tx, { authData: {}, ...options, authFun: authFun as string })
-    : await options.onAccount.signTransaction(tx, options)
+  const signed = await options.onAccount.signTransaction(tx, {
+    ...options,
+    authFun,
+    networkId: (await options.onNode.getStatus()).networkId,
+  });
 
   return options.innerTx === true
     ? { hash: buildTxHash(signed), rawTx: signed }
-    : await sendTransaction(signed, options)
+    : sendTransaction(signed, options);
 }
 
-type SendOptionsType = Parameters<AccountBase['signTransaction']>[1] & Parameters<typeof sendTransaction>[1]
-& Partial<Omit<Parameters<typeof signUsingGA>[1], 'onAccount' | 'onCompiler'>>
-& Pick<Parameters<typeof signUsingGA>[1], 'onAccount' | 'onCompiler'>
+type SendOptionsType = Parameters<AccountBase['signTransaction']>[1]
+& Parameters<typeof sendTransaction>[1] & { onAccount: AccountBase };
 export interface SendOptions extends SendOptionsType {}
 interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {}
 
-export async function signUsingGA (
-  tx: EncodedData<'tx'>,
-  { authData, authFun, ...options }: {
-    authData: Parameters<typeof createMetaTx>[1]
-    authFun: Parameters<typeof createMetaTx>[2]
-  } & Parameters<typeof createMetaTx>[3]
-): Promise<EncodedData<'tx'>> {
-  return await createMetaTx(tx, authData, authFun, options)
-}
-
 /**
  * Send coins to another account
+ * @category chain
  * @param amount - Amount to spend
  * @param recipientIdOrName - Address or name of recipient account
  * @param options - Options
  * @returns Transaction
  */
-export async function spend (
+export async function spend(
   amount: number | string,
-  recipientIdOrName: EncodedData<'ak'> | AensName,
-  options: SpendOptions
+  recipientIdOrName: Encoded.AccountAddress | AensName,
+  options: SpendOptions,
 ): ReturnType<typeof send> {
-  return await send(
-    await _buildTx(TX_TYPE.spend, {
+  return send(
+    await _buildTx(Tag.SpendTx, {
       ...options,
       senderId: await options.onAccount.address(options),
-      recipientId: await resolveName(recipientIdOrName, 'account_pubkey', options),
-      amount
+      recipientId: await resolveName<Encoding.AccountAddress>(
+        recipientIdOrName,
+        'account_pubkey',
+        options,
+      ),
+      amount,
     }),
-    options
-  )
+    options,
+  );
 }
 
-type SpendOptionsType = BuildTxOptions<TX_TYPE.spend, 'senderId' | 'recipientId' | 'amount'>
-& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions
+type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions;
 interface SpendOptions extends SpendOptionsType {}
 
 // TODO: Rename to spendFraction
 /**
  * Send a fraction of coin balance to another account
+ * @category chain
  * @param fraction - Fraction of balance to spend (between 0 and 1)
  * @param recipientIdOrName - Address or name of recipient account
  * @param options - Options
  * @returns Transaction
  */
-export async function transferFunds (
+export async function transferFunds(
   fraction: number | string,
-  recipientIdOrName: AensName | EncodedData<'ak'>,
-  options: TransferFundsOptions
+  recipientIdOrName: AensName | Encoded.AccountAddress,
+  options: TransferFundsOptions,
 ): ReturnType<typeof send> {
   if (fraction < 0 || fraction > 1) {
-    throw new ArgumentError('fraction', 'a number between 0 and 1', fraction)
+    throw new ArgumentError('fraction', 'a number between 0 and 1', fraction);
   }
-  const recipientId = await resolveName<'ak'>(recipientIdOrName, 'account_pubkey', options)
-  const senderId = await options.onAccount.address(options)
+  const recipientId = await resolveName<Encoding.AccountAddress>(
+    recipientIdOrName,
+    'account_pubkey',
+    options,
+  );
+  const senderId = await options.onAccount.address(options);
   const balance = new BigNumber(
-    await getBalance.bind(options.onAccount)(senderId, options)
-  )
-  const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP)
+    await getBalance.bind(options.onAccount)(senderId, options),
+  );
+  const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
   const { tx: { fee } } = unpackTx(
-    await _buildTx(TX_TYPE.spend, { ...options, senderId, recipientId, amount: desiredAmount }),
-    TX_TYPE.spend
-  )
+    await _buildTx(Tag.SpendTx, {
+      ...options, senderId, recipientId, amount: desiredAmount,
+    }),
+    Tag.SpendTx,
+  );
   // Reducing of the amount may reduce transaction fee, so this is not completely accurate
-  const amount = desiredAmount.plus(fee).gt(balance) ? balance.minus(fee) : desiredAmount
-  return await send(
-    await _buildTx(TX_TYPE.spend, { ...options, senderId, recipientId, amount }),
-    options
-  )
+  const amount = desiredAmount.plus(fee).gt(balance) ? balance.minus(fee) : desiredAmount;
+  return send(
+    await _buildTx(Tag.SpendTx, {
+      ...options, senderId, recipientId, amount,
+    }),
+    options,
+  );
 }
 
-type TransferFundsOptionsType = BuildTxOptions<TX_TYPE.spend, 'senderId' | 'recipientId' | 'amount'>
-& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions
+type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions;
 interface TransferFundsOptions extends TransferFundsOptionsType {}
 
 /**
  * Submit transaction of another account paying for it (fee and gas)
+ * @category chain
  * @param transaction - tx_<base64>-encoded transaction
  * @param options - Options
  * @returns Object Transaction
  */
-export async function payForTransaction (
-  transaction: EncodedData<'tx'>, options: PayForTransactionOptions
+export async function payForTransaction(
+  transaction: Encoded.Transaction,
+  options: PayForTransactionOptions,
 ): ReturnType<typeof send> {
-  return await send(
+  return send(
     await _buildTx(
-      TX_TYPE.payingFor,
-      { ...options, payerId: await options.onAccount.address(options), tx: transaction }
+      Tag.PayingForTx,
+      { ...options, payerId: await options.onAccount.address(options), tx: transaction },
     ),
-    options
-  )
+    options,
+  );
 }
 
 interface PayForTransactionOptions extends
-  BuildTxOptions<TX_TYPE.payingFor, 'payerId' | 'tx'>, SendOptions {
-  onAccount: AccountBase
+  BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx'>, SendOptions {
+  onAccount: AccountBase;
 }

package/src/tx/builder/address.ts

@@ -0,0 +1,50 @@
+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}
+ */
+const idTagToEncoding = [
+  Encoding.AccountAddress,
+  Encoding.Name,
+  Encoding.Commitment,
+  Encoding.OracleAddress,
+  Encoding.ContractAddress,
+  Encoding.Channel,
+] as const;
+
+type AddressEncodings = typeof idTagToEncoding[number];
+
+/**
+ * Utility function to create and _id type
+ * @category transaction builder
+ * @param hashId - Encoded hash
+ * @returns Buffer Buffer with ID tag and decoded HASh
+ */
+export function writeId(hashId: Encoded.Generic<AddressEncodings>): Buffer {
+  if (typeof hashId !== 'string') throw new ArgumentError('hashId', 'a string', hashId);
+  const encoding = hashId.slice(0, 2);
+  if (!isItemOfArray(encoding, idTagToEncoding)) throw new TagNotFoundError(encoding);
+  const idTag = idTagToEncoding.indexOf(encoding) + 1;
+  return Buffer.from([...toBytes(idTag), ...decode(hashId)]);
+}
+
+/**
+ * Utility function to read and _id type
+ * @category transaction builder
+ * @param buf - Data
+ * @returns Encoided hash string with prefix
+ */
+export function readId(buf: Buffer): Encoded.Generic<AddressEncodings> {
+  const idTag = Buffer.from(buf).readUIntBE(0, 1);
+  const encoding = idTagToEncoding[idTag - 1];
+  if (encoding == null) throw new PrefixNotFoundError(idTag);
+  return encode(buf.slice(1, buf.length), encoding);
+}

package/src/tx/builder/constants.ts

@@ -1,31 +1,24 @@
-import { EncodingType } from './../../utils/encoder'
-import BigNumber from 'bignumber.js'
-import { mapObject } from '../../utils/other'
+import BigNumber from 'bignumber.js';
+import { mapObject } from '../../utils/other';
 
 // # AENS
-export type AensName = `${string}.chain`
-export const NAME_TTL = 180000
+export type AensName = `${string}.chain`;
+export const NAME_TTL = 180000;
 // # max number of block into the future that the name is going to be available
 // # https://github.com/aeternity/protocol/blob/epoch-v0.22.0/AENS.md#update
 // # https://github.com/aeternity/protocol/blob/44a93d3aab957ca820183c3520b9daf6b0fedff4/AENS.md#aens-entry
-export const NAME_MAX_TTL = 36000
-export const NAME_MAX_CLIENT_TTL = 84600
-export const CLIENT_TTL = NAME_MAX_CLIENT_TTL
-export const MIN_GAS_PRICE = 1e9
+export const NAME_MAX_TTL = 36000;
+export const NAME_MAX_CLIENT_TTL = 84600;
+export const CLIENT_TTL = NAME_MAX_CLIENT_TTL;
+export const MIN_GAS_PRICE = 1e9;
 // # see https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L67
-export const NAME_FEE_MULTIPLIER = 1e14 // 100000000000000
-export const NAME_FEE_BID_INCREMENT = 0.05 // # the increment is in percentage
+export const NAME_FEE_MULTIPLIER = 1e14; // 100000000000000
+export const NAME_FEE_BID_INCREMENT = 0.05; // # the increment is in percentage
 // # see https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L272
-export const NAME_BID_TIMEOUT_BLOCKS = 480 // # ~1 day
+export const NAME_BID_TIMEOUT_BLOCKS = 480; // # ~1 day
 // # this is the max length for a domain that requires a base fee to be paid
-export const NAME_MAX_LENGTH_FEE = 31
-export const NAME_BID_MAX_LENGTH = 12 // # this is the max length for a domain to be part of a bid
-export enum POINTER_KEY_BY_PREFIX {
-  ak = 'account_pubkey',
-  ok = 'oracle_pubkey',
-  ct = 'contract_pubkey',
-  ch = 'channel'
-}
+export const NAME_MAX_LENGTH_FEE = 31;
+export const NAME_BID_MAX_LENGTH = 12; // # this is the max length for a domain to be part of a bid
 // # https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L290
 // # https://github.com/aeternity/protocol/blob/master/AENS.md#protocol-fees-and-protection-times
 // # bid ranges:
@@ -60,37 +53,74 @@ export const NAME_BID_RANGES = mapObject({
   4: 1346269,
   3: 2178309,
   2: 3524578,
-  1: 5702887
-}, ([key, value]) => [key, new BigNumber(value).times(NAME_FEE_MULTIPLIER)])
-
-// # Tag constant for ids (type uint8)
-// # see https://github.com/aeternity/protocol/blob/master/serializations.md#the-id-type
-// # <<Tag:1/unsigned-integer-unit:8, Hash:32/binary-unit:8>>
-const ID_TAG_ACCOUNT = 1
-const ID_TAG_NAME = 2
-const ID_TAG_COMMITMENT = 3
-const ID_TAG_ORACLE = 4
-const ID_TAG_CONTRACT = 5
-const ID_TAG_CHANNEL = 6
+  1: 5702887,
+}, ([key, value]) => [key, new BigNumber(value).times(NAME_FEE_MULTIPLIER)]);
 
-export const ID_TAG = {
-  account: ID_TAG_ACCOUNT,
-  name: ID_TAG_NAME,
-  commitment: ID_TAG_COMMITMENT,
-  oracle: ID_TAG_ORACLE,
-  contract: ID_TAG_CONTRACT,
-  channel: ID_TAG_CHANNEL
+/**
+ * Enum with tag types
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/serializations.md#binary-serialization}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_chain_objects.erl#L39-L97}
+ */
+// TODO: implement serialisation for commented-out tags
+export enum Tag {
+  Account = 10,
+  SignedTx = 11,
+  SpendTx = 12,
+  // Oracle = 20,
+  // OracleQuery = 21,
+  OracleRegisterTx = 22,
+  OracleQueryTx = 23,
+  OracleResponseTx = 24,
+  OracleExtendTx = 25,
+  // Name = 30,
+  // NameCommitment = 31,
+  NameClaimTx = 32,
+  NamePreclaimTx = 33,
+  NameUpdateTx = 34,
+  NameRevokeTx = 35,
+  NameTransferTx = 36,
+  // NameAuction = 37,
+  Contract = 40,
+  ContractCall = 41,
+  ContractCreateTx = 42,
+  ContractCallTx = 43,
+  ChannelCreateTx = 50,
+  // ChannelSetDelegatesTx = 501,
+  ChannelDepositTx = 51,
+  ChannelWithdrawTx = 52,
+  ChannelForceProgressTx = 521,
+  ChannelCloseMutualTx = 53,
+  ChannelCloseSoloTx = 54,
+  ChannelSlashTx = 55,
+  ChannelSettleTx = 56,
+  ChannelOffChainTx = 57,
+  ChannelOffChainUpdateTransfer = 570,
+  ChannelOffChainUpdateDeposit = 571,
+  ChannelOffChainUpdateWithdraw = 572,
+  ChannelOffChainUpdateCreateContract = 573,
+  ChannelOffChainUpdateCallContract = 574,
+  // ChannelOffChainUpdateMeta = 576,
+  ChannelClientReconnectTx = 575,
+  Channel = 58,
+  ChannelSnapshotSoloTx = 59,
+  TreesPoi = 60,
+  // TreesDb = 61,
+  StateTrees = 62,
+  Mtree = 63,
+  MtreeValue = 64,
+  ContractsMtree = 621,
+  CallsMtree = 622,
+  ChannelsMtree = 623,
+  NameserviceMtree = 624,
+  OraclesMtree = 625,
+  AccountsMtree = 626,
+  CompilerSophia = 70,
+  GaAttachTx = 80,
+  GaMetaTx = 81,
+  PayingForTx = 82,
+  // KeyBlock = 100,
+  // MicroBlock = 101,
+  // LightMicroBlock = 102,
+  // Pof = 200,
 }
-
-export const PREFIX_ID_TAG = {
-  ak: ID_TAG.account,
-  nm: ID_TAG.name,
-  cm: ID_TAG.commitment,
-  ok: ID_TAG.oracle,
-  ct: ID_TAG.contract,
-  ch: ID_TAG.channel
-} as const
-
-export const ID_TAG_PREFIX = mapObject(
-  PREFIX_ID_TAG, ([key, value]: [EncodingType, number]) => [value, key]
-)

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

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

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

@@ -0,0 +1,21 @@
+import coinAmount from './coin-amount';
+import { Int } from './u-int';
+import { IllegalArgumentError } from '../../../utils/errors';
+
+export default {
+  ...coinAmount,
+
+  /**
+   * @param value - Deposit value in string format. Should be equal to '0'.
+   * @param options - Options
+   * @returns Deposit value Buffer.
+   */
+  serialize(
+    value: Int | undefined,
+    options: Parameters<typeof coinAmount['serialize']>[1],
+  ): Buffer {
+    value ??= 0;
+    if (+value !== 0) throw new IllegalArgumentError(`Contract deposit is not refundable, so it should be equal 0, got ${value.toString()} instead`);
+    return coinAmount.serialize(value, options);
+  },
+};

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

@@ -0,0 +1,143 @@
+import BigNumber from 'bignumber.js';
+import { IllegalArgumentError } from '../../../utils/errors';
+import { MIN_GAS_PRICE, Tag } from '../constants';
+import coinAmount from './coin-amount';
+import { isKeyOfObject } from '../../../utils/other';
+
+const BASE_GAS = 15000;
+const GAS_PER_BYTE = 20;
+const KEY_BLOCK_INTERVAL = 3;
+
+/**
+ * Calculate the Base fee gas
+ * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
+ * @param txType - The transaction type
+ * @returns The base fee
+ * @example
+ * ```js
+ * TX_FEE_BASE('channelForceProgress') => new BigNumber(30 * 15000)
+ * ```
+ */
+const TX_FEE_BASE_GAS = (txType: Tag): BigNumber => {
+  const feeFactors = {
+    [Tag.ChannelForceProgressTx]: 30,
+    [Tag.ChannelOffChainTx]: 0,
+    [Tag.ChannelOffChainUpdateCallContract]: 0,
+    [Tag.ChannelOffChainUpdateCreateContract]: 0,
+    [Tag.ChannelOffChainUpdateDeposit]: 0,
+    [Tag.ChannelOffChainUpdateWithdraw]: 0,
+    [Tag.ChannelOffChainUpdateTransfer]: 0,
+    [Tag.ContractCreateTx]: 5,
+    [Tag.ContractCallTx]: 12,
+    [Tag.GaAttachTx]: 5,
+    [Tag.GaMetaTx]: 5,
+    [Tag.PayingForTx]: 1 / 5,
+  } as const;
+  const factor = feeFactors[txType as keyof typeof feeFactors] ?? 1;
+  return new BigNumber(factor * BASE_GAS);
+};
+
+/**
+ * Calculate fee for Other types of transactions
+ * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
+ * @param txType - The transaction type
+ * @param txSize - The transaction size
+ * @returns parameters - The transaction parameters
+ * @returns parameters.relativeTtl - The relative ttl
+ * @returns parameters.innerTxSize - The size of the inner transaction
+ * @returns The Other fee
+ * @example
+ * ```js
+ * TX_FEE_OTHER_GAS('oracleResponse',10, { relativeTtl: 10, innerTxSize: 10 })
+ *  => new BigNumber(10).times(20).plus(Math.ceil(32000 * 10 / Math.floor(60 * 24 * 365 / 2)))
+ * ```
+ */
+const TX_FEE_OTHER_GAS = (
+  txType: Tag,
+  txSize: number,
+  { relativeTtl, innerTxSize }: { relativeTtl: number; innerTxSize: number },
+): BigNumber => {
+  switch (txType) {
+    case Tag.OracleRegisterTx:
+    case Tag.OracleExtendTx:
+    case Tag.OracleQueryTx:
+    case Tag.OracleResponseTx:
+      return new BigNumber(txSize)
+        .times(GAS_PER_BYTE)
+        .plus(
+          Math.ceil((32000 * relativeTtl) / Math.floor((60 * 24 * 365) / KEY_BLOCK_INTERVAL)),
+        );
+    case Tag.GaMetaTx:
+    case Tag.PayingForTx:
+      return new BigNumber(txSize).minus(innerTxSize).times(GAS_PER_BYTE);
+    default:
+      return new BigNumber(txSize).times(GAS_PER_BYTE);
+  }
+};
+
+function getOracleRelativeTtl(params: any, txType: Tag): number {
+  const ttlKeys = {
+    [Tag.OracleRegisterTx]: 'oracleTtlValue',
+    [Tag.OracleExtendTx]: 'oracleTtlValue',
+    [Tag.OracleQueryTx]: 'queryTtlValue',
+    [Tag.OracleResponseTx]: 'responseTtlValue',
+  } as const;
+
+  if (!isKeyOfObject(txType, ttlKeys)) return 1;
+  return params[ttlKeys[txType]];
+}
+
+/**
+ * Calculate fee based on tx type and params
+ */
+export function buildFee(txType: Tag, buildTx: any): BigNumber {
+  const { rlpEncoded: { length }, txObject } = buildTx;
+
+  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
+        : 0,
+    }))
+    .times(MIN_GAS_PRICE);
+}
+
+/**
+ * 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,
+): BigNumber {
+  let fee = new BigNumber(0);
+  let previousFee;
+  do {
+    previousFee = fee;
+    fee = buildFee(txType, rebuildTx(fee));
+  } while (!fee.eq(previousFee));
+  return fee;
+}
+
+export default {
+  ...coinAmount,
+
+  serializeAettos(
+    _value: string | undefined,
+    { txType, rebuildTx, _computingMinFee }:
+    { txType: Tag; rebuildTx: (params: any) => any; _computingMinFee?: string },
+  ): string {
+    if (_computingMinFee != null) return _computingMinFee;
+    const minFee = calculateMinFee(txType, (fee) => rebuildTx({ _computingMinFee: fee }));
+    const value = new BigNumber(_value ?? minFee);
+    if (minFee.gt(value)) {
+      throw new IllegalArgumentError(`Fee ${value.toString()} must be bigger then ${minFee}`);
+    }
+    return value.toFixed();
+  },
+
+  serialize: coinAmount.serializeOptional,
+};

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

@@ -0,0 +1,9 @@
+export default {
+  serialize(value: string): Buffer {
+    return Buffer.from(value);
+  },
+
+  deserialize(value: Buffer): string {
+    return value.toString();
+  },
+};

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

@@ -0,0 +1,41 @@
+import { IllegalArgumentError } from '../../../utils/errors';
+import { MIN_GAS_PRICE, Tag } from '../constants';
+import shortUInt from './short-u-int';
+import { buildFee } from './fee';
+
+function calculateGasLimitMax(
+  txType: Tag,
+  gasMax: number,
+  rebuildTx: (value: number) => any,
+): number {
+  return gasMax - +buildFee(txType, rebuildTx(gasMax)).dividedBy(MIN_GAS_PRICE);
+}
+
+export default {
+  ...shortUInt,
+
+  serialize(
+    _value: number | undefined,
+    {
+      txType, rebuildTx, gasMax = 6e6, _computingGasLimit,
+    }: {
+      txType: Tag;
+      rebuildTx: (params: any) => any;
+      gasMax: number;
+      _computingGasLimit?: number;
+    },
+  ): Buffer {
+    if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);
+
+    const gasLimitMax = calculateGasLimitMax(
+      txType,
+      gasMax,
+      (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit }),
+    );
+    const value = _value ?? gasLimitMax;
+    if (value > gasLimitMax) {
+      throw new IllegalArgumentError(`Gas limit ${value} must be less or equal to ${gasLimitMax}`);
+    }
+    return shortUInt.serialize(value);
+  },
+};