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

package/dist/taquito.umd.js

@@ -2,7 +2,7 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@taquito/rpc'), require('@taquito/http-utils'), require('@taquito/core'), require('rxjs'), require('rxjs/operators'), require('bignumber.js'), require('@taquito/utils'), require('@taquito/michelson-encoder'), require('@taquito/michel-codec'), require('@taquito/local-forging'), require('@taquito/signer')) :
   typeof define === 'function' && define.amd ? define(['exports', '@taquito/rpc', '@taquito/http-utils', '@taquito/core', 'rxjs', 'rxjs/operators', 'bignumber.js', '@taquito/utils', '@taquito/michelson-encoder', '@taquito/michel-codec', '@taquito/local-forging', '@taquito/signer'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquito = {}, global.rpc, global.httpUtils, global.core, global.rxjs, global.operators, global.BigNumber, global.utils, global.michelsonEncoder, global.michelCodec, global.localForging, global.taquitoSigner));
-})(this, (function (exports, rpc, httpUtils, core, rxjs, operators, BigNumber, utils, michelsonEncoder, michelCodec, localForging, signer) { 'use strict';
+})(this, (function (exports, rpc, httpUtils, core, rxjs, operators, BigNumberJs, utils, michelsonEncoder, michelCodec, localForging, signer) { 'use strict';
 
   function formatErrorMessage(error, stringToReplace) {
       const body = JSON.parse(error.body);
@@ -416,18 +416,19 @@
       }
   }
 
+  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)
@@ -449,7 +450,7 @@
           totalAllocationBurn,
           totalOriginationBurn,
           totalPaidStorageDiff,
-          totalStorageBurn: new BigNumber(totalStorage.multipliedBy(COST_PER_BYTE)),
+          totalStorageBurn: new BigNumber$8(totalStorage.multipliedBy(COST_PER_BYTE)),
       };
   };
 
@@ -870,6 +871,10 @@
       }
   }
 
+  const isBlockHashIdentifier = (block) => {
+      return utils.validateBlock(block) === utils.ValidationResult.VALID;
+  };
+
   class OriginationWalletOperation extends WalletOperation {
       constructor(opHash, context, newHead$) {
           super(opHash, context, newHead$);
@@ -912,7 +917,10 @@
           }
           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);
       }
   }
 
@@ -1148,6 +1156,13 @@
       get includedInBlock() {
           return this._foundAt;
       }
+      async getInclusionBlock() {
+          const inclusionBlock = await this._includedInBlock.pipe(operators.first()).toPromise();
+          if (!inclusionBlock) {
+              throw new Error('Inclusion block is undefined');
+          }
+          return inclusionBlock;
+      }
       /**
        *
        * @param hash Operation hash
@@ -1161,6 +1176,7 @@
           this.results = results;
           this.context = context;
           this._pollingConfig$ = new rxjs.ReplaySubject(1);
+          this._includedInBlock = new rxjs.ReplaySubject(1);
           this.currentHead$ = this._pollingConfig$.pipe(operators.switchMap((config) => {
               return new rxjs.BehaviorSubject(config).pipe(operators.timeout({
                   each: config.timeout * 1000,
@@ -1175,11 +1191,13 @@
           // Observable that emit once operation is seen in a block
           this.confirmed$ = this.currentHead$.pipe(operators.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;
@@ -1607,6 +1625,12 @@
   };
 
   class Provider {
+      clearRpcCache() {
+          const rpc = this.context.rpc;
+          if (typeof rpc.deleteAllCachedData === 'function') {
+              rpc.deleteAllCachedData();
+          }
+      }
       parseRpcErrors(error) {
           if (!(error instanceof httpUtils.HttpResponseError)) {
               return [];
@@ -1642,7 +1666,7 @@
               }
           }
       }
-      parseCounterInThePastAdjustments(error) {
+      parseCounterAdjustments(error) {
           return this.parseRpcErrors(error)
               .filter((value) => {
               const id = value.id;
@@ -1650,7 +1674,8 @@
               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');
@@ -1660,7 +1685,7 @@
               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)
@@ -1883,7 +1908,7 @@
               };
           }
           catch (error) {
-              const adjustments = this.parseCounterInThePastAdjustments(error);
+              const adjustments = this.parseCounterAdjustments(error);
               const patchedOp = this.patchSimulationCounters(op, adjustments);
               if (patchedOp) {
                   try {
@@ -1934,11 +1959,21 @@
           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);
           }
@@ -1951,13 +1986,68 @@
           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,
+              },
+          };
+      }
   }
 
   /******************************************************************************
@@ -2183,6 +2273,115 @@
       }
   }
 
+  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 httpUtils.HttpResponseError && e.status === httpUtils.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 michelsonEncoder.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
    */
@@ -2235,13 +2434,14 @@
    * 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)
@@ -2325,8 +2525,11 @@
       /**
        * 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);
       }
   }
 
@@ -2428,114 +2631,8 @@
       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 httpUtils.HttpResponseError && e.status === httpUtils.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 michelsonEncoder.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,
@@ -2562,15 +2659,15 @@
       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;
@@ -2585,7 +2682,7 @@
           return this.getOperationLimits(constants, {
               opsNeedingGasLimitPatch: typeof gasLimit === 'undefined' ? 1 : 0,
               explicitGasLimitTotal: revealNeeded
-                  ? new BigNumber(getRevealGasLimit(publicKeyHash))
+                  ? new BigNumber$7(getRevealGasLimit(publicKeyHash))
                   : undefined,
           });
       }
@@ -3415,7 +3512,7 @@
           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,
@@ -4422,6 +4519,7 @@
       rpc.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);
@@ -4466,8 +4564,8 @@
           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'));
@@ -4794,6 +4892,7 @@
       }
   }
 
+  const BigNumber$5 = BigNumberJs.BigNumber;
   /**
    * Delegation operation provide utility function to fetch newly issued delegation
    *
@@ -4830,9 +4929,9 @@
           return Number(this.params.storage_limit);
       }
       get consumedGas() {
-          BigNumber.BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.BigNumber.ROUND_UP });
+          BigNumber$5.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$5.ROUND_UP });
           return this.consumedMilliGas
-              ? new BigNumber.BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
+              ? new BigNumber$5(this.consumedMilliGas).dividedBy(1000).toString()
               : undefined;
       }
       get consumedMilliGas() {
@@ -4843,6 +4942,7 @@
       }
   }
 
+  const BigNumber$4 = BigNumberJs.BigNumber;
   /**
    * Origination operation provide utility function to fetch newly originated contract
    *
@@ -4879,9 +4979,9 @@
           return Number(this.params.storage_limit);
       }
       get consumedGas() {
-          BigNumber.BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.BigNumber.ROUND_UP });
+          BigNumber$4.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$4.ROUND_UP });
           return this.consumedMilliGas
-              ? new BigNumber.BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
+              ? new BigNumber$4(this.consumedMilliGas).dividedBy(1000).toString()
               : undefined;
       }
       get consumedMilliGas() {
@@ -4910,10 +5010,15 @@
           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 = BigNumberJs.BigNumber;
   /**
    * RegisterGlobalConstantOperation provides utility functions to fetch a newly issued operation of kind register_global_constant
    */
@@ -4951,9 +5056,9 @@
           return this.operationResults?.errors;
       }
       get consumedGas() {
-          BigNumber.BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.BigNumber.ROUND_UP });
+          BigNumber$3.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber$3.ROUND_UP });
           return this.consumedMilliGas
-              ? new BigNumber.BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
+              ? new BigNumber$3(this.consumedMilliGas).dividedBy(1000).toString()
               : undefined;
       }
       get consumedMilliGas() {
@@ -4961,6 +5066,7 @@
       }
   }
 
+  const BigNumber$2 = BigNumberJs.BigNumber;
   /**
    * Reveal operation provides utility functions to fetch a newly issued revelation
    */
@@ -5011,8 +5117,8 @@
           }, 0);
       }
       get consumedGas() {
-          BigNumber.BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.BigNumber.ROUND_UP });
-          return new BigNumber.BigNumber(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'));
@@ -5028,6 +5134,7 @@
       }
   }
 
+  const BigNumber$1 = BigNumberJs;
   /**
    * Transaction operation provides utility functions to fetch a newly issued transaction
    *
@@ -5055,7 +5162,7 @@
           }
       }
       get amount() {
-          return new BigNumber(this.params.amount);
+          return new BigNumber$1(this.params.amount);
       }
       get destination() {
           return this.params.destination;
@@ -5075,8 +5182,8 @@
           }, 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'));
@@ -5092,6 +5199,7 @@
       }
   }
 
+  const BigNumber = BigNumberJs.BigNumber;
   /**
    *
    * Transfer tickets from a Tezos address (tz1, tz2 or tz3) to a smart contract address (KT1) (everything on layer 1 at this step)
@@ -5123,9 +5231,9 @@
           return Number(this.params.storage_limit);
       }
       get consumedGas() {
-          BigNumber.BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.BigNumber.ROUND_UP });
+          BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_UP });
           return this.consumedMilliGas
-              ? new BigNumber.BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
+              ? new BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
               : undefined;
       }
       get consumedMilliGas() {
@@ -5491,6 +5599,30 @@
       }
   }
 
+  const CONTRACT_READ_RETRY_DELAYS_MS = [0, 200, 400, 800];
+  const sleep = (durationMs) => new Promise((resolve) => {
+      setTimeout(resolve, durationMs);
+  });
+  const isNotFoundError = (error) => error instanceof httpUtils.HttpResponseError && error.status === httpUtils.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);
@@ -5507,12 +5639,14 @@
        * @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 = utils.validateContractAddress(contract);
           if (contractValidation !== utils.ValidationResult.VALID) {
               throw new core.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;
           }
@@ -5523,7 +5657,7 @@
           else {
               contractSchema = michelsonEncoder.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
       }
       /**
        *
@@ -5540,10 +5674,9 @@
           const { key, type } = schema.EncodeBigMapKey(keyToEncode);
           const { packed } = await this.context.packer.packData({ data: key, type });
           const encodedExpr = utils.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));
       }
       /**
        *
@@ -5603,11 +5736,8 @@
        * @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);
       }
       /**
        *
@@ -6107,17 +6237,28 @@
           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 httpUtils.HttpResponseError &&
-                  error.status === httpUtils.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 = utils.validateContractAddress(address);
+          if (addressValidation !== utils.ValidationResult.VALID) {
+              throw new core.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);
       }
       /**
@@ -6558,17 +6699,28 @@
               // 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 httpUtils.HttpResponseError &&
-                  error.status === httpUtils.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 = utils.validateContractAddress(address);
+          if (addressValidation !== utils.ValidationResult.VALID) {
+              throw new core.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);
       }
   }
@@ -7209,7 +7361,7 @@
                   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
@@ -7413,8 +7565,8 @@
 
   // 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"
   };
 
   /**