@taquito/taquito 25.0.0-beta.1 → 25.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/lib/estimate/errors.js +11 -1
- package/dist/lib/estimate/rpc-estimate-provider.js +171 -10
- package/dist/lib/version.js +2 -2
- package/dist/taquito.es6.js +183 -13
- package/dist/taquito.es6.js.map +1 -1
- package/dist/taquito.min.js +1 -1
- package/dist/taquito.min.js.LICENSE.txt +0 -2
- package/dist/taquito.umd.js +183 -12
- package/dist/taquito.umd.js.map +1 -1
- package/dist/types/estimate/errors.d.ts +5 -0
- package/dist/types/estimate/rpc-estimate-provider.d.ts +9 -0
- package/package.json +9 -9
package/dist/taquito.umd.js
CHANGED
|
@@ -3881,6 +3881,15 @@
|
|
|
3881
3881
|
this.message = 'Public key is unknown, unable to estimate the reveal operation in Wallet API.';
|
|
3882
3882
|
}
|
|
3883
3883
|
}
|
|
3884
|
+
class BatchGasLimitExceededError extends core.TaquitoError {
|
|
3885
|
+
constructor(requiredGasLimit, hardGasLimitPerBlock) {
|
|
3886
|
+
super();
|
|
3887
|
+
this.requiredGasLimit = requiredGasLimit;
|
|
3888
|
+
this.hardGasLimitPerBlock = hardGasLimitPerBlock;
|
|
3889
|
+
this.name = 'BatchGasLimitExceededError';
|
|
3890
|
+
this.message = `Batch gas estimation requires at least ${requiredGasLimit} gas, which exceeds the per-block limit of ${hardGasLimitPerBlock}. Split the batch into smaller operations.`;
|
|
3891
|
+
}
|
|
3892
|
+
}
|
|
3884
3893
|
|
|
3885
3894
|
// stub signature that won't be verified by tezos rpc simulate_operation
|
|
3886
3895
|
const STUB_SIGNATURE = 'edsigtkpiSSschcaCt9pUVrpNPf7TTcgvgDEDD6NCEHMy8NNQJCGnMfLZzYoQj74yLjo9wx6MPVV29CvVzgi7qEcEUok3k7AuMg';
|
|
@@ -3899,6 +3908,7 @@
|
|
|
3899
3908
|
this.REVEAL_LENGTH_TZ4 = 622; // injecting size tz4=620
|
|
3900
3909
|
this.MILLIGAS_BUFFER = 100 * 1000; // 100 buffer depends on operation kind
|
|
3901
3910
|
this.STORAGE_BUFFER = 20; // according to octez-client
|
|
3911
|
+
this.UNKNOWN_GAS_LIMIT_PER_OPERATION = 1000;
|
|
3902
3912
|
this.prepare = new PrepareProvider(this.context);
|
|
3903
3913
|
}
|
|
3904
3914
|
async getKeys() {
|
|
@@ -3956,6 +3966,129 @@
|
|
|
3956
3966
|
};
|
|
3957
3967
|
}
|
|
3958
3968
|
}
|
|
3969
|
+
hasOperationGasExhausted(errors) {
|
|
3970
|
+
return errors.some((error) => error.id.endsWith('gas_exhausted.operation'));
|
|
3971
|
+
}
|
|
3972
|
+
getOperationResult(content) {
|
|
3973
|
+
return content?.metadata?.operation_result;
|
|
3974
|
+
}
|
|
3975
|
+
getInternalOperationResults(content) {
|
|
3976
|
+
const internalResults = content?.metadata?.internal_operation_results;
|
|
3977
|
+
return Array.isArray(internalResults) ? internalResults : [];
|
|
3978
|
+
}
|
|
3979
|
+
operationResultHasGasExhausted(result) {
|
|
3980
|
+
return Array.isArray(result?.errors)
|
|
3981
|
+
? result.errors.some((error) => error.id?.endsWith('gas_exhausted.operation'))
|
|
3982
|
+
: false;
|
|
3983
|
+
}
|
|
3984
|
+
findGasExhaustedContentIndex(contents) {
|
|
3985
|
+
const directFailureIndex = contents.findIndex((content) => this.operationResultHasGasExhausted(this.getOperationResult(content)));
|
|
3986
|
+
if (directFailureIndex !== -1) {
|
|
3987
|
+
return directFailureIndex;
|
|
3988
|
+
}
|
|
3989
|
+
const internalFailureIndex = contents.findIndex((content) => this.getInternalOperationResults(content).some((internalResult) => this.operationResultHasGasExhausted(internalResult.result)));
|
|
3990
|
+
if (internalFailureIndex !== -1) {
|
|
3991
|
+
return internalFailureIndex;
|
|
3992
|
+
}
|
|
3993
|
+
const firstSkippedIndex = contents.findIndex((content) => this.getOperationResult(content)?.status === 'skipped');
|
|
3994
|
+
return firstSkippedIndex > 0 ? firstSkippedIndex - 1 : -1;
|
|
3995
|
+
}
|
|
3996
|
+
getContentGasLimit(content) {
|
|
3997
|
+
const gasLimit = Number(content?.gas_limit);
|
|
3998
|
+
return Number.isFinite(gasLimit) && gasLimit >= 0 ? gasLimit : 0;
|
|
3999
|
+
}
|
|
4000
|
+
getMeasuredGasLimit(content, hardGasLimitPerOperation) {
|
|
4001
|
+
const operationResults = flattenOperationResult({ contents: [content] });
|
|
4002
|
+
const consumedMilligas = operationResults.reduce((total, result) => total + (Number(result.consumed_milligas) || 0), 0);
|
|
4003
|
+
if (consumedMilligas <= 0) {
|
|
4004
|
+
return;
|
|
4005
|
+
}
|
|
4006
|
+
const safetyGas = isOpWithGasBuffer(content) ? this.MILLIGAS_BUFFER / 1000 : 0;
|
|
4007
|
+
return Math.min(Math.ceil(consumedMilligas / 1000) + safetyGas, hardGasLimitPerOperation);
|
|
4008
|
+
}
|
|
4009
|
+
rebalanceGasLimits(op, opResponse, preparedOperation, constants) {
|
|
4010
|
+
const hardGasLimitPerOperation = Number(constants.hard_gas_limit_per_operation);
|
|
4011
|
+
const hardGasLimitPerBlock = Number(constants.hard_gas_limit_per_block);
|
|
4012
|
+
const patchableIndexes = preparedOperation.simulation?.gasLimitPatchableIndexes?.filter((index) => index >= 0 && index < opResponse.contents.length);
|
|
4013
|
+
if (!Array.isArray(op.operation.contents) ||
|
|
4014
|
+
!patchableIndexes?.length ||
|
|
4015
|
+
!Number.isFinite(hardGasLimitPerOperation) ||
|
|
4016
|
+
!Number.isFinite(hardGasLimitPerBlock)) {
|
|
4017
|
+
return;
|
|
4018
|
+
}
|
|
4019
|
+
const responseContents = opResponse.contents;
|
|
4020
|
+
const starvedIndex = this.findGasExhaustedContentIndex(responseContents);
|
|
4021
|
+
if (starvedIndex === -1 || !patchableIndexes.includes(starvedIndex)) {
|
|
4022
|
+
return;
|
|
4023
|
+
}
|
|
4024
|
+
const patchableIndexSet = new Set(patchableIndexes);
|
|
4025
|
+
const contents = op.operation.contents.map((content) => ({
|
|
4026
|
+
...content,
|
|
4027
|
+
}));
|
|
4028
|
+
const patchedGasLimits = new Map();
|
|
4029
|
+
let fixedGasTotal = 0;
|
|
4030
|
+
let measuredGasTotal = 0;
|
|
4031
|
+
const unknownPatchableIndexes = [];
|
|
4032
|
+
for (const [index, content] of responseContents.entries()) {
|
|
4033
|
+
if (!patchableIndexSet.has(index)) {
|
|
4034
|
+
fixedGasTotal += this.getContentGasLimit(contents[index]);
|
|
4035
|
+
continue;
|
|
4036
|
+
}
|
|
4037
|
+
if (index === starvedIndex) {
|
|
4038
|
+
continue;
|
|
4039
|
+
}
|
|
4040
|
+
const status = this.getOperationResult(content)?.status;
|
|
4041
|
+
const measuredGasLimit = status === 'applied' || status === 'backtracked'
|
|
4042
|
+
? this.getMeasuredGasLimit(content, hardGasLimitPerOperation)
|
|
4043
|
+
: undefined;
|
|
4044
|
+
if (typeof measuredGasLimit === 'number') {
|
|
4045
|
+
patchedGasLimits.set(index, measuredGasLimit);
|
|
4046
|
+
measuredGasTotal += measuredGasLimit;
|
|
4047
|
+
}
|
|
4048
|
+
else {
|
|
4049
|
+
unknownPatchableIndexes.push(index);
|
|
4050
|
+
}
|
|
4051
|
+
}
|
|
4052
|
+
const requiredKnownGas = fixedGasTotal + measuredGasTotal;
|
|
4053
|
+
if (requiredKnownGas > hardGasLimitPerBlock) {
|
|
4054
|
+
throw new BatchGasLimitExceededError(requiredKnownGas, hardGasLimitPerBlock);
|
|
4055
|
+
}
|
|
4056
|
+
const gasAvailableAfterKnown = hardGasLimitPerBlock - requiredKnownGas;
|
|
4057
|
+
const minimumUnknownGas = unknownPatchableIndexes.length + 1;
|
|
4058
|
+
if (gasAvailableAfterKnown < minimumUnknownGas) {
|
|
4059
|
+
throw new BatchGasLimitExceededError(requiredKnownGas + minimumUnknownGas, hardGasLimitPerBlock);
|
|
4060
|
+
}
|
|
4061
|
+
const unknownGasLimit = unknownPatchableIndexes.length > 0
|
|
4062
|
+
? Math.min(this.UNKNOWN_GAS_LIMIT_PER_OPERATION, Math.floor((gasAvailableAfterKnown - 1) / unknownPatchableIndexes.length))
|
|
4063
|
+
: 0;
|
|
4064
|
+
const gasReservedForUnknown = unknownGasLimit * unknownPatchableIndexes.length;
|
|
4065
|
+
const starvedGasLimit = Math.min(hardGasLimitPerOperation, gasAvailableAfterKnown - gasReservedForUnknown);
|
|
4066
|
+
if (starvedGasLimit <= 0) {
|
|
4067
|
+
return;
|
|
4068
|
+
}
|
|
4069
|
+
patchedGasLimits.set(starvedIndex, starvedGasLimit);
|
|
4070
|
+
for (const index of unknownPatchableIndexes) {
|
|
4071
|
+
patchedGasLimits.set(index, unknownGasLimit);
|
|
4072
|
+
}
|
|
4073
|
+
let patched = false;
|
|
4074
|
+
for (const [index, gasLimit] of patchedGasLimits.entries()) {
|
|
4075
|
+
if (this.getContentGasLimit(contents[index]) === gasLimit) {
|
|
4076
|
+
continue;
|
|
4077
|
+
}
|
|
4078
|
+
contents[index].gas_limit = gasLimit.toString();
|
|
4079
|
+
patched = true;
|
|
4080
|
+
}
|
|
4081
|
+
if (!patched) {
|
|
4082
|
+
return;
|
|
4083
|
+
}
|
|
4084
|
+
return {
|
|
4085
|
+
...op,
|
|
4086
|
+
operation: {
|
|
4087
|
+
...op.operation,
|
|
4088
|
+
contents: contents,
|
|
4089
|
+
},
|
|
4090
|
+
};
|
|
4091
|
+
}
|
|
3959
4092
|
async calculateEstimates(op, constants) {
|
|
3960
4093
|
let feeParams = DEFAULT_FEE_PARAMS;
|
|
3961
4094
|
try {
|
|
@@ -3968,24 +4101,61 @@
|
|
|
3968
4101
|
catch {
|
|
3969
4102
|
// Fall back to L1 defaults when the endpoint is missing or unavailable.
|
|
3970
4103
|
}
|
|
3971
|
-
const
|
|
4104
|
+
const forgedOperation = await this.forge(op);
|
|
4105
|
+
const { opbytes: initialOpBytes, opOb: { branch, contents }, } = forgedOperation;
|
|
3972
4106
|
const operation = {
|
|
3973
4107
|
operation: { branch, contents, signature: STUB_SIGNATURE },
|
|
3974
4108
|
chain_id: await this.context.readProvider.getChainId(),
|
|
3975
4109
|
};
|
|
3976
|
-
|
|
3977
|
-
|
|
3978
|
-
|
|
3979
|
-
|
|
3980
|
-
|
|
3981
|
-
|
|
4110
|
+
let currentOperation = operation;
|
|
4111
|
+
let opResponse;
|
|
4112
|
+
let simulatedOperation;
|
|
4113
|
+
let opbytes = initialOpBytes;
|
|
4114
|
+
let lastError;
|
|
4115
|
+
const maxRebalanceAttempts = (op.simulation?.gasLimitPatchableIndexes?.length ?? 0) + 1;
|
|
4116
|
+
for (let attempt = 0; attempt <= maxRebalanceAttempts; attempt++) {
|
|
4117
|
+
// Keep PreparedOperation on attempt 0 for provider-level block/counter recovery. Rebalance
|
|
4118
|
+
// retries intentionally omit it so patchSimulationGasLimits cannot restore the even split.
|
|
4119
|
+
const simulated = await this.simulate(currentOperation, attempt === 0 ? op : undefined);
|
|
4120
|
+
opResponse = simulated.opResponse;
|
|
4121
|
+
simulatedOperation = simulated.op;
|
|
4122
|
+
currentOperation = simulated.op;
|
|
4123
|
+
const errors = [...flattenErrors(opResponse, 'backtracked'), ...flattenErrors(opResponse)];
|
|
4124
|
+
if (errors.length === 0) {
|
|
4125
|
+
break;
|
|
4126
|
+
}
|
|
4127
|
+
lastError = new TezosOperationError(errors, 'Error occurred during estimation', opResponse.contents);
|
|
4128
|
+
if (!this.hasOperationGasExhausted(errors)) {
|
|
4129
|
+
throw lastError;
|
|
4130
|
+
}
|
|
4131
|
+
const rebalancedOperation = this.rebalanceGasLimits(currentOperation, opResponse, op, constants);
|
|
4132
|
+
if (!rebalancedOperation || attempt === maxRebalanceAttempts) {
|
|
4133
|
+
throw lastError;
|
|
4134
|
+
}
|
|
4135
|
+
currentOperation = rebalancedOperation;
|
|
4136
|
+
opResponse = undefined;
|
|
4137
|
+
simulatedOperation = undefined;
|
|
3982
4138
|
}
|
|
4139
|
+
if (!opResponse || !simulatedOperation) {
|
|
4140
|
+
throw lastError ?? new Error('Unable to simulate operation for estimation');
|
|
4141
|
+
}
|
|
4142
|
+
if (simulatedOperation !== operation) {
|
|
4143
|
+
if (!simulatedOperation.operation.branch) {
|
|
4144
|
+
throw new Error('Unable to reforge simulated operation without a branch');
|
|
4145
|
+
}
|
|
4146
|
+
opbytes = await this.context.forger.forge({
|
|
4147
|
+
branch: simulatedOperation.operation.branch,
|
|
4148
|
+
contents: simulatedOperation.operation.contents,
|
|
4149
|
+
});
|
|
4150
|
+
}
|
|
4151
|
+
const { cost_per_byte, origination_size } = constants;
|
|
3983
4152
|
let numberOfOps = 1;
|
|
3984
|
-
if (Array.isArray(
|
|
4153
|
+
if (Array.isArray(simulatedOperation.operation.contents) &&
|
|
4154
|
+
simulatedOperation.operation.contents.length > 1) {
|
|
3985
4155
|
numberOfOps =
|
|
3986
4156
|
opResponse.contents[0].kind === 'reveal'
|
|
3987
|
-
?
|
|
3988
|
-
:
|
|
4157
|
+
? simulatedOperation.operation.contents.length - 1
|
|
4158
|
+
: simulatedOperation.operation.contents.length;
|
|
3989
4159
|
}
|
|
3990
4160
|
return opResponse.contents.map((x) => {
|
|
3991
4161
|
const content = x;
|
|
@@ -7570,8 +7740,8 @@
|
|
|
7570
7740
|
|
|
7571
7741
|
// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
|
|
7572
7742
|
const VERSION = {
|
|
7573
|
-
"commitHash": "
|
|
7574
|
-
"version": "25.0.0
|
|
7743
|
+
"commitHash": "13f62cd47ea018312f100b660d0225604c757afa",
|
|
7744
|
+
"version": "25.0.0"
|
|
7575
7745
|
};
|
|
7576
7746
|
|
|
7577
7747
|
/**
|
|
@@ -8064,6 +8234,7 @@
|
|
|
8064
8234
|
get: function () { return michelsonEncoder.UnitValue; }
|
|
8065
8235
|
});
|
|
8066
8236
|
exports.BallotOperation = BallotOperation;
|
|
8237
|
+
exports.BatchGasLimitExceededError = BatchGasLimitExceededError;
|
|
8067
8238
|
exports.BatchOperation = BatchOperation;
|
|
8068
8239
|
exports.BigMapAbstraction = BigMapAbstraction;
|
|
8069
8240
|
exports.COST_PER_BYTE = COST_PER_BYTE;
|
package/dist/taquito.umd.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"taquito.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"taquito.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
|
|
@@ -6,3 +6,8 @@ import { TaquitoError } from '@taquito/core';
|
|
|
6
6
|
export declare class RevealEstimateError extends TaquitoError {
|
|
7
7
|
constructor();
|
|
8
8
|
}
|
|
9
|
+
export declare class BatchGasLimitExceededError extends TaquitoError {
|
|
10
|
+
readonly requiredGasLimit: number;
|
|
11
|
+
readonly hardGasLimitPerBlock: number;
|
|
12
|
+
constructor(requiredGasLimit: number, hardGasLimitPerBlock: number);
|
|
13
|
+
}
|
|
@@ -16,9 +16,18 @@ export declare class RPCEstimateProvider extends Provider implements EstimationP
|
|
|
16
16
|
private readonly REVEAL_LENGTH_TZ4;
|
|
17
17
|
private readonly MILLIGAS_BUFFER;
|
|
18
18
|
private readonly STORAGE_BUFFER;
|
|
19
|
+
private readonly UNKNOWN_GAS_LIMIT_PER_OPERATION;
|
|
19
20
|
private prepare;
|
|
20
21
|
private getKeys;
|
|
21
22
|
private getEstimationPropertiesFromOperationContent;
|
|
23
|
+
private hasOperationGasExhausted;
|
|
24
|
+
private getOperationResult;
|
|
25
|
+
private getInternalOperationResults;
|
|
26
|
+
private operationResultHasGasExhausted;
|
|
27
|
+
private findGasExhaustedContentIndex;
|
|
28
|
+
private getContentGasLimit;
|
|
29
|
+
private getMeasuredGasLimit;
|
|
30
|
+
private rebalanceGasLimits;
|
|
22
31
|
private calculateEstimates;
|
|
23
32
|
/**
|
|
24
33
|
*
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@taquito/taquito",
|
|
3
|
-
"version": "25.0.0
|
|
3
|
+
"version": "25.0.0",
|
|
4
4
|
"description": "TypeScript SDK for building wallets, dapps, and tooling on Tezos.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"taquito",
|
|
@@ -60,14 +60,14 @@
|
|
|
60
60
|
]
|
|
61
61
|
},
|
|
62
62
|
"dependencies": {
|
|
63
|
-
"@taquito/core": "^25.0.0
|
|
64
|
-
"@taquito/http-utils": "^25.0.0
|
|
65
|
-
"@taquito/local-forging": "^25.0.0
|
|
66
|
-
"@taquito/michel-codec": "^25.0.0
|
|
67
|
-
"@taquito/michelson-encoder": "^25.0.0
|
|
68
|
-
"@taquito/rpc": "^25.0.0
|
|
69
|
-
"@taquito/signer": "^25.0.0
|
|
70
|
-
"@taquito/utils": "^25.0.0
|
|
63
|
+
"@taquito/core": "^25.0.0",
|
|
64
|
+
"@taquito/http-utils": "^25.0.0",
|
|
65
|
+
"@taquito/local-forging": "^25.0.0",
|
|
66
|
+
"@taquito/michel-codec": "^25.0.0",
|
|
67
|
+
"@taquito/michelson-encoder": "^25.0.0",
|
|
68
|
+
"@taquito/rpc": "^25.0.0",
|
|
69
|
+
"@taquito/signer": "^25.0.0",
|
|
70
|
+
"@taquito/utils": "^25.0.0",
|
|
71
71
|
"bignumber.js": "^10.0.2",
|
|
72
72
|
"rxjs": "^7.8.2"
|
|
73
73
|
},
|