@taquito/wallet-connect 24.3.0-beta.0 → 24.3.0-beta.2

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaplingStateAbstraction = void 0;
+class SaplingStateAbstraction {
+    constructor(id, provider) {
+        this.id = id;
+        this.provider = provider;
+    }
+    /**
+     *
+     * 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
+     *
+     */
+    async getSaplingDiff(block) {
+        return this.provider.getSaplingDiffByID(this.id.toString(), block);
+    }
+    getId() {
+        return this.id.toString();
+    }
+}
+exports.SaplingStateAbstraction = SaplingStateAbstraction;

package/dist/lib/taquito/src/contract/semantic.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smartContractAbstractionSemantic = void 0;
+const michelson_encoder_1 = require("@taquito/michelson-encoder");
+const big_map_1 = require("./big-map");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const sapling_state_abstraction_1 = require("./sapling-state-abstraction");
+/**
+ * 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) => ({
+    // Provide a specific abstraction for BigMaps
+    big_map: (val, code) => {
+        if (!val || !('int' in val) || val.int === undefined) {
+            // Return an empty object in case of missing big map ID
+            return {};
+        }
+        else {
+            const schema = new michelson_encoder_1.Schema(code);
+            return new big_map_1.BigMapAbstraction(new bignumber_js_1.default(val.int), schema, provider);
+        }
+    },
+    sapling_state: (val) => {
+        if (!val || !('int' in val) || val.int === undefined) {
+            // Return an empty object in case of missing sapling state ID
+            return {};
+        }
+        else {
+            return new sapling_state_abstraction_1.SaplingStateAbstraction(new bignumber_js_1.default(val.int), provider);
+        }
+    },
+    /*
+    // TODO: embed useful other abstractions
+    'contract':  () => {},
+    'address':  () => {}
+    */
+});
+exports.smartContractAbstractionSemantic = smartContractAbstractionSemantic;

package/dist/lib/taquito/src/contract/view_lambda.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIEW_LAMBDA = void 0;
+const code = [
+    {
+        prim: 'parameter',
+        args: [
+            {
+                prim: 'lambda',
+                args: [
+                    { prim: 'unit' },
+                    {
+                        prim: 'pair',
+                        args: [{ prim: 'list', args: [{ prim: 'operation' }] }, { prim: 'unit' }],
+                    },
+                ],
+            },
+        ],
+    },
+    { prim: 'storage', args: [{ prim: 'unit' }] },
+    { prim: 'code', args: [[{ prim: 'CAR' }, { prim: 'UNIT' }, { prim: 'EXEC' }]] },
+];
+const storage = 'Unit';
+exports.VIEW_LAMBDA = {
+    code,
+    storage
+};

package/dist/lib/taquito/src/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPCResponseError = exports.ConfirmationTimeoutError = exports.InvalidConfirmationCountError = void 0;
+const core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates invalid confirmation count has been passed or configured
+ */
+class InvalidConfirmationCountError extends core_1.ParameterValidationError {
+    constructor(invalidConfirmations) {
+        super();
+        this.invalidConfirmations = invalidConfirmations;
+        this.name = 'InvalidConfirmationCountError';
+        this.message = `Invalid confirmation count ${invalidConfirmations} expecting at least 1`;
+    }
+}
+exports.InvalidConfirmationCountError = InvalidConfirmationCountError;
+/**
+ *  @category Error
+ *  Error that indicates that confirmation polling timed out
+ */
+class ConfirmationTimeoutError extends core_1.NetworkError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'ConfirmationTimeoutError';
+    }
+}
+exports.ConfirmationTimeoutError = ConfirmationTimeoutError;
+/**
+ *  @category Error
+ *  Error that indicates an error being returned from the RPC response
+ */
+class RPCResponseError extends core_1.RpcError {
+    constructor(message, cause) {
+        super();
+        this.message = message;
+        this.cause = cause;
+        this.name = 'RPCResponseError';
+    }
+}
+exports.RPCResponseError = RPCResponseError;

package/dist/lib/taquito/src/estimate/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevealEstimateError = void 0;
+const core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates unable to get public key to estimate reveal operation in Wallet API
+ */
+class RevealEstimateError extends core_1.TaquitoError {
+    constructor() {
+        super();
+        this.name = 'RevealEstimateError';
+        this.message = 'Public key is unknown, unable to estimate the reveal operation in Wallet API.';
+    }
+}
+exports.RevealEstimateError = RevealEstimateError;

package/dist/lib/taquito/src/estimate/estimate-provider-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/taquito/src/estimate/estimate.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 :
+ *
+ *  Estimate a transfer operation :
+ * ```
+ * // Assuming that provider and signer are already configured...
+ *
+ * const amount = 2;
+ * const address = 'tz1h3rQ8wBxFd8L9B3d7Jhaawu6Z568XU3xY';
+ *
+ * // Estimate gasLimit, storageLimit and fees for a transfer operation
+ * const est = await Tezos.estimate.transfer({ to: address, amount: amount })
+ * console.log(est.burnFeeMutez, est.gasLimit, est.minimalFeeMutez, est.storageLimit,
+ *  est.suggestedFeeMutez, est.totalCost, est.usingBaseFeeMutez)
+ *
+ * ```
+ *
+ * Estimate a contract origination :
+ * ```
+ * // generic.json is referring to a Michelson Smart Contract
+ *
+ * const genericMultisigJSON = require('./generic.json')
+ * const est = await Tezos.estimate.originate({
+ *   code: genericMultisigJSON,
+ *   storage: {
+ *     stored_counter: 0,
+ *     threshold: 1,
+ *     keys: ['edpkuLxx9PQD8fZ45eUzrK3BhfDZJHhBuK4Zi49DcEGANwd2rpX82t']
+ *   }
+ * })
+ * console.log(est.burnFeeMutez, est.gasLimit, est.minimalFeeMutez, est.storageLimit,
+ *   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, 
+    /**
+     * Base fee in mutez (1 mutez = 1e10−6 tez)
+     */
+    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;
+    }
+    /**
+     * 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));
+    }
+    /**
+     *  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);
+    }
+    /**
+     * 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 * this.feeParams.feePerGasMutez +
+            Number(this.opSize) * this.feeParams.feePerByteMutez);
+    }
+    roundUp(nanotez) {
+        return Math.ceil(Number(nanotez));
+    }
+    /**
+     * 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 + this.feeParams.minimalFeeMutez);
+    }
+    /**
+     * The suggested fee for the operation which includes minimal fees and a small buffer.
+     */
+    get suggestedFeeMutez() {
+        return this.roundUp(this.operationFeeMutez + this.feeParams.minimalFeeMutez * 1.2);
+    }
+    /**
+     * Fees according to your specified base fee will ensure that at least minimum fees are used.
+     */
+    get usingBaseFeeMutez() {
+        return (Math.max(Number(this.baseFeeMutez), this.feeParams.minimalFeeMutez) +
+            this.roundUp(this.operationFeeMutez));
+    }
+    /**
+     * The sum of `minimalFeeMutez` + `burnFeeMutez`.
+     */
+    get totalCost() {
+        return this.minimalFeeMutez + this.burnFeeMutez;
+    }
+    /**
+     * 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() {
+        return Number(this._milligasLimit);
+    }
+    static createEstimateInstanceFromProperties(estimateProperties) {
+        let milligasLimit = 0;
+        let storageLimit = 0;
+        let opSize = 0;
+        let minimalFeePerStorageByteMutez = 0;
+        let baseFeeMutez;
+        const feeParams = estimateProperties[0]?.feeParams;
+        estimateProperties.forEach((estimate) => {
+            milligasLimit += estimate.milligasLimit;
+            storageLimit += estimate.storageLimit;
+            opSize += estimate.opSize;
+            minimalFeePerStorageByteMutez = Math.max(estimate.minimalFeePerStorageByteMutez, minimalFeePerStorageByteMutez);
+            if (estimate.baseFeeMutez) {
+                baseFeeMutez = baseFeeMutez ? baseFeeMutez + estimate.baseFeeMutez : estimate.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, x.feeParams));
+    }
+}
+exports.Estimate = Estimate;

package/dist/lib/taquito/src/estimate/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./estimate"), exports);
+__exportStar(require("./estimate-provider-interface"), exports);
+__exportStar(require("./rpc-estimate-provider"), exports);
+__exportStar(require("./errors"), exports);