@aeternity/aepp-sdk 13.3.3 → 14.1.0

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

@@ -1,191 +0,0 @@
-import BigNumber from 'bignumber.js';
-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 gas
- * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
- * @param txType - The transaction type
- * @returns The base gas
- * @example
- * ```js
- * TX_BASE_GAS(Tag.ChannelForceProgressTx) => 30 * 15000
- * ```
- */
-const TX_BASE_GAS = (txType: Tag): number => {
-  const feeFactors = {
-    [Tag.ChannelForceProgressTx]: 30,
-    [Tag.ChannelOffChainTx]: 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 factor * BASE_GAS;
-};
-
-/**
- * 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 gas
- * @example
- * ```js
- * TX_OTHER_GAS(Tag.OracleResponseTx, 10, { relativeTtl: 12, innerTxSize: 0 })
- *  => 10 * 20 + Math.ceil(32000 * 12 / Math.floor(60 * 24 * 365 / 3))
- * ```
- */
-const TX_OTHER_GAS = (
-  txType: Tag,
-  txSize: number,
-  { relativeTtl, innerTxSize }: { relativeTtl: number; innerTxSize: number },
-): number => {
-  switch (txType) {
-    case Tag.OracleRegisterTx:
-    case Tag.OracleExtendTx:
-    case Tag.OracleQueryTx:
-    case Tag.OracleResponseTx:
-      return txSize * GAS_PER_BYTE
-        + Math.ceil((32000 * relativeTtl) / Math.floor((60 * 24 * 365) / KEY_BLOCK_INTERVAL));
-    case Tag.GaMetaTx:
-    case Tag.PayingForTx:
-      return (txSize - innerTxSize) * GAS_PER_BYTE;
-    default:
-      return txSize * GAS_PER_BYTE;
-  }
-};
-
-function getOracleRelativeTtl(params: any): number {
-  const ttlKeys = {
-    [Tag.OracleRegisterTx]: 'oracleTtlValue',
-    [Tag.OracleExtendTx]: 'oracleTtlValue',
-    [Tag.OracleQueryTx]: 'queryTtlValue',
-    [Tag.OracleResponseTx]: 'responseTtlValue',
-  } as const;
-
-  const { tag } = params;
-  if (!isKeyOfObject(tag, ttlKeys)) return 1;
-  return params[ttlKeys[tag]];
-}
-
-/**
- * Calculate gas based on tx type and params
- */
-export function buildGas(
-  builtTx: Encoded.Transaction,
-  unpackTx: typeof unpackTxType,
-  buildTx: typeof buildTxType,
-): number {
-  const { length } = decode(builtTx);
-  const txObject = unpackTx(builtTx);
-
-  let innerTxSize = 0;
-  if (txObject.tag === Tag.GaMetaTx || txObject.tag === Tag.PayingForTx) {
-    innerTxSize = decode(buildTx(txObject.tx.encodedTx)).length;
-  }
-
-  return TX_BASE_GAS(txObject.tag)
-    + TX_OTHER_GAS(txObject.tag, length, {
-      relativeTtl: getOracleRelativeTtl(txObject), innerTxSize,
-    });
-}
-
-/**
- * Calculate min fee
- * @category transaction builder
- * @param rebuildTx - Callback to get built transaction with specific fee
- */
-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 = 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,
-    }: SerializeAettosParams,
-    { _canIncreaseFee }: { _canIncreaseFee?: boolean },
-  ): string {
-    if (_computingMinFee != null) return _computingMinFee.toFixed();
-    const minFee = calculateMinFee(
-      (fee) => rebuildTx({ _computingMinFee: fee }),
-      unpackTx,
-      buildTx,
-    );
-    const value = _value?.startsWith(gasPricePrefix) === true
-      ? minFee.dividedBy(MIN_GAS_PRICE).times(_value.replace(gasPricePrefix, ''))
-      : new BigNumber(_value ?? minFee);
-    if (minFee.gt(value)) {
-      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/field.ts

@@ -1,9 +0,0 @@
-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

@@ -1,46 +0,0 @@
-import { IllegalArgumentError } from '../../../utils/errors';
-import { Tag, MAX_AUTH_FUN_GAS } from '../constants';
-import shortUInt from './short-u-int';
-import { buildGas } from './fee';
-import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
-
-function calculateGasLimitMax(
-  gasMax: number,
-  rebuildTx: (value: number) => any,
-  unpackTx: typeof unpackTxType,
-  buildTx: typeof buildTxType,
-): number {
-  return gasMax - +buildGas(rebuildTx(gasMax), unpackTx, buildTx);
-}
-
-export default {
-  ...shortUInt,
-
-  serialize(
-    _value: number | undefined,
-    {
-      tag, rebuildTx, unpackTx, buildTx, _computingGasLimit,
-    }: {
-      tag: Tag;
-      rebuildTx: (params: any) => any;
-      unpackTx: typeof unpackTxType;
-      buildTx: typeof buildTxType;
-      _computingGasLimit?: number;
-    },
-    { gasMax = 6e6 }: { gasMax?: number },
-  ): Buffer {
-    if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);
-
-    const gasLimitMax = tag === Tag.GaMetaTx ? MAX_AUTH_FUN_GAS : calculateGasLimitMax(
-      gasMax,
-      (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit, _canIncreaseFee: true }),
-      unpackTx,
-      buildTx,
-    );
-    const value = _value ?? gasLimitMax;
-    if (value > gasLimitMax) {
-      throw new IllegalArgumentError(`Gas limit ${value} must be less or equal to ${gasLimitMax}`);
-    }
-    return shortUInt.serialize(value);
-  },
-};

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

@@ -1,67 +0,0 @@
-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();
-  if (!semverSatisfies(nodeVersion, '6.13.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,40 +0,0 @@
-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[]]>]>;
-export interface Field {
-  serialize: (value: any, options: any, parameters: any) => BinaryData;
-  prepare?: (value: any, options: any, parameters: any) => Promise<any>;
-  deserialize: (value: BinaryData, options: any) => any;
-  recursiveType?: boolean;
-}

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

@@ -1,45 +0,0 @@
-import { Tag } from '../constants';
-import {
-  encode, Encoding, Encoded, decode,
-} from '../../../utils/encoder';
-import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
-
-export default function genMapField<E extends Encoding, T extends Tag>(encoding: E, tag: T): {
-  serialize: (
-    // TODO: replace with `TxParams & { tag: T }`,
-    //  but fix TS2502 value is referenced directly or indirectly in its own type annotation
-    value: Record<Encoded.Generic<E>, any>, options: { buildTx: typeof buildTxType }
-  ) => Buffer;
-  deserialize: (
-    value: Buffer, options: { unpackTx: typeof unpackTxType },
-    // TODO: replace with `TxUnpacked & { tag: T }`,
-    //  TS2577 Return type annotation circularly references itself
-  ) => Record<Encoded.Generic<E>, any>;
-  recursiveType: true;
-} {
-  return {
-    serialize(object, { buildTx }) {
-      return decode(buildTx({
-        tag: Tag.Mtree,
-        values: Object.entries(object).map(([key, value]) => ({
-          tag: Tag.MtreeValue,
-          key: decode(key as Encoded.Generic<E>),
-          value: decode(buildTx({ ...value as any, tag })),
-        })),
-      }));
-    },
-
-    deserialize(buffer, { unpackTx }) {
-      const { values } = unpackTx(encode(buffer, Encoding.Transaction), Tag.Mtree);
-      return Object.fromEntries(values
-        // TODO: remove after resolving https://github.com/aeternity/aeternity/issues/4066
-        .filter(({ key }) => encoding !== Encoding.ContractAddress || key.length === 32)
-        .map(({ key, value }) => [
-          encode(key, encoding),
-          unpackTx(encode(value, Encoding.Transaction), tag),
-        ])) as Record<Encoded.Generic<E>, any>;
-    },
-
-    recursiveType: true,
-  };
-}

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

@@ -1,243 +0,0 @@
-import { encode as rlpEncode, Input } from 'rlp';
-import { Tag } from '../constants';
-import { hash } from '../../../utils/crypto';
-import {
-  MerkleTreeHashMismatchError,
-  MissingNodeInTreeError,
-  UnknownPathNibbleError,
-  UnexpectedTsError,
-  UnknownNodeLengthError,
-  InternalError,
-} from '../../../utils/errors';
-import {
-  decode, encode, Encoded, Encoding,
-} from '../../../utils/encoder';
-import type { unpackTx } from '..';
-import type { TxUnpacked } from '../schema.generated';
-
-enum NodeType {
-  Branch,
-  Extension,
-  Leaf,
-}
-
-type MPTreeBinary = [Buffer, Array<[Buffer, Buffer[]]>];
-
-class MPTree<E extends Encoding, T extends Tag> {
-  readonly #rootHash: string;
-
-  #isComplete = true;
-
-  get isComplete(): boolean {
-    return this.#isComplete;
-  }
-
-  readonly #nodes: { [key: string]: Buffer[] };
-
-  readonly #encoding: E;
-
-  readonly #tag: T;
-
-  readonly #unpackTx: typeof unpackTx;
-
-  static #nodeHash(node: Input): string {
-    return Buffer.from(hash(rlpEncode(node))).toString('hex');
-  }
-
-  /**
-   * Deserialize Merkle Patricia Tree
-   * @param binary - Binary
-   * @param tag - Tag to use to decode value
-   * @param unpTx - Implementation of unpackTx use to decode values
-   * @returns Merkle Patricia Tree
-   */
-  constructor(binary: MPTreeBinary, encoding: E, tag: T, unpTx: typeof unpackTx) {
-    this.#encoding = encoding;
-    this.#tag = tag;
-    this.#unpackTx = unpTx;
-    this.#rootHash = binary[0].toString('hex');
-    this.#nodes = Object.fromEntries(
-      binary[1].map((node) => [node[0].toString('hex'), node[1]]),
-    );
-
-    if (this.#nodes[this.#rootHash] == null) {
-      if (Object.keys(this.#nodes).length !== 0) {
-        throw new MissingNodeInTreeError('Can\'t find a node by root hash');
-      }
-      this.#isComplete = false;
-      return;
-    }
-    Object.entries(this.#nodes).forEach(([key, node]) => {
-      if (MPTree.#nodeHash(node) !== key) throw new MerkleTreeHashMismatchError();
-      const { type } = MPTree.#parseNode(node);
-      switch (type) {
-        case NodeType.Branch:
-          node
-            .slice(0, 16)
-            .filter((n) => n.length)
-            .forEach((n) => {
-              // TODO: enable after resolving https://github.com/aeternity/aeternity/issues/4066
-              // if (n.length !== 32) {
-              //   throw new ArgumentError('MPTree branch item length', 32, n.length);
-              // }
-              if (this.#nodes[n.toString('hex')] == null) this.#isComplete = false;
-            });
-          break;
-        case NodeType.Extension:
-          if (this.#nodes[node[1].toString('hex')] == null) {
-            throw new MissingNodeInTreeError('Can\'t find a node by hash in extension node');
-          }
-          break;
-        case NodeType.Leaf:
-          break;
-        default:
-          throw new InternalError(`Unknown MPTree node type: ${type}`);
-      }
-    });
-  }
-
-  isEqual(tree: MPTree<E, T>): boolean {
-    return this.#rootHash === tree.#rootHash;
-  }
-
-  static #parseNode(node: Buffer[]): { type: NodeType; value?: Buffer; path?: string } {
-    switch (node.length) {
-      case 17:
-        return {
-          type: NodeType.Branch,
-          ...node[16].length !== 0 && { value: node[16] },
-        };
-      case 2: {
-        const nibble = node[0][0] >> 4; // eslint-disable-line no-bitwise
-        if (nibble > 3) throw new UnknownPathNibbleError(nibble);
-        const type = nibble <= 1 ? NodeType.Extension : NodeType.Leaf;
-        const slice = [0, 2].includes(nibble) ? 2 : 1;
-        return {
-          type,
-          ...type === NodeType.Leaf && { value: node[1] },
-          path: node[0].toString('hex').slice(slice),
-        };
-      }
-      default:
-        throw new UnknownNodeLengthError(node.length);
-    }
-  }
-
-  /**
-   * Serialize Merkle Patricia Tree
-   * @returns Binary
-   */
-  serialize(): MPTreeBinary {
-    return [
-      Buffer.from(this.#rootHash, 'hex'),
-      Object.entries(this.#nodes).map(([mptHash, value]) => ([
-        Buffer.from(mptHash, 'hex'),
-        value,
-      ])),
-    ];
-  }
-
-  /**
-   * Retrieve value from Merkle Patricia Tree
-   * @param _key - The key of the element to retrieve
-   * @returns Value associated to the specified key
-   */
-  #getRaw(_key: string): Buffer | undefined {
-    let searchFrom = this.#rootHash;
-    let key = _key;
-    while (true) { // eslint-disable-line no-constant-condition
-      const node = this.#nodes[searchFrom];
-      if (node == null) {
-        if (!this.isComplete) return undefined;
-        throw new InternalError('Can\'t find node in complete tree');
-      }
-      const { type, value, path } = MPTree.#parseNode(node);
-      switch (type) {
-        case NodeType.Branch:
-          if (key.length === 0) return value;
-          searchFrom = node[+`0x${key[0]}`].toString('hex');
-          key = key.substring(1);
-          break;
-        case NodeType.Extension:
-          if (key.substring(0, path?.length) !== path) return undefined;
-          searchFrom = node[1].toString('hex');
-          key = key.substring(path.length);
-          break;
-        case NodeType.Leaf:
-          if (path !== key) return undefined;
-          return value;
-        default:
-          throw new InternalError(`Unknown MPTree node type: ${type}`);
-      }
-    }
-  }
-
-  /**
-   * Retrieve value from Merkle Patricia Tree
-   * @param key - The key of the element to retrieve
-   * @returns Value associated to the specified key
-   */
-  get(key: Encoded.Generic<E>): TxUnpacked & { tag: T } | undefined {
-    const d = this.#getRaw(decode(key).toString('hex'));
-    if (d == null) return d;
-    return this.#unpackTx(encode(d, Encoding.Transaction), this.#tag);
-  }
-
-  #entriesRaw(): Array<[string, Buffer]> {
-    const entries: Array<[string, Buffer]> = [];
-    const rec = (searchFrom: string, key: string): void => {
-      const node = this.#nodes[searchFrom];
-      if (node == null) {
-        if (!this.isComplete) return;
-        throw new InternalError('Can\'t find node in complete tree');
-      }
-      const { type, value, path } = MPTree.#parseNode(node);
-      switch (type) {
-        case NodeType.Branch:
-          node
-            .slice(0, 16)
-            .map((t, idx): [typeof t, number] => [t, idx])
-            .filter(([t]) => t.length)
-            .forEach(([t, idx]) => rec(t.toString('hex'), key + idx.toString(16)));
-          if (value != null) entries.push([key, value]);
-          break;
-        case NodeType.Extension:
-          rec(node[1].toString('hex'), key + path);
-          break;
-        case NodeType.Leaf:
-          if (value == null) throw new UnexpectedTsError();
-          entries.push([key + path, value]);
-          break;
-        default:
-          throw new InternalError(`Unknown MPTree node type: ${type}`);
-      }
-    };
-    rec(this.#rootHash, '');
-    return entries;
-  }
-
-  toObject(): Record<Encoded.Generic<E>, TxUnpacked & { tag: T }> {
-    return Object.fromEntries(this.#entriesRaw()
-      // TODO: remove after resolving https://github.com/aeternity/aeternity/issues/4066
-      .filter(([k]) => this.#encoding !== Encoding.ContractAddress || k.length !== 66)
-      .map(([k, v]) => [
-        encode(Buffer.from(k, 'hex'), this.#encoding),
-        this.#unpackTx(encode(v, Encoding.Transaction), this.#tag),
-      ])) as Record<Encoded.Generic<E>, TxUnpacked & { tag: T }>;
-  }
-}
-
-export default function genMPTreeField<E extends Encoding, T extends Tag>(encoding: E, tag: T): {
-  serialize: (value: MPTree<E, T>) => MPTreeBinary;
-  deserialize: (value: MPTreeBinary, o: { unpackTx: typeof unpackTx }) => MPTree<E, T>;
-} {
-  return {
-    serialize(value) {
-      return value.serialize();
-    },
-
-    deserialize(value, { unpackTx }) {
-      return new MPTree(value, encoding, tag, unpackTx);
-    },
-  };
-}

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

@@ -1,32 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { getMinimumNameFee } from '../helpers';
-import { InsufficientNameFeeError } from '../../../utils/errors';
-import coinAmount from './coin-amount';
-import { AensName, Int } from '../constants';
-
-export default {
-  ...coinAmount,
-
-  serializeAettos(
-    _value: string | undefined,
-    txFields: { name: AensName },
-  ): string {
-    const minNameFee = getMinimumNameFee(txFields.name);
-    const value = new BigNumber(_value ?? minNameFee);
-    if (minNameFee.gt(value)) throw new InsufficientNameFeeError(value, minNameFee);
-    return value.toFixed();
-  },
-
-  /**
-   * @param value - AENS name fee
-   * @param txFields - Transaction fields
-   * @param txFields.name - AENS Name in transaction
-   */
-  serialize(
-    value: Int | undefined,
-    txFields: { name: AensName } & Parameters<typeof coinAmount['serialize']>[1],
-    parameters: Parameters<typeof coinAmount['serialize']>[2],
-  ): Buffer {
-    return coinAmount.serialize.call(this, value, txFields, parameters);
-  },
-};

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

@@ -1,17 +0,0 @@
-import { AensName } from '../constants';
-import { produceNameId, isNameValid } from '../helpers';
-import address from './address';
-import { Encoded, Encoding } from '../../../utils/encoder';
-
-const addressName = address(Encoding.Name);
-
-export default {
-  ...addressName,
-
-  /**
-   * @param value - AENS name ID
-   */
-  serialize(value: AensName | Encoded.Name): Buffer {
-    return addressName.serialize(isNameValid(value) ? produceNameId(value) : value);
-  },
-};