@aeternity/aepp-sdk 14.1.0 → 15.0.0

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

@@ -1,27 +1,38 @@
 import { IllegalArgumentError } from '../../../utils/errors.js';
-import { Tag, MAX_AUTH_FUN_GAS } from '../constants.js';
+import { Tag } from '../constants.js';
+import { defaultProtocolParameters, getGasLimitDivisor } from '../protocol-parameters.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);
+import { serializeAsIsParam } from './interface.js';
+function calculateGasLimitMax(gasMax, rebuildTx, unpackTx, buildTx, protocolParameters) {
+  return gasMax - +buildGas(rebuildTx(gasMax), unpackTx, buildTx, protocolParameters);
 }
 export default {
   ...shortUInt,
-  serialize(_value, {
-    tag,
-    rebuildTx,
-    unpackTx,
-    buildTx,
-    _computingGasLimit
-  }, {
-    gasMax = 6e6
+  serialize(_value, params, {
+    gasMax,
+    protocolParameters = defaultProtocolParameters
   }) {
+    const {
+      tag,
+      rebuildTx,
+      unpackTx,
+      buildTx,
+      _computingGasLimit
+    } = params;
     if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);
-    const gasLimitMax = tag === Tag.GaMetaTx ? MAX_AUTH_FUN_GAS : calculateGasLimitMax(gasMax, gasLimit => rebuildTx({
+    if (params[serializeAsIsParam] === true && _value != null) return shortUInt.serialize(_value);
+    const gasLimitMax = tag === Tag.GaMetaTx ? protocolParameters.maxAuthFunGas : calculateGasLimitMax(gasMax !== null && gasMax !== void 0 ? gasMax : protocolParameters.blockGasLimit, gasLimit => rebuildTx({
       _computingGasLimit: gasLimit,
       _canIncreaseFee: true
-    }), unpackTx, buildTx);
-    const value = _value !== null && _value !== void 0 ? _value : gasLimitMax;
+    }), unpackTx, buildTx, protocolParameters);
+    // node raises the ceiling above through the parameter this tag reads, so the value defaulted
+    // here is lowered by that raise — see `getGasLimitDivisor`. Only the default: a caller passing
+    // `gasLimit`, or capping it with `gasMax`, chose it itself — except on `GaMetaTx`, whose
+    // ceiling is `maxAuthFunGas` and never reads `gasMax`
+    const capped = gasMax != null && tag !== Tag.GaMetaTx;
+    const raise = capped ? 1 : getGasLimitDivisor(protocolParameters, tag);
+    const value = _value !== null && _value !== void 0 ? _value : raise > 1 ? Math.floor(gasLimitMax / raise) : gasLimitMax;
     if (value > gasLimitMax) {
       throw new IllegalArgumentError(`Gas limit ${value} must be less or equal to ${gasLimitMax}`);
     }

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

@@ -1 +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":[]}
+{"version":3,"file":"gas-limit.js","names":["IllegalArgumentError","Tag","defaultProtocolParameters","getGasLimitDivisor","shortUInt","buildGas","serializeAsIsParam","calculateGasLimitMax","gasMax","rebuildTx","unpackTx","buildTx","protocolParameters","serialize","_value","params","tag","_computingGasLimit","gasLimitMax","GaMetaTx","maxAuthFunGas","blockGasLimit","gasLimit","_canIncreaseFee","capped","raise","value","Math","floor"],"sources":["../../../../src/tx/builder/field-types/gas-limit.ts"],"sourcesContent":["import { IllegalArgumentError } from '../../../utils/errors.js';\nimport { Tag } from '../constants.js';\nimport {\n  defaultProtocolParameters,\n  getGasLimitDivisor,\n  ProtocolParameters,\n  ProtocolParametersOption,\n} from '../protocol-parameters.js';\nimport shortUInt from './short-u-int.js';\nimport { buildGas } from './fee.js';\nimport { serializeAsIsParam, SerializeAsIsParams } from './interface.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  protocolParameters: ProtocolParameters,\n): number {\n  return gasMax - +buildGas(rebuildTx(gasMax), unpackTx, buildTx, protocolParameters);\n}\n\nexport default {\n  ...shortUInt,\n\n  serialize(\n    _value: number | undefined,\n    params: {\n      tag: Tag;\n      rebuildTx: (params: any) => any;\n      unpackTx: typeof unpackTxType;\n      buildTx: typeof buildTxType;\n      _computingGasLimit?: number;\n    } & SerializeAsIsParams,\n    {\n      gasMax,\n      protocolParameters = defaultProtocolParameters,\n    }: { gasMax?: number } & ProtocolParametersOption,\n  ): Buffer {\n    const { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit } = params;\n    if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);\n    if (params[serializeAsIsParam] === true && _value != null) return shortUInt.serialize(_value);\n\n    const gasLimitMax =\n      tag === Tag.GaMetaTx\n        ? protocolParameters.maxAuthFunGas\n        : calculateGasLimitMax(\n            gasMax ?? protocolParameters.blockGasLimit,\n            (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit, _canIncreaseFee: true }),\n            unpackTx,\n            buildTx,\n            protocolParameters,\n          );\n    // node raises the ceiling above through the parameter this tag reads, so the value defaulted\n    // here is lowered by that raise — see `getGasLimitDivisor`. Only the default: a caller passing\n    // `gasLimit`, or capping it with `gasMax`, chose it itself — except on `GaMetaTx`, whose\n    // ceiling is `maxAuthFunGas` and never reads `gasMax`\n    const capped = gasMax != null && tag !== Tag.GaMetaTx;\n    const raise = capped ? 1 : getGasLimitDivisor(protocolParameters, tag);\n    const value = _value ?? (raise > 1 ? Math.floor(gasLimitMax / raise) : 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,QAAQ,iBAAiB;AACrC,SACEC,yBAAyB,EACzBC,kBAAkB,QAGb,2BAA2B;AAClC,OAAOC,SAAS,MAAM,kBAAkB;AACxC,SAASC,QAAQ,QAAQ,UAAU;AACnC,SAASC,kBAAkB,QAA6B,gBAAgB;AAGxE,SAASC,oBAAoBA,CAC3BC,MAAc,EACdC,SAAiC,EACjCC,QAA6B,EAC7BC,OAA2B,EAC3BC,kBAAsC,EAC9B;EACR,OAAOJ,MAAM,GAAG,CAACH,QAAQ,CAACI,SAAS,CAACD,MAAM,CAAC,EAAEE,QAAQ,EAAEC,OAAO,EAAEC,kBAAkB,CAAC;AACrF;AAEA,eAAe;EACb,GAAGR,SAAS;EAEZS,SAASA,CACPC,MAA0B,EAC1BC,MAMuB,EACvB;IACEP,MAAM;IACNI,kBAAkB,GAAGV;EACyB,CAAC,EACzC;IACR,MAAM;MAAEc,GAAG;MAAEP,SAAS;MAAEC,QAAQ;MAAEC,OAAO;MAAEM;IAAmB,CAAC,GAAGF,MAAM;IACxE,IAAIE,kBAAkB,IAAI,IAAI,EAAE,OAAOb,SAAS,CAACS,SAAS,CAACI,kBAAkB,CAAC;IAC9E,IAAIF,MAAM,CAACT,kBAAkB,CAAC,KAAK,IAAI,IAAIQ,MAAM,IAAI,IAAI,EAAE,OAAOV,SAAS,CAACS,SAAS,CAACC,MAAM,CAAC;IAE7F,MAAMI,WAAW,GACfF,GAAG,KAAKf,GAAG,CAACkB,QAAQ,GAChBP,kBAAkB,CAACQ,aAAa,GAChCb,oBAAoB,CAClBC,MAAM,aAANA,MAAM,cAANA,MAAM,GAAII,kBAAkB,CAACS,aAAa,EACzCC,QAAQ,IAAKb,SAAS,CAAC;MAAEQ,kBAAkB,EAAEK,QAAQ;MAAEC,eAAe,EAAE;IAAK,CAAC,CAAC,EAChFb,QAAQ,EACRC,OAAO,EACPC,kBACF,CAAC;IACP;IACA;IACA;IACA;IACA,MAAMY,MAAM,GAAGhB,MAAM,IAAI,IAAI,IAAIQ,GAAG,KAAKf,GAAG,CAACkB,QAAQ;IACrD,MAAMM,KAAK,GAAGD,MAAM,GAAG,CAAC,GAAGrB,kBAAkB,CAACS,kBAAkB,EAAEI,GAAG,CAAC;IACtE,MAAMU,KAAK,GAAGZ,MAAM,aAANA,MAAM,cAANA,MAAM,GAAKW,KAAK,GAAG,CAAC,GAAGE,IAAI,CAACC,KAAK,CAACV,WAAW,GAAGO,KAAK,CAAC,GAAGP,WAAY;IACnF,IAAIQ,KAAK,GAAGR,WAAW,EAAE;MACvB,MAAM,IAAIlB,oBAAoB,CAAC,aAAa0B,KAAK,6BAA6BR,WAAW,EAAE,CAAC;IAC9F;IACA,OAAOd,SAAS,CAACS,SAAS,CAACa,KAAK,CAAC;EACnC;AACF,CAAC","ignoreList":[]}

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

@@ -1,16 +1,18 @@
 import { Int } from '../constants.js';
+import { ProtocolParameters, ProtocolParametersOption } from '../protocol-parameters.js';
+import { SerializeAsIsParams } from './interface.js';
 import Node from '../../../Node.js';
 import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter.js';
-export declare function getCachedIncreasedGasPrice(node: Node): Promise<bigint>;
+export declare function getCachedIncreasedGasPrice(nodeOrProxy: Node, parameters?: ProtocolParameters): Promise<bigint>;
 declare const _default: {
-    prepare(value: Int | undefined, params: {}, { onNode, denomination, }: {
+    prepare(value: Int | undefined, params: {}, { onNode, denomination, protocolParameters, }: {
         onNode?: Node;
         /**
          * @deprecated no replacement implemented yet
          */
         denomination?: AE_AMOUNT_FORMATS;
-    }): Promise<Int | undefined>;
-    serializeAettos(value?: string | undefined): string;
+    } & ProtocolParametersOption): Promise<Int | undefined>;
+    serializeAettos(value: string | undefined, params: SerializeAsIsParams, { protocolParameters }: ProtocolParametersOption): string;
     serialize(value: Int | undefined, params: {}, { denomination, ...options }: {
         denomination?: AE_AMOUNT_FORMATS;
     }): Buffer;

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

@@ -1,28 +1,88 @@
 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 { defaultProtocolParameters, getCachedProtocolParameters, getGasPriceDivisor } from '../protocol-parameters.js';
+import { serializeAsIsParam } from './interface.js';
+import { unwrapProxy } from '../../../utils/wrap-proxy.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;
+
+// the ceiling is based on the gas price of the SDK release and not on the one node reports, so
+// that node can't raise its own limit — a node asking for more than the ceiling gets an
+// underpriced transaction rather than the user an unbounded fee. Max microblock fee is 600ae or
+// 35usd, counted with the gas of the SDK release — see `getGasPriceDivisor`
+const maxSafeGasPrice = defaultProtocolParameters.minGasPrice * 100000n;
+
+/**
+ * Gas price the recent demand of the network suggests, cached per node. Depends on the network
+ * only — the miner floor is applied by the caller, so that a caller providing its own
+ * {@link ProtocolParameters} doesn't put a gas price based on them into a cache others share.
+ *
+ * The request is cached rather than its result, and this body has no `await` before registering
+ * it: `buildTxAsync` prepares fields concurrently, so `fee.prepare` and `gasPrice.prepare` both
+ * ask before either could write a result, and sharing the promise keeps that one round trip.
+ */
+function getCachedDemandGasPrice(node) {
+  const cached = gasPriceCache.get(node);
+  if (cached != null && cached.time > Date.now() - 20 * 1000) {
+    return cached;
   }
-  gasPriceCache.set(node, {
+  const gasPrice = (async () => {
+    const {
+      minGasPrice,
+      utilization
+    } = (await node.getRecentGasPrices())[0];
+    const price = utilization < 70 ? 0n : BigInt(new BigNumber(minGasPrice.toString()).times(1.01).integerValue().toFixed());
+    if (price <= maxSafeGasPrice) return price;
+    console.warn(`Estimated gas price ${price} exceeds the maximum safe value for unknown reason.` + ` It will be limited to ${maxSafeGasPrice}.` + ' To overcome this restriction provide `gasPrice`/`fee` in options.');
+    return maxSafeGasPrice;
+  })();
+  const entry = {
     gasPrice,
     time: Date.now()
+  };
+  gasPriceCache.set(node, entry);
+  gasPrice.then(() => {
+    // the interval is about how long the value stays representative, and it starts when the
+    // value is known — stamping the request instead would shorten it by the round trip, and on
+    // a link slower than the interval every build would open a request of its own
+    entry.time = Date.now();
+  },
+  // a request that failed may succeed on the next transaction built, and a gas price that can't
+  // be requested fails the build — unlike `getCachedProtocolParameters`, which caches its
+  // failures because it falls back to the parameters of the SDK release and the build goes on
+  () => {
+    if (gasPriceCache.get(node) === entry) gasPriceCache.delete(node);
   });
+  return entry;
+}
+export async function getCachedIncreasedGasPrice(nodeOrProxy, parameters) {
+  const node = unwrapProxy(nodeOrProxy);
+  const demandEntry = getCachedDemandGasPrice(node);
+  // the caller may have been given the parameters to build against, requesting them from node
+  // would both waste a request and ignore the `minMinerGasPrice` it was asked to use
+  const [protocolParameters, demandGasPrice] = await Promise.all([parameters !== null && parameters !== void 0 ? parameters : getCachedProtocolParameters(node), demandEntry.gasPrice]);
+  let gasPrice = demandGasPrice;
+
+  // 0n means "the consensus minimum", it is below what the miner of this node accepts
+  const minerFloor = protocolParameters.minMinerGasPrice > protocolParameters.minGasPrice ? protocolParameters.minMinerGasPrice : 0n;
+  if (gasPrice < minerFloor) gasPrice = minerFloor;
+
+  // the ceiling goes down by the factor the parameters raise the fee gas by — see
+  // `getGasPriceDivisor`. Counted in thousandths so that a hard fork raising the gas a few percent
+  // lowers the ceiling a few percent, rather than halving it by rounding the factor up
+  const gasRaise = BigInt(Math.ceil(getGasPriceDivisor(protocolParameters) * 1000));
+  // this can't cut the miner floor applied above: `checkParametersNotExcessive` bounds the miner
+  // minimum times the fee gas raise by `maxRaiseFactor`, and the ceiling is 100 times
+  // `maxRaiseFactor` above the minimum gas price, so it stays 100 times above the floor
+  const ceiling = maxSafeGasPrice * 1000n / gasRaise;
+  if (gasPrice > ceiling) {
+    if (gasRaise > 1000n && demandEntry.ceilingWarned !== true) {
+      demandEntry.ceilingWarned = true;
+      console.warn(`Estimated gas price ${gasPrice} exceeds the maximum safe value ${ceiling} for the` + ' protocol parameters node reports. It will be limited to it, so the transaction may be' + ' not mined while the demand stays above it. To overcome this restriction provide' + ' `gasPrice`/`fee`, or `protocolParameters` in options.');
+    }
+    gasPrice = ceiling;
+  }
   return gasPrice;
 }
 
@@ -31,21 +91,27 @@ export default {
   ...coinAmount,
   async prepare(value, params, {
     onNode,
-    denomination
+    denomination,
+    protocolParameters
   }) {
     if (value != null) return value;
     if (onNode == null) {
       throw new ArgumentError('onNode', 'provided (or provide `gasPrice` instead)', onNode);
     }
-    const gasPrice = await getCachedIncreasedGasPrice(onNode);
+    const gasPrice = await getCachedIncreasedGasPrice(onNode, protocolParameters);
     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}`);
+  serializeAettos(value, params, {
+    protocolParameters = defaultProtocolParameters
+  }) {
+    const minGasPrice = protocolParameters.minGasPrice.toString();
+    if (value == null) return minGasPrice;
+    if (params[serializeAsIsParam] === true) return value;
+    if (new BigNumber(value).lt(minGasPrice)) {
+      throw new IllegalArgumentError(`Gas price ${value} must be bigger than ${minGasPrice}`);
     }
     return value;
   }

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

@@ -1 +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      /**\n       * @deprecated no replacement implemented yet\n       */\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,OAAOA,SAAS,MAAM,cAAc;AACpC,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;EAOF,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":[]}
+{"version":3,"file":"gas-price.js","names":["BigNumber","coinAmount","ArgumentError","IllegalArgumentError","defaultProtocolParameters","getCachedProtocolParameters","getGasPriceDivisor","serializeAsIsParam","unwrapProxy","formatAmount","gasPriceCache","WeakMap","maxSafeGasPrice","minGasPrice","getCachedDemandGasPrice","node","cached","get","time","Date","now","gasPrice","utilization","getRecentGasPrices","price","BigInt","toString","times","integerValue","toFixed","console","warn","entry","set","then","delete","getCachedIncreasedGasPrice","nodeOrProxy","parameters","demandEntry","protocolParameters","demandGasPrice","Promise","all","minerFloor","minMinerGasPrice","gasRaise","Math","ceil","ceiling","ceilingWarned","prepare","value","params","onNode","denomination","undefined","targetDenomination","serializeAettos","lt"],"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 } from '../constants.js';\nimport {\n  defaultProtocolParameters,\n  getCachedProtocolParameters,\n  getGasPriceDivisor,\n  ProtocolParameters,\n  ProtocolParametersOption,\n} from '../protocol-parameters.js';\nimport { serializeAsIsParam, SerializeAsIsParams } from './interface.js';\nimport { unwrapProxy } from '../../../utils/wrap-proxy.js';\nimport Node from '../../../Node.js';\nimport { AE_AMOUNT_FORMATS, formatAmount } from '../../../utils/amount-formatter.js';\n\ninterface GasPriceCacheEntry {\n  time: number;\n  gasPrice: Promise<bigint>;\n  /**\n   * `getCachedIncreasedGasPrice` runs once per field that asks for a gas price — twice per contract\n   * transaction, since `fee.prepare` asks as well — while the ceiling it may warn about is a\n   * property of the network and of the parameters, not of the field. Warn once per refresh.\n   */\n  ceilingWarned?: boolean;\n}\nconst gasPriceCache: WeakMap<Node, GasPriceCacheEntry> = new WeakMap();\n\n// the ceiling is based on the gas price of the SDK release and not on the one node reports, so\n// that node can't raise its own limit — a node asking for more than the ceiling gets an\n// underpriced transaction rather than the user an unbounded fee. Max microblock fee is 600ae or\n// 35usd, counted with the gas of the SDK release — see `getGasPriceDivisor`\nconst maxSafeGasPrice = defaultProtocolParameters.minGasPrice * 100000n;\n\n/**\n * Gas price the recent demand of the network suggests, cached per node. Depends on the network\n * only — the miner floor is applied by the caller, so that a caller providing its own\n * {@link ProtocolParameters} doesn't put a gas price based on them into a cache others share.\n *\n * The request is cached rather than its result, and this body has no `await` before registering\n * it: `buildTxAsync` prepares fields concurrently, so `fee.prepare` and `gasPrice.prepare` both\n * ask before either could write a result, and sharing the promise keeps that one round trip.\n */\nfunction getCachedDemandGasPrice(node: Node): GasPriceCacheEntry {\n  const cached = gasPriceCache.get(node);\n  if (cached != null && cached.time > Date.now() - 20 * 1000) {\n    return cached;\n  }\n  const gasPrice = (async () => {\n    const { minGasPrice, utilization } = (await node.getRecentGasPrices())[0];\n    const price =\n      utilization < 70\n        ? 0n\n        : BigInt(new BigNumber(minGasPrice.toString()).times(1.01).integerValue().toFixed());\n    if (price <= maxSafeGasPrice) return price;\n    console.warn(\n      `Estimated gas price ${price} 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    return maxSafeGasPrice;\n  })();\n  const entry: GasPriceCacheEntry = { gasPrice, time: Date.now() };\n  gasPriceCache.set(node, entry);\n  gasPrice.then(\n    () => {\n      // the interval is about how long the value stays representative, and it starts when the\n      // value is known — stamping the request instead would shorten it by the round trip, and on\n      // a link slower than the interval every build would open a request of its own\n      entry.time = Date.now();\n    },\n    // a request that failed may succeed on the next transaction built, and a gas price that can't\n    // be requested fails the build — unlike `getCachedProtocolParameters`, which caches its\n    // failures because it falls back to the parameters of the SDK release and the build goes on\n    () => {\n      if (gasPriceCache.get(node) === entry) gasPriceCache.delete(node);\n    },\n  );\n  return entry;\n}\n\nexport async function getCachedIncreasedGasPrice(\n  nodeOrProxy: Node,\n  parameters?: ProtocolParameters,\n): Promise<bigint> {\n  const node = unwrapProxy(nodeOrProxy);\n  const demandEntry = getCachedDemandGasPrice(node);\n  // the caller may have been given the parameters to build against, requesting them from node\n  // would both waste a request and ignore the `minMinerGasPrice` it was asked to use\n  const [protocolParameters, demandGasPrice] = await Promise.all([\n    parameters ?? getCachedProtocolParameters(node),\n    demandEntry.gasPrice,\n  ]);\n  let gasPrice = demandGasPrice;\n\n  // 0n means \"the consensus minimum\", it is below what the miner of this node accepts\n  const minerFloor =\n    protocolParameters.minMinerGasPrice > protocolParameters.minGasPrice\n      ? protocolParameters.minMinerGasPrice\n      : 0n;\n  if (gasPrice < minerFloor) gasPrice = minerFloor;\n\n  // the ceiling goes down by the factor the parameters raise the fee gas by — see\n  // `getGasPriceDivisor`. Counted in thousandths so that a hard fork raising the gas a few percent\n  // lowers the ceiling a few percent, rather than halving it by rounding the factor up\n  const gasRaise = BigInt(Math.ceil(getGasPriceDivisor(protocolParameters) * 1000));\n  // this can't cut the miner floor applied above: `checkParametersNotExcessive` bounds the miner\n  // minimum times the fee gas raise by `maxRaiseFactor`, and the ceiling is 100 times\n  // `maxRaiseFactor` above the minimum gas price, so it stays 100 times above the floor\n  const ceiling = (maxSafeGasPrice * 1000n) / gasRaise;\n  if (gasPrice > ceiling) {\n    if (gasRaise > 1000n && demandEntry.ceilingWarned !== true) {\n      demandEntry.ceilingWarned = true;\n      console.warn(\n        `Estimated gas price ${gasPrice} exceeds the maximum safe value ${ceiling} for the` +\n          ' protocol parameters node reports. It will be limited to it, so the transaction may be' +\n          ' not mined while the demand stays above it. To overcome this restriction provide' +\n          ' `gasPrice`/`fee`, or `protocolParameters` in options.',\n      );\n    }\n    gasPrice = ceiling;\n  }\n\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      protocolParameters,\n    }: {\n      onNode?: Node;\n      /**\n       * @deprecated no replacement implemented yet\n       */\n      denomination?: AE_AMOUNT_FORMATS;\n    } & ProtocolParametersOption,\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, protocolParameters);\n    if (gasPrice === 0n) return undefined;\n    return formatAmount(gasPrice, { targetDenomination: denomination });\n  },\n\n  serializeAettos(\n    value: string | undefined,\n    params: SerializeAsIsParams,\n    { protocolParameters = defaultProtocolParameters }: ProtocolParametersOption,\n  ): string {\n    const minGasPrice = protocolParameters.minGasPrice.toString();\n    if (value == null) return minGasPrice;\n    if (params[serializeAsIsParam] === true) return value;\n    if (new BigNumber(value).lt(minGasPrice)) {\n      throw new IllegalArgumentError(`Gas price ${value} must be bigger than ${minGasPrice}`);\n    }\n    return value;\n  },\n};\n"],"mappings":"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","ignoreList":[]}

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

@@ -1,7 +1,27 @@
 export type BinaryData = Buffer | Buffer[] | Buffer[][] | Array<[Buffer, Array<[Buffer, Buffer[]]>]>;
+/**
+ * Set in the params of a transaction that is re-serialized rather than built — see
+ * `rebuildUnpackedTx`. Fields that check their value against the protocol parameters serialize it
+ * as it is instead: the transaction already exists, its values may belong to other parameters than
+ * the ones this build runs against, and re-checking them would reject a valid transaction that is
+ * serialized verbatim anyway.
+ *
+ * A symbol so that it can't come out of a `JSON.parse`. It is not a trust boundary either way —
+ * `protocolParameters` decides what those same checks compare against and is a plain string key,
+ * as are `fee`, `gasPrice`, and `gasLimit`.
+ */
+export declare const serializeAsIsParam: unique symbol;
+export interface SerializeAsIsParams {
+    [serializeAsIsParam]?: boolean;
+}
 export interface Field {
     serialize: (value: any, options: any, parameters: any) => BinaryData;
     prepare?: (value: any, options: any, parameters: any) => Promise<any>;
+    /**
+     * Set by the fields holding a transaction that may still have to be built — and priced — so that
+     * `buildTxAsync` can tell them from the ones holding a plain value. See `genTransactionField`.
+     */
+    nestedTransaction?: boolean;
     deserialize: (value: BinaryData, options: any) => any;
     recursiveType?: boolean;
 }

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

@@ -1,2 +1,18 @@
-export {};
+// TODO: give `Field` an optional `validate` that `buildTx` runs before `serialize` and
+//  `rebuildUnpackedTx` skips, so that a field can't check a value without being asked to. Needs
+//  `packRecord` to stop passing params and options through the same channel first — a string key
+//  in that channel would be forgeable from `JSON.parse`, which is why this is a symbol — and
+//  `fee` to stop sharing its fixpoint between the default and the check [breaking change]
+/**
+ * Set in the params of a transaction that is re-serialized rather than built — see
+ * `rebuildUnpackedTx`. Fields that check their value against the protocol parameters serialize it
+ * as it is instead: the transaction already exists, its values may belong to other parameters than
+ * the ones this build runs against, and re-checking them would reject a valid transaction that is
+ * serialized verbatim anyway.
+ *
+ * A symbol so that it can't come out of a `JSON.parse`. It is not a trust boundary either way —
+ * `protocolParameters` decides what those same checks compare against and is a plain string key,
+ * as are `fee`, `gasPrice`, and `gasLimit`.
+ */
+export const serializeAsIsParam = Symbol('serializeAsIs');
 //# sourceMappingURL=interface.js.map

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

@@ -1 +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":[]}
+{"version":3,"file":"interface.js","names":["serializeAsIsParam","Symbol"],"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\n// TODO: give `Field` an optional `validate` that `buildTx` runs before `serialize` and\n//  `rebuildUnpackedTx` skips, so that a field can't check a value without being asked to. Needs\n//  `packRecord` to stop passing params and options through the same channel first — a string key\n//  in that channel would be forgeable from `JSON.parse`, which is why this is a symbol — and\n//  `fee` to stop sharing its fixpoint between the default and the check [breaking change]\n/**\n * Set in the params of a transaction that is re-serialized rather than built — see\n * `rebuildUnpackedTx`. Fields that check their value against the protocol parameters serialize it\n * as it is instead: the transaction already exists, its values may belong to other parameters than\n * the ones this build runs against, and re-checking them would reject a valid transaction that is\n * serialized verbatim anyway.\n *\n * A symbol so that it can't come out of a `JSON.parse`. It is not a trust boundary either way —\n * `protocolParameters` decides what those same checks compare against and is a plain string key,\n * as are `fee`, `gasPrice`, and `gasLimit`.\n */\nexport const serializeAsIsParam: unique symbol = Symbol('serializeAsIs');\n\nexport interface SerializeAsIsParams {\n  [serializeAsIsParam]?: boolean;\n}\n\nexport interface Field {\n  serialize: (value: any, options: any, parameters: any) => BinaryData;\n  prepare?: (value: any, options: any, parameters: any) => Promise<any>;\n  /**\n   * Set by the fields holding a transaction that may still have to be built — and priced — so that\n   * `buildTxAsync` can tell them from the ones holding a plain value. See `genTransactionField`.\n   */\n  nestedTransaction?: boolean;\n  deserialize: (value: BinaryData, options: any) => any;\n  recursiveType?: boolean;\n}\n"],"mappings":"AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,kBAAiC,GAAGC,MAAM,CAAC,eAAe,CAAC","ignoreList":[]}

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

@@ -1,9 +1,10 @@
 import coinAmount from './coin-amount.js';
+import { SerializeAsIsParams } from './interface.js';
 import { AensName, Int } from '../constants.js';
 declare const _default: {
     serializeAettos(_value: string | undefined, txFields: {
         name: AensName;
-    }): string;
+    } & SerializeAsIsParams): string;
     /**
      * @param value - AENS name fee
      * @param txFields - Transaction fields
@@ -11,7 +12,7 @@ declare const _default: {
      */
     serialize(value: Int | undefined, txFields: {
         name: AensName;
-    } & Parameters<(typeof coinAmount)["serialize"]>[1], parameters: Parameters<(typeof coinAmount)["serialize"]>[2]): Buffer;
+    } & SerializeAsIsParams & Parameters<(typeof coinAmount)["serialize"]>[1], parameters: Parameters<(typeof coinAmount)["serialize"]>[2]): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

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

@@ -2,9 +2,15 @@ import BigNumber from 'bignumber.js';
 import { getMinimumNameFee } from '../helpers.js';
 import { InsufficientNameFeeError } from '../../../utils/errors.js';
 import coinAmount from './coin-amount.js';
+import { serializeAsIsParam } from './interface.js';
 export default {
   ...coinAmount,
   serializeAettos(_value, txFields) {
+    // SDK-release table, node reports it as `nameClaimFees` (all zeroes on a protocol that doesn't
+    // enforce it) — skipped on re-serialization, see `serializeAsIsParam`
+    if (txFields[serializeAsIsParam] === true && _value != null) {
+      return new BigNumber(_value).toFixed();
+    }
     const minNameFee = getMinimumNameFee(txFields.name);
     const value = new BigNumber(_value !== null && _value !== void 0 ? _value : minNameFee);
     if (minNameFee.gt(value)) throw new InsufficientNameFeeError(value, minNameFee);

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

@@ -1 +1 @@
-{"version":3,"file":"name-fee.js","names":["BigNumber","getMinimumNameFee","InsufficientNameFeeError","coinAmount","serializeAettos","_value","txFields","minNameFee","name","value","gt","toFixed","serialize","parameters","call"],"sources":["../../../../src/tx/builder/field-types/name-fee.ts"],"sourcesContent":["import BigNumber from 'bignumber.js';\nimport { getMinimumNameFee } from '../helpers.js';\nimport { InsufficientNameFeeError } from '../../../utils/errors.js';\nimport coinAmount from './coin-amount.js';\nimport { AensName, Int } from '../constants.js';\n\nexport default {\n  ...coinAmount,\n\n  serializeAettos(_value: string | undefined, txFields: { name: AensName }): string {\n    const minNameFee = getMinimumNameFee(txFields.name);\n    const value = new BigNumber(_value ?? minNameFee);\n    if (minNameFee.gt(value)) throw new InsufficientNameFeeError(value, minNameFee);\n    return value.toFixed();\n  },\n\n  /**\n   * @param value - AENS name fee\n   * @param txFields - Transaction fields\n   * @param txFields.name - AENS Name in transaction\n   */\n  serialize(\n    value: Int | undefined,\n    txFields: { name: AensName } & Parameters<(typeof coinAmount)['serialize']>[1],\n    parameters: Parameters<(typeof coinAmount)['serialize']>[2],\n  ): Buffer {\n    return coinAmount.serialize.call(this, value, txFields, parameters);\n  },\n};\n"],"mappings":"AAAA,OAAOA,SAAS,MAAM,cAAc;AACpC,SAASC,iBAAiB,QAAQ,eAAe;AACjD,SAASC,wBAAwB,QAAQ,0BAA0B;AACnE,OAAOC,UAAU,MAAM,kBAAkB;AAGzC,eAAe;EACb,GAAGA,UAAU;EAEbC,eAAeA,CAACC,MAA0B,EAAEC,QAA4B,EAAU;IAChF,MAAMC,UAAU,GAAGN,iBAAiB,CAACK,QAAQ,CAACE,IAAI,CAAC;IACnD,MAAMC,KAAK,GAAG,IAAIT,SAAS,CAACK,MAAM,aAANA,MAAM,cAANA,MAAM,GAAIE,UAAU,CAAC;IACjD,IAAIA,UAAU,CAACG,EAAE,CAACD,KAAK,CAAC,EAAE,MAAM,IAAIP,wBAAwB,CAACO,KAAK,EAAEF,UAAU,CAAC;IAC/E,OAAOE,KAAK,CAACE,OAAO,CAAC,CAAC;EACxB,CAAC;EAED;AACF;AACA;AACA;AACA;EACEC,SAASA,CACPH,KAAsB,EACtBH,QAA8E,EAC9EO,UAA2D,EACnD;IACR,OAAOV,UAAU,CAACS,SAAS,CAACE,IAAI,CAAC,IAAI,EAAEL,KAAK,EAAEH,QAAQ,EAAEO,UAAU,CAAC;EACrE;AACF,CAAC","ignoreList":[]}
+{"version":3,"file":"name-fee.js","names":["BigNumber","getMinimumNameFee","InsufficientNameFeeError","coinAmount","serializeAsIsParam","serializeAettos","_value","txFields","toFixed","minNameFee","name","value","gt","serialize","parameters","call"],"sources":["../../../../src/tx/builder/field-types/name-fee.ts"],"sourcesContent":["import BigNumber from 'bignumber.js';\nimport { getMinimumNameFee } from '../helpers.js';\nimport { InsufficientNameFeeError } from '../../../utils/errors.js';\nimport coinAmount from './coin-amount.js';\nimport { serializeAsIsParam, SerializeAsIsParams } from './interface.js';\nimport { AensName, Int } from '../constants.js';\n\nexport default {\n  ...coinAmount,\n\n  serializeAettos(\n    _value: string | undefined,\n    txFields: { name: AensName } & SerializeAsIsParams,\n  ): string {\n    // SDK-release table, node reports it as `nameClaimFees` (all zeroes on a protocol that doesn't\n    // enforce it) — skipped on re-serialization, see `serializeAsIsParam`\n    if (txFields[serializeAsIsParam] === true && _value != null) {\n      return new BigNumber(_value).toFixed();\n    }\n    const minNameFee = getMinimumNameFee(txFields.name);\n    const value = new BigNumber(_value ?? minNameFee);\n    if (minNameFee.gt(value)) throw new InsufficientNameFeeError(value, minNameFee);\n    return value.toFixed();\n  },\n\n  /**\n   * @param value - AENS name fee\n   * @param txFields - Transaction fields\n   * @param txFields.name - AENS Name in transaction\n   */\n  serialize(\n    value: Int | undefined,\n    txFields: { name: AensName } & SerializeAsIsParams &\n      Parameters<(typeof coinAmount)['serialize']>[1],\n    parameters: Parameters<(typeof coinAmount)['serialize']>[2],\n  ): Buffer {\n    return coinAmount.serialize.call(this, value, txFields, parameters);\n  },\n};\n"],"mappings":"AAAA,OAAOA,SAAS,MAAM,cAAc;AACpC,SAASC,iBAAiB,QAAQ,eAAe;AACjD,SAASC,wBAAwB,QAAQ,0BAA0B;AACnE,OAAOC,UAAU,MAAM,kBAAkB;AACzC,SAASC,kBAAkB,QAA6B,gBAAgB;AAGxE,eAAe;EACb,GAAGD,UAAU;EAEbE,eAAeA,CACbC,MAA0B,EAC1BC,QAAkD,EAC1C;IACR;IACA;IACA,IAAIA,QAAQ,CAACH,kBAAkB,CAAC,KAAK,IAAI,IAAIE,MAAM,IAAI,IAAI,EAAE;MAC3D,OAAO,IAAIN,SAAS,CAACM,MAAM,CAAC,CAACE,OAAO,CAAC,CAAC;IACxC;IACA,MAAMC,UAAU,GAAGR,iBAAiB,CAACM,QAAQ,CAACG,IAAI,CAAC;IACnD,MAAMC,KAAK,GAAG,IAAIX,SAAS,CAACM,MAAM,aAANA,MAAM,cAANA,MAAM,GAAIG,UAAU,CAAC;IACjD,IAAIA,UAAU,CAACG,EAAE,CAACD,KAAK,CAAC,EAAE,MAAM,IAAIT,wBAAwB,CAACS,KAAK,EAAEF,UAAU,CAAC;IAC/E,OAAOE,KAAK,CAACH,OAAO,CAAC,CAAC;EACxB,CAAC;EAED;AACF;AACA;AACA;AACA;EACEK,SAASA,CACPF,KAAsB,EACtBJ,QACiD,EACjDO,UAA2D,EACnD;IACR,OAAOX,UAAU,CAACU,SAAS,CAACE,IAAI,CAAC,IAAI,EAAEJ,KAAK,EAAEJ,QAAQ,EAAEO,UAAU,CAAC;EACrE;AACF,CAAC","ignoreList":[]}

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

@@ -1,6 +1,7 @@
 import { NamePointer as NamePointerString } from '../../../apis/node/index.js';
 import { Encoded, Encoding } from '../../../utils/encoder.js';
 import { AddressEncodings } from './address.js';
+import { SerializeAsIsParams } from './interface.js';
 type NamePointer = NamePointerString & {
     id: Encoded.Generic<AddressEncodings>;
 };
@@ -8,7 +9,7 @@ type NamePointerRaw = NamePointerString & {
     id: Encoded.Generic<AddressEncodings | Encoding.Bytearray>;
 };
 declare const _default: <AllowRaw extends boolean>(allowRaw: AllowRaw) => {
-    serialize: (pointers: Array<AllowRaw extends true ? NamePointerRaw : NamePointer>) => Buffer[][];
+    serialize: (pointers: Array<AllowRaw extends true ? NamePointerRaw : NamePointer>, params: SerializeAsIsParams) => Buffer[][];
     deserialize: (pointers: Array<[key: Buffer, id: Buffer]>) => Array<AllowRaw extends true ? NamePointerRaw : NamePointer>;
 };
 export default _default;

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

@@ -4,6 +4,7 @@ import { Encoding, decode, encode } from '../../../utils/encoder.js';
 import { isEncoded } from '../../../utils/crypto.js';
 import { IllegalArgumentError, DecodeError, ArgumentError } from '../../../utils/errors.js';
 import address, { idTagToEncoding } from './address.js';
+import { serializeAsIsParam } from './interface.js';
 const ID_TAG = _Buffer.from([1]);
 const DATA_TAG = _Buffer.from([2]);
 const DATA_LENGTH_MAX = 1024;
@@ -16,10 +17,13 @@ export default allowRaw => ({
    * Helper function to build pointers for name update TX
    * @param pointers - Array of pointers
    * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`
+   * @param params - Transaction params
    * @returns Serialized pointers array
    */
-  serialize(pointers) {
-    if (pointers.length > 32) {
+  serialize(pointers, params) {
+    // SDK-release limit, node reports it as `namePointersMaxCount` (omitted on a protocol that
+    // imposes no limit) — skipped on re-serialization, see `serializeAsIsParam`
+    if (params[serializeAsIsParam] !== true && pointers.length > 32) {
       throw new IllegalArgumentError(`Expected 32 pointers or less, got ${pointers.length} instead`);
     }
     return pointers.map(({

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

@@ -1 +1 @@
-{"version":3,"file":"pointers.js","names":["toBytes","Encoding","decode","encode","isEncoded","IllegalArgumentError","DecodeError","ArgumentError","address","idTagToEncoding","ID_TAG","_Buffer","from","DATA_TAG","DATA_LENGTH_MAX","addressAny","allowRaw","serialize","pointers","length","map","key","id","payload","Bytearray","data","concat","deserialize","bKey","bId","toString","tag","subarray","equals"],"sources":["../../../../src/tx/builder/field-types/pointers.ts"],"sourcesContent":["import { NamePointer as NamePointerString } from '../../../apis/node/index.js';\nimport { toBytes } from '../../../utils/bytes.js';\nimport { Encoded, Encoding, decode, encode } from '../../../utils/encoder.js';\nimport { isEncoded } from '../../../utils/crypto.js';\nimport { IllegalArgumentError, DecodeError, ArgumentError } from '../../../utils/errors.js';\nimport address, { AddressEncodings, idTagToEncoding } from './address.js';\n\nconst ID_TAG = Buffer.from([1]);\nconst DATA_TAG = Buffer.from([2]);\nconst DATA_LENGTH_MAX = 1024;\nconst addressAny = address(...idTagToEncoding);\n\n// TODO: remove after fixing node types\ntype NamePointer = NamePointerString & {\n  id: Encoded.Generic<AddressEncodings>;\n};\ntype NamePointerRaw = NamePointerString & {\n  id: Encoded.Generic<AddressEncodings | Encoding.Bytearray>;\n};\n\nexport default <AllowRaw extends boolean>(\n  allowRaw: AllowRaw,\n): {\n  serialize: (pointers: Array<AllowRaw extends true ? NamePointerRaw : NamePointer>) => Buffer[][];\n  deserialize: (\n    pointers: Array<[key: Buffer, id: Buffer]>,\n  ) => Array<AllowRaw extends true ? NamePointerRaw : NamePointer>;\n} => ({\n  /**\n   * Helper function to build pointers for name update TX\n   * @param pointers - Array of pointers\n   * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`\n   * @returns Serialized pointers array\n   */\n  serialize(pointers) {\n    if (pointers.length > 32) {\n      throw new IllegalArgumentError(\n        `Expected 32 pointers or less, got ${pointers.length} instead`,\n      );\n    }\n    return pointers.map(({ key, id }) => {\n      let payload;\n      if (isEncoded(id, ...idTagToEncoding)) {\n        payload = [...(allowRaw ? [ID_TAG] : []), addressAny.serialize(id)];\n      }\n      if (isEncoded(id, Encoding.Bytearray)) {\n        const data = decode(id);\n        if (data.length > DATA_LENGTH_MAX) {\n          throw new ArgumentError(\n            'Raw pointer',\n            `shorter than ${DATA_LENGTH_MAX + 1} bytes`,\n            `${data.length} bytes`,\n          );\n        }\n        payload = [DATA_TAG, data];\n      }\n      if (payload == null) throw new DecodeError(`Unknown AENS pointer value: ${id}`);\n      return [toBytes(key), Buffer.concat(payload)];\n    });\n  },\n\n  /**\n   * Helper function to read pointers from name update TX\n   * @param pointers - Array of pointers\n   * @returns Deserialize pointer array\n   */\n  deserialize(pointers) {\n    return pointers.map(([bKey, bId]) => {\n      if (!allowRaw) return { key: bKey.toString(), id: addressAny.deserialize(bId) };\n      const tag = bId.subarray(0, 1);\n      const payload = bId.subarray(1);\n      let id;\n      if (tag.equals(ID_TAG)) id = addressAny.deserialize(payload);\n      // TS can't figure out the real type depending on allowRaw\n      if (tag.equals(DATA_TAG)) id = encode(payload, Encoding.Bytearray) as Encoded.AccountAddress;\n      if (id == null) throw new DecodeError(`Unknown AENS pointer tag: ${tag}`);\n      return { key: bKey.toString(), id };\n    });\n  },\n});\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"pointers.js","names":["toBytes","Encoding","decode","encode","isEncoded","IllegalArgumentError","DecodeError","ArgumentError","address","idTagToEncoding","serializeAsIsParam","ID_TAG","_Buffer","from","DATA_TAG","DATA_LENGTH_MAX","addressAny","allowRaw","serialize","pointers","params","length","map","key","id","payload","Bytearray","data","concat","deserialize","bKey","bId","toString","tag","subarray","equals"],"sources":["../../../../src/tx/builder/field-types/pointers.ts"],"sourcesContent":["import { NamePointer as NamePointerString } from '../../../apis/node/index.js';\nimport { toBytes } from '../../../utils/bytes.js';\nimport { Encoded, Encoding, decode, encode } from '../../../utils/encoder.js';\nimport { isEncoded } from '../../../utils/crypto.js';\nimport { IllegalArgumentError, DecodeError, ArgumentError } from '../../../utils/errors.js';\nimport address, { AddressEncodings, idTagToEncoding } from './address.js';\nimport { serializeAsIsParam, SerializeAsIsParams } from './interface.js';\n\nconst ID_TAG = Buffer.from([1]);\nconst DATA_TAG = Buffer.from([2]);\nconst DATA_LENGTH_MAX = 1024;\nconst addressAny = address(...idTagToEncoding);\n\n// TODO: remove after fixing node types\ntype NamePointer = NamePointerString & {\n  id: Encoded.Generic<AddressEncodings>;\n};\ntype NamePointerRaw = NamePointerString & {\n  id: Encoded.Generic<AddressEncodings | Encoding.Bytearray>;\n};\n\nexport default <AllowRaw extends boolean>(\n  allowRaw: AllowRaw,\n): {\n  serialize: (\n    pointers: Array<AllowRaw extends true ? NamePointerRaw : NamePointer>,\n    params: SerializeAsIsParams,\n  ) => Buffer[][];\n  deserialize: (\n    pointers: Array<[key: Buffer, id: Buffer]>,\n  ) => Array<AllowRaw extends true ? NamePointerRaw : NamePointer>;\n} => ({\n  /**\n   * Helper function to build pointers for name update TX\n   * @param pointers - Array of pointers\n   * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`\n   * @param params - Transaction params\n   * @returns Serialized pointers array\n   */\n  serialize(pointers, params) {\n    // SDK-release limit, node reports it as `namePointersMaxCount` (omitted on a protocol that\n    // imposes no limit) — skipped on re-serialization, see `serializeAsIsParam`\n    if (params[serializeAsIsParam] !== true && pointers.length > 32) {\n      throw new IllegalArgumentError(\n        `Expected 32 pointers or less, got ${pointers.length} instead`,\n      );\n    }\n    return pointers.map(({ key, id }) => {\n      let payload;\n      if (isEncoded(id, ...idTagToEncoding)) {\n        payload = [...(allowRaw ? [ID_TAG] : []), addressAny.serialize(id)];\n      }\n      if (isEncoded(id, Encoding.Bytearray)) {\n        const data = decode(id);\n        if (data.length > DATA_LENGTH_MAX) {\n          throw new ArgumentError(\n            'Raw pointer',\n            `shorter than ${DATA_LENGTH_MAX + 1} bytes`,\n            `${data.length} bytes`,\n          );\n        }\n        payload = [DATA_TAG, data];\n      }\n      if (payload == null) throw new DecodeError(`Unknown AENS pointer value: ${id}`);\n      return [toBytes(key), Buffer.concat(payload)];\n    });\n  },\n\n  /**\n   * Helper function to read pointers from name update TX\n   * @param pointers - Array of pointers\n   * @returns Deserialize pointer array\n   */\n  deserialize(pointers) {\n    return pointers.map(([bKey, bId]) => {\n      if (!allowRaw) return { key: bKey.toString(), id: addressAny.deserialize(bId) };\n      const tag = bId.subarray(0, 1);\n      const payload = bId.subarray(1);\n      let id;\n      if (tag.equals(ID_TAG)) id = addressAny.deserialize(payload);\n      // TS can't figure out the real type depending on allowRaw\n      if (tag.equals(DATA_TAG)) id = encode(payload, Encoding.Bytearray) as Encoded.AccountAddress;\n      if (id == null) throw new DecodeError(`Unknown AENS pointer tag: ${tag}`);\n      return { key: bKey.toString(), id };\n    });\n  },\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -1,10 +1,13 @@
 import { Tag } from '../constants.js';
+import type { ProtocolParametersOption } from '../protocol-parameters.js';
+import { SerializeAsIsParams } from './interface.js';
 import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index.js';
 export default function genTransactionField<T extends Tag = Tag>(tag?: T): {
     serialize: (value: any, options: {
         buildTx: typeof buildTxType;
-    }) => Buffer;
+    } & ProtocolParametersOption & SerializeAsIsParams) => Buffer;
     deserialize: (value: Buffer, options: {
         unpackTx: typeof unpackTxType;
     }) => any;
+    nestedTransaction: true;
 };

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

@@ -1,10 +1,14 @@
 import { Buffer as _Buffer } from "buffer";
 import { decode, encode, Encoding } from '../../../utils/encoder.js';
+import { serializeAsIsParam } from './interface.js';
 export default function genTransactionField(tag) {
   return {
-    serialize(txParams, {
-      buildTx
-    }) {
+    nestedTransaction: true,
+    serialize(txParams, options) {
+      const {
+        buildTx,
+        protocolParameters
+      } = options;
       if (ArrayBuffer.isView(txParams)) return _Buffer.from(txParams);
       if (typeof txParams === 'string' && txParams.startsWith('tx_')) {
         return decode(txParams);
@@ -13,6 +17,17 @@ export default function genTransactionField(tag) {
         ...txParams,
         ...(tag != null && {
           tag
+        }),
+        // a nested transaction that is not built yet is built against the parameters of the
+        // outer one, otherwise it would be priced by the parameters of the SDK release
+        ...(protocolParameters != null && {
+          protocolParameters
+        }),
+        // a transaction nested in one that is only re-serialized is re-serialized as well —
+        // without this the innermost transaction of a `PayingForTx` wrapping a `GaMetaTx` gets
+        // its already fixed values checked against the parameters of the outermost one
+        ...(options[serializeAsIsParam] === true && {
+          [serializeAsIsParam]: true
         })
       }));
     },

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

@@ -1 +1 @@
-{"version":3,"file":"transaction.js","names":["decode","encode","Encoding","genTransactionField","tag","serialize","txParams","buildTx","ArrayBuffer","isView","_Buffer","from","startsWith","deserialize","buf","unpackTx","Transaction"],"sources":["../../../../src/tx/builder/field-types/transaction.ts"],"sourcesContent":["import { decode, encode, Encoded, Encoding } from '../../../utils/encoder.js';\nimport { Tag } from '../constants.js';\nimport type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index.js';\n\nexport default function genTransactionField<T extends Tag = Tag>(\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: { buildTx: typeof buildTxType },\n  ) => Buffer;\n  deserialize: (\n    value: Buffer,\n    options: { unpackTx: typeof unpackTxType },\n    // TODO: replace with `TxUnpacked & { tag: T }`,\n    //  TS2577 Return type annotation circularly references itself\n  ) => any;\n} {\n  return {\n    serialize(txParams, { buildTx }) {\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(buildTx({ ...txParams, ...(tag != null && { tag }) }));\n    },\n\n    deserialize(buf, { unpackTx }) {\n      return unpackTx(encode(buf, Encoding.Transaction), tag);\n    },\n  };\n}\n"],"mappings":";AAAA,SAASA,MAAM,EAAEC,MAAM,EAAWC,QAAQ,QAAQ,2BAA2B;AAI7E,eAAe,SAASC,mBAAmBA,CACzCC,GAAO,EAcP;EACA,OAAO;IACLC,SAASA,CAACC,QAAQ,EAAE;MAAEC;IAAQ,CAAC,EAAE;MAC/B,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,OAAO,CAAC;QAAE,GAAGD,QAAQ;QAAE,IAAIF,GAAG,IAAI,IAAI,IAAI;UAAEA;QAAI,CAAC;MAAE,CAAC,CAAC,CAAC;IACtE,CAAC;IAEDS,WAAWA,CAACC,GAAG,EAAE;MAAEC;IAAS,CAAC,EAAE;MAC7B,OAAOA,QAAQ,CAACd,MAAM,CAACa,GAAG,EAAEZ,QAAQ,CAACc,WAAW,CAAC,EAAEZ,GAAG,CAAC;IACzD;EACF,CAAC;AACH","ignoreList":[]}
+{"version":3,"file":"transaction.js","names":["decode","encode","Encoding","serializeAsIsParam","genTransactionField","tag","nestedTransaction","serialize","txParams","options","buildTx","protocolParameters","ArrayBuffer","isView","_Buffer","from","startsWith","deserialize","buf","unpackTx","Transaction"],"sources":["../../../../src/tx/builder/field-types/transaction.ts"],"sourcesContent":["import { decode, encode, Encoded, Encoding } from '../../../utils/encoder.js';\nimport { Tag } from '../constants.js';\nimport type { ProtocolParametersOption } from '../protocol-parameters.js';\nimport { serializeAsIsParam, SerializeAsIsParams } from './interface.js';\nimport type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index.js';\n\nexport default function genTransactionField<T extends Tag = Tag>(\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: { buildTx: typeof buildTxType } & ProtocolParametersOption & SerializeAsIsParams,\n  ) => Buffer;\n  deserialize: (\n    value: Buffer,\n    options: { unpackTx: typeof unpackTxType },\n    // TODO: replace with `TxUnpacked & { tag: T }`,\n    //  TS2577 Return type annotation circularly references itself\n  ) => any;\n  nestedTransaction: true;\n} {\n  return {\n    nestedTransaction: true,\n\n    serialize(txParams, options) {\n      const { buildTx, protocolParameters } = options;\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(\n        buildTx({\n          ...txParams,\n          ...(tag != null && { tag }),\n          // a nested transaction that is not built yet is built against the parameters of the\n          // outer one, otherwise it would be priced by the parameters of the SDK release\n          ...(protocolParameters != null && { protocolParameters }),\n          // a transaction nested in one that is only re-serialized is re-serialized as well —\n          // without this the innermost transaction of a `PayingForTx` wrapping a `GaMetaTx` gets\n          // its already fixed values checked against the parameters of the outermost one\n          ...(options[serializeAsIsParam] === true && { [serializeAsIsParam]: true }),\n        }),\n      );\n    },\n\n    deserialize(buf, { unpackTx }) {\n      return unpackTx(encode(buf, Encoding.Transaction), tag);\n    },\n  };\n}\n"],"mappings":";AAAA,SAASA,MAAM,EAAEC,MAAM,EAAWC,QAAQ,QAAQ,2BAA2B;AAG7E,SAASC,kBAAkB,QAA6B,gBAAgB;AAGxE,eAAe,SAASC,mBAAmBA,CACzCC,GAAO,EAeP;EACA,OAAO;IACLC,iBAAiB,EAAE,IAAI;IAEvBC,SAASA,CAACC,QAAQ,EAAEC,OAAO,EAAE;MAC3B,MAAM;QAAEC,OAAO;QAAEC;MAAmB,CAAC,GAAGF,OAAO;MAC/C,IAAIG,WAAW,CAACC,MAAM,CAACL,QAAQ,CAAC,EAAE,OAAOM,OAAA,CAAOC,IAAI,CAACP,QAAe,CAAC;MACrE,IAAI,OAAOA,QAAQ,KAAK,QAAQ,IAAIA,QAAQ,CAACQ,UAAU,CAAC,KAAK,CAAC,EAAE;QAC9D,OAAOhB,MAAM,CAACQ,QAA+B,CAAC;MAChD;MACA,OAAOR,MAAM,CACXU,OAAO,CAAC;QACN,GAAGF,QAAQ;QACX,IAAIH,GAAG,IAAI,IAAI,IAAI;UAAEA;QAAI,CAAC,CAAC;QAC3B;QACA;QACA,IAAIM,kBAAkB,IAAI,IAAI,IAAI;UAAEA;QAAmB,CAAC,CAAC;QACzD;QACA;QACA;QACA,IAAIF,OAAO,CAACN,kBAAkB,CAAC,KAAK,IAAI,IAAI;UAAE,CAACA,kBAAkB,GAAG;QAAK,CAAC;MAC5E,CAAC,CACH,CAAC;IACH,CAAC;IAEDc,WAAWA,CAACC,GAAG,EAAE;MAAEC;IAAS,CAAC,EAAE;MAC7B,OAAOA,QAAQ,CAAClB,MAAM,CAACiB,GAAG,EAAEhB,QAAQ,CAACkB,WAAW,CAAC,EAAEf,GAAG,CAAC;IACzD;EACF,CAAC;AACH","ignoreList":[]}

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

@@ -5,10 +5,9 @@ import { _getPollInterval } from '../../../chain.js';
  */
 declare const _default: {
     serialize(value: number | undefined): Buffer;
-    prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
+    prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, ...options }: {
         onNode?: Node;
         absoluteTtl?: boolean;
-        _isInternalBuild?: boolean;
     } & Omit<Parameters<typeof _getPollInterval>[1], "onNode">): Promise<number | undefined>;
     deserialize(value: Buffer): number;
 };

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

@@ -2,6 +2,10 @@ import shortUInt from './short-u-int.js';
 import { ArgumentError } from '../../../utils/errors.js';
 import { getHeight } from '../../../chain.js';
 
+// TODO: restore after the mainnet mining issue is solved, was used via `_isInternalBuild` flag
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const DEFAULT_INTERNAL_RELATIVE_TTL = 3;
+
 /**
  * Time to leave
  */
@@ -15,16 +19,15 @@ export default {
   {
     onNode,
     absoluteTtl,
-    _isInternalBuild,
     ...options
   }) {
-    if (absoluteTtl !== true && value !== 0 && (value != null || _isInternalBuild === true)) {
+    if (absoluteTtl !== true && value !== 0 && value != null) {
       if (onNode == null) throw new ArgumentError('onNode', 'provided', onNode);
-      value = (value !== null && value !== void 0 ? value : 3) + (await getHeight({
+      value += await getHeight({
         ...options,
         onNode,
         cached: true
-      }));
+      });
     }
     return value;
   }

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

@@ -1 +1 @@
-{"version":3,"file":"ttl.js","names":["shortUInt","ArgumentError","getHeight","serialize","value","prepare","params","onNode","absoluteTtl","_isInternalBuild","options","cached"],"sources":["../../../../src/tx/builder/field-types/ttl.ts"],"sourcesContent":["import shortUInt from './short-u-int.js';\nimport Node from '../../../Node.js';\nimport { ArgumentError } from '../../../utils/errors.js';\nimport { _getPollInterval, getHeight } from '../../../chain.js';\n\n/**\n * Time to leave\n */\nexport default {\n  ...shortUInt,\n\n  serialize(value: number | undefined): Buffer {\n    return shortUInt.serialize(value ?? 0);\n  },\n\n  async prepare(\n    value: number | undefined,\n    params: {},\n    // TODO: { absoluteTtl: true } | { absoluteTtl: false, onNode: Node }\n    {\n      onNode,\n      absoluteTtl,\n      _isInternalBuild,\n      ...options\n    }: {\n      onNode?: Node;\n      absoluteTtl?: boolean;\n      _isInternalBuild?: boolean;\n    } & Omit<Parameters<typeof _getPollInterval>[1], 'onNode'>,\n  ) {\n    if (absoluteTtl !== true && value !== 0 && (value != null || _isInternalBuild === true)) {\n      if (onNode == null) throw new ArgumentError('onNode', 'provided', onNode);\n      value = (value ?? 3) + (await getHeight({ ...options, onNode, cached: true }));\n    }\n    return value;\n  },\n};\n"],"mappings":"AAAA,OAAOA,SAAS,MAAM,kBAAkB;AAExC,SAASC,aAAa,QAAQ,0BAA0B;AACxD,SAA2BC,SAAS,QAAQ,mBAAmB;;AAE/D;AACA;AACA;AACA,eAAe;EACb,GAAGF,SAAS;EAEZG,SAASA,CAACC,KAAyB,EAAU;IAC3C,OAAOJ,SAAS,CAACG,SAAS,CAACC,KAAK,aAALA,KAAK,cAALA,KAAK,GAAI,CAAC,CAAC;EACxC,CAAC;EAED,MAAMC,OAAOA,CACXD,KAAyB,EACzBE,MAAU;EACV;EACA;IACEC,MAAM;IACNC,WAAW;IACXC,gBAAgB;IAChB,GAAGC;EAKoD,CAAC,EAC1D;IACA,IAAIF,WAAW,KAAK,IAAI,IAAIJ,KAAK,KAAK,CAAC,KAAKA,KAAK,IAAI,IAAI,IAAIK,gBAAgB,KAAK,IAAI,CAAC,EAAE;MACvF,IAAIF,MAAM,IAAI,IAAI,EAAE,MAAM,IAAIN,aAAa,CAAC,QAAQ,EAAE,UAAU,EAAEM,MAAM,CAAC;MACzEH,KAAK,GAAG,CAACA,KAAK,aAALA,KAAK,cAALA,KAAK,GAAI,CAAC,KAAK,MAAMF,SAAS,CAAC;QAAE,GAAGQ,OAAO;QAAEH,MAAM;QAAEI,MAAM,EAAE;MAAK,CAAC,CAAC,CAAC;IAChF;IACA,OAAOP,KAAK;EACd;AACF,CAAC","ignoreList":[]}
+{"version":3,"file":"ttl.js","names":["shortUInt","ArgumentError","getHeight","DEFAULT_INTERNAL_RELATIVE_TTL","serialize","value","prepare","params","onNode","absoluteTtl","options","cached"],"sources":["../../../../src/tx/builder/field-types/ttl.ts"],"sourcesContent":["import shortUInt from './short-u-int.js';\nimport Node from '../../../Node.js';\nimport { ArgumentError } from '../../../utils/errors.js';\nimport { _getPollInterval, getHeight } from '../../../chain.js';\n\n// TODO: restore after the mainnet mining issue is solved, was used via `_isInternalBuild` flag\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst DEFAULT_INTERNAL_RELATIVE_TTL = 3;\n\n/**\n * Time to leave\n */\nexport default {\n  ...shortUInt,\n\n  serialize(value: number | undefined): Buffer {\n    return shortUInt.serialize(value ?? 0);\n  },\n\n  async prepare(\n    value: number | undefined,\n    params: {},\n    // TODO: { absoluteTtl: true } | { absoluteTtl: false, onNode: Node }\n    {\n      onNode,\n      absoluteTtl,\n      ...options\n    }: {\n      onNode?: Node;\n      absoluteTtl?: boolean;\n    } & Omit<Parameters<typeof _getPollInterval>[1], 'onNode'>,\n  ) {\n    if (absoluteTtl !== true && value !== 0 && value != null) {\n      if (onNode == null) throw new ArgumentError('onNode', 'provided', onNode);\n      value += await getHeight({ ...options, onNode, cached: true });\n    }\n    return value;\n  },\n};\n"],"mappings":"AAAA,OAAOA,SAAS,MAAM,kBAAkB;AAExC,SAASC,aAAa,QAAQ,0BAA0B;AACxD,SAA2BC,SAAS,QAAQ,mBAAmB;;AAE/D;AACA;AACA,MAAMC,6BAA6B,GAAG,CAAC;;AAEvC;AACA;AACA;AACA,eAAe;EACb,GAAGH,SAAS;EAEZI,SAASA,CAACC,KAAyB,EAAU;IAC3C,OAAOL,SAAS,CAACI,SAAS,CAACC,KAAK,aAALA,KAAK,cAALA,KAAK,GAAI,CAAC,CAAC;EACxC,CAAC;EAED,MAAMC,OAAOA,CACXD,KAAyB,EACzBE,MAAU;EACV;EACA;IACEC,MAAM;IACNC,WAAW;IACX,GAAGC;EAIoD,CAAC,EAC1D;IACA,IAAID,WAAW,KAAK,IAAI,IAAIJ,KAAK,KAAK,CAAC,IAAIA,KAAK,IAAI,IAAI,EAAE;MACxD,IAAIG,MAAM,IAAI,IAAI,EAAE,MAAM,IAAIP,aAAa,CAAC,QAAQ,EAAE,UAAU,EAAEO,MAAM,CAAC;MACzEH,KAAK,IAAI,MAAMH,SAAS,CAAC;QAAE,GAAGQ,OAAO;QAAEF,MAAM;QAAEG,MAAM,EAAE;MAAK,CAAC,CAAC;IAChE;IACA,OAAON,KAAK;EACd;AACF,CAAC","ignoreList":[]}