@taquito/taquito 24.3.1-beta.1 → 25.0.0-rc.1

package/README.md

@@ -7,7 +7,7 @@ The `@taquito/taquito` package contains higher-level functionality that builds u
 ## CDN Bundle
 
 ```html
-<script src="https://unpkg.com/@taquito/taquito@24.3.1-beta.1/dist/taquito.min.js"
+<script src="https://unpkg.com/@taquito/taquito@25.0.0-rc.1/dist/taquito.min.js"
 crossorigin="anonymous" integrity="sha384-IxvP0ECHi5oqLyz94wF85pU9+ktcsL1HHtA42MITxZsGbsUMEu/g+0Vkjj5vqiMR"></script>
 ```
 

package/dist/lib/constants.js

@@ -49,6 +49,7 @@ var Protocols;
     Protocols["PsRiotuma"] = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7";
     Protocols["PtSeouLou"] = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh";
     Protocols["PtTALLiNt"] = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu";
+    Protocols["PsUshuai9"] = "PsUshuai9QapM5TGj1JpuVGkdxz5GykdnEvS6Rh8SUVrARvZLCY";
     Protocols["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(Protocols || (exports.Protocols = Protocols = {}));
 exports.protocols = {
@@ -72,7 +73,8 @@ exports.protocols = {
     '022': [Protocols.PsRiotuma],
     '023': [Protocols.PtSeouLou],
     '024': [Protocols.PtTALLiNt],
-    '025': [Protocols.ProtoALpha],
+    '025': [Protocols.PsUshuai9],
+    '026': [Protocols.ProtoALpha],
 };
 var ChainIds;
 (function (ChainIds) {
@@ -99,6 +101,7 @@ var ChainIds;
     ChainIds["RIONET"] = "NetXPdgaoabtBth";
     ChainIds["SEOULNET"] = "NetXd56aBs1aeW3";
     ChainIds["TALLINNNET"] = "NetXe8DbhW9A1eS";
+    ChainIds["USHUAIANET"] = "NetXpX8WSZkAZZA";
 })(ChainIds || (exports.ChainIds = ChainIds = {}));
 const getRevealGasLimit = (address) => Math.round((getRevealGasLimitInternal(address) * 37) / 10);
 exports.getRevealGasLimit = getRevealGasLimit;

package/dist/lib/estimate/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RevealEstimateError = void 0;
+exports.BatchGasLimitExceededError = exports.RevealEstimateError = void 0;
 const core_1 = require("@taquito/core");
 /**
  *  @category Error
@@ -14,3 +14,13 @@ class RevealEstimateError extends core_1.TaquitoError {
     }
 }
 exports.RevealEstimateError = RevealEstimateError;
+class BatchGasLimitExceededError extends core_1.TaquitoError {
+    constructor(requiredGasLimit, hardGasLimitPerBlock) {
+        super();
+        this.requiredGasLimit = requiredGasLimit;
+        this.hardGasLimitPerBlock = hardGasLimitPerBlock;
+        this.name = 'BatchGasLimitExceededError';
+        this.message = `Batch gas estimation requires at least ${requiredGasLimit} gas, which exceeds the per-block limit of ${hardGasLimitPerBlock}. Split the batch into smaller operations.`;
+    }
+}
+exports.BatchGasLimitExceededError = BatchGasLimitExceededError;

package/dist/lib/estimate/rpc-estimate-provider.js

@@ -28,6 +28,7 @@ class RPCEstimateProvider extends provider_1.Provider {
         this.REVEAL_LENGTH_TZ4 = 622; // injecting size tz4=620
         this.MILLIGAS_BUFFER = 100 * 1000; // 100 buffer depends on operation kind
         this.STORAGE_BUFFER = 20; // according to octez-client
+        this.UNKNOWN_GAS_LIMIT_PER_OPERATION = 1000;
         this.prepare = new prepare_provider_1.PrepareProvider(this.context);
     }
     async getKeys() {
@@ -85,6 +86,129 @@ class RPCEstimateProvider extends provider_1.Provider {
             };
         }
     }
+    hasOperationGasExhausted(errors) {
+        return errors.some((error) => error.id.endsWith('gas_exhausted.operation'));
+    }
+    getOperationResult(content) {
+        return content?.metadata?.operation_result;
+    }
+    getInternalOperationResults(content) {
+        const internalResults = content?.metadata?.internal_operation_results;
+        return Array.isArray(internalResults) ? internalResults : [];
+    }
+    operationResultHasGasExhausted(result) {
+        return Array.isArray(result?.errors)
+            ? result.errors.some((error) => error.id?.endsWith('gas_exhausted.operation'))
+            : false;
+    }
+    findGasExhaustedContentIndex(contents) {
+        const directFailureIndex = contents.findIndex((content) => this.operationResultHasGasExhausted(this.getOperationResult(content)));
+        if (directFailureIndex !== -1) {
+            return directFailureIndex;
+        }
+        const internalFailureIndex = contents.findIndex((content) => this.getInternalOperationResults(content).some((internalResult) => this.operationResultHasGasExhausted(internalResult.result)));
+        if (internalFailureIndex !== -1) {
+            return internalFailureIndex;
+        }
+        const firstSkippedIndex = contents.findIndex((content) => this.getOperationResult(content)?.status === 'skipped');
+        return firstSkippedIndex > 0 ? firstSkippedIndex - 1 : -1;
+    }
+    getContentGasLimit(content) {
+        const gasLimit = Number(content?.gas_limit);
+        return Number.isFinite(gasLimit) && gasLimit >= 0 ? gasLimit : 0;
+    }
+    getMeasuredGasLimit(content, hardGasLimitPerOperation) {
+        const operationResults = (0, errors_1.flattenOperationResult)({ contents: [content] });
+        const consumedMilligas = operationResults.reduce((total, result) => total + (Number(result.consumed_milligas) || 0), 0);
+        if (consumedMilligas <= 0) {
+            return;
+        }
+        const safetyGas = (0, types_1.isOpWithGasBuffer)(content) ? this.MILLIGAS_BUFFER / 1000 : 0;
+        return Math.min(Math.ceil(consumedMilligas / 1000) + safetyGas, hardGasLimitPerOperation);
+    }
+    rebalanceGasLimits(op, opResponse, preparedOperation, constants) {
+        const hardGasLimitPerOperation = Number(constants.hard_gas_limit_per_operation);
+        const hardGasLimitPerBlock = Number(constants.hard_gas_limit_per_block);
+        const patchableIndexes = preparedOperation.simulation?.gasLimitPatchableIndexes?.filter((index) => index >= 0 && index < opResponse.contents.length);
+        if (!Array.isArray(op.operation.contents) ||
+            !patchableIndexes?.length ||
+            !Number.isFinite(hardGasLimitPerOperation) ||
+            !Number.isFinite(hardGasLimitPerBlock)) {
+            return;
+        }
+        const responseContents = opResponse.contents;
+        const starvedIndex = this.findGasExhaustedContentIndex(responseContents);
+        if (starvedIndex === -1 || !patchableIndexes.includes(starvedIndex)) {
+            return;
+        }
+        const patchableIndexSet = new Set(patchableIndexes);
+        const contents = op.operation.contents.map((content) => ({
+            ...content,
+        }));
+        const patchedGasLimits = new Map();
+        let fixedGasTotal = 0;
+        let measuredGasTotal = 0;
+        const unknownPatchableIndexes = [];
+        for (const [index, content] of responseContents.entries()) {
+            if (!patchableIndexSet.has(index)) {
+                fixedGasTotal += this.getContentGasLimit(contents[index]);
+                continue;
+            }
+            if (index === starvedIndex) {
+                continue;
+            }
+            const status = this.getOperationResult(content)?.status;
+            const measuredGasLimit = status === 'applied' || status === 'backtracked'
+                ? this.getMeasuredGasLimit(content, hardGasLimitPerOperation)
+                : undefined;
+            if (typeof measuredGasLimit === 'number') {
+                patchedGasLimits.set(index, measuredGasLimit);
+                measuredGasTotal += measuredGasLimit;
+            }
+            else {
+                unknownPatchableIndexes.push(index);
+            }
+        }
+        const requiredKnownGas = fixedGasTotal + measuredGasTotal;
+        if (requiredKnownGas > hardGasLimitPerBlock) {
+            throw new errors_2.BatchGasLimitExceededError(requiredKnownGas, hardGasLimitPerBlock);
+        }
+        const gasAvailableAfterKnown = hardGasLimitPerBlock - requiredKnownGas;
+        const minimumUnknownGas = unknownPatchableIndexes.length + 1;
+        if (gasAvailableAfterKnown < minimumUnknownGas) {
+            throw new errors_2.BatchGasLimitExceededError(requiredKnownGas + minimumUnknownGas, hardGasLimitPerBlock);
+        }
+        const unknownGasLimit = unknownPatchableIndexes.length > 0
+            ? Math.min(this.UNKNOWN_GAS_LIMIT_PER_OPERATION, Math.floor((gasAvailableAfterKnown - 1) / unknownPatchableIndexes.length))
+            : 0;
+        const gasReservedForUnknown = unknownGasLimit * unknownPatchableIndexes.length;
+        const starvedGasLimit = Math.min(hardGasLimitPerOperation, gasAvailableAfterKnown - gasReservedForUnknown);
+        if (starvedGasLimit <= 0) {
+            return;
+        }
+        patchedGasLimits.set(starvedIndex, starvedGasLimit);
+        for (const index of unknownPatchableIndexes) {
+            patchedGasLimits.set(index, unknownGasLimit);
+        }
+        let patched = false;
+        for (const [index, gasLimit] of patchedGasLimits.entries()) {
+            if (this.getContentGasLimit(contents[index]) === gasLimit) {
+                continue;
+            }
+            contents[index].gas_limit = gasLimit.toString();
+            patched = true;
+        }
+        if (!patched) {
+            return;
+        }
+        return {
+            ...op,
+            operation: {
+                ...op.operation,
+                contents: contents,
+            },
+        };
+    }
     async calculateEstimates(op, constants) {
         let feeParams = estimate_1.DEFAULT_FEE_PARAMS;
         try {
@@ -97,24 +221,61 @@ class RPCEstimateProvider extends provider_1.Provider {
         catch {
             // Fall back to L1 defaults when the endpoint is missing or unavailable.
         }
-        const { opbytes, opOb: { branch, contents }, } = await this.forge(op);
+        const forgedOperation = await this.forge(op);
+        const { opbytes: initialOpBytes, opOb: { branch, contents }, } = forgedOperation;
         const operation = {
             operation: { branch, contents, signature: STUB_SIGNATURE },
             chain_id: await this.context.readProvider.getChainId(),
         };
-        const { opResponse } = await this.simulate(operation, op);
-        const { cost_per_byte, origination_size } = constants;
-        const errors = [...(0, errors_1.flattenErrors)(opResponse, 'backtracked'), ...(0, errors_1.flattenErrors)(opResponse)];
-        // Fail early in case of errors
-        if (errors.length) {
-            throw new errors_1.TezosOperationError(errors, 'Error occurred during estimation', opResponse.contents);
+        let currentOperation = operation;
+        let opResponse;
+        let simulatedOperation;
+        let opbytes = initialOpBytes;
+        let lastError;
+        const maxRebalanceAttempts = (op.simulation?.gasLimitPatchableIndexes?.length ?? 0) + 1;
+        for (let attempt = 0; attempt <= maxRebalanceAttempts; attempt++) {
+            // Keep PreparedOperation on attempt 0 for provider-level block/counter recovery. Rebalance
+            // retries intentionally omit it so patchSimulationGasLimits cannot restore the even split.
+            const simulated = await this.simulate(currentOperation, attempt === 0 ? op : undefined);
+            opResponse = simulated.opResponse;
+            simulatedOperation = simulated.op;
+            currentOperation = simulated.op;
+            const errors = [...(0, errors_1.flattenErrors)(opResponse, 'backtracked'), ...(0, errors_1.flattenErrors)(opResponse)];
+            if (errors.length === 0) {
+                break;
+            }
+            lastError = new errors_1.TezosOperationError(errors, 'Error occurred during estimation', opResponse.contents);
+            if (!this.hasOperationGasExhausted(errors)) {
+                throw lastError;
+            }
+            const rebalancedOperation = this.rebalanceGasLimits(currentOperation, opResponse, op, constants);
+            if (!rebalancedOperation || attempt === maxRebalanceAttempts) {
+                throw lastError;
+            }
+            currentOperation = rebalancedOperation;
+            opResponse = undefined;
+            simulatedOperation = undefined;
+        }
+        if (!opResponse || !simulatedOperation) {
+            throw lastError ?? new Error('Unable to simulate operation for estimation');
         }
+        if (simulatedOperation !== operation) {
+            if (!simulatedOperation.operation.branch) {
+                throw new Error('Unable to reforge simulated operation without a branch');
+            }
+            opbytes = await this.context.forger.forge({
+                branch: simulatedOperation.operation.branch,
+                contents: simulatedOperation.operation.contents,
+            });
+        }
+        const { cost_per_byte, origination_size } = constants;
         let numberOfOps = 1;
-        if (Array.isArray(op.opOb.contents) && op.opOb.contents.length > 1) {
+        if (Array.isArray(simulatedOperation.operation.contents) &&
+            simulatedOperation.operation.contents.length > 1) {
             numberOfOps =
                 opResponse.contents[0].kind === 'reveal'
-                    ? op.opOb.contents.length - 1
-                    : op.opOb.contents.length;
+                    ? simulatedOperation.operation.contents.length - 1
+                    : simulatedOperation.operation.contents.length;
         }
         return opResponse.contents.map((x) => {
             const content = x;

package/dist/lib/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 exports.VERSION = {
-    "commitHash": "9647402fcc62c98bf3907a30214fea8871b30bea",
-    "version": "24.3.1-beta.1"
+    "commitHash": "13f62cd47ea018312f100b660d0225604c757afa",
+    "version": "25.0.0-rc.1"
 };

package/dist/taquito.es6.js

@@ -219,6 +219,7 @@ var Protocols;
     Protocols["PsRiotuma"] = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7";
     Protocols["PtSeouLou"] = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh";
     Protocols["PtTALLiNt"] = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu";
+    Protocols["PsUshuai9"] = "PsUshuai9QapM5TGj1JpuVGkdxz5GykdnEvS6Rh8SUVrARvZLCY";
     Protocols["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(Protocols || (Protocols = {}));
 const protocols = {
@@ -242,7 +243,8 @@ const protocols = {
     '022': [Protocols.PsRiotuma],
     '023': [Protocols.PtSeouLou],
     '024': [Protocols.PtTALLiNt],
-    '025': [Protocols.ProtoALpha],
+    '025': [Protocols.PsUshuai9],
+    '026': [Protocols.ProtoALpha],
 };
 var ChainIds;
 (function (ChainIds) {
@@ -269,6 +271,7 @@ var ChainIds;
     ChainIds["RIONET"] = "NetXPdgaoabtBth";
     ChainIds["SEOULNET"] = "NetXd56aBs1aeW3";
     ChainIds["TALLINNNET"] = "NetXe8DbhW9A1eS";
+    ChainIds["USHUAIANET"] = "NetXpX8WSZkAZZA";
 })(ChainIds || (ChainIds = {}));
 const getRevealGasLimit = (address) => Math.round((getRevealGasLimitInternal(address) * 37) / 10);
 const getRevealGasLimitInternal = (address) => {
@@ -3886,6 +3889,15 @@ class RevealEstimateError extends TaquitoError {
         this.message = 'Public key is unknown, unable to estimate the reveal operation in Wallet API.';
     }
 }
+class BatchGasLimitExceededError extends TaquitoError {
+    constructor(requiredGasLimit, hardGasLimitPerBlock) {
+        super();
+        this.requiredGasLimit = requiredGasLimit;
+        this.hardGasLimitPerBlock = hardGasLimitPerBlock;
+        this.name = 'BatchGasLimitExceededError';
+        this.message = `Batch gas estimation requires at least ${requiredGasLimit} gas, which exceeds the per-block limit of ${hardGasLimitPerBlock}. Split the batch into smaller operations.`;
+    }
+}
 
 // stub signature that won't be verified by tezos rpc simulate_operation
 const STUB_SIGNATURE = 'edsigtkpiSSschcaCt9pUVrpNPf7TTcgvgDEDD6NCEHMy8NNQJCGnMfLZzYoQj74yLjo9wx6MPVV29CvVzgi7qEcEUok3k7AuMg';
@@ -3904,6 +3916,7 @@ class RPCEstimateProvider extends Provider {
         this.REVEAL_LENGTH_TZ4 = 622; // injecting size tz4=620
         this.MILLIGAS_BUFFER = 100 * 1000; // 100 buffer depends on operation kind
         this.STORAGE_BUFFER = 20; // according to octez-client
+        this.UNKNOWN_GAS_LIMIT_PER_OPERATION = 1000;
         this.prepare = new PrepareProvider(this.context);
     }
     async getKeys() {
@@ -3961,6 +3974,129 @@ class RPCEstimateProvider extends Provider {
             };
         }
     }
+    hasOperationGasExhausted(errors) {
+        return errors.some((error) => error.id.endsWith('gas_exhausted.operation'));
+    }
+    getOperationResult(content) {
+        return content?.metadata?.operation_result;
+    }
+    getInternalOperationResults(content) {
+        const internalResults = content?.metadata?.internal_operation_results;
+        return Array.isArray(internalResults) ? internalResults : [];
+    }
+    operationResultHasGasExhausted(result) {
+        return Array.isArray(result?.errors)
+            ? result.errors.some((error) => error.id?.endsWith('gas_exhausted.operation'))
+            : false;
+    }
+    findGasExhaustedContentIndex(contents) {
+        const directFailureIndex = contents.findIndex((content) => this.operationResultHasGasExhausted(this.getOperationResult(content)));
+        if (directFailureIndex !== -1) {
+            return directFailureIndex;
+        }
+        const internalFailureIndex = contents.findIndex((content) => this.getInternalOperationResults(content).some((internalResult) => this.operationResultHasGasExhausted(internalResult.result)));
+        if (internalFailureIndex !== -1) {
+            return internalFailureIndex;
+        }
+        const firstSkippedIndex = contents.findIndex((content) => this.getOperationResult(content)?.status === 'skipped');
+        return firstSkippedIndex > 0 ? firstSkippedIndex - 1 : -1;
+    }
+    getContentGasLimit(content) {
+        const gasLimit = Number(content?.gas_limit);
+        return Number.isFinite(gasLimit) && gasLimit >= 0 ? gasLimit : 0;
+    }
+    getMeasuredGasLimit(content, hardGasLimitPerOperation) {
+        const operationResults = flattenOperationResult({ contents: [content] });
+        const consumedMilligas = operationResults.reduce((total, result) => total + (Number(result.consumed_milligas) || 0), 0);
+        if (consumedMilligas <= 0) {
+            return;
+        }
+        const safetyGas = isOpWithGasBuffer(content) ? this.MILLIGAS_BUFFER / 1000 : 0;
+        return Math.min(Math.ceil(consumedMilligas / 1000) + safetyGas, hardGasLimitPerOperation);
+    }
+    rebalanceGasLimits(op, opResponse, preparedOperation, constants) {
+        const hardGasLimitPerOperation = Number(constants.hard_gas_limit_per_operation);
+        const hardGasLimitPerBlock = Number(constants.hard_gas_limit_per_block);
+        const patchableIndexes = preparedOperation.simulation?.gasLimitPatchableIndexes?.filter((index) => index >= 0 && index < opResponse.contents.length);
+        if (!Array.isArray(op.operation.contents) ||
+            !patchableIndexes?.length ||
+            !Number.isFinite(hardGasLimitPerOperation) ||
+            !Number.isFinite(hardGasLimitPerBlock)) {
+            return;
+        }
+        const responseContents = opResponse.contents;
+        const starvedIndex = this.findGasExhaustedContentIndex(responseContents);
+        if (starvedIndex === -1 || !patchableIndexes.includes(starvedIndex)) {
+            return;
+        }
+        const patchableIndexSet = new Set(patchableIndexes);
+        const contents = op.operation.contents.map((content) => ({
+            ...content,
+        }));
+        const patchedGasLimits = new Map();
+        let fixedGasTotal = 0;
+        let measuredGasTotal = 0;
+        const unknownPatchableIndexes = [];
+        for (const [index, content] of responseContents.entries()) {
+            if (!patchableIndexSet.has(index)) {
+                fixedGasTotal += this.getContentGasLimit(contents[index]);
+                continue;
+            }
+            if (index === starvedIndex) {
+                continue;
+            }
+            const status = this.getOperationResult(content)?.status;
+            const measuredGasLimit = status === 'applied' || status === 'backtracked'
+                ? this.getMeasuredGasLimit(content, hardGasLimitPerOperation)
+                : undefined;
+            if (typeof measuredGasLimit === 'number') {
+                patchedGasLimits.set(index, measuredGasLimit);
+                measuredGasTotal += measuredGasLimit;
+            }
+            else {
+                unknownPatchableIndexes.push(index);
+            }
+        }
+        const requiredKnownGas = fixedGasTotal + measuredGasTotal;
+        if (requiredKnownGas > hardGasLimitPerBlock) {
+            throw new BatchGasLimitExceededError(requiredKnownGas, hardGasLimitPerBlock);
+        }
+        const gasAvailableAfterKnown = hardGasLimitPerBlock - requiredKnownGas;
+        const minimumUnknownGas = unknownPatchableIndexes.length + 1;
+        if (gasAvailableAfterKnown < minimumUnknownGas) {
+            throw new BatchGasLimitExceededError(requiredKnownGas + minimumUnknownGas, hardGasLimitPerBlock);
+        }
+        const unknownGasLimit = unknownPatchableIndexes.length > 0
+            ? Math.min(this.UNKNOWN_GAS_LIMIT_PER_OPERATION, Math.floor((gasAvailableAfterKnown - 1) / unknownPatchableIndexes.length))
+            : 0;
+        const gasReservedForUnknown = unknownGasLimit * unknownPatchableIndexes.length;
+        const starvedGasLimit = Math.min(hardGasLimitPerOperation, gasAvailableAfterKnown - gasReservedForUnknown);
+        if (starvedGasLimit <= 0) {
+            return;
+        }
+        patchedGasLimits.set(starvedIndex, starvedGasLimit);
+        for (const index of unknownPatchableIndexes) {
+            patchedGasLimits.set(index, unknownGasLimit);
+        }
+        let patched = false;
+        for (const [index, gasLimit] of patchedGasLimits.entries()) {
+            if (this.getContentGasLimit(contents[index]) === gasLimit) {
+                continue;
+            }
+            contents[index].gas_limit = gasLimit.toString();
+            patched = true;
+        }
+        if (!patched) {
+            return;
+        }
+        return {
+            ...op,
+            operation: {
+                ...op.operation,
+                contents: contents,
+            },
+        };
+    }
     async calculateEstimates(op, constants) {
         let feeParams = DEFAULT_FEE_PARAMS;
         try {
@@ -3973,24 +4109,61 @@ class RPCEstimateProvider extends Provider {
         catch {
             // Fall back to L1 defaults when the endpoint is missing or unavailable.
         }
-        const { opbytes, opOb: { branch, contents }, } = await this.forge(op);
+        const forgedOperation = await this.forge(op);
+        const { opbytes: initialOpBytes, opOb: { branch, contents }, } = forgedOperation;
         const operation = {
             operation: { branch, contents, signature: STUB_SIGNATURE },
             chain_id: await this.context.readProvider.getChainId(),
         };
-        const { opResponse } = await this.simulate(operation, op);
-        const { cost_per_byte, origination_size } = constants;
-        const errors = [...flattenErrors(opResponse, 'backtracked'), ...flattenErrors(opResponse)];
-        // Fail early in case of errors
-        if (errors.length) {
-            throw new TezosOperationError(errors, 'Error occurred during estimation', opResponse.contents);
+        let currentOperation = operation;
+        let opResponse;
+        let simulatedOperation;
+        let opbytes = initialOpBytes;
+        let lastError;
+        const maxRebalanceAttempts = (op.simulation?.gasLimitPatchableIndexes?.length ?? 0) + 1;
+        for (let attempt = 0; attempt <= maxRebalanceAttempts; attempt++) {
+            // Keep PreparedOperation on attempt 0 for provider-level block/counter recovery. Rebalance
+            // retries intentionally omit it so patchSimulationGasLimits cannot restore the even split.
+            const simulated = await this.simulate(currentOperation, attempt === 0 ? op : undefined);
+            opResponse = simulated.opResponse;
+            simulatedOperation = simulated.op;
+            currentOperation = simulated.op;
+            const errors = [...flattenErrors(opResponse, 'backtracked'), ...flattenErrors(opResponse)];
+            if (errors.length === 0) {
+                break;
+            }
+            lastError = new TezosOperationError(errors, 'Error occurred during estimation', opResponse.contents);
+            if (!this.hasOperationGasExhausted(errors)) {
+                throw lastError;
+            }
+            const rebalancedOperation = this.rebalanceGasLimits(currentOperation, opResponse, op, constants);
+            if (!rebalancedOperation || attempt === maxRebalanceAttempts) {
+                throw lastError;
+            }
+            currentOperation = rebalancedOperation;
+            opResponse = undefined;
+            simulatedOperation = undefined;
         }
+        if (!opResponse || !simulatedOperation) {
+            throw lastError ?? new Error('Unable to simulate operation for estimation');
+        }
+        if (simulatedOperation !== operation) {
+            if (!simulatedOperation.operation.branch) {
+                throw new Error('Unable to reforge simulated operation without a branch');
+            }
+            opbytes = await this.context.forger.forge({
+                branch: simulatedOperation.operation.branch,
+                contents: simulatedOperation.operation.contents,
+            });
+        }
+        const { cost_per_byte, origination_size } = constants;
         let numberOfOps = 1;
-        if (Array.isArray(op.opOb.contents) && op.opOb.contents.length > 1) {
+        if (Array.isArray(simulatedOperation.operation.contents) &&
+            simulatedOperation.operation.contents.length > 1) {
             numberOfOps =
                 opResponse.contents[0].kind === 'reveal'
-                    ? op.opOb.contents.length - 1
-                    : op.opOb.contents.length;
+                    ? simulatedOperation.operation.contents.length - 1
+                    : simulatedOperation.operation.contents.length;
         }
         return opResponse.contents.map((x) => {
             const content = x;
@@ -7575,8 +7748,8 @@ class Context {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 const VERSION = {
-    "commitHash": "9647402fcc62c98bf3907a30214fea8871b30bea",
-    "version": "24.3.1-beta.1"
+    "commitHash": "13f62cd47ea018312f100b660d0225604c757afa",
+    "version": "25.0.0-rc.1"
 };
 
 /**
@@ -8052,5 +8225,5 @@ class TezosToolkit {
     }
 }
 
-export { BallotOperation, BatchOperation, BigMapAbstraction, COST_PER_BYTE, ChainIds, CompositeForger, Context, ContractAbstraction, ContractMethodObject, ContractView, DEFAULT_FEE_PARAMS, DEFAULT_SMART_CONTRACT_METHOD_NAME, DefaultGlobalConstantsProvider, DelegateOperation, DelegationWalletOperation, DrainDelegateOperation, Estimate, GlobalConstantNotFound, IncreasePaidStorageOperation, InvalidBalanceError, InvalidCodeParameter, InvalidDelegationSource, InvalidEstimateValueError, InvalidInitParameter, InvalidParameterError, InvalidViewSimulationContext, LegacyWalletProvider, MANAGER_LAMBDA, MichelCodecPacker, MichelCodecParser, NoopParser, ORIGINATION_SIZE, ObservableSubscription, Operation, OperationBatch, OriginationOperation, OriginationParameterError, OriginationWalletOperation, PollingSubscribeProvider, PrepareProvider, ProposalsOperation, Protocols, REVEAL_STORAGE_LIMIT, RPCEstimateProvider, RegisterGlobalConstantOperation, RegisterGlobalConstantWalletOperation, RevealEstimateError, RevealOperation, RevealOperationError, RpcForger, RpcInjector, RpcPacker, RpcReadAdapter, SaplingStateAbstraction, SmartRollupAddMessagesOperation, SmartRollupOriginateOperation, TaquitoLocalForger, TezosOperationError, TezosPreapplyFailureError, TezosToolkit, TransactionOperation, TransactionWalletOperation, TransferTicketOperation, TransferTicketWalletOperation, UnconfiguredGlobalConstantsProviderError, UpdateCompanionKeyOperation, UpdateConsensusKeyOperation, VIEW_LAMBDA, ViewSimulationError, Wallet, WalletOperation, WalletOperationBatch, attachKind, compose, createActivationOperation, createBallotOperation, createDrainDelegateOperation, createIncreasePaidStorageOperation, createOriginationOperation, createProposalsOperation, createRegisterDelegateOperation, createRegisterGlobalConstantOperation, createRevealOperation, createSetDelegateOperation, createSmartRollupAddMessagesOperation, createSmartRollupExecuteOutboxMessageOperation, createSmartRollupOriginateOperation, createTransferOperation, createTransferTicketOperation, createUpdateCompanionKeyOperation, createUpdateConsensusKeyOperation, defaultConfigConfirmation, feeParamsFromMempoolFilter, findWithKind, getRevealFee, getRevealFeeInternal, getRevealGasLimit, hasMetadata, hasMetadataWithInternalOperationResult, hasMetadataWithResult, importKey, isKind, isOpRequireReveal, isOpWithFee, isOpWithGasBuffer, isSourceOp, protocols, smartContractAbstractionSemantic, validateAndExtractFailwith };
+export { BallotOperation, BatchGasLimitExceededError, BatchOperation, BigMapAbstraction, COST_PER_BYTE, ChainIds, CompositeForger, Context, ContractAbstraction, ContractMethodObject, ContractView, DEFAULT_FEE_PARAMS, DEFAULT_SMART_CONTRACT_METHOD_NAME, DefaultGlobalConstantsProvider, DelegateOperation, DelegationWalletOperation, DrainDelegateOperation, Estimate, GlobalConstantNotFound, IncreasePaidStorageOperation, InvalidBalanceError, InvalidCodeParameter, InvalidDelegationSource, InvalidEstimateValueError, InvalidInitParameter, InvalidParameterError, InvalidViewSimulationContext, LegacyWalletProvider, MANAGER_LAMBDA, MichelCodecPacker, MichelCodecParser, NoopParser, ORIGINATION_SIZE, ObservableSubscription, Operation, OperationBatch, OriginationOperation, OriginationParameterError, OriginationWalletOperation, PollingSubscribeProvider, PrepareProvider, ProposalsOperation, Protocols, REVEAL_STORAGE_LIMIT, RPCEstimateProvider, RegisterGlobalConstantOperation, RegisterGlobalConstantWalletOperation, RevealEstimateError, RevealOperation, RevealOperationError, RpcForger, RpcInjector, RpcPacker, RpcReadAdapter, SaplingStateAbstraction, SmartRollupAddMessagesOperation, SmartRollupOriginateOperation, TaquitoLocalForger, TezosOperationError, TezosPreapplyFailureError, TezosToolkit, TransactionOperation, TransactionWalletOperation, TransferTicketOperation, TransferTicketWalletOperation, UnconfiguredGlobalConstantsProviderError, UpdateCompanionKeyOperation, UpdateConsensusKeyOperation, VIEW_LAMBDA, ViewSimulationError, Wallet, WalletOperation, WalletOperationBatch, attachKind, compose, createActivationOperation, createBallotOperation, createDrainDelegateOperation, createIncreasePaidStorageOperation, createOriginationOperation, createProposalsOperation, createRegisterDelegateOperation, createRegisterGlobalConstantOperation, createRevealOperation, createSetDelegateOperation, createSmartRollupAddMessagesOperation, createSmartRollupExecuteOutboxMessageOperation, createSmartRollupOriginateOperation, createTransferOperation, createTransferTicketOperation, createUpdateCompanionKeyOperation, createUpdateConsensusKeyOperation, defaultConfigConfirmation, feeParamsFromMempoolFilter, findWithKind, getRevealFee, getRevealFeeInternal, getRevealGasLimit, hasMetadata, hasMetadataWithInternalOperationResult, hasMetadataWithResult, importKey, isKind, isOpRequireReveal, isOpWithFee, isOpWithGasBuffer, isSourceOp, protocols, smartContractAbstractionSemantic, validateAndExtractFailwith };
 //# sourceMappingURL=taquito.es6.js.map

package/dist/taquito.es6.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}