@aeternity/aepp-sdk 13.3.2 → 14.0.0

package/es/tx/builder/field-types/entry.js

@@ -0,0 +1,26 @@
+import { Buffer as _Buffer } from "buffer";
+import { decode, encode, Encoding } from '../../../utils/encoder.js';
+export default function genEntryField(tag) {
+  return {
+    serialize(txParams, {
+      packEntry
+    }) {
+      if (ArrayBuffer.isView(txParams)) return _Buffer.from(txParams);
+      if (typeof txParams === 'string' && txParams.startsWith('tx_')) {
+        return decode(txParams);
+      }
+      return decode(packEntry({
+        ...txParams,
+        ...(tag != null && {
+          tag
+        })
+      }));
+    },
+    deserialize(buf, {
+      unpackEntry
+    }) {
+      return unpackEntry(encode(buf, Encoding.Bytearray), tag);
+    }
+  };
+}
+//# sourceMappingURL=entry.js.map

package/es/tx/builder/field-types/entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.js","names":["decode","encode","Encoding","genEntryField","tag","serialize","txParams","packEntry","ArrayBuffer","isView","_Buffer","from","startsWith","deserialize","buf","unpackEntry","Bytearray"],"sources":["../../../../src/tx/builder/field-types/entry.ts"],"sourcesContent":["import { decode, encode, Encoded, Encoding } from '../../../utils/encoder.js';\nimport { EntryTag } from '../entry/constants.js';\nimport type { unpackEntry as unpackEntryType, packEntry as packEntryType } from '../entry/index.js';\n\nexport default function genEntryField<T extends EntryTag = EntryTag>(\n  tag?: T,\n): {\n  serialize: (\n    // TODO: replace with `TxParams & { tag: T }`,\n    //  but fix TS2502 value is referenced directly or indirectly in its own type annotation\n    value: any,\n    options: { packEntry: typeof packEntryType },\n  ) => Buffer;\n  deserialize: (\n    value: Buffer,\n    options: { unpackEntry: typeof unpackEntryType },\n    // TODO: replace with `TxUnpacked & { tag: T }`,\n    //  TS2577 Return type annotation circularly references itself\n  ) => any;\n} {\n  return {\n    serialize(txParams, { packEntry }) {\n      if (ArrayBuffer.isView(txParams)) return Buffer.from(txParams as any);\n      if (typeof txParams === 'string' && txParams.startsWith('tx_')) {\n        return decode(txParams as Encoded.Transaction);\n      }\n      return decode(packEntry({ ...txParams, ...(tag != null && { tag }) }));\n    },\n\n    deserialize(buf, { unpackEntry }) {\n      return unpackEntry(encode(buf, Encoding.Bytearray), tag);\n    },\n  };\n}\n"],"mappings":";AAAA,SAASA,MAAM,EAAEC,MAAM,EAAWC,QAAQ,QAAQ,2BAA2B;AAI7E,eAAe,SAASC,aAAaA,CACnCC,GAAO,EAcP;EACA,OAAO;IACLC,SAASA,CAACC,QAAQ,EAAE;MAAEC;IAAU,CAAC,EAAE;MACjC,IAAIC,WAAW,CAACC,MAAM,CAACH,QAAQ,CAAC,EAAE,OAAOI,OAAA,CAAOC,IAAI,CAACL,QAAe,CAAC;MACrE,IAAI,OAAOA,QAAQ,KAAK,QAAQ,IAAIA,QAAQ,CAACM,UAAU,CAAC,KAAK,CAAC,EAAE;QAC9D,OAAOZ,MAAM,CAACM,QAA+B,CAAC;MAChD;MACA,OAAON,MAAM,CAACO,SAAS,CAAC;QAAE,GAAGD,QAAQ;QAAE,IAAIF,GAAG,IAAI,IAAI,IAAI;UAAEA;QAAI,CAAC;MAAE,CAAC,CAAC,CAAC;IACxE,CAAC;IAEDS,WAAWA,CAACC,GAAG,EAAE;MAAEC;IAAY,CAAC,EAAE;MAChC,OAAOA,WAAW,CAACd,MAAM,CAACa,GAAG,EAAEZ,QAAQ,CAACc,SAAS,CAAC,EAAEZ,GAAG,CAAC;IAC1D;EACF,CAAC;AACH","ignoreList":[]}

package/es/tx/builder/field-types/enumeration.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export default function genEnumerationField<Enum extends {
     [key: string]: number | string;
 }>(enm: Enum): {

package/es/tx/builder/field-types/enumeration.js

@@ -0,0 +1,27 @@
+import { Buffer as _Buffer } from "buffer";
+import { ArgumentError } from '../../../utils/errors.js';
+import { isItemOfArray } from '../../../utils/other.js';
+export default function genEnumerationField(enm) {
+  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;
+    }
+  };
+}
+//# sourceMappingURL=enumeration.js.map

package/es/tx/builder/field-types/enumeration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumeration.js","names":["ArgumentError","isItemOfArray","genEnumerationField","enm","values","Object","filter","v","serialize","value","_Buffer","from","deserialize","buffer","length"],"sources":["../../../../src/tx/builder/field-types/enumeration.ts"],"sourcesContent":["import { ArgumentError } from '../../../utils/errors.js';\nimport { isItemOfArray } from '../../../utils/other.js';\n\nexport default function genEnumerationField<Enum extends { [key: string]: number | string }>(\n  enm: Enum,\n): {\n  serialize: (value: Enum[keyof Enum]) => Buffer;\n  deserialize: (value: Buffer) => Enum[keyof Enum];\n} {\n  const values = Object.values(enm).filter((v) => typeof v === 'number');\n  return {\n    serialize(value) {\n      if (typeof value !== 'number') throw new ArgumentError('value', 'to be a number', value);\n      if (value > 0xff) throw new ArgumentError('value', 'to be less than 256', value);\n      if (!isItemOfArray(value, values)) {\n        throw new ArgumentError('value', 'to be a value of Enum', value);\n      }\n      return Buffer.from([value]);\n    },\n\n    deserialize(buffer) {\n      if (buffer.length !== 1) {\n        throw new ArgumentError('buffer', 'to have single element', buffer.length);\n      }\n      const value = buffer[0];\n      if (!isItemOfArray(value, values)) {\n        throw new ArgumentError('value', 'to be a value of Enum', value);\n      }\n      return value as Enum[keyof Enum];\n    },\n  };\n}\n"],"mappings":";AAAA,SAASA,aAAa,QAAQ,0BAA0B;AACxD,SAASC,aAAa,QAAQ,yBAAyB;AAEvD,eAAe,SAASC,mBAAmBA,CACzCC,GAAS,EAIT;EACA,MAAMC,MAAM,GAAGC,MAAM,CAACD,MAAM,CAACD,GAAG,CAAC,CAACG,MAAM,CAAEC,CAAC,IAAK,OAAOA,CAAC,KAAK,QAAQ,CAAC;EACtE,OAAO;IACLC,SAASA,CAACC,KAAK,EAAE;MACf,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE,MAAM,IAAIT,aAAa,CAAC,OAAO,EAAE,gBAAgB,EAAES,KAAK,CAAC;MACxF,IAAIA,KAAK,GAAG,IAAI,EAAE,MAAM,IAAIT,aAAa,CAAC,OAAO,EAAE,qBAAqB,EAAES,KAAK,CAAC;MAChF,IAAI,CAACR,aAAa,CAACQ,KAAK,EAAEL,MAAM,CAAC,EAAE;QACjC,MAAM,IAAIJ,aAAa,CAAC,OAAO,EAAE,uBAAuB,EAAES,KAAK,CAAC;MAClE;MACA,OAAOC,OAAA,CAAOC,IAAI,CAAC,CAACF,KAAK,CAAC,CAAC;IAC7B,CAAC;IAEDG,WAAWA,CAACC,MAAM,EAAE;MAClB,IAAIA,MAAM,CAACC,MAAM,KAAK,CAAC,EAAE;QACvB,MAAM,IAAId,aAAa,CAAC,QAAQ,EAAE,wBAAwB,EAAEa,MAAM,CAACC,MAAM,CAAC;MAC5E;MACA,MAAML,KAAK,GAAGI,MAAM,CAAC,CAAC,CAAC;MACvB,IAAI,CAACZ,aAAa,CAACQ,KAAK,EAAEL,MAAM,CAAC,EAAE;QACjC,MAAM,IAAIJ,aAAa,CAAC,OAAO,EAAE,uBAAuB,EAAES,KAAK,CAAC;MAClE;MACA,OAAOA,KAAK;IACd;EACF,CAAC;AACH","ignoreList":[]}

package/es/tx/builder/field-types/fee.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="node" />
-import BigNumber from 'bignumber.js';
-import { Int } from '../constants';
-import coinAmount from './coin-amount';
-import { Encoded } from '../../../utils/encoder';
-import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
-import Node from '../../../Node';
+import { BigNumber } from 'bignumber.js';
+import { Int } from '../constants.js';
+import coinAmount from './coin-amount.js';
+import { Encoded } from '../../../utils/encoder.js';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index.js';
+import Node from '../../../Node.js';
 /**
  * Calculate gas based on tx type and params
  */
@@ -17,10 +16,10 @@ export interface SerializeAettosParams {
 }
 declare const _default: {
     prepare(value: Int | undefined, params: {}, { onNode }: {
-        onNode?: Node | undefined;
+        onNode?: Node;
     }): Promise<Int | undefined>;
-    serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: SerializeAettosParams, { _canIncreaseFee }: {
-        _canIncreaseFee?: boolean | undefined;
+    serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee }: SerializeAettosParams, { _canIncreaseFee }: {
+        _canIncreaseFee?: boolean;
     }): string;
     serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & SerializeAettosParams, options: {
         _canIncreaseFee?: boolean;

package/es/tx/builder/field-types/fee.js

@@ -0,0 +1,160 @@
+import { BigNumber } from 'bignumber.js';
+import { ArgumentError, IllegalArgumentError } from '../../../utils/errors.js';
+import { MIN_GAS_PRICE, Tag } from '../constants.js';
+import uInt from './u-int.js';
+import coinAmount from './coin-amount.js';
+import { getCachedIncreasedGasPrice } from './gas-price.js';
+import { isKeyOfObject } from '../../../utils/other.js';
+import { decode } from '../../../utils/encoder.js';
+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 => {
+  var _feeFactors;
+  const feeFactors = {
+    [Tag.ChannelForceProgressTx]: 30,
+    [Tag.ChannelOffChainTx]: 0,
+    [Tag.ContractCreateTx]: 5,
+    [Tag.ContractCallTx]: 12,
+    [Tag.GaAttachTx]: 5,
+    [Tag.GaMetaTx]: 5,
+    [Tag.PayingForTx]: 1 / 5
+  };
+  const factor = (_feeFactors = feeFactors[txType]) !== null && _feeFactors !== void 0 ? _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, txSize, {
+  relativeTtl,
+  innerTxSize
+}) => {
+  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) {
+  const ttlKeys = {
+    [Tag.OracleRegisterTx]: 'oracleTtlValue',
+    [Tag.OracleExtendTx]: 'oracleTtlValue',
+    [Tag.OracleQueryTx]: 'queryTtlValue',
+    [Tag.OracleResponseTx]: 'responseTtlValue'
+  };
+  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, unpackTx, buildTx) {
+  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, unpackTx, buildTx) {
+  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 default {
+  ...coinAmount,
+  async prepare(value, params, {
+    onNode
+  }) {
+    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, {
+    rebuildTx,
+    unpackTx,
+    buildTx,
+    _computingMinFee
+  }, {
+    _canIncreaseFee
+  }) {
+    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 !== null && _value !== void 0 ? _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, params, options) {
+    if (typeof value === 'string' && value.startsWith(gasPricePrefix)) {
+      return uInt.serialize(this.serializeAettos(value, params, options));
+    }
+    return coinAmount.serialize.call(this, value, params, options);
+  }
+};
+//# sourceMappingURL=fee.js.map

package/es/tx/builder/field-types/fee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee.js","names":["BigNumber","ArgumentError","IllegalArgumentError","MIN_GAS_PRICE","Tag","uInt","coinAmount","getCachedIncreasedGasPrice","isKeyOfObject","decode","BASE_GAS","GAS_PER_BYTE","KEY_BLOCK_INTERVAL","TX_BASE_GAS","txType","_feeFactors","feeFactors","ChannelForceProgressTx","ChannelOffChainTx","ContractCreateTx","ContractCallTx","GaAttachTx","GaMetaTx","PayingForTx","factor","TX_OTHER_GAS","txSize","relativeTtl","innerTxSize","OracleRegisterTx","OracleExtendTx","OracleQueryTx","OracleResponseTx","Math","ceil","floor","getOracleRelativeTtl","params","ttlKeys","tag","buildGas","builtTx","unpackTx","buildTx","length","txObject","tx","encodedTx","calculateMinFee","rebuildTx","fee","previousFee","times","eq","gasPricePrefix","prepare","value","onNode","gasPrice","undefined","serializeAettos","_value","_computingMinFee","_canIncreaseFee","toFixed","minFee","startsWith","dividedBy","replace","gt","toString","serialize","options","call"],"sources":["../../../../src/tx/builder/field-types/fee.ts"],"sourcesContent":["import { BigNumber } from 'bignumber.js';\nimport { ArgumentError, IllegalArgumentError } from '../../../utils/errors.js';\nimport { Int, MIN_GAS_PRICE, Tag } from '../constants.js';\nimport uInt from './u-int.js';\nimport coinAmount from './coin-amount.js';\nimport { getCachedIncreasedGasPrice } from './gas-price.js';\nimport { isKeyOfObject } from '../../../utils/other.js';\nimport { decode, Encoded } from '../../../utils/encoder.js';\nimport type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index.js';\nimport Node from '../../../Node.js';\n\nconst BASE_GAS = 15000;\nconst GAS_PER_BYTE = 20;\nconst KEY_BLOCK_INTERVAL = 3;\n\n/**\n * Calculate the base gas\n * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}\n * @param txType - The transaction type\n * @returns The base gas\n * @example\n * ```js\n * TX_BASE_GAS(Tag.ChannelForceProgressTx) => 30 * 15000\n * ```\n */\nconst TX_BASE_GAS = (txType: Tag): number => {\n  const feeFactors = {\n    [Tag.ChannelForceProgressTx]: 30,\n    [Tag.ChannelOffChainTx]: 0,\n    [Tag.ContractCreateTx]: 5,\n    [Tag.ContractCallTx]: 12,\n    [Tag.GaAttachTx]: 5,\n    [Tag.GaMetaTx]: 5,\n    [Tag.PayingForTx]: 1 / 5,\n  } as const;\n  const factor = feeFactors[txType as keyof typeof feeFactors] ?? 1;\n  return factor * BASE_GAS;\n};\n\n/**\n * Calculate gas for other types of transactions\n * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}\n * @param txType - The transaction type\n * @param txSize - The transaction size\n * @returns parameters - The transaction parameters\n * @returns parameters.relativeTtl - The relative ttl\n * @returns parameters.innerTxSize - The size of the inner transaction\n * @returns The other gas\n * @example\n * ```js\n * TX_OTHER_GAS(Tag.OracleResponseTx, 10, { relativeTtl: 12, innerTxSize: 0 })\n *  => 10 * 20 + Math.ceil(32000 * 12 / Math.floor(60 * 24 * 365 / 3))\n * ```\n */\nconst TX_OTHER_GAS = (\n  txType: Tag,\n  txSize: number,\n  { relativeTtl, innerTxSize }: { relativeTtl: number; innerTxSize: number },\n): number => {\n  switch (txType) {\n    case Tag.OracleRegisterTx:\n    case Tag.OracleExtendTx:\n    case Tag.OracleQueryTx:\n    case Tag.OracleResponseTx:\n      return (\n        txSize * GAS_PER_BYTE +\n        Math.ceil((32000 * relativeTtl) / Math.floor((60 * 24 * 365) / KEY_BLOCK_INTERVAL))\n      );\n    case Tag.GaMetaTx:\n    case Tag.PayingForTx:\n      return (txSize - innerTxSize) * GAS_PER_BYTE;\n    default:\n      return txSize * GAS_PER_BYTE;\n  }\n};\n\nfunction getOracleRelativeTtl(params: any): number {\n  const ttlKeys = {\n    [Tag.OracleRegisterTx]: 'oracleTtlValue',\n    [Tag.OracleExtendTx]: 'oracleTtlValue',\n    [Tag.OracleQueryTx]: 'queryTtlValue',\n    [Tag.OracleResponseTx]: 'responseTtlValue',\n  } as const;\n\n  const { tag } = params;\n  if (!isKeyOfObject(tag, ttlKeys)) return 1;\n  return params[ttlKeys[tag]];\n}\n\n/**\n * Calculate gas based on tx type and params\n */\nexport function buildGas(\n  builtTx: Encoded.Transaction,\n  unpackTx: typeof unpackTxType,\n  buildTx: typeof buildTxType,\n): number {\n  const { length } = decode(builtTx);\n  const txObject = unpackTx(builtTx);\n\n  let innerTxSize = 0;\n  if (txObject.tag === Tag.GaMetaTx || txObject.tag === Tag.PayingForTx) {\n    innerTxSize = decode(buildTx(txObject.tx.encodedTx)).length;\n  }\n\n  return (\n    TX_BASE_GAS(txObject.tag) +\n    TX_OTHER_GAS(txObject.tag, length, {\n      relativeTtl: getOracleRelativeTtl(txObject),\n      innerTxSize,\n    })\n  );\n}\n\n/**\n * Calculate min fee\n * @category transaction builder\n * @param rebuildTx - Callback to get built transaction with specific fee\n */\nfunction calculateMinFee(\n  rebuildTx: (value: BigNumber) => Encoded.Transaction,\n  unpackTx: typeof unpackTxType,\n  buildTx: typeof buildTxType,\n): BigNumber {\n  let fee = new BigNumber(0);\n  let previousFee;\n  do {\n    previousFee = fee;\n    fee = new BigNumber(MIN_GAS_PRICE).times(buildGas(rebuildTx(fee), unpackTx, buildTx));\n  } while (!fee.eq(previousFee));\n  return fee;\n}\n\n// TODO: Get rid of this workaround. Transaction builder can't accept/return gas price instead of\n// fee because it may get a decimal gas price. So, it should accept the optional `gasPrice` even\n// if it is not a contract-related transaction. And use this `gasPrice` to calculate `fee`.\nconst gasPricePrefix = '_gas-price:';\n\nexport interface SerializeAettosParams {\n  rebuildTx: (params: any) => Encoded.Transaction;\n  unpackTx: typeof unpackTxType;\n  buildTx: typeof buildTxType;\n  _computingMinFee?: BigNumber;\n}\n\nexport default {\n  ...coinAmount,\n\n  async prepare(\n    value: Int | undefined,\n    params: {},\n    { onNode }: { onNode?: Node },\n  ): Promise<Int | undefined> {\n    if (value != null) return value;\n    if (onNode == null) {\n      throw new ArgumentError('onNode', 'provided (or provide `fee` instead)', onNode);\n    }\n    const gasPrice = await getCachedIncreasedGasPrice(onNode);\n    if (gasPrice === 0n) return undefined;\n    return gasPricePrefix + gasPrice;\n  },\n\n  serializeAettos(\n    _value: string | undefined,\n    { rebuildTx, unpackTx, buildTx, _computingMinFee }: SerializeAettosParams,\n    { _canIncreaseFee }: { _canIncreaseFee?: boolean },\n  ): string {\n    if (_computingMinFee != null) return _computingMinFee.toFixed();\n    const minFee = calculateMinFee(\n      (fee) => rebuildTx({ _computingMinFee: fee }),\n      unpackTx,\n      buildTx,\n    );\n    const value =\n      _value?.startsWith(gasPricePrefix) === true\n        ? minFee.dividedBy(MIN_GAS_PRICE).times(_value.replace(gasPricePrefix, ''))\n        : new BigNumber(_value ?? minFee);\n    if (minFee.gt(value)) {\n      if (_canIncreaseFee === true) return minFee.toFixed();\n      throw new IllegalArgumentError(`Fee ${value.toString()} must be bigger than ${minFee}`);\n    }\n    return value.toFixed();\n  },\n\n  serialize(\n    value: Parameters<typeof coinAmount.serialize>[0],\n    params: Parameters<typeof coinAmount.serialize>[1] & SerializeAettosParams,\n    options: { _canIncreaseFee?: boolean } & Parameters<typeof coinAmount.serialize>[2],\n  ): Buffer {\n    if (typeof value === 'string' && value.startsWith(gasPricePrefix)) {\n      return uInt.serialize(this.serializeAettos(value, params, options));\n    }\n    return coinAmount.serialize.call(this, value, params, options);\n  },\n};\n"],"mappings":"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","ignoreList":[]}

package/es/tx/builder/field-types/field.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 declare const _default: {
     serialize(value: string): Buffer;
     deserialize(value: Buffer): string;

package/es/tx/builder/field-types/field.js

@@ -0,0 +1,10 @@
+import { Buffer as _Buffer } from "buffer";
+export default {
+  serialize(value) {
+    return _Buffer.from(value);
+  },
+  deserialize(value) {
+    return value.toString();
+  }
+};
+//# sourceMappingURL=field.js.map

package/es/tx/builder/field-types/field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.js","names":["serialize","value","_Buffer","from","deserialize","toString"],"sources":["../../../../src/tx/builder/field-types/field.ts"],"sourcesContent":["export default {\n  serialize(value: string): Buffer {\n    return Buffer.from(value);\n  },\n\n  deserialize(value: Buffer): string {\n    return value.toString();\n  },\n};\n"],"mappings":";AAAA,eAAe;EACbA,SAASA,CAACC,KAAa,EAAU;IAC/B,OAAOC,OAAA,CAAOC,IAAI,CAACF,KAAK,CAAC;EAC3B,CAAC;EAEDG,WAAWA,CAACH,KAAa,EAAU;IACjC,OAAOA,KAAK,CAACI,QAAQ,CAAC,CAAC;EACzB;AACF,CAAC","ignoreList":[]}

package/es/tx/builder/field-types/gas-limit.d.ts

@@ -1,15 +1,14 @@
-/// <reference types="node" />
-import { Tag } from '../constants';
-import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+import { Tag } from '../constants.js';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index.js';
 declare const _default: {
     serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
         tag: Tag;
         rebuildTx: (params: any) => any;
         unpackTx: typeof unpackTxType;
         buildTx: typeof buildTxType;
-        _computingGasLimit?: number | undefined;
+        _computingGasLimit?: number;
     }, { gasMax }: {
-        gasMax?: number | undefined;
+        gasMax?: number;
     }): Buffer;
     deserialize(value: Buffer): number;
 };

package/es/tx/builder/field-types/gas-limit.js

@@ -0,0 +1,31 @@
+import { IllegalArgumentError } from '../../../utils/errors.js';
+import { Tag, MAX_AUTH_FUN_GAS } from '../constants.js';
+import shortUInt from './short-u-int.js';
+import { buildGas } from './fee.js';
+function calculateGasLimitMax(gasMax, rebuildTx, unpackTx, buildTx) {
+  return gasMax - +buildGas(rebuildTx(gasMax), unpackTx, buildTx);
+}
+export default {
+  ...shortUInt,
+  serialize(_value, {
+    tag,
+    rebuildTx,
+    unpackTx,
+    buildTx,
+    _computingGasLimit
+  }, {
+    gasMax = 6e6
+  }) {
+    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 !== null && _value !== void 0 ? _value : gasLimitMax;
+    if (value > gasLimitMax) {
+      throw new IllegalArgumentError(`Gas limit ${value} must be less or equal to ${gasLimitMax}`);
+    }
+    return shortUInt.serialize(value);
+  }
+};
+//# sourceMappingURL=gas-limit.js.map

package/es/tx/builder/field-types/gas-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gas-limit.js","names":["IllegalArgumentError","Tag","MAX_AUTH_FUN_GAS","shortUInt","buildGas","calculateGasLimitMax","gasMax","rebuildTx","unpackTx","buildTx","serialize","_value","tag","_computingGasLimit","gasLimitMax","GaMetaTx","gasLimit","_canIncreaseFee","value"],"sources":["../../../../src/tx/builder/field-types/gas-limit.ts"],"sourcesContent":["import { IllegalArgumentError } from '../../../utils/errors.js';\nimport { Tag, MAX_AUTH_FUN_GAS } from '../constants.js';\nimport shortUInt from './short-u-int.js';\nimport { buildGas } from './fee.js';\nimport type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index.js';\n\nfunction calculateGasLimitMax(\n  gasMax: number,\n  rebuildTx: (value: number) => any,\n  unpackTx: typeof unpackTxType,\n  buildTx: typeof buildTxType,\n): number {\n  return gasMax - +buildGas(rebuildTx(gasMax), unpackTx, buildTx);\n}\n\nexport default {\n  ...shortUInt,\n\n  serialize(\n    _value: number | undefined,\n    {\n      tag,\n      rebuildTx,\n      unpackTx,\n      buildTx,\n      _computingGasLimit,\n    }: {\n      tag: Tag;\n      rebuildTx: (params: any) => any;\n      unpackTx: typeof unpackTxType;\n      buildTx: typeof buildTxType;\n      _computingGasLimit?: number;\n    },\n    { gasMax = 6e6 }: { gasMax?: number },\n  ): Buffer {\n    if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);\n\n    const gasLimitMax =\n      tag === Tag.GaMetaTx\n        ? MAX_AUTH_FUN_GAS\n        : calculateGasLimitMax(\n            gasMax,\n            (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit, _canIncreaseFee: true }),\n            unpackTx,\n            buildTx,\n          );\n    const value = _value ?? gasLimitMax;\n    if (value > gasLimitMax) {\n      throw new IllegalArgumentError(`Gas limit ${value} must be less or equal to ${gasLimitMax}`);\n    }\n    return shortUInt.serialize(value);\n  },\n};\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,0BAA0B;AAC/D,SAASC,GAAG,EAAEC,gBAAgB,QAAQ,iBAAiB;AACvD,OAAOC,SAAS,MAAM,kBAAkB;AACxC,SAASC,QAAQ,QAAQ,UAAU;AAGnC,SAASC,oBAAoBA,CAC3BC,MAAc,EACdC,SAAiC,EACjCC,QAA6B,EAC7BC,OAA2B,EACnB;EACR,OAAOH,MAAM,GAAG,CAACF,QAAQ,CAACG,SAAS,CAACD,MAAM,CAAC,EAAEE,QAAQ,EAAEC,OAAO,CAAC;AACjE;AAEA,eAAe;EACb,GAAGN,SAAS;EAEZO,SAASA,CACPC,MAA0B,EAC1B;IACEC,GAAG;IACHL,SAAS;IACTC,QAAQ;IACRC,OAAO;IACPI;EAOF,CAAC,EACD;IAAEP,MAAM,GAAG;EAAyB,CAAC,EAC7B;IACR,IAAIO,kBAAkB,IAAI,IAAI,EAAE,OAAOV,SAAS,CAACO,SAAS,CAACG,kBAAkB,CAAC;IAE9E,MAAMC,WAAW,GACfF,GAAG,KAAKX,GAAG,CAACc,QAAQ,GAChBb,gBAAgB,GAChBG,oBAAoB,CAClBC,MAAM,EACLU,QAAQ,IAAKT,SAAS,CAAC;MAAEM,kBAAkB,EAAEG,QAAQ;MAAEC,eAAe,EAAE;IAAK,CAAC,CAAC,EAChFT,QAAQ,EACRC,OACF,CAAC;IACP,MAAMS,KAAK,GAAGP,MAAM,aAANA,MAAM,cAANA,MAAM,GAAIG,WAAW;IACnC,IAAII,KAAK,GAAGJ,WAAW,EAAE;MACvB,MAAM,IAAId,oBAAoB,CAAC,aAAakB,KAAK,6BAA6BJ,WAAW,EAAE,CAAC;IAC9F;IACA,OAAOX,SAAS,CAACO,SAAS,CAACQ,KAAK,CAAC;EACnC;AACF,CAAC","ignoreList":[]}

package/es/tx/builder/field-types/gas-price.d.ts

@@ -1,16 +1,15 @@
-/// <reference types="node" />
-import { Int } from '../constants';
-import Node from '../../../Node';
-import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
+import { Int } from '../constants.js';
+import Node from '../../../Node.js';
+import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter.js';
 export declare function getCachedIncreasedGasPrice(node: Node): Promise<bigint>;
 declare const _default: {
-    prepare(value: Int | undefined, params: {}, { onNode, denomination }: {
-        onNode?: Node | undefined;
-        denomination?: AE_AMOUNT_FORMATS | undefined;
+    prepare(value: Int | undefined, params: {}, { onNode, denomination, }: {
+        onNode?: Node;
+        denomination?: AE_AMOUNT_FORMATS;
     }): Promise<Int | undefined>;
     serializeAettos(value?: string | undefined): string;
     serialize(value: Int | undefined, params: {}, { denomination, ...options }: {
-        denomination?: AE_AMOUNT_FORMATS | undefined;
+        denomination?: AE_AMOUNT_FORMATS;
     }): Buffer;
     deserialize(value: Buffer): string;
 };

package/es/tx/builder/field-types/gas-price.js

@@ -0,0 +1,53 @@
+import { BigNumber } from 'bignumber.js';
+import coinAmount from './coin-amount.js';
+import { ArgumentError, IllegalArgumentError } from '../../../utils/errors.js';
+import { MIN_GAS_PRICE } from '../constants.js';
+import { formatAmount } from '../../../utils/amount-formatter.js';
+const gasPriceCache = new WeakMap();
+export async function getCachedIncreasedGasPrice(node) {
+  const cache = gasPriceCache.get(node);
+  if (cache != null && cache.time > Date.now() - 20 * 1000) {
+    return cache.gasPrice;
+  }
+  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.');
+    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, params, {
+    onNode,
+    denomination
+  }) {
+    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 = MIN_GAS_PRICE.toString()) {
+    if (+value < MIN_GAS_PRICE) {
+      throw new IllegalArgumentError(`Gas price ${value.toString()} must be bigger than ${MIN_GAS_PRICE}`);
+    }
+    return value;
+  }
+};
+//# sourceMappingURL=gas-price.js.map

package/es/tx/builder/field-types/gas-price.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gas-price.js","names":["BigNumber","coinAmount","ArgumentError","IllegalArgumentError","MIN_GAS_PRICE","formatAmount","gasPriceCache","WeakMap","getCachedIncreasedGasPrice","node","cache","get","time","Date","now","gasPrice","minGasPrice","utilization","getRecentGasPrices","BigInt","toString","times","integerValue","toFixed","maxSafeGasPrice","console","warn","set","prepare","value","params","onNode","denomination","undefined","targetDenomination","serializeAettos"],"sources":["../../../../src/tx/builder/field-types/gas-price.ts"],"sourcesContent":["import { BigNumber } from 'bignumber.js';\nimport coinAmount from './coin-amount.js';\nimport { ArgumentError, IllegalArgumentError } from '../../../utils/errors.js';\nimport { Int, MIN_GAS_PRICE } from '../constants.js';\nimport Node from '../../../Node.js';\nimport { AE_AMOUNT_FORMATS, formatAmount } from '../../../utils/amount-formatter.js';\n\nconst gasPriceCache: WeakMap<Node, { time: number; gasPrice: bigint }> = new WeakMap();\n\nexport async function getCachedIncreasedGasPrice(node: Node): Promise<bigint> {\n  const cache = gasPriceCache.get(node);\n  if (cache != null && cache.time > Date.now() - 20 * 1000) {\n    return cache.gasPrice;\n  }\n\n  const { minGasPrice, utilization } = (await node.getRecentGasPrices())[0];\n  let gasPrice =\n    utilization < 70\n      ? 0n\n      : BigInt(new BigNumber(minGasPrice.toString()).times(1.01).integerValue().toFixed());\n\n  const maxSafeGasPrice = BigInt(MIN_GAS_PRICE) * 100000n; // max microblock fee is 600ae or 35usd\n  if (gasPrice > maxSafeGasPrice) {\n    console.warn(\n      `Estimated gas price ${gasPrice} exceeds the maximum safe value for unknown reason.` +\n        ` It will be limited to ${maxSafeGasPrice}.` +\n        ' To overcome this restriction provide `gasPrice`/`fee` in options.',\n    );\n    gasPrice = maxSafeGasPrice;\n  }\n\n  gasPriceCache.set(node, { gasPrice, time: Date.now() });\n  return gasPrice;\n}\n\n// TODO: use withFormatting after using a single type for coins representation\nexport default {\n  ...coinAmount,\n\n  async prepare(\n    value: Int | undefined,\n    params: {},\n    {\n      onNode,\n      denomination,\n    }: {\n      onNode?: Node;\n      denomination?: AE_AMOUNT_FORMATS;\n    },\n  ): Promise<Int | undefined> {\n    if (value != null) return value;\n    if (onNode == null) {\n      throw new ArgumentError('onNode', 'provided (or provide `gasPrice` instead)', onNode);\n    }\n    const gasPrice = await getCachedIncreasedGasPrice(onNode);\n    if (gasPrice === 0n) return undefined;\n    return formatAmount(gasPrice, { targetDenomination: denomination });\n  },\n\n  serializeAettos(value: string | undefined = MIN_GAS_PRICE.toString()): string {\n    if (+value < MIN_GAS_PRICE) {\n      throw new IllegalArgumentError(\n        `Gas price ${value.toString()} must be bigger than ${MIN_GAS_PRICE}`,\n      );\n    }\n    return value;\n  },\n};\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,cAAc;AACxC,OAAOC,UAAU,MAAM,kBAAkB;AACzC,SAASC,aAAa,EAAEC,oBAAoB,QAAQ,0BAA0B;AAC9E,SAAcC,aAAa,QAAQ,iBAAiB;AAEpD,SAA4BC,YAAY,QAAQ,oCAAoC;AAEpF,MAAMC,aAAgE,GAAG,IAAIC,OAAO,CAAC,CAAC;AAEtF,OAAO,eAAeC,0BAA0BA,CAACC,IAAU,EAAmB;EAC5E,MAAMC,KAAK,GAAGJ,aAAa,CAACK,GAAG,CAACF,IAAI,CAAC;EACrC,IAAIC,KAAK,IAAI,IAAI,IAAIA,KAAK,CAACE,IAAI,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,IAAI,EAAE;IACxD,OAAOJ,KAAK,CAACK,QAAQ;EACvB;EAEA,MAAM;IAAEC,WAAW;IAAEC;EAAY,CAAC,GAAG,CAAC,MAAMR,IAAI,CAACS,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC;EACzE,IAAIH,QAAQ,GACVE,WAAW,GAAG,EAAE,GACZ,EAAE,GACFE,MAAM,CAAC,IAAInB,SAAS,CAACgB,WAAW,CAACI,QAAQ,CAAC,CAAC,CAAC,CAACC,KAAK,CAAC,IAAI,CAAC,CAACC,YAAY,CAAC,CAAC,CAACC,OAAO,CAAC,CAAC,CAAC;EAExF,MAAMC,eAAe,GAAGL,MAAM,CAACf,aAAa,CAAC,GAAG,OAAO,CAAC,CAAC;EACzD,IAAIW,QAAQ,GAAGS,eAAe,EAAE;IAC9BC,OAAO,CAACC,IAAI,CACV,uBAAuBX,QAAQ,qDAAqD,GAClF,0BAA0BS,eAAe,GAAG,GAC5C,oEACJ,CAAC;IACDT,QAAQ,GAAGS,eAAe;EAC5B;EAEAlB,aAAa,CAACqB,GAAG,CAAClB,IAAI,EAAE;IAAEM,QAAQ;IAAEH,IAAI,EAAEC,IAAI,CAACC,GAAG,CAAC;EAAE,CAAC,CAAC;EACvD,OAAOC,QAAQ;AACjB;;AAEA;AACA,eAAe;EACb,GAAGd,UAAU;EAEb,MAAM2B,OAAOA,CACXC,KAAsB,EACtBC,MAAU,EACV;IACEC,MAAM;IACNC;EAIF,CAAC,EACyB;IAC1B,IAAIH,KAAK,IAAI,IAAI,EAAE,OAAOA,KAAK;IAC/B,IAAIE,MAAM,IAAI,IAAI,EAAE;MAClB,MAAM,IAAI7B,aAAa,CAAC,QAAQ,EAAE,0CAA0C,EAAE6B,MAAM,CAAC;IACvF;IACA,MAAMhB,QAAQ,GAAG,MAAMP,0BAA0B,CAACuB,MAAM,CAAC;IACzD,IAAIhB,QAAQ,KAAK,EAAE,EAAE,OAAOkB,SAAS;IACrC,OAAO5B,YAAY,CAACU,QAAQ,EAAE;MAAEmB,kBAAkB,EAAEF;IAAa,CAAC,CAAC;EACrE,CAAC;EAEDG,eAAeA,CAACN,KAAyB,GAAGzB,aAAa,CAACgB,QAAQ,CAAC,CAAC,EAAU;IAC5E,IAAI,CAACS,KAAK,GAAGzB,aAAa,EAAE;MAC1B,MAAM,IAAID,oBAAoB,CAC5B,aAAa0B,KAAK,CAACT,QAAQ,CAAC,CAAC,wBAAwBhB,aAAa,EACpE,CAAC;IACH;IACA,OAAOyB,KAAK;EACd;AACF,CAAC","ignoreList":[]}

package/es/tx/builder/field-types/interface.d.ts

@@ -0,0 +1,7 @@
+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/es/tx/builder/field-types/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interface.js.map

package/es/tx/builder/field-types/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","names":[],"sources":["../../../../src/tx/builder/field-types/interface.ts"],"sourcesContent":["export type BinaryData =\n  | Buffer\n  | Buffer[]\n  | Buffer[][]\n  | Array<[Buffer, Array<[Buffer, Buffer[]]>]>;\n\nexport interface Field {\n  serialize: (value: any, options: any, parameters: any) => BinaryData;\n  prepare?: (value: any, options: any, parameters: any) => Promise<any>;\n  deserialize: (value: BinaryData, options: any) => any;\n  recursiveType?: boolean;\n}\n"],"mappings":"","ignoreList":[]}

package/es/tx/builder/field-types/map.d.ts

@@ -1,13 +1,12 @@
-/// <reference types="node" />
-import { Tag } from '../constants';
-import { Encoding, Encoded } 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): {
+import { EntryTag } from '../entry/constants.js';
+import { Encoding, Encoded } from '../../../utils/encoder.js';
+import type { unpackEntry as unpackEntryType, packEntry as packEntryType } from '../entry/index.js';
+export default function genMapField<E extends Encoding, T extends EntryTag>(encoding: E, tag: T): {
     serialize: (value: Record<Encoded.Generic<E>, any>, options: {
-        buildTx: typeof buildTxType;
+        packEntry: typeof packEntryType;
     }) => Buffer;
     deserialize: (value: Buffer, options: {
-        unpackTx: typeof unpackTxType;
+        unpackEntry: typeof unpackEntryType;
     }) => Record<Encoded.Generic<E>, any>;
     recursiveType: true;
 };

package/es/tx/builder/field-types/map.js

@@ -0,0 +1,38 @@
+import { EntryTag } from '../entry/constants.js';
+import { encode, Encoding, decode } from '../../../utils/encoder.js';
+export default function genMapField(encoding, tag) {
+  return {
+    serialize(object, {
+      packEntry
+    }) {
+      return decode(packEntry({
+        tag: EntryTag.Mtree,
+        values: Object.entries(object).map(([key, value]) => ({
+          tag: EntryTag.MtreeValue,
+          key: decode(key),
+          value: decode(packEntry({
+            ...value,
+            tag
+          }))
+        }))
+      }));
+    },
+    deserialize(buffer, {
+      unpackEntry
+    }) {
+      const {
+        values
+      } = unpackEntry(encode(buffer, Encoding.Bytearray), EntryTag.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), unpackEntry(encode(value, Encoding.Bytearray), tag)]));
+    },
+    recursiveType: true
+  };
+}
+//# sourceMappingURL=map.js.map

package/es/tx/builder/field-types/map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","names":["EntryTag","encode","Encoding","decode","genMapField","encoding","tag","serialize","object","packEntry","Mtree","values","Object","entries","map","key","value","MtreeValue","deserialize","buffer","unpackEntry","Bytearray","fromEntries","filter","ContractAddress","length","recursiveType"],"sources":["../../../../src/tx/builder/field-types/map.ts"],"sourcesContent":["import { EntryTag } from '../entry/constants.js';\nimport { encode, Encoding, Encoded, decode } from '../../../utils/encoder.js';\nimport type { unpackEntry as unpackEntryType, packEntry as packEntryType } from '../entry/index.js';\n\nexport default function genMapField<E extends Encoding, T extends EntryTag>(\n  encoding: E,\n  tag: T,\n): {\n  serialize: (\n    // TODO: replace with `TxParams & { tag: T }`,\n    //  but fix TS2502 value is referenced directly or indirectly in its own type annotation\n    value: Record<Encoded.Generic<E>, any>,\n    options: { packEntry: typeof packEntryType },\n  ) => Buffer;\n  deserialize: (\n    value: Buffer,\n    options: { unpackEntry: typeof unpackEntryType },\n    // TODO: replace with `TxUnpacked & { tag: T }`,\n    //  TS2577 Return type annotation circularly references itself\n  ) => Record<Encoded.Generic<E>, any>;\n  recursiveType: true;\n} {\n  return {\n    serialize(object, { packEntry }) {\n      return decode(\n        packEntry({\n          tag: EntryTag.Mtree,\n          values: Object.entries(object).map(\n            ([key, value]) =>\n              ({\n                tag: EntryTag.MtreeValue,\n                key: decode(key as Encoded.Generic<E>),\n                value: decode(packEntry({ ...(value as any), tag })),\n              }) as const,\n          ),\n        }),\n      );\n    },\n\n    deserialize(buffer, { unpackEntry }) {\n      const { values } = unpackEntry(encode(buffer, Encoding.Bytearray), EntryTag.Mtree);\n      return Object.fromEntries(\n        values\n          // TODO: remove after resolving https://github.com/aeternity/aeternity/issues/4066\n          .filter(({ key }) => encoding !== Encoding.ContractAddress || key.length === 32)\n          .map(({ key, value }) => [\n            encode(key, encoding),\n            unpackEntry(encode(value, Encoding.Bytearray), tag),\n          ]),\n      ) as Record<Encoded.Generic<E>, any>;\n    },\n\n    recursiveType: true,\n  };\n}\n"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,uBAAuB;AAChD,SAASC,MAAM,EAAEC,QAAQ,EAAWC,MAAM,QAAQ,2BAA2B;AAG7E,eAAe,SAASC,WAAWA,CACjCC,QAAW,EACXC,GAAM,EAeN;EACA,OAAO;IACLC,SAASA,CAACC,MAAM,EAAE;MAAEC;IAAU,CAAC,EAAE;MAC/B,OAAON,MAAM,CACXM,SAAS,CAAC;QACRH,GAAG,EAAEN,QAAQ,CAACU,KAAK;QACnBC,MAAM,EAAEC,MAAM,CAACC,OAAO,CAACL,MAAM,CAAC,CAACM,GAAG,CAChC,CAAC,CAACC,GAAG,EAAEC,KAAK,CAAC,MACV;UACCV,GAAG,EAAEN,QAAQ,CAACiB,UAAU;UACxBF,GAAG,EAAEZ,MAAM,CAACY,GAAyB,CAAC;UACtCC,KAAK,EAAEb,MAAM,CAACM,SAAS,CAAC;YAAE,GAAIO,KAAa;YAAEV;UAAI,CAAC,CAAC;QACrD,CAAC,CACL;MACF,CAAC,CACH,CAAC;IACH,CAAC;IAEDY,WAAWA,CAACC,MAAM,EAAE;MAAEC;IAAY,CAAC,EAAE;MACnC,MAAM;QAAET;MAAO,CAAC,GAAGS,WAAW,CAACnB,MAAM,CAACkB,MAAM,EAAEjB,QAAQ,CAACmB,SAAS,CAAC,EAAErB,QAAQ,CAACU,KAAK,CAAC;MAClF,OAAOE,MAAM,CAACU,WAAW,CACvBX;MACE;MAAA,CACCY,MAAM,CAAC,CAAC;QAAER;MAAI,CAAC,KAAKV,QAAQ,KAAKH,QAAQ,CAACsB,eAAe,IAAIT,GAAG,CAACU,MAAM,KAAK,EAAE,CAAC,CAC/EX,GAAG,CAAC,CAAC;QAAEC,GAAG;QAAEC;MAAM,CAAC,KAAK,CACvBf,MAAM,CAACc,GAAG,EAAEV,QAAQ,CAAC,EACrBe,WAAW,CAACnB,MAAM,CAACe,KAAK,EAAEd,QAAQ,CAACmB,SAAS,CAAC,EAAEf,GAAG,CAAC,CACpD,CACL,CAAC;IACH,CAAC;IAEDoB,aAAa,EAAE;EACjB,CAAC;AACH","ignoreList":[]}

package/es/tx/builder/field-types/mptree.d.ts

@@ -1,20 +1,19 @@
-/// <reference types="node" />
-import { Tag } from '../constants';
-import { Encoded, Encoding } from '../../../utils/encoder';
-import type { unpackTx } from '..';
-import type { TxUnpacked } from '../schema.generated';
+import { EntryTag } from '../entry/constants.js';
+import { Encoded, Encoding } from '../../../utils/encoder.js';
+import type { unpackEntry } from '../entry/index.js';
+import type { EntUnpacked } from '../entry/schema.generated.js';
 type MPTreeBinary = [Buffer, Array<[Buffer, Buffer[]]>];
-declare class MPTree<E extends Encoding, T extends Tag> {
+declare class MPTree<E extends Encoding, T extends EntryTag> {
     #private;
     get isComplete(): boolean;
     /**
      * Deserialize Merkle Patricia Tree
      * @param binary - Binary
      * @param tag - Tag to use to decode value
-     * @param unpTx - Implementation of unpackTx use to decode values
+     * @param unpEnt - Implementation of unpackEntry use to decode values
      * @returns Merkle Patricia Tree
      */
-    constructor(binary: MPTreeBinary, encoding: E, tag: T, unpTx: typeof unpackTx);
+    constructor(binary: MPTreeBinary, encoding: E, tag: T, unpEnt: typeof unpackEntry);
     isEqual(tree: MPTree<E, T>): boolean;
     /**
      * Serialize Merkle Patricia Tree
@@ -26,17 +25,17 @@ declare class MPTree<E extends Encoding, T extends Tag> {
      * @param key - The key of the element to retrieve
      * @returns Value associated to the specified key
      */
-    get(key: Encoded.Generic<E>): TxUnpacked & {
+    get(key: Encoded.Generic<E>): (EntUnpacked & {
         tag: T;
-    } | undefined;
-    toObject(): Record<Encoded.Generic<E>, TxUnpacked & {
+    }) | undefined;
+    toObject(): Record<Encoded.Generic<E>, EntUnpacked & {
         tag: T;
     }>;
 }
-export default function genMPTreeField<E extends Encoding, T extends Tag>(encoding: E, tag: T): {
+export default function genMPTreeField<E extends Encoding, T extends EntryTag>(encoding: E, tag: T): {
     serialize: (value: MPTree<E, T>) => MPTreeBinary;
     deserialize: (value: MPTreeBinary, o: {
-        unpackTx: typeof unpackTx;
+        unpackEntry: typeof unpackEntry;
     }) => MPTree<E, T>;
 };
 export {};