@aeternity/aepp-sdk 13.2.2 → 13.3.1

package/src/tx/builder/delegation/schema.ts

@@ -0,0 +1,61 @@
+import SchemaTypes from '../SchemaTypes';
+import { address, nameId, shortUIntConst } from '../field-types';
+import {
+  Encoded, Encoding, decode, encode,
+} from '../../../utils/encoder';
+
+/**
+ * @category delegation signature
+ */
+export enum DelegationTag {
+  AensWildcard = 1,
+  AensName = 2,
+  AensPreclaim = 3,
+  Oracle = 4,
+  OracleResponse = 5,
+}
+
+const oracleAddressField = address(Encoding.OracleAddress);
+const queryIdField = {
+  serialize(value: Encoded.OracleQueryId): Buffer {
+    return oracleAddressField.serialize(encode(decode(value), Encoding.OracleAddress));
+  },
+  deserialize(value: Buffer): Encoded.OracleQueryId {
+    return encode(decode(oracleAddressField.deserialize(value)), Encoding.OracleQueryId);
+  },
+} as const;
+
+/**
+ * @see {@link https://github.com/aeternity/protocol/blob/8a9d1d1206174627f6aaef86159dc9c643080653/contracts/fate.md#from-ceres-serialized-signature-data}
+ */
+export const schemas = [{
+  tag: shortUIntConst(DelegationTag.AensWildcard),
+  version: shortUIntConst(1, true),
+  accountAddress: address(Encoding.AccountAddress),
+  contractAddress: address(Encoding.ContractAddress),
+}, {
+  tag: shortUIntConst(DelegationTag.AensName),
+  version: shortUIntConst(1, true),
+  accountAddress: address(Encoding.AccountAddress),
+  nameId,
+  contractAddress: address(Encoding.ContractAddress),
+}, {
+  tag: shortUIntConst(DelegationTag.AensPreclaim),
+  version: shortUIntConst(1, true),
+  accountAddress: address(Encoding.AccountAddress),
+  contractAddress: address(Encoding.ContractAddress),
+}, {
+  tag: shortUIntConst(DelegationTag.Oracle),
+  version: shortUIntConst(1, true),
+  accountAddress: address(Encoding.AccountAddress),
+  contractAddress: address(Encoding.ContractAddress),
+}, {
+  tag: shortUIntConst(DelegationTag.OracleResponse),
+  version: shortUIntConst(1, true),
+  queryId: queryIdField,
+  contractAddress: address(Encoding.ContractAddress),
+}] as const;
+
+type Schemas = SchemaTypes<typeof schemas>;
+export type DlgParams = Schemas['TxParams'];
+export type DlgUnpacked = Schemas['TxUnpacked'];

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

@@ -6,19 +6,20 @@ export default {
   ...uInt,
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  serializeAettos(value: string | undefined, params: {}): string {
+  serializeAettos(value: string | undefined, params: {}, options: {}): string {
     return value ?? '0';
   },
 
   serialize(
     value: Int | undefined,
     params: {},
-    { denomination = AE_AMOUNT_FORMATS.AETTOS }: { denomination?: AE_AMOUNT_FORMATS },
+    { denomination = AE_AMOUNT_FORMATS.AETTOS, ...options }: { denomination?: AE_AMOUNT_FORMATS },
   ): Buffer {
     return uInt.serialize(
       this.serializeAettos(
         value != null ? formatAmount(value, { denomination }) : value,
         params,
+        options,
       ),
     );
   },

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

@@ -2,7 +2,6 @@ import {
   decode, encode, Encoded, 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): {
@@ -28,9 +27,7 @@ export default function genEntryField<T extends Tag = Tag>(tag?: T): {
     },
 
     deserialize(buf, { unpackTx }) {
-      const tx = unpackTx(encode(buf, Encoding.Transaction));
-      if (tag != null && tx.tag !== tag) throw new ArgumentError('Tag', Tag[tag], Tag[tx.tag]);
-      return tx;
+      return unpackTx(encode(buf, Encoding.Transaction), tag);
     },
   };
 }

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

@@ -1,34 +1,32 @@
 import BigNumber from 'bignumber.js';
-import { IllegalArgumentError } from '../../../utils/errors';
-import { MIN_GAS_PRICE, Tag } from '../constants';
+import { ArgumentError, IllegalArgumentError } from '../../../utils/errors';
+import { Int, MIN_GAS_PRICE, Tag } from '../constants';
+import uInt from './u-int';
 import coinAmount from './coin-amount';
+import { getCachedIncreasedGasPrice } from './gas-price';
 import { isKeyOfObject } from '../../../utils/other';
 import { decode, Encoded } from '../../../utils/encoder';
 import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+import Node from '../../../Node';
 
 const BASE_GAS = 15000;
 const GAS_PER_BYTE = 20;
 const KEY_BLOCK_INTERVAL = 3;
 
 /**
- * Calculate the Base fee gas
+ * Calculate the base gas
  * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
  * @param txType - The transaction type
- * @returns The base fee
+ * @returns The base gas
  * @example
  * ```js
- * TX_FEE_BASE('channelForceProgress') => new BigNumber(30 * 15000)
+ * TX_BASE_GAS(Tag.ChannelForceProgressTx) => 30 * 15000
  * ```
  */
-const TX_FEE_BASE_GAS = (txType: Tag): BigNumber => {
+const TX_BASE_GAS = (txType: Tag): number => {
   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,
@@ -36,44 +34,41 @@ const TX_FEE_BASE_GAS = (txType: Tag): BigNumber => {
     [Tag.PayingForTx]: 1 / 5,
   } as const;
   const factor = feeFactors[txType as keyof typeof feeFactors] ?? 1;
-  return new BigNumber(factor * BASE_GAS);
+  return factor * BASE_GAS;
 };
 
 /**
- * Calculate fee for Other types of transactions
+ * Calculate gas 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
+ * @returns The other gas
  * @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)))
+ * TX_OTHER_GAS(Tag.OracleResponseTx, 10, { relativeTtl: 12, innerTxSize: 0 })
+ *  => 10 * 20 + Math.ceil(32000 * 12 / Math.floor(60 * 24 * 365 / 3))
  * ```
  */
-const TX_FEE_OTHER_GAS = (
+const TX_OTHER_GAS = (
   txType: Tag,
   txSize: number,
   { relativeTtl, innerTxSize }: { relativeTtl: number; innerTxSize: number },
-): BigNumber => {
+): number => {
   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)),
-        );
+      return txSize * GAS_PER_BYTE
+        + 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);
+      return (txSize - innerTxSize) * GAS_PER_BYTE;
     default:
-      return new BigNumber(txSize).times(GAS_PER_BYTE);
+      return txSize * GAS_PER_BYTE;
   }
 };
 
@@ -91,13 +86,13 @@ function getOracleRelativeTtl(params: any): number {
 }
 
 /**
- * Calculate fee based on tx type and params
+ * Calculate gas based on tx type and params
  */
-export function buildFee(
+export function buildGas(
   builtTx: Encoded.Transaction,
   unpackTx: typeof unpackTxType,
   buildTx: typeof buildTxType,
-): BigNumber {
+): number {
   const { length } = decode(builtTx);
   const txObject = unpackTx(builtTx);
 
@@ -106,11 +101,10 @@ export function buildFee(
     innerTxSize = decode(buildTx(txObject.tx.encodedTx)).length;
   }
 
-  return TX_FEE_BASE_GAS(txObject.tag)
-    .plus(TX_FEE_OTHER_GAS(txObject.tag, length, {
+  return TX_BASE_GAS(txObject.tag)
+    + TX_OTHER_GAS(txObject.tag, length, {
       relativeTtl: getOracleRelativeTtl(txObject), innerTxSize,
-    }))
-    .times(MIN_GAS_PRICE);
+    });
 }
 
 /**
@@ -127,25 +121,46 @@ function calculateMinFee(
   let previousFee;
   do {
     previousFee = fee;
-    fee = buildFee(rebuildTx(fee), unpackTx, buildTx);
+    fee = new BigNumber(MIN_GAS_PRICE).times(buildGas(rebuildTx(fee), unpackTx, buildTx));
   } while (!fee.eq(previousFee));
   return fee;
 }
 
+// TODO: Get rid of this workaround. Transaction builder can't accept/return gas price instead of
+// fee because it may get a decimal gas price. So, it should accept the optional `gasPrice` even
+// if it is not a contract-related transaction. And use this `gasPrice` to calculate `fee`.
+const gasPricePrefix = '_gas-price:';
+
+export interface SerializeAettosParams {
+  rebuildTx: (params: any) => Encoded.Transaction;
+  unpackTx: typeof unpackTxType;
+  buildTx: typeof buildTxType;
+  _computingMinFee?: BigNumber;
+}
+
 export default {
   ...coinAmount,
 
+  async prepare(
+    value: Int | undefined,
+    params: {},
+    { onNode }: { onNode?: Node },
+  ): Promise<Int | undefined> {
+    if (value != null) return value;
+    if (onNode == null) {
+      throw new ArgumentError('onNode', 'provided (or provide `fee` instead)', onNode);
+    }
+    const gasPrice = await getCachedIncreasedGasPrice(onNode);
+    if (gasPrice === 0n) return undefined;
+    return gasPricePrefix + gasPrice;
+  },
+
   serializeAettos(
     _value: string | undefined,
     {
-      rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee,
-    }: {
-      rebuildTx: (params: any) => Encoded.Transaction;
-      unpackTx: typeof unpackTxType;
-      buildTx: typeof buildTxType;
-      _computingMinFee?: BigNumber;
-      _pickBiggerFee?: boolean;
-    },
+      rebuildTx, unpackTx, buildTx, _computingMinFee,
+    }: SerializeAettosParams,
+    { _canIncreaseFee }: { _canIncreaseFee?: boolean },
   ): string {
     if (_computingMinFee != null) return _computingMinFee.toFixed();
     const minFee = calculateMinFee(
@@ -153,11 +168,24 @@ export default {
       unpackTx,
       buildTx,
     );
-    const value = new BigNumber(_value ?? minFee);
+    const value = _value?.startsWith(gasPricePrefix) === true
+      ? minFee.dividedBy(MIN_GAS_PRICE).times(_value.replace(gasPricePrefix, ''))
+      : new BigNumber(_value ?? minFee);
     if (minFee.gt(value)) {
-      if (_pickBiggerFee === true) return minFee.toFixed();
+      if (_canIncreaseFee === true) return minFee.toFixed();
       throw new IllegalArgumentError(`Fee ${value.toString()} must be bigger than ${minFee}`);
     }
     return value.toFixed();
   },
+
+  serialize(
+    value: Parameters<typeof coinAmount.serialize>[0],
+    params: Parameters<typeof coinAmount.serialize>[1] & SerializeAettosParams,
+    options: { _canIncreaseFee?: boolean } & Parameters<typeof coinAmount.serialize>[2],
+  ): Buffer {
+    if (typeof value === 'string' && value.startsWith(gasPricePrefix)) {
+      return uInt.serialize(this.serializeAettos(value, params, options));
+    }
+    return coinAmount.serialize.call(this, value, params, options);
+  },
 };

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

@@ -1,7 +1,7 @@
 import { IllegalArgumentError } from '../../../utils/errors';
-import { MIN_GAS_PRICE, Tag, MAX_AUTH_FUN_GAS } from '../constants';
+import { Tag, MAX_AUTH_FUN_GAS } from '../constants';
 import shortUInt from './short-u-int';
-import { buildFee } from './fee';
+import { buildGas } from './fee';
 import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 
 function calculateGasLimitMax(
@@ -10,7 +10,7 @@ function calculateGasLimitMax(
   unpackTx: typeof unpackTxType,
   buildTx: typeof buildTxType,
 ): number {
-  return gasMax - +buildFee(rebuildTx(gasMax), unpackTx, buildTx).dividedBy(MIN_GAS_PRICE);
+  return gasMax - +buildGas(rebuildTx(gasMax), unpackTx, buildTx);
 }
 
 export default {
@@ -33,7 +33,7 @@ export default {
 
     const gasLimitMax = tag === Tag.GaMetaTx ? MAX_AUTH_FUN_GAS : calculateGasLimitMax(
       gasMax,
-      (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit, _pickBiggerFee: true }),
+      (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit, _canIncreaseFee: true }),
       unpackTx,
       buildTx,
     );

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

@@ -1,14 +1,70 @@
-import coinAmount from './coin-amount';
-import { IllegalArgumentError } from '../../../utils/errors';
-import { MIN_GAS_PRICE } from '../constants';
-
-export default {
-  ...coinAmount,
-
-  serializeAettos(value: string | undefined = MIN_GAS_PRICE.toString()): string {
-    if (+value < MIN_GAS_PRICE) {
-      throw new IllegalArgumentError(`Gas price ${value.toString()} must be bigger than ${MIN_GAS_PRICE}`);
-    }
-    return value;
-  },
-};
+import BigNumber from 'bignumber.js';
+import coinAmount from './coin-amount';
+import { ArgumentError, IllegalArgumentError } from '../../../utils/errors';
+import { Int, MIN_GAS_PRICE } from '../constants';
+import Node from '../../../Node';
+import { AE_AMOUNT_FORMATS, formatAmount } from '../../../utils/amount-formatter';
+import semverSatisfies from '../../../utils/semver-satisfies';
+
+const gasPriceCache: WeakMap<Node, { time: number; gasPrice: bigint }> = new WeakMap();
+
+export async function getCachedIncreasedGasPrice(node: Node): Promise<bigint> {
+  const cache = gasPriceCache.get(node);
+  if (cache != null && cache.time > Date.now() - 20 * 1000) {
+    return cache.gasPrice;
+  }
+
+  // TODO: remove after requiring node@6.13.0
+  const { nodeVersion } = await node._getCachedStatus();
+  // TODO: remove remove '6.12.0+' check after releasing 6.13.0
+  if (!nodeVersion.startsWith('6.12.0+') && !semverSatisfies(nodeVersion, '6.13.0', '8.0.0')) {
+    return 0n;
+  }
+
+  const { minGasPrice, utilization } = (await node.getRecentGasPrices())[0];
+  let gasPrice = utilization < 70 ? 0n : BigInt(
+    new BigNumber(minGasPrice.toString()).times(1.01).integerValue().toFixed(),
+  );
+
+  const maxSafeGasPrice = BigInt(MIN_GAS_PRICE) * 100000n; // max microblock fee is 600ae or 35usd
+  if (gasPrice > maxSafeGasPrice) {
+    console.warn([
+      `Estimated gas price ${gasPrice} exceeds the maximum safe value for unknown reason.`,
+      `It will be limited to ${maxSafeGasPrice}.`,
+      'To overcome this restriction provide `gasPrice`/`fee` in options.',
+    ].join(' '));
+    gasPrice = maxSafeGasPrice;
+  }
+
+  gasPriceCache.set(node, { gasPrice, time: Date.now() });
+  return gasPrice;
+}
+
+// TODO: use withFormatting after using a single type for coins representation
+export default {
+  ...coinAmount,
+
+  async prepare(
+    value: Int | undefined,
+    params: {},
+    { onNode, denomination }: {
+      onNode?: Node;
+      denomination?: AE_AMOUNT_FORMATS;
+    },
+  ): Promise<Int | undefined> {
+    if (value != null) return value;
+    if (onNode == null) {
+      throw new ArgumentError('onNode', 'provided (or provide `gasPrice` instead)', onNode);
+    }
+    const gasPrice = await getCachedIncreasedGasPrice(onNode);
+    if (gasPrice === 0n) return undefined;
+    return formatAmount(gasPrice, { targetDenomination: denomination });
+  },
+
+  serializeAettos(value: string | undefined = MIN_GAS_PRICE.toString()): string {
+    if (+value < MIN_GAS_PRICE) {
+      throw new IllegalArgumentError(`Gas price ${value.toString()} must be bigger than ${MIN_GAS_PRICE}`);
+    }
+    return value;
+  },
+};

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

@@ -1,31 +1,34 @@
-import abiVersion from './abi-version';
-import address from './address';
-import array from './array';
-import boolean from './boolean';
-import coinAmount from './coin-amount';
-import ctVersion from './ct-version';
-import deposit from './deposit';
-import encoded from './encoded';
-import entry from './entry';
-import enumeration from './enumeration';
-import fee from './fee';
-import field from './field';
-import gasLimit from './gas-limit';
-import gasPrice from './gas-price';
-import map from './map';
-import mptree from './mptree';
-import name from './name';
-import nameFee from './name-fee';
-import nameId from './name-id';
-import nonce from './nonce';
-import pointers from './pointers';
-import raw from './raw';
-import shortUInt from './short-u-int';
-import shortUIntConst from './short-u-int-const';
-import string from './string';
-import ttl from './ttl';
-import uInt from './u-int';
-import wrapped from './wrapped';
+export { default as abiVersion } from './abi-version';
+export { default as address } from './address';
+export { default as array } from './array';
+export { default as boolean } from './boolean';
+export { default as coinAmount } from './coin-amount';
+export { default as ctVersion } from './ct-version';
+export { default as encoded } from './encoded';
+export { default as entry } from './entry';
+export { default as enumeration } from './enumeration';
+export { default as fee } from './fee';
+export { default as field } from './field';
+export { default as gasLimit } from './gas-limit';
+export { default as gasPrice } from './gas-price';
+export { default as map } from './map';
+export { default as mptree } from './mptree';
+export { default as name } from './name';
+export { default as nameFee } from './name-fee';
+export { default as nameId } from './name-id';
+export { default as nonce } from './nonce';
+export { default as pointers } from './pointers';
+export { default as pointers2 } from './pointers2';
+export { default as queryFee } from './query-fee';
+export { default as raw } from './raw';
+export { default as shortUInt } from './short-u-int';
+export { default as shortUIntConst } from './short-u-int-const';
+export { default as string } from './string';
+export { default as ttl } from './ttl';
+export { default as uInt } from './u-int';
+export { default as withDefault } from './with-default';
+export { default as withFormatting } from './with-formatting';
+export { default as wrapped } from './wrapped';
 
 export type BinaryData = Buffer | Buffer[] | Buffer[][]
 | Array<[Buffer, Array<[Buffer, Buffer[]]>]>;
@@ -35,34 +38,3 @@ export interface Field {
   deserialize: (value: BinaryData, options: any) => any;
   recursiveType?: boolean;
 }
-
-export {
-  abiVersion,
-  address,
-  array,
-  boolean,
-  coinAmount,
-  ctVersion,
-  deposit,
-  encoded,
-  entry,
-  enumeration,
-  fee,
-  field,
-  gasLimit,
-  gasPrice,
-  map,
-  mptree,
-  name,
-  nameFee,
-  nameId,
-  nonce,
-  pointers,
-  raw,
-  shortUInt,
-  shortUIntConst,
-  string,
-  ttl,
-  uInt,
-  wrapped,
-};

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

@@ -18,7 +18,7 @@ export default {
   },
 
   /**
-   * @param value - AENS name fee Buffer
+   * @param value - AENS name fee
    * @param txFields - Transaction fields
    * @param txFields.name - AENS Name in transaction
    */

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

@@ -11,7 +11,11 @@ export default function genNonceField<SenderKey extends string>(senderKey: Sende
     value: number | undefined,
     params: {},
     // TODO: replace `string` with AddressEncodings
-    options: { [key in SenderKey]: string } & { strategy?: NextNonceStrategy; onNode?: Node },
+    options: { [key in SenderKey]: string } & {
+      strategy?: NextNonceStrategy;
+      onNode?: Node;
+      _isInternalBuild?: boolean;
+    },
   ) => Promise<number>;
   deserialize: (value: Buffer) => number;
   senderKey: string;
@@ -21,6 +25,8 @@ export default function genNonceField<SenderKey extends string>(senderKey: Sende
 
     async prepare(value, params, options) {
       if (value != null) return value;
+      // TODO: uncomment the below line
+      // if (options._isInternalBuild === true) return 0;
       const { onNode, strategy } = options;
       const senderId = options[senderKey];
       const requirement = 'provided (or provide `nonce` instead)';

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

@@ -0,0 +1,62 @@
+import { NamePointer as NamePointerString } from '../../../apis/node';
+import { toBytes } from '../../../utils/bytes';
+import {
+  Encoded, Encoding, decode, encode,
+} from '../../../utils/encoder';
+import { isAddressValid } from '../../../utils/crypto';
+import { IllegalArgumentError, DecodeError, ArgumentError } from '../../../utils/errors';
+import address, { AddressEncodings, idTagToEncoding } from './address';
+
+const ID_TAG = Buffer.from([1]);
+const DATA_TAG = Buffer.from([2]);
+const DATA_LENGTH_MAX = 1024;
+const addressAny = address(...idTagToEncoding);
+
+// TODO: remove after fixing node types
+type NamePointer = NamePointerString & {
+  id: Encoded.Generic<AddressEncodings | Encoding.Bytearray>;
+};
+
+export default {
+  /**
+   * Helper function to build pointers for name update TX
+   * @param pointers - Array of pointers
+   * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`
+   * @returns Serialized pointers array
+   */
+  serialize(pointers: NamePointer[]): Buffer[][] {
+    if (pointers.length > 32) {
+      throw new IllegalArgumentError(`Expected 32 pointers or less, got ${pointers.length} instead`);
+    }
+    return pointers.map(({ key, id }) => {
+      let payload;
+      if (isAddressValid(id, ...idTagToEncoding)) payload = [ID_TAG, addressAny.serialize(id)];
+      if (isAddressValid(id, Encoding.Bytearray)) {
+        const data = decode(id);
+        if (data.length > DATA_LENGTH_MAX) {
+          throw new ArgumentError('Raw pointer', `shorter than ${DATA_LENGTH_MAX + 1} bytes`, `${data.length} bytes`);
+        }
+        payload = [DATA_TAG, data];
+      }
+      if (payload == null) throw new DecodeError(`Unknown AENS pointer value: ${id}`);
+      return [toBytes(key), Buffer.concat(payload)];
+    });
+  },
+
+  /**
+   * Helper function to read pointers from name update TX
+   * @param pointers - Array of pointers
+   * @returns Deserialize pointer array
+   */
+  deserialize(pointers: Array<[key: Buffer, id: Buffer]>): NamePointer[] {
+    return pointers.map(([bKey, bId]) => {
+      const tag = bId.subarray(0, 1);
+      const payload = bId.subarray(1);
+      let id;
+      if (tag.equals(ID_TAG)) id = addressAny.deserialize(payload);
+      if (tag.equals(DATA_TAG)) id = encode(payload, Encoding.Bytearray);
+      if (id == null) throw new DecodeError(`Unknown AENS pointer tag: ${tag}`);
+      return { key: bKey.toString(), id };
+    });
+  },
+};

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

@@ -0,0 +1,25 @@
+import coinAmount from './coin-amount';
+import { Int } from '../constants';
+import Node from '../../../Node';
+import { Encoded } from '../../../utils/encoder';
+import { ArgumentError } from '../../../utils/errors';
+
+/**
+ * Oracle query fee
+ */
+export default {
+  ...coinAmount,
+
+  async prepare(
+    value: Int | undefined,
+    params: {},
+    options: { oracleId?: Encoded.OracleAddress; onNode?: Node },
+  ) {
+    if (value != null) return value;
+    const { onNode, oracleId } = options;
+    const requirement = 'provided (or provide `queryFee` instead)';
+    if (onNode == null) throw new ArgumentError('onNode', requirement, onNode);
+    if (oracleId == null) throw new ArgumentError('oracleId', requirement, oracleId);
+    return (await onNode.getOracleByPubkey(oracleId)).queryFee.toString();
+  },
+};