@aeternity/aepp-sdk 15.0.0 → 15.0.1

package/dist/aepp-sdk.cjs

@@ -7373,6 +7373,7 @@ __webpack_require__.d(__webpack_exports__, {
   getExecutionCostBySignedTx: () => (/* reexport */ getExecutionCostBySignedTx),
   getExecutionCostUsingNode: () => (/* reexport */ getExecutionCostUsingNode),
   getFileSystem: () => (/* reexport */ getFileSystem),
+  getFloorGasPrice: () => (/* reexport */ getFloorGasPrice),
   getGeneration: () => (/* reexport */ getGeneration),
   getHeight: () => (/* reexport */ getHeight),
   getKeyBlock: () => (/* reexport */ getKeyBlock),
@@ -9249,8 +9250,9 @@ const MAX_AUTH_FUN_GAS = 50000;
  * The consensus minimum gas price as it was at the moment of the SDK release.
  * @category transaction builder
  * @deprecated a node may run another minimum gas price, and this constant is wrong on it. Use
- * `(await getCachedProtocolParameters(node)).minGasPrice` for the value the connected node
- * reports, or `defaultProtocolParameters.minGasPrice` for this one.
+ * `getFloorGasPrice(await getCachedProtocolParameters(node))` to price a transaction for the
+ * connected node — the consensus minimum it reports is below what its miner accepts on a public
+ * network. `defaultProtocolParameters.minGasPrice` is this constant.
  */
 const MIN_GAS_PRICE = 1e9; // TODO: don't use number for ae
 /**
@@ -10101,6 +10103,18 @@ function getProtocolDetails(protocolVersion, type) {
     abiVersion: protocol.abiVersion[0]
   };
 }
+
+/**
+ * Whether all known consensus protocols pick the same versions for `type`, so asking node for its
+ * protocol can't change them.
+ */
+function isProtocolIndependent(type) {
+  const [first, ...others] = Object.keys(ProtocolToVmAbi).map(protocol => getProtocolDetails(+protocol, type));
+  return others.every(({
+    vmVersion,
+    abiVersion
+  }) => vmVersion === first.vmVersion && abiVersion === first.abiVersion);
+}
 /* harmony default export */ const ct_version = ({
   serialize(value, params, {
     consensusProtocolVersion = ConsensusProtocolVersion.Ceres
@@ -10113,7 +10127,7 @@ function getProtocolDetails(protocolVersion, type) {
   options) {
     if (value != null) return value;
     if (options.consensusProtocolVersion != null) return undefined;
-    if (Object.keys(ConsensusProtocolVersion).length === 2) return undefined;
+    if (isProtocolIndependent('contract-create')) return undefined;
     if (options.onNode != null) {
       return getProtocolDetails((await options.onNode.getNodeInfo()).consensusProtocolVersion, 'contract-create');
     }
@@ -10148,10 +10162,12 @@ const serializeAsIsParam = Symbol('serializeAsIs');
 ;// ./src/tx/builder/field-types/abi-version.ts
 
 
+function getKind(tag) {
+  return Tag.ContractCallTx === tag || Tag.GaMetaTx === tag ? 'contract-call' : 'oracle-call';
+}
 /* harmony default export */ const abi_version = ({
   _getProtocolDetails(c, tag) {
-    const kind = Tag.ContractCallTx === tag || Tag.GaMetaTx === tag ? 'contract-call' : 'oracle-call';
-    return getProtocolDetails(c, kind).abiVersion;
+    return getProtocolDetails(c, getKind(tag)).abiVersion;
   },
   serialize(value, {
     tag
@@ -10168,7 +10184,7 @@ const serializeAsIsParam = Symbol('serializeAsIs');
   options) {
     if (value != null) return value;
     if (options.consensusProtocolVersion != null) return undefined;
-    if (Object.keys(ConsensusProtocolVersion).length === 2) return undefined;
+    if (isProtocolIndependent(getKind(tag))) return undefined;
     if (options.onNode != null) {
       return this._getProtocolDetails((await options.onNode.getNodeInfo()).consensusProtocolVersion, tag);
     }
@@ -10401,7 +10417,7 @@ const defaultProtocolParameters = freezeParameters({
       [AbiVersion.Fate]: 5 * BASE_GAS
     },
     [Tag.ContractCallTx]: {
-      [AbiVersion.Sophia]: 12 * BASE_GAS,
+      [AbiVersion.Sophia]: 30 * BASE_GAS,
       [AbiVersion.Fate]: 12 * BASE_GAS
     },
     [Tag.GaAttachTx]: {
@@ -10591,8 +10607,9 @@ function checkRaiseNotExcessive(what, raise) {
 function checkParametersNotExcessive(parameters) {
   const d = defaultProtocolParameters;
   const defaultMinGasPrice = Number(d.minGasPrice);
-  // a gas price of 0 makes every fee 0 — the network would reject the transaction, and the
-  // `minFee / minGasPrice` of the demand-based fee is a division by zero
+  // no network runs a consensus minimum of 0 (node reports 1e6 since Minerva), and with a miner
+  // minimum of 0 as well it makes every fee 0 and the `minFee / getFloorGasPrice` of the
+  // demand-based fee a division by zero
   if (parameters.minGasPrice < 1n) {
     throw new NodeError(`Node reports the minimum gas price as ${parameters.minGasPrice}, a transaction can't be` + ' priced against it. Provide `protocolParameters` in options to build a transaction' + ' against these parameters anyway.');
   }
@@ -10610,10 +10627,13 @@ function checkParametersNotExcessive(parameters) {
     gasRaises.push(checkNotExcessive(`the base gas of ${Tag[+tag]}`, gas, defaultBaseGasOf(+tag)));
   });
   Object.entries(parameters.contractTxBaseGas).forEach(([tag, byAbiVersion]) => {
-    const sdkValue = defaultBaseGasOf(+tag);
     Object.entries(byAbiVersion).forEach(([abiVersion, gas]) => {
       const name = `the base gas of ${Tag[+tag]} at abi version ${abiVersion}`;
-      gasRaises.push(checkNotExcessive(name, gas, sdkValue));
+      // an abi version the SDK release prices is bounded by its own value — the budget of the
+      // priciest one is not a budget for the others. An abi version it doesn't price is charged
+      // the maximum of the ones it does, see `getTxBaseGas`
+      const sdkValue = d.contractTxBaseGas[+tag]?.[+abiVersion];
+      gasRaises.push(checkNotExcessive(name, gas, sdkValue !== null && sdkValue !== void 0 ? sdkValue : defaultBaseGasOf(+tag)));
     });
   });
   const defaultStateGasRatio = defaultStateGasPerBlock.part / defaultStateGasPerBlock.whole;
@@ -10678,6 +10698,22 @@ function getGasLimitDivisor(parameters, tag) {
   if (raises == null) return 1;
   return tag === Tag.GaMetaTx ? raises.maxAuthFunGas : raises.blockGasLimit;
 }
+
+/**
+ * Gas price the minimum fee is counted at and the `gasPrice` of a contract transaction defaults
+ * to: the miner minimum when it is above the consensus one. Node reads the price a transaction
+ * pays as the lower of its `gasPrice` and its fee over its fee gas, so pricing either below the
+ * miner minimum gets it refused with `too_low_gas_price_for_miner`.
+ * @category transaction builder
+ * @param parameters - Parameters a transaction is built against
+ */
+function getFloorGasPrice(parameters) {
+  const {
+    minGasPrice,
+    minMinerGasPrice
+  } = parameters;
+  return minMinerGasPrice > minGasPrice ? minMinerGasPrice : minGasPrice;
+}
 function mapByTxType(entries, map) {
   return Object.fromEntries(entries.map(([txType, value]) => [getTag(txType), map(value)])
   // a transaction type the SDK doesn't implement, or won't ever build (`ChannelClientReconnectTx`)
@@ -10919,9 +10955,11 @@ async function getCachedIncreasedGasPrice(nodeOrProxy, parameters) {
   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;
+  // 0n means "the consensus minimum", only a miner asking for more lifts it
+  const floorGasPrice = getFloorGasPrice(protocolParameters);
+  if (floorGasPrice > protocolParameters.minGasPrice && gasPrice < floorGasPrice) {
+    gasPrice = floorGasPrice;
+  }
 
   // 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
@@ -10962,11 +11000,13 @@ async function getCachedIncreasedGasPrice(nodeOrProxy, parameters) {
   serializeAettos(value, params, {
     protocolParameters = defaultProtocolParameters
   }) {
-    const minGasPrice = protocolParameters.minGasPrice.toString();
-    if (value == null) return minGasPrice;
+    // defaulted and checked against the floor `prepare` applies, for a build that gets no
+    // `prepare` — see `getFloorGasPrice`. Provide `protocolParameters` to build for another node
+    const floorGasPrice = getFloorGasPrice(protocolParameters).toString();
+    if (value == null) return floorGasPrice;
     if (params[serializeAsIsParam] === true) return value;
-    if (new (external_bignumber_js_default())(value).lt(minGasPrice)) {
-      throw new IllegalArgumentError(`Gas price ${value} must be bigger than ${minGasPrice}`);
+    if (new (external_bignumber_js_default())(value).lt(floorGasPrice)) {
+      throw new IllegalArgumentError(`Gas price ${value} must be bigger than ${floorGasPrice}`);
     }
     return value;
   }
@@ -11083,12 +11123,12 @@ function buildGas(builtTx, unpackTx, buildTx, protocolParameters) {
  * @param rebuildTx - Callback to get built transaction with specific fee
  */
 function calculateMinFee(rebuildTx, unpackTx, buildTx, protocolParameters) {
-  const minGasPrice = new (external_bignumber_js_default())(protocolParameters.minGasPrice.toString());
+  const floorGasPrice = new (external_bignumber_js_default())(getFloorGasPrice(protocolParameters).toString());
   let fee = new (external_bignumber_js_default())(0);
   let previousFee;
   do {
     previousFee = fee;
-    fee = minGasPrice.times(buildGas(rebuildTx(fee), unpackTx, buildTx, protocolParameters));
+    fee = floorGasPrice.times(buildGas(rebuildTx(fee), unpackTx, buildTx, protocolParameters));
   } while (!fee.eq(previousFee));
   return fee;
 }
@@ -11126,7 +11166,7 @@ const gasPricePrefix = '_gas-price:';
     const minFee = calculateMinFee(fee => rebuildTx({
       _computingMinFee: fee
     }), unpackTx, buildTx, protocolParameters);
-    const value = _value?.startsWith(gasPricePrefix) === true ? minFee.dividedBy(protocolParameters.minGasPrice.toString()).times(_value.replace(gasPricePrefix, '')) : new (external_bignumber_js_default())(_value !== null && _value !== void 0 ? _value : minFee);
+    const value = _value?.startsWith(gasPricePrefix) === true ? minFee.dividedBy(getFloorGasPrice(protocolParameters).toString()).times(_value.replace(gasPricePrefix, '')) : new (external_bignumber_js_default())(_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}`);
@@ -23885,9 +23925,9 @@ async function buildAuthTxHashInternal(transaction, {
   let payload = hash(concatBuffers([Buffer.from(nodeNetworkId), decode(transaction)]));
   if (fee == null) throw new ArgumentError('fee', 'provided (in Ceres)', fee);
   if (gasPrice == null) throw new ArgumentError('gasPrice', 'provided (in Ceres)', gasPrice);
-  // the entry checks `gasPrice` against the consensus minimum the same way a transaction does,
-  // so it needs the same parameters — without them a `gasPrice` correct for the network this
-  // node runs is rejected whenever that network runs a lower minimum than the SDK release.
+  // the entry checks `gasPrice` the same way a transaction does, so it needs the same parameters
+  // — without them a `gasPrice` correct for the network this node runs is rejected whenever that
+  // network prices a transaction below the SDK release.
   // Not requested at all when there is nothing to check, so that re-deriving the hash of an
   // existing transaction needs no round trip and works on a transaction of another network
   payload = hash(decode(packEntry({