@taquito/taquito 24.3.0-beta.2 → 24.3.0-beta.4

package/dist/taquito.es6.js

@@ -4,8 +4,8 @@ import { HttpResponseError, STATUS_CODE } from '@taquito/http-utils';
 import { TezosToolkitConfigError, ParameterValidationError, RpcError, TaquitoError, NetworkError, InvalidOperationHashError, InvalidViewParameterError, DeprecationError, InvalidChainIdError, PublicKeyNotFoundError, InvalidOperationKindError as InvalidOperationKindError$1, ProhibitedActionError, InvalidProofError, InvalidAddressError, InvalidAmountError, InvalidStakingAddressError, InvalidKeyHashError as InvalidKeyHashError$1, InvalidContractAddressError, InvalidFinalizeUnstakeAmountError } from '@taquito/core';
 import { Observable, ReplaySubject, range, of, combineLatest, from, defer, concat, BehaviorSubject, throwError, EMPTY, Subject, NEVER, timer } from 'rxjs';
 import { first, switchMap, concatMap, endWith, tap, share, map, filter, catchError, distinctUntilChanged, takeWhile, startWith, timeout, mergeMap, shareReplay, takeUntil, retry, exhaustMap, distinctUntilKeyChanged } from 'rxjs/operators';
-import BigNumber, { BigNumber as BigNumber$1 } from 'bignumber.js';
-import { validateOperation, ValidationResult, format, InvalidOperationKindError, validateAddress, validateChain, validateContractAddress, b58DecodeAndCheckPrefix, publicKeyHashPrefixes, PrefixV2, publicKeyPrefixes, validateKeyHash, InvalidKeyHashError, payloadLength, encodeExpr } from '@taquito/utils';
+import BigNumberJs, { BigNumber as BigNumber$9 } from 'bignumber.js';
+import { validateOperation, ValidationResult, validateBlock, format, InvalidOperationKindError, validateAddress, validateChain, validateContractAddress, b58DecodeAndCheckPrefix, publicKeyHashPrefixes, PrefixV2, publicKeyPrefixes, validateKeyHash, InvalidKeyHashError, payloadLength, encodeExpr } from '@taquito/utils';
 import { Schema, ParameterSchema, ViewSchema, EventSchema, MichelsonMap, Token } from '@taquito/michelson-encoder';
 export { MichelsonMap, Token, UnitValue } from '@taquito/michelson-encoder';
 import { Parser, packDataBytes } from '@taquito/michel-codec';
@@ -424,18 +424,19 @@ class InvalidEstimateValueError extends ParameterValidationError {
     }
 }
 
+const BigNumber$8 = BigNumberJs;
 const receiptFromOperation = (op, { ALLOCATION_BURN, ORIGINATION_BURN } = {
     ALLOCATION_BURN: 257,
     ORIGINATION_BURN: 257,
 }) => {
-    BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_UP });
+    BigNumber$8.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$8.ROUND_UP });
     const operationResults = flattenOperationResult({ contents: op });
-    let totalMilliGas = new BigNumber(0);
-    let totalStorage = new BigNumber(0);
-    let totalFee = new BigNumber(0);
-    let totalOriginationBurn = new BigNumber(0);
-    let totalAllocationBurn = new BigNumber(0);
-    let totalPaidStorageDiff = new BigNumber(0);
+    let totalMilliGas = new BigNumber$8(0);
+    let totalStorage = new BigNumber$8(0);
+    let totalFee = new BigNumber$8(0);
+    let totalOriginationBurn = new BigNumber$8(0);
+    let totalAllocationBurn = new BigNumber$8(0);
+    let totalPaidStorageDiff = new BigNumber$8(0);
     operationResults.forEach((result) => {
         totalFee = totalFee.plus(result.fee || 0);
         totalOriginationBurn = totalOriginationBurn.plus(Array.isArray(result.originated_contracts)
@@ -457,7 +458,7 @@ const receiptFromOperation = (op, { ALLOCATION_BURN, ORIGINATION_BURN } = {
         totalAllocationBurn,
         totalOriginationBurn,
         totalPaidStorageDiff,
-        totalStorageBurn: new BigNumber(totalStorage.multipliedBy(COST_PER_BYTE)),
+        totalStorageBurn: new BigNumber$8(totalStorage.multipliedBy(COST_PER_BYTE)),
     };
 };
 
@@ -878,6 +879,10 @@ class IncreasePaidStorageWalletOperation extends WalletOperation {
     }
 }
 
+const isBlockHashIdentifier = (block) => {
+    return validateBlock(block) === ValidationResult.VALID;
+};
+
 class OriginationWalletOperation extends WalletOperation {
     constructor(opHash, context, newHead$) {
         super(opHash, context, newHead$);
@@ -920,7 +925,10 @@ class OriginationWalletOperation extends WalletOperation {
         }
         await this.confirmation();
         const inclusionBlock = await this.getInclusionBlock();
-        return this.context.wallet.at(address, undefined, inclusionBlock.header.level);
+        if (!isBlockHashIdentifier(inclusionBlock.hash)) {
+            throw new OriginationWalletOperationError('Inclusion block hash is invalid');
+        }
+        return this.context.wallet.at(address, undefined, inclusionBlock.hash);
     }
 }
 
@@ -1156,6 +1164,13 @@ class Operation {
     get includedInBlock() {
         return this._foundAt;
     }
+    async getInclusionBlock() {
+        const inclusionBlock = await this._includedInBlock.pipe(first()).toPromise();
+        if (!inclusionBlock) {
+            throw new Error('Inclusion block is undefined');
+        }
+        return inclusionBlock;
+    }
     /**
      *
      * @param hash Operation hash
@@ -1169,6 +1184,7 @@ class Operation {
         this.results = results;
         this.context = context;
         this._pollingConfig$ = new ReplaySubject(1);
+        this._includedInBlock = new ReplaySubject(1);
         this.currentHead$ = this._pollingConfig$.pipe(switchMap((config) => {
             return new BehaviorSubject(config).pipe(timeout({
                 each: config.timeout * 1000,
@@ -1183,11 +1199,13 @@ class Operation {
         // Observable that emit once operation is seen in a block
         this.confirmed$ = this.currentHead$.pipe(map((head) => {
             for (let i = 3; i >= 0; i--) {
-                head.operations[i].forEach((op) => {
+                for (const op of head.operations[i]) {
                     if (op.hash === this.hash) {
                         this._foundAt = head.header.level;
+                        this._includedInBlock.next(head);
+                        return this._foundAt;
                     }
-                });
+                }
             }
             if (head.header.level - this._foundAt >= 0) {
                 return this._foundAt;
@@ -1615,6 +1633,12 @@ const createSmartRollupExecuteOutboxMessageOperation = async ({ source, fee, gas
 };
 
 class Provider {
+    clearRpcCache() {
+        const rpc = this.context.rpc;
+        if (typeof rpc.deleteAllCachedData === 'function') {
+            rpc.deleteAllCachedData();
+        }
+    }
     parseRpcErrors(error) {
         if (!(error instanceof HttpResponseError)) {
             return [];
@@ -1650,7 +1674,7 @@ class Provider {
             }
         }
     }
-    parseCounterInThePastAdjustments(error) {
+    parseCounterAdjustments(error) {
         return this.parseRpcErrors(error)
             .filter((value) => {
             const id = value.id;
@@ -1658,7 +1682,8 @@ class Provider {
             const expected = value.expected;
             const found = value.found;
             return (typeof id === 'string' &&
-                id.endsWith('contract.counter_in_the_past') &&
+                (id.endsWith('contract.counter_in_the_past') ||
+                    id.endsWith('contract.counter_in_the_future')) &&
                 typeof contract === 'string' &&
                 typeof expected === 'string' &&
                 typeof found === 'string');
@@ -1668,7 +1693,7 @@ class Provider {
             expected: BigInt(value.expected),
             found: BigInt(value.found),
         }))
-            .filter((value) => value.expected > value.found);
+            .filter((value) => value.expected !== value.found);
     }
     hasGasLimitTooHighAndBlockExhausted(error) {
         const ids = this.parseRpcErrors(error)
@@ -1891,7 +1916,7 @@ class Provider {
             };
         }
         catch (error) {
-            const adjustments = this.parseCounterInThePastAdjustments(error);
+            const adjustments = this.parseCounterAdjustments(error);
             const patchedOp = this.patchSimulationCounters(op, adjustments);
             if (patchedOp) {
                 try {
@@ -1942,11 +1967,21 @@ class Provider {
         return opRequireReveal;
     }
     async signAndInject(forgedBytes) {
-        const signed = await this.signer.sign(forgedBytes.opbytes, new Uint8Array([3]));
-        forgedBytes.opbytes = signed.sbytes;
-        forgedBytes.opOb.signature = signed.prefixSig;
+        let signedForgedBytes = await this.signForgedBytes(forgedBytes);
         const opResponse = [];
-        const results = await this.rpc.preapplyOperations([forgedBytes.opOb]);
+        let results;
+        try {
+            results = await this.rpc.preapplyOperations([signedForgedBytes.opOb]);
+        }
+        catch (error) {
+            const adjustments = this.parseCounterAdjustments(error);
+            const patchedForgedBytes = await this.patchForgedBytesCounters(signedForgedBytes, adjustments);
+            if (!patchedForgedBytes) {
+                throw error;
+            }
+            signedForgedBytes = await this.signForgedBytes(patchedForgedBytes);
+            results = await this.rpc.preapplyOperations([signedForgedBytes.opOb]);
+        }
         if (!Array.isArray(results)) {
             throw new TezosPreapplyFailureError(results);
         }
@@ -1959,13 +1994,68 @@ class Provider {
         if (errors.length) {
             throw new TezosOperationError(errors, 'Error occurred during validation simulation of operation', opResponse);
         }
+        const hash = await this.context.injector.inject(signedForgedBytes.opbytes);
+        this.clearRpcCache();
         return {
-            hash: await this.context.injector.inject(forgedBytes.opbytes),
-            forgedBytes,
+            hash,
+            forgedBytes: signedForgedBytes,
             opResponse,
             context: this.context.clone(),
         };
     }
+    async signForgedBytes(forgedBytes) {
+        const signed = await this.signer.sign(forgedBytes.opbytes, new Uint8Array([3]));
+        return {
+            ...forgedBytes,
+            opbytes: signed.sbytes,
+            opOb: {
+                ...forgedBytes.opOb,
+                signature: signed.prefixSig,
+            },
+        };
+    }
+    async patchForgedBytesCounters(forgedBytes, adjustments) {
+        if (adjustments.length === 0 || !Array.isArray(forgedBytes.opOb.contents)) {
+            return;
+        }
+        const branch = forgedBytes.opOb.branch;
+        if (typeof branch !== 'string') {
+            return;
+        }
+        const contents = forgedBytes.opOb.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;
+        }
+        const unsignedOpBytes = await this.context.forger.forge({
+            branch,
+            contents,
+        });
+        return {
+            ...forgedBytes,
+            opbytes: unsignedOpBytes,
+            opOb: {
+                ...forgedBytes.opOb,
+                contents,
+            },
+        };
+    }
 }
 
 /******************************************************************************
@@ -2191,6 +2281,115 @@ class ContractMethodFactory {
     }
 }
 
+class BigMapAbstraction {
+    constructor(id, schema, provider, defaultBlock) {
+        this.id = id;
+        this.schema = schema;
+        this.provider = provider;
+        this.defaultBlock = defaultBlock;
+    }
+    /**
+     *
+     * Fetch one value in a big map
+     *
+     * @param keyToEncode Key to query (will be encoded properly according to the schema)
+     * @param block optional block level to fetch the values from (head will be use by default)
+     * @returns Return a well formatted json object of a big map value or undefined if the key is not found in the big map
+     *
+     */
+    async get(keyToEncode, block) {
+        try {
+            const id = await this.provider.getBigMapKeyByID(this.id.toString(), keyToEncode, this.schema, block ?? this.defaultBlock);
+            return id;
+        }
+        catch (e) {
+            if (e instanceof HttpResponseError && e.status === STATUS_CODE.NOT_FOUND) {
+                return undefined;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    /**
+     *
+     * Fetch multiple values in a big map
+     * All values will be fetched on the same block level. If a block is specified in the request, the values will be fetched at it.
+     * Otherwise, a first request will be done to the node to fetch the level of the head and all values will be fetched at this level.
+     * If one of the keys does not exist in the big map, its value will be set to undefined.
+     *
+     * @param keysToEncode Array of keys to query (will be encoded properly according to the schema)
+     * @param block optional block level to fetch the values from
+     * @param batchSize optional batch size representing the number of requests to execute in parallel
+     * @returns A MichelsonMap containing the keys queried in the big map and their value in a well-formatted JSON object format
+     *
+     */
+    async getMultipleValues(keysToEncode, block, batchSize = 5) {
+        return this.provider.getBigMapKeysByID(this.id.toString(), keysToEncode, this.schema, block ?? this.defaultBlock, batchSize);
+    }
+    toJSON() {
+        return this.id.toString();
+    }
+    toString() {
+        return this.id.toString();
+    }
+}
+
+class SaplingStateAbstraction {
+    constructor(id, provider, defaultBlock) {
+        this.id = id;
+        this.provider = provider;
+        this.defaultBlock = defaultBlock;
+    }
+    /**
+     *
+     * Fetch the sapling state
+     *
+     * @param block optional block level to fetch the values from (head will be use by default)
+     * @returns Return a json object of the sapling_state
+     *
+     */
+    async getSaplingDiff(block) {
+        return this.provider.getSaplingDiffByID(this.id.toString(), block ?? this.defaultBlock);
+    }
+    getId() {
+        return this.id.toString();
+    }
+}
+
+/**
+ * Override the default michelson encoder semantic to provide richer abstraction over storage properties
+ * @param p StorageProvider (contract API)
+ */
+// Override the default michelson encoder semantic to provide richer abstraction over storage properties
+const smartContractAbstractionSemantic = (provider, block) => ({
+    // Provide a specific abstraction for BigMaps
+    big_map: (val, code) => {
+        if (!val || !('int' in val) || val.int === undefined) {
+            // Return an empty object in case of missing big map ID
+            return {};
+        }
+        else {
+            const schema = new Schema(code);
+            return new BigMapAbstraction(new BigNumberJs(val.int), schema, provider, block);
+        }
+    },
+    sapling_state: (val) => {
+        if (!val || !('int' in val) || val.int === undefined) {
+            // Return an empty object in case of missing sapling state ID
+            return {};
+        }
+        else {
+            return new SaplingStateAbstraction(new BigNumberJs(val.int), provider, block);
+        }
+    },
+    /*
+    // TODO: embed useful other abstractions
+    'contract':  () => {},
+    'address':  () => {}
+    */
+});
+
 /**
  * Utility class to retrieve data from a smart contract's storage without incurring fees via a contract's view method
  */
@@ -2243,13 +2442,14 @@ const isView = (entrypoint) => {
  * Smart contract abstraction
  */
 class ContractAbstraction {
-    constructor(address, script, provider, storageProvider, entrypoints, rpc, readProvider) {
+    constructor(address, script, provider, storageProvider, entrypoints, rpc, readProvider, readBlock = 'head') {
         this.address = address;
         this.script = script;
         this.storageProvider = storageProvider;
         this.entrypoints = entrypoints;
         this.rpc = rpc;
         this.readProvider = readProvider;
+        this.readBlock = readBlock;
         /**
          * Contains methods that are implemented by the target Tezos Smart Contract, and offers the user to call the Smart Contract methods as if they were native TS/JS methods.
          * `methodsObject` serves the exact same purpose as the `methods` member. The difference is that it allows passing the parameter in an object format when calling the smart contract method (instead of the flattened representation)
@@ -2333,8 +2533,11 @@ class ContractAbstraction {
     /**
      * Return a friendly representation of the smart contract storage
      */
-    storage() {
-        return this.storageProvider.getStorage(this.address, this.schema);
+    async storage() {
+        if (this.readBlock !== 'head') {
+            return this.schema.Execute(this.script.storage, smartContractAbstractionSemantic(this.storageProvider, this.readBlock));
+        }
+        return this.storageProvider.getStorage(this.address, this.schema, this.readBlock);
     }
 }
 
@@ -2436,114 +2639,8 @@ function compose(functioncomposer1, functioncomposer2) {
     return (contractAbstraction, context) => functioncomposer2(functioncomposer1(contractAbstraction, context), context);
 }
 
-class SaplingStateAbstraction {
-    constructor(id, provider) {
-        this.id = id;
-        this.provider = provider;
-    }
-    /**
-     *
-     * Fetch the sapling state
-     *
-     * @param block optional block level to fetch the values from (head will be use by default)
-     * @returns Return a json object of the sapling_state
-     *
-     */
-    async getSaplingDiff(block) {
-        return this.provider.getSaplingDiffByID(this.id.toString(), block);
-    }
-    getId() {
-        return this.id.toString();
-    }
-}
-
-class BigMapAbstraction {
-    constructor(id, schema, provider) {
-        this.id = id;
-        this.schema = schema;
-        this.provider = provider;
-    }
-    /**
-     *
-     * Fetch one value in a big map
-     *
-     * @param keyToEncode Key to query (will be encoded properly according to the schema)
-     * @param block optional block level to fetch the values from (head will be use by default)
-     * @returns Return a well formatted json object of a big map value or undefined if the key is not found in the big map
-     *
-     */
-    async get(keyToEncode, block) {
-        try {
-            const id = await this.provider.getBigMapKeyByID(this.id.toString(), keyToEncode, this.schema, block);
-            return id;
-        }
-        catch (e) {
-            if (e instanceof HttpResponseError && e.status === STATUS_CODE.NOT_FOUND) {
-                return undefined;
-            }
-            else {
-                throw e;
-            }
-        }
-    }
-    /**
-     *
-     * Fetch multiple values in a big map
-     * All values will be fetched on the same block level. If a block is specified in the request, the values will be fetched at it.
-     * Otherwise, a first request will be done to the node to fetch the level of the head and all values will be fetched at this level.
-     * If one of the keys does not exist in the big map, its value will be set to undefined.
-     *
-     * @param keysToEncode Array of keys to query (will be encoded properly according to the schema)
-     * @param block optional block level to fetch the values from
-     * @param batchSize optional batch size representing the number of requests to execute in parallel
-     * @returns A MichelsonMap containing the keys queried in the big map and their value in a well-formatted JSON object format
-     *
-     */
-    async getMultipleValues(keysToEncode, block, batchSize = 5) {
-        return this.provider.getBigMapKeysByID(this.id.toString(), keysToEncode, this.schema, block, batchSize);
-    }
-    toJSON() {
-        return this.id.toString();
-    }
-    toString() {
-        return this.id.toString();
-    }
-}
-
-/**
- * Override the default michelson encoder semantic to provide richer abstraction over storage properties
- * @param p ContractProvider (contract API)
- */
-// Override the default michelson encoder semantic to provide richer abstraction over storage properties
-const smartContractAbstractionSemantic = (provider) => ({
-    // Provide a specific abstraction for BigMaps
-    big_map: (val, code) => {
-        if (!val || !('int' in val) || val.int === undefined) {
-            // Return an empty object in case of missing big map ID
-            return {};
-        }
-        else {
-            const schema = new Schema(code);
-            return new BigMapAbstraction(new BigNumber(val.int), schema, provider);
-        }
-    },
-    sapling_state: (val) => {
-        if (!val || !('int' in val) || val.int === undefined) {
-            // Return an empty object in case of missing sapling state ID
-            return {};
-        }
-        else {
-            return new SaplingStateAbstraction(new BigNumber(val.int), provider);
-        }
-    },
-    /*
-    // TODO: embed useful other abstractions
-    'contract':  () => {},
-    'address':  () => {}
-    */
-});
-
 var _PrepareProvider_counters;
+const BigNumber$7 = BigNumberJs;
 const mergeLimits = (userDefinedLimit, defaultLimits) => {
     return {
         fee: userDefinedLimit.fee ?? defaultLimits.fee,
@@ -2570,15 +2667,15 @@ class PrepareProvider extends Provider {
     async getHeadCounter(pkh) {
         return this.context.readProvider.getCounter(pkh, 'head') ?? '0';
     }
-    adjustGasForManagerOperations(gasLimitBlock, gaslimitOp, opsNeedingGasLimitPatch, explicitGasLimitTotal = new BigNumber(0)) {
+    adjustGasForManagerOperations(gasLimitBlock, gaslimitOp, opsNeedingGasLimitPatch, explicitGasLimitTotal = new BigNumber$7(0)) {
         if (opsNeedingGasLimitPatch <= 0) {
             return gaslimitOp;
         }
         const remainingBlockGas = gasLimitBlock.minus(explicitGasLimitTotal);
         if (remainingBlockGas.lte(0)) {
-            return new BigNumber(0);
+            return new BigNumber$7(0);
         }
-        return BigNumber.min(gaslimitOp, remainingBlockGas.div(opsNeedingGasLimitPatch).integerValue(BigNumber.ROUND_DOWN));
+        return BigNumber$7.min(gaslimitOp, remainingBlockGas.div(opsNeedingGasLimitPatch).integerValue(BigNumber$7.ROUND_DOWN));
     }
     getOperationLimits(constants, options = {}) {
         const { hard_gas_limit_per_operation, hard_gas_limit_per_block, hard_storage_limit_per_operation, } = constants;
@@ -2593,7 +2690,7 @@ class PrepareProvider extends Provider {
         return this.getOperationLimits(constants, {
             opsNeedingGasLimitPatch: typeof gasLimit === 'undefined' ? 1 : 0,
             explicitGasLimitTotal: revealNeeded
-                ? new BigNumber(getRevealGasLimit(publicKeyHash))
+                ? new BigNumber$7(getRevealGasLimit(publicKeyHash))
                 : undefined,
         });
     }
@@ -3423,7 +3520,7 @@ class PrepareProvider extends Provider {
         const { pkh, publicKey } = await this.getKeys();
         const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
         const revealNeeded = await this.isRevealOpNeeded(batchParams, pkh);
-        const explicitGasLimitTotal = batchParams.reduce((acc, op) => isOpWithFee(op) && typeof op.gasLimit !== 'undefined' ? acc.plus(op.gasLimit) : acc, revealNeeded ? new BigNumber(getRevealGasLimit(pkh)) : new BigNumber(0));
+        const explicitGasLimitTotal = batchParams.reduce((acc, op) => isOpWithFee(op) && typeof op.gasLimit !== 'undefined' ? acc.plus(op.gasLimit) : acc, revealNeeded ? new BigNumber$7(getRevealGasLimit(pkh)) : new BigNumber$7(0));
         const DEFAULT_PARAMS = this.getOperationLimits(protocolConstants, {
             opsNeedingGasLimitPatch: batchParams.filter((op) => isOpWithFee(op) && typeof op.gasLimit === 'undefined').length,
             explicitGasLimitTotal,
@@ -4430,6 +4527,7 @@ const BATCH_KINDS = [
     OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE,
 ];
 
+const BigNumber$6 = BigNumberJs;
 class BatchOperation extends Operation {
     constructor(hash, params, source, raw, results, context) {
         super(hash, raw, results, context);
@@ -4474,8 +4572,8 @@ class BatchOperation extends Operation {
         return this.sumProp(this.params, 'storage_limit');
     }
     get consumedGas() {
-        BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_UP });
-        return new BigNumber(this.consumedMilliGas).dividedBy(1000).toString();
+        BigNumber$6.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$6.ROUND_UP });
+        return new BigNumber$6(this.consumedMilliGas).dividedBy(1000).toString();
     }
     get consumedMilliGas() {
         return String(this.sumProp(flattenOperationResult({ contents: this.results }), 'consumed_milligas'));
@@ -4802,6 +4900,7 @@ class RPCBatchProvider {
     }
 }
 
+const BigNumber$5 = BigNumber$9;
 /**
  * Delegation operation provide utility function to fetch newly issued delegation
  *
@@ -4838,9 +4937,9 @@ class DelegateOperation extends Operation {
         return Number(this.params.storage_limit);
     }
     get consumedGas() {
-        BigNumber$1.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$1.ROUND_UP });
+        BigNumber$5.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$5.ROUND_UP });
         return this.consumedMilliGas
-            ? new BigNumber$1(this.consumedMilliGas).dividedBy(1000).toString()
+            ? new BigNumber$5(this.consumedMilliGas).dividedBy(1000).toString()
             : undefined;
     }
     get consumedMilliGas() {
@@ -4851,6 +4950,7 @@ class DelegateOperation extends Operation {
     }
 }
 
+const BigNumber$4 = BigNumber$9;
 /**
  * Origination operation provide utility function to fetch newly originated contract
  *
@@ -4887,9 +4987,9 @@ class OriginationOperation extends Operation {
         return Number(this.params.storage_limit);
     }
     get consumedGas() {
-        BigNumber$1.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$1.ROUND_UP });
+        BigNumber$4.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$4.ROUND_UP });
         return this.consumedMilliGas
-            ? new BigNumber$1(this.consumedMilliGas).dividedBy(1000).toString()
+            ? new BigNumber$4(this.consumedMilliGas).dividedBy(1000).toString()
             : undefined;
     }
     get consumedMilliGas() {
@@ -4918,10 +5018,15 @@ class OriginationOperation extends Operation {
         if (!Number.isFinite(this.includedInBlock)) {
             throw new OriginationOperationError('Confirmation completed but includedInBlock was not set');
         }
-        return this.contractProvider.at(this.contractAddress, undefined, this.includedInBlock);
+        const inclusionBlock = await this.getInclusionBlock();
+        if (!isBlockHashIdentifier(inclusionBlock.hash)) {
+            throw new OriginationOperationError('Confirmation completed but includedInBlock was not set');
+        }
+        return this.contractProvider.at(this.contractAddress, undefined, inclusionBlock.hash);
     }
 }
 
+const BigNumber$3 = BigNumber$9;
 /**
  * RegisterGlobalConstantOperation provides utility functions to fetch a newly issued operation of kind register_global_constant
  */
@@ -4959,9 +5064,9 @@ class RegisterGlobalConstantOperation extends Operation {
         return this.operationResults?.errors;
     }
     get consumedGas() {
-        BigNumber$1.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$1.ROUND_UP });
+        BigNumber$3.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$3.ROUND_UP });
         return this.consumedMilliGas
-            ? new BigNumber$1(this.consumedMilliGas).dividedBy(1000).toString()
+            ? new BigNumber$3(this.consumedMilliGas).dividedBy(1000).toString()
             : undefined;
     }
     get consumedMilliGas() {
@@ -4969,6 +5074,7 @@ class RegisterGlobalConstantOperation extends Operation {
     }
 }
 
+const BigNumber$2 = BigNumber$9;
 /**
  * Reveal operation provides utility functions to fetch a newly issued revelation
  */
@@ -5019,8 +5125,8 @@ class RevealOperation extends Operation {
         }, 0);
     }
     get consumedGas() {
-        BigNumber$1.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$1.ROUND_UP });
-        return new BigNumber$1(this.consumedMilliGas).dividedBy(1000).toString();
+        BigNumber$2.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$2.ROUND_UP });
+        return new BigNumber$2(this.consumedMilliGas).dividedBy(1000).toString();
     }
     get consumedMilliGas() {
         return String(this.sumProp(flattenOperationResult({ contents: this.operationResults }), 'consumed_milligas'));
@@ -5036,6 +5142,7 @@ class RevealOperation extends Operation {
     }
 }
 
+const BigNumber$1 = BigNumberJs;
 /**
  * Transaction operation provides utility functions to fetch a newly issued transaction
  *
@@ -5063,7 +5170,7 @@ class TransactionOperation extends Operation {
         }
     }
     get amount() {
-        return new BigNumber(this.params.amount);
+        return new BigNumber$1(this.params.amount);
     }
     get destination() {
         return this.params.destination;
@@ -5083,8 +5190,8 @@ class TransactionOperation extends Operation {
         }, 0);
     }
     get consumedGas() {
-        BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_UP });
-        return new BigNumber(this.consumedMilliGas).dividedBy(1000).toString();
+        BigNumber$1.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$1.ROUND_UP });
+        return new BigNumber$1(this.consumedMilliGas).dividedBy(1000).toString();
     }
     get consumedMilliGas() {
         return String(this.sumProp(flattenOperationResult({ contents: this.operationResults }), 'consumed_milligas'));
@@ -5100,6 +5207,7 @@ class TransactionOperation extends Operation {
     }
 }
 
+const BigNumber = BigNumber$9;
 /**
  *
  * Transfer tickets from a Tezos address (tz1, tz2 or tz3) to a smart contract address (KT1) (everything on layer 1 at this step)
@@ -5131,9 +5239,9 @@ class TransferTicketOperation extends Operation {
         return Number(this.params.storage_limit);
     }
     get consumedGas() {
-        BigNumber$1.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$1.ROUND_UP });
+        BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_UP });
         return this.consumedMilliGas
-            ? new BigNumber$1(this.consumedMilliGas).dividedBy(1000).toString()
+            ? new BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
             : undefined;
     }
     get consumedMilliGas() {
@@ -5499,6 +5607,30 @@ class SmartRollupExecuteOutboxMessageOperation extends Operation {
     }
 }
 
+const CONTRACT_READ_RETRY_DELAYS_MS = [0, 200, 400, 800];
+const sleep = (durationMs) => new Promise((resolve) => {
+    setTimeout(resolve, durationMs);
+});
+const isNotFoundError = (error) => error instanceof HttpResponseError && error.status === STATUS_CODE.NOT_FOUND;
+const retryOnNotFound = async (read, retryDelaysMs = CONTRACT_READ_RETRY_DELAYS_MS) => {
+    let lastError;
+    for (const delayMs of retryDelaysMs) {
+        if (delayMs > 0) {
+            await sleep(delayMs);
+        }
+        try {
+            return await read();
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+            lastError = error;
+        }
+    }
+    throw lastError;
+};
+
 class RpcContractProvider extends Provider {
     constructor(context, estimator) {
         super(context);
@@ -5515,12 +5647,14 @@ class RpcContractProvider extends Provider {
      * @throws {@link InvalidContractAddressError}
      * @see https://tezos.gitlab.io/api/rpc.html#get-block-id-context-contracts-contract-id-script
      */
-    async getStorage(contract, schema) {
+    async getStorage(contract, schema, block = 'head') {
         const contractValidation = validateContractAddress(contract);
         if (contractValidation !== ValidationResult.VALID) {
             throw new InvalidContractAddressError(contract, contractValidation);
         }
-        const script = await this.context.readProvider.getScript(contract, 'head');
+        const script = block === 'head'
+            ? await retryOnNotFound(() => this.context.readProvider.getScript(contract, 'head'))
+            : await this.context.readProvider.getScript(contract, block);
         if (!schema) {
             schema = script;
         }
@@ -5531,7 +5665,7 @@ class RpcContractProvider extends Provider {
         else {
             contractSchema = Schema.fromRPCResponse({ script: schema });
         }
-        return contractSchema.Execute(script.storage, smartContractAbstractionSemantic(this)); // Cast into T because only the caller can know the true type of the storage
+        return contractSchema.Execute(script.storage, smartContractAbstractionSemantic(this, block)); // Cast into T because only the caller can know the true type of the storage
     }
     /**
      *
@@ -5548,10 +5682,9 @@ class RpcContractProvider extends Provider {
         const { key, type } = schema.EncodeBigMapKey(keyToEncode);
         const { packed } = await this.context.packer.packData({ data: key, type });
         const encodedExpr = encodeExpr(packed);
-        const bigMapValue = block
-            ? await this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, block)
-            : await this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, 'head');
-        return schema.ExecuteOnBigMapValue(bigMapValue, smartContractAbstractionSemantic(this));
+        const requestedBlock = block ?? 'head';
+        const bigMapValue = await this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, requestedBlock);
+        return schema.ExecuteOnBigMapValue(bigMapValue, smartContractAbstractionSemantic(this, requestedBlock));
     }
     /**
      *
@@ -5611,11 +5744,8 @@ class RpcContractProvider extends Provider {
      * @param block optional block level to fetch the value from
      *
      */
-    async getSaplingDiffByID(id, block) {
-        const saplingState = block
-            ? await this.context.readProvider.getSaplingDiffById({ id: id.toString() }, block)
-            : await this.context.readProvider.getSaplingDiffById({ id: id.toString() }, 'head');
-        return saplingState;
+    async getSaplingDiffByID(id, block = 'head') {
+        return this.context.readProvider.getSaplingDiffById({ id: id.toString() }, block);
     }
     /**
      *
@@ -6115,17 +6245,28 @@ class RpcContractProvider extends Provider {
         catch (error) {
             // Shadownet's rolling nodes occasionally 404 a just-originated contract at the exact
             // inclusion level even after confirmation. Retry at head so the contract abstraction still
-            // resolves once the node's contract index catches up.
-            if (block !== 'head' &&
-                error instanceof HttpResponseError &&
-                error.status === STATUS_CODE.NOT_FOUND) {
-                contractState = await loadContractState('head');
+            // resolves once the node's contract index catches up. The head index can lag briefly too,
+            // so give it a few bounded retries before surfacing the 404.
+            if (block !== 'head' && isNotFoundError(error)) {
+                contractState = await retryOnNotFound(() => loadContractState('head'));
             }
             else {
                 throw error;
             }
         }
-        const abs = new ContractAbstraction(address, contractState.script, this, this, contractState.entrypoints, rpc, readProvider);
+        const abs = new ContractAbstraction(address, contractState.script, this, this, contractState.entrypoints, rpc, readProvider, 'head');
+        return contractAbstractionComposer(abs, this.context);
+    }
+    async atExactBlock(address, contractAbstractionComposer = (x) => x, block) {
+        const addressValidation = validateContractAddress(address);
+        if (addressValidation !== ValidationResult.VALID) {
+            throw new InvalidContractAddressError(address, addressValidation);
+        }
+        const rpc = this.context.withExtensions().rpc;
+        const readProvider = this.context.withExtensions().readProvider;
+        const script = await readProvider.getScript(address, block);
+        const entrypoints = await rpc.getEntrypoints(address, { block: String(block) });
+        const abs = new ContractAbstraction(address, script, this, this, entrypoints, rpc, readProvider, block);
         return contractAbstractionComposer(abs, this.context);
     }
     /**
@@ -6566,17 +6707,28 @@ class Wallet {
             // Newly originated contracts can be visible at the operation's inclusion level in one RPC
             // call and still lag on another endpoint of the same rolling node. Retry at head so
             // wallet op.contract() behaves like octez-client, which resolves the originated contract
-            // after confirmation instead of pinning itself to a stale context forever.
-            if (block !== 'head' &&
-                error instanceof HttpResponseError &&
-                error.status === STATUS_CODE.NOT_FOUND) {
-                contractState = await loadContractState('head');
+            // after confirmation instead of pinning itself to a stale context forever. The head index
+            // can lag briefly as well, so bound a few retries there too.
+            if (block !== 'head' && isNotFoundError(error)) {
+                contractState = await retryOnNotFound(() => loadContractState('head'));
             }
             else {
                 throw error;
             }
         }
-        const abs = new ContractAbstraction(address, contractState.script, this, this.context.contract, contractState.entrypoints, rpc, readProvider);
+        const abs = new ContractAbstraction(address, contractState.script, this, this.context.contract, contractState.entrypoints, rpc, readProvider, 'head');
+        return contractAbstractionComposer(abs, this.context);
+    }
+    async atExactBlock(address, contractAbstractionComposer = (x) => x, block) {
+        const addressValidation = validateContractAddress(address);
+        if (addressValidation !== ValidationResult.VALID) {
+            throw new InvalidContractAddressError(address, addressValidation);
+        }
+        const rpc = this.context.withExtensions().rpc;
+        const readProvider = this.context.withExtensions().readProvider;
+        const script = await readProvider.getScript(address, block);
+        const entrypoints = await rpc.getEntrypoints(address, { block: String(block) });
+        const abs = new ContractAbstraction(address, script, this, this.context.contract, entrypoints, rpc, readProvider, block);
         return contractAbstractionComposer(abs, this.context);
     }
 }
@@ -7217,7 +7369,7 @@ class PollingSubscribeProvider {
                 const constants = await this.context.readProvider.getProtocolConstants('head');
                 const blockTime = constants.minimal_block_delay
                     ? constants.minimal_block_delay.multipliedBy(1000)
-                    : new BigNumber(defaultIntervalTestnetsMainnet);
+                    : new BigNumberJs(defaultIntervalTestnetsMainnet);
                 const confirmationPollingInterval = blockTime.dividedBy(3);
                 this.config.pollingIntervalMilliseconds =
                     confirmationPollingInterval.toNumber() === 0
@@ -7421,8 +7573,8 @@ class Context {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 const VERSION = {
-    "commitHash": "fb73f1546d3dff2fbba7741ca6006680212bef16",
-    "version": "24.3.0-beta.2"
+    "commitHash": "768729af84b0c773f536e6fbb3acb02ab656d88d",
+    "version": "24.3.0-beta.4"
 };
 
 /**