@tezos-x/octez.js 0.9.0

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

@@ -0,0 +1,35 @@
+"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 {
+    constructor(id, provider) {
+        this.id = id;
+        this.provider = provider;
+    }
+    /**
+     *
+     * @description 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);
+        });
+    }
+    getId() {
+        return this.id.toString();
+    }
+}
+exports.SaplingStateAbstraction = SaplingStateAbstraction;

package/dist/lib/contract/semantic.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smartContractAbstractionSemantic = void 0;
+const octez_js_michelson_encoder_1 = require("@tezos-x/octez.js-michelson-encoder");
+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
+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 octez_js_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/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/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPCResponseError = exports.ConfirmationTimeoutError = exports.InvalidConfirmationCountError = void 0;
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error that indicates invalid confirmation count has been passed or configured
+ */
+class InvalidConfirmationCountError extends octez_js_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
+ *  @description Error that indicates that confirmation polling timed out
+ */
+class ConfirmationTimeoutError extends octez_js_core_1.NetworkError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'ConfirmationTimeoutError';
+    }
+}
+exports.ConfirmationTimeoutError = ConfirmationTimeoutError;
+/**
+ *  @category Error
+ *  @description Error that indicates an error being returned from the RPC response
+ */
+class RPCResponseError extends octez_js_core_1.RpcError {
+    constructor(message, cause) {
+        super();
+        this.message = message;
+        this.cause = cause;
+        this.name = 'RPCResponseError';
+    }
+}
+exports.RPCResponseError = RPCResponseError;

package/dist/lib/estimate/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevealEstimateError = void 0;
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error that indicates unable to get public key to estimate reveal operation in Wallet API
+ */
+class RevealEstimateError extends octez_js_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/estimate/estimate-provider-interface.js

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

package/dist/lib/estimate/estimate.js

@@ -0,0 +1,130 @@
+"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;
+/**
+ * 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)
+ *
+ * ```
+ */
+class Estimate {
+    constructor(_milligasLimit, _storageLimit, opSize, minimalFeePerStorageByteMutez, 
+    /**
+     * @description Base fee in mutez (1 mutez = 1e10−6 tez)
+     */
+    baseFeeMutez = MINIMAL_FEE_MUTEZ) {
+        this._milligasLimit = _milligasLimit;
+        this._storageLimit = _storageLimit;
+        this.opSize = opSize;
+        this.minimalFeePerStorageByteMutez = minimalFeePerStorageByteMutez;
+        this.baseFeeMutez = baseFeeMutez;
+    }
+    /**
+     * @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)
+     */
+    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.
+     */
+    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.
+     */
+    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);
+    }
+    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.
+     */
+    get minimalFeeMutez() {
+        return this.roundUp(this.operationFeeMutez + MINIMAL_FEE_MUTEZ);
+    }
+    /**
+     * @description 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);
+    }
+    /**
+     * @description 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));
+    }
+    /**
+     * @description The sum of `minimalFeeMutez` + `burnFeeMutez`.
+     */
+    get totalCost() {
+        return this.minimalFeeMutez + this.burnFeeMutez;
+    }
+    /**
+     * @description 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;
+        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);
+    }
+    static createArrayEstimateInstancesFromProperties(estimateProperties) {
+        return estimateProperties.map((x) => new Estimate(x.milligasLimit, x.storageLimit, x.opSize, x.minimalFeePerStorageByteMutez, x.baseFeeMutez));
+    }
+}
+exports.Estimate = Estimate;

package/dist/lib/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);