@taquito/taquito 24.2.0 → 24.3.0-beta.1

package/dist/lib/provider.js

@@ -1,32 +1,183 @@
 "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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Provider = void 0;
+const http_utils_1 = require("@taquito/http-utils");
 const types_1 = require("./operations/types");
 const errors_1 = require("./operations/errors");
 const prepare_1 = require("./contract/prepare");
 const rpc_1 = require("@taquito/rpc");
 const utils_1 = require("@taquito/utils");
 class Provider {
+    parseRpcErrors(error) {
+        if (!(error instanceof http_utils_1.HttpResponseError)) {
+            return [];
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(error.body);
+        }
+        catch {
+            return [];
+        }
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.filter((value) => {
+            return typeof value === 'object' && value !== null;
+        });
+    }
+    toBigInt(value) {
+        if (typeof value === 'bigint') {
+            return value;
+        }
+        if (typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value)) {
+            return BigInt(value);
+        }
+        if (typeof value === 'string' && /^-?\d+$/.test(value)) {
+            return BigInt(value);
+        }
+        if (typeof value === 'object' && value !== null && 'toString' in value) {
+            const normalized = value.toString();
+            if (/^-?\d+$/.test(normalized)) {
+                return BigInt(normalized);
+            }
+        }
+    }
+    parseCounterInThePastAdjustments(error) {
+        return this.parseRpcErrors(error)
+            .filter((value) => {
+            const id = value.id;
+            const contract = value.contract;
+            const expected = value.expected;
+            const found = value.found;
+            return (typeof id === 'string' &&
+                id.endsWith('contract.counter_in_the_past') &&
+                typeof contract === 'string' &&
+                typeof expected === 'string' &&
+                typeof found === 'string');
+        })
+            .map((value) => ({
+            contract: value.contract,
+            expected: BigInt(value.expected),
+            found: BigInt(value.found),
+        }))
+            .filter((value) => value.expected > value.found);
+    }
+    hasGasLimitTooHighAndBlockExhausted(error) {
+        const ids = this.parseRpcErrors(error)
+            .map((value) => value.id)
+            .filter((value) => typeof value === 'string');
+        return (ids.some((id) => id.endsWith('gas_limit_too_high')) &&
+            ids.some((id) => id.endsWith('gas_exhausted.block')));
+    }
+    async patchSimulationGasLimits(op, error, gasLimitPatchableIndexes) {
+        if (!this.hasGasLimitTooHighAndBlockExhausted(error)) {
+            return;
+        }
+        if (!Array.isArray(op.operation.contents)) {
+            return;
+        }
+        const constants = await this.context.readProvider.getProtocolConstants('head');
+        const hardGasLimitPerOperation = this.toBigInt(constants.hard_gas_limit_per_operation);
+        const hardGasLimitPerBlock = this.toBigInt(constants.hard_gas_limit_per_block);
+        const zero = BigInt(0);
+        if (typeof hardGasLimitPerOperation === 'undefined' ||
+            typeof hardGasLimitPerBlock === 'undefined' ||
+            hardGasLimitPerOperation <= zero ||
+            hardGasLimitPerBlock <= zero) {
+            return;
+        }
+        const contents = op.operation.contents.map((content) => ({ ...content }));
+        const adjustableIndexes = gasLimitPatchableIndexes && gasLimitPatchableIndexes.length > 0
+            ? gasLimitPatchableIndexes.filter((index) => index >= 0 && index < contents.length)
+            : [];
+        let explicitGasLimitTotal = zero;
+        for (const [index, content] of contents.entries()) {
+            const kind = content.kind;
+            const gasLimit = this.toBigInt(content.gas_limit);
+            if (typeof gasLimit === 'undefined') {
+                continue;
+            }
+            if (adjustableIndexes.length === 0) {
+                if (kind !== 'reveal' && gasLimit >= hardGasLimitPerOperation) {
+                    adjustableIndexes.push(index);
+                    continue;
+                }
+            }
+            else if (adjustableIndexes.includes(index)) {
+                continue;
+            }
+            explicitGasLimitTotal += gasLimit;
+        }
+        if (adjustableIndexes.length === 0) {
+            return;
+        }
+        // Mirror octez-client's `may_patch_limits` logic in injection.ml:
+        // only rebalance manager operations whose gas limit was auto-assigned for
+        // simulation, while treating reveal and user-specified gas limits as already
+        // consuming part of the block budget.
+        const remainingBlockGas = hardGasLimitPerBlock - explicitGasLimitTotal;
+        const evenlyDistributedGas = remainingBlockGas > zero ? remainingBlockGas / BigInt(adjustableIndexes.length) : zero;
+        const patchedGasLimit = evenlyDistributedGas > hardGasLimitPerOperation
+            ? hardGasLimitPerOperation
+            : evenlyDistributedGas;
+        let patched = false;
+        for (const index of adjustableIndexes) {
+            const content = contents[index];
+            const currentGasLimit = this.toBigInt(content.gas_limit);
+            if (currentGasLimit === patchedGasLimit) {
+                continue;
+            }
+            contents[index].gas_limit = patchedGasLimit.toString();
+            patched = true;
+        }
+        if (!patched) {
+            return;
+        }
+        return {
+            ...op,
+            operation: {
+                ...op.operation,
+                contents,
+            },
+        };
+    }
+    patchSimulationCounters(op, adjustments) {
+        if (adjustments.length === 0) {
+            return;
+        }
+        if (!Array.isArray(op.operation.contents)) {
+            return;
+        }
+        const contents = op.operation.contents.map((content) => ({ ...content }));
+        let patched = false;
+        for (const adjustment of adjustments) {
+            const delta = adjustment.expected - adjustment.found;
+            for (const content of contents) {
+                const source = content.source;
+                const counter = content.counter;
+                if (source !== adjustment.contract || typeof counter === 'undefined') {
+                    continue;
+                }
+                const contentCounter = BigInt(String(counter));
+                if (contentCounter < adjustment.found) {
+                    continue;
+                }
+                content.counter = (contentCounter + delta).toString();
+                patched = true;
+            }
+        }
+        if (!patched) {
+            return;
+        }
+        return {
+            ...op,
+            operation: {
+                ...op.operation,
+                contents,
+            },
+        };
+    }
     get rpc() {
         return this.context.rpc;
     }
@@ -36,98 +187,143 @@ class Provider {
     constructor(context) {
         this.context = context;
     }
-    forge(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ opOb: { branch, contents, protocol }, counter }) {
-            const forgedBytes = yield this.context.forger.forge({ branch, contents });
-            return {
-                opbytes: forgedBytes,
-                opOb: {
-                    branch,
-                    contents,
-                    protocol,
-                },
-                counter,
-            };
-        });
+    async forge({ opOb: { branch, contents, protocol }, counter }) {
+        const forgedBytes = await this.context.forger.forge({ branch, contents });
+        return {
+            opbytes: forgedBytes,
+            opOb: {
+                branch,
+                contents,
+                protocol,
+            },
+            counter,
+        };
     }
-    estimate(_a, estimator) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var { fee, gasLimit, storageLimit } = _a, rest = __rest(_a, ["fee", "gasLimit", "storageLimit"]);
-            let calculatedFee = fee;
-            let calculatedGas = gasLimit;
-            let calculatedStorage = storageLimit;
-            if (calculatedFee && calculatedFee % 1 !== 0) {
-                throw new errors_1.InvalidEstimateValueError(`Fee value must not be a decimal: ${calculatedFee}`);
-            }
-            if (calculatedGas && calculatedGas % 1 !== 0) {
-                throw new errors_1.InvalidEstimateValueError(`Gas Limit value must not be a decimal: ${calculatedGas}`);
-            }
-            if (calculatedStorage && calculatedStorage % 1 !== 0) {
-                throw new errors_1.InvalidEstimateValueError(`Storage Limit value must not be a decimal: ${calculatedStorage}`);
-            }
-            if (fee === undefined || gasLimit === undefined || storageLimit === undefined) {
-                const estimation = yield estimator(Object.assign({ fee, gasLimit, storageLimit }, rest));
-                calculatedFee !== null && calculatedFee !== void 0 ? calculatedFee : (calculatedFee = estimation.suggestedFeeMutez);
-                calculatedGas !== null && calculatedGas !== void 0 ? calculatedGas : (calculatedGas = estimation.gasLimit);
-                calculatedStorage !== null && calculatedStorage !== void 0 ? calculatedStorage : (calculatedStorage = estimation.storageLimit);
-            }
-            return {
-                fee: calculatedFee,
-                gasLimit: calculatedGas,
-                storageLimit: calculatedStorage,
-            };
-        });
+    async estimate({ fee, gasLimit, storageLimit, ...rest }, estimator) {
+        let calculatedFee = fee;
+        let calculatedGas = gasLimit;
+        let calculatedStorage = storageLimit;
+        if (calculatedFee && calculatedFee % 1 !== 0) {
+            throw new errors_1.InvalidEstimateValueError(`Fee value must not be a decimal: ${calculatedFee}`);
+        }
+        if (calculatedGas && calculatedGas % 1 !== 0) {
+            throw new errors_1.InvalidEstimateValueError(`Gas Limit value must not be a decimal: ${calculatedGas}`);
+        }
+        if (calculatedStorage && calculatedStorage % 1 !== 0) {
+            throw new errors_1.InvalidEstimateValueError(`Storage Limit value must not be a decimal: ${calculatedStorage}`);
+        }
+        if (fee === undefined || gasLimit === undefined || storageLimit === undefined) {
+            const estimation = await estimator({ fee, gasLimit, storageLimit, ...rest });
+            calculatedFee ?? (calculatedFee = estimation.suggestedFeeMutez);
+            calculatedGas ?? (calculatedGas = estimation.gasLimit);
+            calculatedStorage ?? (calculatedStorage = estimation.storageLimit);
+        }
+        return {
+            fee: calculatedFee,
+            gasLimit: calculatedGas,
+            storageLimit: calculatedStorage,
+        };
     }
-    getRPCOp(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (param.kind) {
-                case rpc_1.OpKind.TRANSACTION:
-                    return (0, prepare_1.createTransferOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.ORIGINATION:
-                    return (0, prepare_1.createOriginationOperation)(yield this.context.parser.prepareCodeOrigination(Object.assign({}, param)));
-                case rpc_1.OpKind.DELEGATION:
-                    return (0, prepare_1.createSetDelegateOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT:
-                    return (0, prepare_1.createRegisterGlobalConstantOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.INCREASE_PAID_STORAGE:
-                    return (0, prepare_1.createIncreasePaidStorageOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.UPDATE_CONSENSUS_KEY:
-                    return (0, prepare_1.createUpdateConsensusKeyOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.UPDATE_COMPANION_KEY:
-                    return (0, prepare_1.createUpdateCompanionKeyOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.TRANSFER_TICKET:
-                    return (0, prepare_1.createTransferTicketOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES:
-                    return (0, prepare_1.createSmartRollupAddMessagesOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.SMART_ROLLUP_ORIGINATE:
-                    return (0, prepare_1.createSmartRollupOriginateOperation)(Object.assign({}, param));
-                case rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE:
-                    return (0, prepare_1.createSmartRollupExecuteOutboxMessageOperation)(Object.assign({}, param));
-                default:
-                    throw new utils_1.InvalidOperationKindError(param.kind);
-            }
-        });
+    async getRPCOp(param) {
+        switch (param.kind) {
+            case rpc_1.OpKind.TRANSACTION:
+                return (0, prepare_1.createTransferOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.ORIGINATION:
+                return (0, prepare_1.createOriginationOperation)(await this.context.parser.prepareCodeOrigination({
+                    ...param,
+                }));
+            case rpc_1.OpKind.DELEGATION:
+                return (0, prepare_1.createSetDelegateOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT:
+                return (0, prepare_1.createRegisterGlobalConstantOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.INCREASE_PAID_STORAGE:
+                return (0, prepare_1.createIncreasePaidStorageOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.UPDATE_CONSENSUS_KEY:
+                return (0, prepare_1.createUpdateConsensusKeyOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.UPDATE_COMPANION_KEY:
+                return (0, prepare_1.createUpdateCompanionKeyOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.TRANSFER_TICKET:
+                return (0, prepare_1.createTransferTicketOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES:
+                return (0, prepare_1.createSmartRollupAddMessagesOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.SMART_ROLLUP_ORIGINATE:
+                return (0, prepare_1.createSmartRollupOriginateOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE:
+                return (0, prepare_1.createSmartRollupExecuteOutboxMessageOperation)({
+                    ...param,
+                });
+            default:
+                throw new utils_1.InvalidOperationKindError(param.kind);
+        }
     }
-    simulate(op) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async simulate(op, preparedOperation) {
+        const gasLimitPatchableIndexes = preparedOperation?.simulation?.gasLimitPatchableIndexes;
+        try {
             return {
-                opResponse: yield this.rpc.simulateOperation(op),
+                opResponse: await this.rpc.simulateOperation(op),
                 op,
                 context: this.context.clone(),
             };
-        });
+        }
+        catch (error) {
+            const adjustments = this.parseCounterInThePastAdjustments(error);
+            const patchedOp = this.patchSimulationCounters(op, adjustments);
+            if (patchedOp) {
+                try {
+                    return {
+                        opResponse: await this.rpc.simulateOperation(patchedOp),
+                        op: patchedOp,
+                        context: this.context.clone(),
+                    };
+                }
+                catch (counterRetryError) {
+                    const gasPatchedOp = await this.patchSimulationGasLimits(patchedOp, counterRetryError, gasLimitPatchableIndexes);
+                    if (!gasPatchedOp) {
+                        throw counterRetryError;
+                    }
+                    return {
+                        opResponse: await this.rpc.simulateOperation(gasPatchedOp),
+                        op: gasPatchedOp,
+                        context: this.context.clone(),
+                    };
+                }
+            }
+            const gasPatchedOp = await this.patchSimulationGasLimits(op, error, gasLimitPatchableIndexes);
+            if (!gasPatchedOp) {
+                throw error;
+            }
+            return {
+                opResponse: await this.rpc.simulateOperation(gasPatchedOp),
+                op: gasPatchedOp,
+                context: this.context.clone(),
+            };
+        }
     }
-    isRevealOpNeeded(op, pkh) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return !(yield this.isAccountRevealRequired(pkh)) || !this.isRevealRequiredForOpType(op)
-                ? false
-                : true;
-        });
+    async isRevealOpNeeded(op, pkh) {
+        return !(await this.isAccountRevealRequired(pkh)) || !this.isRevealRequiredForOpType(op)
+            ? false
+            : true;
     }
-    isAccountRevealRequired(publicKeyHash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return !(yield this.context.readProvider.isAccountRevealed(publicKeyHash, 'head'));
-        });
+    async isAccountRevealRequired(publicKeyHash) {
+        return !(await this.context.readProvider.isAccountRevealed(publicKeyHash, 'head'));
     }
     isRevealRequiredForOpType(op) {
         let opRequireReveal = false;
@@ -138,32 +334,30 @@ class Provider {
         }
         return opRequireReveal;
     }
-    signAndInject(forgedBytes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const signed = yield this.signer.sign(forgedBytes.opbytes, new Uint8Array([3]));
-            forgedBytes.opbytes = signed.sbytes;
-            forgedBytes.opOb.signature = signed.prefixSig;
-            const opResponse = [];
-            const results = yield this.rpc.preapplyOperations([forgedBytes.opOb]);
-            if (!Array.isArray(results)) {
-                throw new errors_1.TezosPreapplyFailureError(results);
-            }
-            for (let i = 0; i < results.length; i++) {
-                for (let j = 0; j < results[i].contents.length; j++) {
-                    opResponse.push(results[i].contents[j]);
-                }
-            }
-            const errors = (0, errors_1.flattenErrors)(results);
-            if (errors.length) {
-                throw new errors_1.TezosOperationError(errors, 'Error occurred during validation simulation of operation', opResponse);
+    async signAndInject(forgedBytes) {
+        const signed = await this.signer.sign(forgedBytes.opbytes, new Uint8Array([3]));
+        forgedBytes.opbytes = signed.sbytes;
+        forgedBytes.opOb.signature = signed.prefixSig;
+        const opResponse = [];
+        const results = await this.rpc.preapplyOperations([forgedBytes.opOb]);
+        if (!Array.isArray(results)) {
+            throw new errors_1.TezosPreapplyFailureError(results);
+        }
+        for (let i = 0; i < results.length; i++) {
+            for (let j = 0; j < results[i].contents.length; j++) {
+                opResponse.push(results[i].contents[j]);
             }
-            return {
-                hash: yield this.context.injector.inject(forgedBytes.opbytes),
-                forgedBytes,
-                opResponse,
-                context: this.context.clone(),
-            };
-        });
+        }
+        const errors = (0, errors_1.flattenErrors)(results);
+        if (errors.length) {
+            throw new errors_1.TezosOperationError(errors, 'Error occurred during validation simulation of operation', opResponse);
+        }
+        return {
+            hash: await this.context.injector.inject(forgedBytes.opbytes),
+            forgedBytes,
+            opResponse,
+            context: this.context.clone(),
+        };
     }
 }
 exports.Provider = Provider;