@taquito/taquito 24.2.0 → 24.3.0-beta.0

package/dist/lib/contract/sapling-state-abstraction.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SaplingStateAbstraction = void 0;
 class SaplingStateAbstraction {
@@ -17,16 +8,14 @@ class SaplingStateAbstraction {
     }
     /**
      *
-     * @description Fetch the sapling state
+     * Fetch the sapling state
      *
      * @param block optional block level to fetch the values from (head will be use by default)
      * @returns Return a json object of the sapling_state
      *
      */
-    getSaplingDiff(block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.provider.getSaplingDiffByID(this.id.toString(), block);
-        });
+    async getSaplingDiff(block) {
+        return this.provider.getSaplingDiffByID(this.id.toString(), block);
     }
     getId() {
         return this.id.toString();

package/dist/lib/contract/semantic.js

@@ -6,8 +6,8 @@ const big_map_1 = require("./big-map");
 const bignumber_js_1 = require("bignumber.js");
 const sapling_state_abstraction_1 = require("./sapling-state-abstraction");
 /**
- * @description Override the default michelson encoder semantic to provide richer abstraction over storage properties
- * @param provider ContractProvider (contract API)
+ * Override the default michelson encoder semantic to provide richer abstraction over storage properties
+ * @param p ContractProvider (contract API)
  */
 // Override the default michelson encoder semantic to provide richer abstraction over storage properties
 const smartContractAbstractionSemantic = (provider) => ({

package/dist/lib/errors.js

@@ -4,7 +4,7 @@ exports.RPCResponseError = exports.ConfirmationTimeoutError = exports.InvalidCon
 const core_1 = require("@taquito/core");
 /**
  *  @category Error
- *  @description Error that indicates invalid confirmation count has been passed or configured
+ *  Error that indicates invalid confirmation count has been passed or configured
  */
 class InvalidConfirmationCountError extends core_1.ParameterValidationError {
     constructor(invalidConfirmations) {
@@ -17,7 +17,7 @@ class InvalidConfirmationCountError extends core_1.ParameterValidationError {
 exports.InvalidConfirmationCountError = InvalidConfirmationCountError;
 /**
  *  @category Error
- *  @description Error that indicates that confirmation polling timed out
+ *  Error that indicates that confirmation polling timed out
  */
 class ConfirmationTimeoutError extends core_1.NetworkError {
     constructor(message) {
@@ -29,7 +29,7 @@ class ConfirmationTimeoutError extends core_1.NetworkError {
 exports.ConfirmationTimeoutError = ConfirmationTimeoutError;
 /**
  *  @category Error
- *  @description Error that indicates an error being returned from the RPC response
+ *  Error that indicates an error being returned from the RPC response
  */
 class RPCResponseError extends core_1.RpcError {
     constructor(message, cause) {

package/dist/lib/estimate/errors.js

@@ -4,7 +4,7 @@ exports.RevealEstimateError = void 0;
 const core_1 = require("@taquito/core");
 /**
  *  @category Error
- *  @description Error that indicates unable to get public key to estimate reveal operation in Wallet API
+ *  Error that indicates unable to get public key to estimate reveal operation in Wallet API
  */
 class RevealEstimateError extends core_1.TaquitoError {
     constructor() {

package/dist/lib/estimate/estimate.js

@@ -1,9 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Estimate = void 0;
-const MINIMAL_FEE_MUTEZ = 100;
-const MINIMAL_FEE_PER_BYTE_MUTEZ = 1;
-const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
+exports.Estimate = exports.feeParamsFromMempoolFilter = exports.DEFAULT_FEE_PARAMS = void 0;
+exports.DEFAULT_FEE_PARAMS = {
+    minimalFeeMutez: 100,
+    feePerGasMutez: 0.1,
+    feePerByteMutez: 1,
+};
+const parseRatio = (value) => {
+    if (!Array.isArray(value) || value.length < 2) {
+        return;
+    }
+    const numerator = Number(value[0]);
+    const denominator = Number(value[1]);
+    if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator === 0) {
+        return;
+    }
+    return numerator / denominator;
+};
+const feeParamsFromMempoolFilter = (response) => {
+    // L1 historically behaves like Taquito's long-standing defaults. Tezos X keeps the
+    // same fee formula shape, but these mempool values become material and may change
+    // over time, so estimation must read them from RPC instead of hardcoding them.
+    const minimalFeeMutez = Number(response?.minimal_fees);
+    const feePerGasNanotez = parseRatio(response?.minimal_nanotez_per_gas_unit);
+    const feePerByteNanotez = parseRatio(response?.minimal_nanotez_per_byte);
+    return {
+        minimalFeeMutez: Number.isFinite(minimalFeeMutez)
+            ? minimalFeeMutez
+            : exports.DEFAULT_FEE_PARAMS.minimalFeeMutez,
+        feePerGasMutez: 
+        // `mempool/filter` returns nanotez ratios, while `Estimate` works in mutez.
+        typeof feePerGasNanotez === 'number'
+            ? feePerGasNanotez / 1000
+            : exports.DEFAULT_FEE_PARAMS.feePerGasMutez,
+        feePerByteMutez: typeof feePerByteNanotez === 'number'
+            ? feePerByteNanotez / 1000
+            : exports.DEFAULT_FEE_PARAMS.feePerByteMutez,
+    };
+};
+exports.feeParamsFromMempoolFilter = feeParamsFromMempoolFilter;
 /**
  * Examples of use :
  *
@@ -38,69 +73,79 @@ const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
  *   est.suggestedFeeMutez, est.totalCost, est.usingBaseFeeMutez)
  *
  * ```
+ *
+ * Fee estimation keeps the same overall formula shape on Tezos L1 and on Tezos X / Tezlink:
+ * a fixed minimal fee plus byte and gas-price components. The important difference is that on
+ * Tezos X the byte fee and gas-price terms exposed by `mempool/filter` are material and may
+ * change over time, while on L1 they have historically been close to Taquito's long-standing
+ * defaults. `Estimate` therefore accepts fee parameters computed by the estimator instead of
+ * assuming L1 values internally.
  */
 class Estimate {
     constructor(_milligasLimit, _storageLimit, opSize, minimalFeePerStorageByteMutez, 
     /**
-     * @description Base fee in mutez (1 mutez = 1e10−6 tez)
+     * Base fee in mutez (1 mutez = 1e10−6 tez)
      */
-    baseFeeMutez = MINIMAL_FEE_MUTEZ) {
+    baseFeeMutez = exports.DEFAULT_FEE_PARAMS.minimalFeeMutez, feeParams = exports.DEFAULT_FEE_PARAMS) {
         this._milligasLimit = _milligasLimit;
         this._storageLimit = _storageLimit;
         this.opSize = opSize;
         this.minimalFeePerStorageByteMutez = minimalFeePerStorageByteMutez;
         this.baseFeeMutez = baseFeeMutez;
+        this.feeParams = feeParams;
     }
     /**
-     * @description The number of Mutez that will be burned for the storage of the [operation](https://tezos.gitlab.io/user/glossary.html#operations). (Storage + Allocation fees)
+     * The number of Mutez that will be burned for the storage of the [operation](https://tezos.gitlab.io/user/glossary.html#operations). (Storage + Allocation fees)
      */
     get burnFeeMutez() {
         return this.roundUp(Number(this.storageLimit) * Number(this.minimalFeePerStorageByteMutez));
     }
     /**
-     * @description  The limit on the amount of storage an [operation](https://tezos.gitlab.io/user/glossary.html#operations) can use with 20 buffer.
+     *  The limit on the amount of storage an [operation](https://tezos.gitlab.io/user/glossary.html#operations) can use with 20 buffer.
      */
     get storageLimit() {
         return Math.max(Number(this._storageLimit), 0);
     }
     /**
-     * @description The limit on the amount of [gas](https://tezos.gitlab.io/user/glossary.html#gas) a given operation can consume with 100 buffer depends on the operation.
+     * The limit on the amount of [gas](https://tezos.gitlab.io/user/glossary.html#gas) a given operation can consume with 100 buffer depends on the operation.
      */
     get gasLimit() {
         return this.roundUp(Number(this._milligasLimit) / 1000);
     }
     get operationFeeMutez() {
-        return (this.gasLimit * MINIMAL_FEE_PER_GAS_MUTEZ + Number(this.opSize) * MINIMAL_FEE_PER_BYTE_MUTEZ);
+        return (this.gasLimit * this.feeParams.feePerGasMutez +
+            Number(this.opSize) * this.feeParams.feePerByteMutez);
     }
     roundUp(nanotez) {
         return Math.ceil(Number(nanotez));
     }
     /**
-     * @description Minimum fees for the [operation](https://tezos.gitlab.io/user/glossary.html#operations) according to [baker](https://tezos.gitlab.io/user/glossary.html#baker) defaults.
+     * Minimum fees for the [operation](https://tezos.gitlab.io/user/glossary.html#operations) according to [baker](https://tezos.gitlab.io/user/glossary.html#baker) defaults.
      */
     get minimalFeeMutez() {
-        return this.roundUp(this.operationFeeMutez + MINIMAL_FEE_MUTEZ);
+        return this.roundUp(this.operationFeeMutez + this.feeParams.minimalFeeMutez);
     }
     /**
-     * @description The suggested fee for the operation which includes minimal fees and a small buffer.
+     * The suggested fee for the operation which includes minimal fees and a small buffer.
      */
     get suggestedFeeMutez() {
-        return this.roundUp(this.operationFeeMutez + MINIMAL_FEE_MUTEZ * 1.2);
+        return this.roundUp(this.operationFeeMutez + this.feeParams.minimalFeeMutez * 1.2);
     }
     /**
-     * @description Fees according to your specified base fee will ensure that at least minimum fees are used.
+     * Fees according to your specified base fee will ensure that at least minimum fees are used.
      */
     get usingBaseFeeMutez() {
-        return (Math.max(Number(this.baseFeeMutez), MINIMAL_FEE_MUTEZ) + this.roundUp(this.operationFeeMutez));
+        return (Math.max(Number(this.baseFeeMutez), this.feeParams.minimalFeeMutez) +
+            this.roundUp(this.operationFeeMutez));
     }
     /**
-     * @description The sum of `minimalFeeMutez` + `burnFeeMutez`.
+     * The sum of `minimalFeeMutez` + `burnFeeMutez`.
      */
     get totalCost() {
         return this.minimalFeeMutez + this.burnFeeMutez;
     }
     /**
-     * @description Since Delphinet, consumed gas is provided in milligas for more precision.
+     * Since Delphinet, consumed gas is provided in milligas for more precision.
      * This function returns an estimation of the gas that operation will consume in milligas.
      */
     get consumedMilligas() {
@@ -112,6 +157,7 @@ class Estimate {
         let opSize = 0;
         let minimalFeePerStorageByteMutez = 0;
         let baseFeeMutez;
+        const feeParams = estimateProperties[0]?.feeParams;
         estimateProperties.forEach((estimate) => {
             milligasLimit += estimate.milligasLimit;
             storageLimit += estimate.storageLimit;
@@ -121,10 +167,10 @@ class Estimate {
                 baseFeeMutez = baseFeeMutez ? baseFeeMutez + estimate.baseFeeMutez : estimate.baseFeeMutez;
             }
         });
-        return new Estimate(milligasLimit, storageLimit, opSize, minimalFeePerStorageByteMutez, baseFeeMutez);
+        return new Estimate(milligasLimit, storageLimit, opSize, minimalFeePerStorageByteMutez, baseFeeMutez, feeParams);
     }
     static createArrayEstimateInstancesFromProperties(estimateProperties) {
-        return estimateProperties.map((x) => new Estimate(x.milligasLimit, x.storageLimit, x.opSize, x.minimalFeePerStorageByteMutez, x.baseFeeMutez));
+        return estimateProperties.map((x) => new Estimate(x.milligasLimit, x.storageLimit, x.opSize, x.minimalFeePerStorageByteMutez, x.baseFeeMutez, x.feeParams));
     }
 }
 exports.Estimate = Estimate;