@solana/web3.js 2.0.0-experimental.5e737f9 → 2.0.0-experimental.62b6bd6

package/dist/index.development.js

@@ -122,7 +122,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
   // src/index.ts
   init_env_shim();
 
-  // ../addresses/dist/index.browser.js
+  // ../accounts/dist/index.browser.js
+  init_env_shim();
+
+  // ../codecs-strings/dist/index.browser.js
   init_env_shim();
 
   // ../codecs-core/dist/index.browser.js
@@ -168,11 +171,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function isFixedSize(codec) {
     return "fixedSize" in codec && typeof codec.fixedSize === "number";
   }
-  function assertIsFixedSize(codec, message) {
-    if (!isFixedSize(codec)) {
-      throw new Error(message != null ? message : "Expected a fixed-size codec, got a variable-size one.");
-    }
-  }
   function isVariableSize(codec) {
     return !isFixedSize(codec);
   }
@@ -242,9 +240,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
 
-  // ../codecs-strings/dist/index.browser.js
-  init_env_shim();
-
   // ../codecs-numbers/dist/index.browser.js
   init_env_shim();
   function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
@@ -535,6 +530,98 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
 
+  // ../accounts/dist/index.browser.js
+  var BASE_ACCOUNT_SIZE = 128;
+  function decodeAccount(encodedAccount, decoder) {
+    try {
+      if ("exists" in encodedAccount && !encodedAccount.exists) {
+        return encodedAccount;
+      }
+      return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });
+    } catch (error) {
+      const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);
+      newError.cause = error;
+      throw newError;
+    }
+  }
+  function accountExists(account) {
+    return !("exists" in account) || "exists" in account && account.exists;
+  }
+  function assertAccountDecoded(account) {
+    if (accountExists(account) && account.data instanceof Uint8Array) {
+      throw new Error(`Expected account [${account.address}] to be decoded.`);
+    }
+  }
+  function assertAccountsDecoded(accounts) {
+    const encoded = accounts.filter((a) => accountExists(a) && a.data instanceof Uint8Array);
+    if (encoded.length > 0) {
+      const encodedAddresses = encoded.map((a) => a.address).join(", ");
+      throw new Error(`Expected accounts [${encodedAddresses}] to be decoded.`);
+    }
+  }
+  function parseBase64RpcAccount(address2, rpcAccount) {
+    if (!rpcAccount)
+      return Object.freeze({ address: address2, exists: false });
+    const data = getBase64Encoder().encode(rpcAccount.data[0]);
+    return Object.freeze({ ...parseBaseAccount(rpcAccount), address: address2, data, exists: true });
+  }
+  function parseBase58RpcAccount(address2, rpcAccount) {
+    if (!rpcAccount)
+      return Object.freeze({ address: address2, exists: false });
+    const data = getBase58Encoder().encode(typeof rpcAccount.data === "string" ? rpcAccount.data : rpcAccount.data[0]);
+    return Object.freeze({ ...parseBaseAccount(rpcAccount), address: address2, data, exists: true });
+  }
+  function parseJsonRpcAccount(address2, rpcAccount) {
+    if (!rpcAccount)
+      return Object.freeze({ address: address2, exists: false });
+    const data = rpcAccount.data.parsed.info;
+    return Object.freeze({ ...parseBaseAccount(rpcAccount), address: address2, data, exists: true });
+  }
+  function parseBaseAccount(rpcAccount) {
+    return Object.freeze({
+      executable: rpcAccount.executable,
+      lamports: rpcAccount.lamports,
+      programAddress: rpcAccount.owner
+    });
+  }
+  async function fetchEncodedAccount(rpc, address2, config = {}) {
+    const { abortSignal, ...rpcConfig } = config;
+    const response = await rpc.getAccountInfo(address2, { ...rpcConfig, encoding: "base64" }).send({ abortSignal });
+    return parseBase64RpcAccount(address2, response.value);
+  }
+  async function fetchJsonParsedAccount(rpc, address2, config = {}) {
+    const { abortSignal, ...rpcConfig } = config;
+    const { value: account } = await rpc.getAccountInfo(address2, { ...rpcConfig, encoding: "jsonParsed" }).send({ abortSignal });
+    return !!account && typeof account === "object" && "parsed" in account.data ? parseJsonRpcAccount(address2, account) : parseBase64RpcAccount(address2, account);
+  }
+  async function fetchEncodedAccounts(rpc, addresses, config = {}) {
+    const { abortSignal, ...rpcConfig } = config;
+    const response = await rpc.getMultipleAccounts(addresses, { ...rpcConfig, encoding: "base64" }).send({ abortSignal });
+    return response.value.map((account, index) => parseBase64RpcAccount(addresses[index], account));
+  }
+  async function fetchJsonParsedAccounts(rpc, addresses, config = {}) {
+    const { abortSignal, ...rpcConfig } = config;
+    const response = await rpc.getMultipleAccounts(addresses, { ...rpcConfig, encoding: "jsonParsed" }).send({ abortSignal });
+    return response.value.map((account, index) => {
+      return !!account && typeof account === "object" && "parsed" in account.data ? parseJsonRpcAccount(addresses[index], account) : parseBase64RpcAccount(addresses[index], account);
+    });
+  }
+  function assertAccountExists(account) {
+    if (!account.exists) {
+      throw new Error(`Expected account [${account.address}] to exist.`);
+    }
+  }
+  function assertAccountsExist(accounts) {
+    const missingAccounts = accounts.filter((a) => !a.exists);
+    if (missingAccounts.length > 0) {
+      const missingAddresses = missingAccounts.map((a) => a.address);
+      throw new Error(`Expected accounts [${missingAddresses.join(", ")}] to exist.`);
+    }
+  }
+
+  // ../addresses/dist/index.browser.js
+  init_env_shim();
+
   // ../assertions/dist/index.browser.js
   init_env_shim();
   function assertIsSecureContext() {
@@ -886,6 +973,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
   }
 
+  // ../functional/dist/index.browser.js
+  init_env_shim();
+  function pipe(init, ...fns) {
+    return fns.reduce((acc, fn) => fn(acc), init);
+  }
+
   // ../instructions/dist/index.browser.js
   init_env_shim();
   var AccountRole = /* @__PURE__ */ ((AccountRole22) => {
@@ -1162,9 +1255,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function getArrayEncoder(item, config = {}) {
     var _a, _b;
     const size = (_a = config.size) != null ? _a : getU32Encoder();
-    if (size === "remainder") {
-      assertIsFixedSize(item, 'Codecs of "remainder" size must have fixed-size items.');
-    }
     const fixedSize = computeArrayLikeCodecSize(size, getFixedSize(item));
     const maxSize = (_b = computeArrayLikeCodecSize(size, getMaxSize(item))) != null ? _b : void 0;
     return createEncoder({
@@ -1192,9 +1282,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function getArrayDecoder(item, config = {}) {
     var _a, _b;
     const size = (_a = config.size) != null ? _a : getU32Decoder();
-    if (size === "remainder") {
-      assertIsFixedSize(item, 'Codecs of "remainder" size must have fixed-size items.');
-    }
     const itemSize = getFixedSize(item);
     const fixedSize = computeArrayLikeCodecSize(size, itemSize);
     const maxSize = (_b = computeArrayLikeCodecSize(size, getMaxSize(item))) != null ? _b : void 0;
@@ -1205,7 +1292,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
         if (typeof size === "object" && bytes.slice(offset).length === 0) {
           return [array, offset];
         }
-        const [resolvedSize, newOffset] = readArrayLikeCodecSize(size, itemSize, bytes, offset);
+        if (size === "remainder") {
+          while (offset < bytes.length) {
+            const [value, newOffset2] = item.read(bytes, offset);
+            offset = newOffset2;
+            array.push(value);
+          }
+          return [array, offset];
+        }
+        const [resolvedSize, newOffset] = typeof size === "number" ? [size, offset] : size.read(bytes, offset);
         offset = newOffset;
         for (let i = 0; i < resolvedSize; i += 1) {
           const [value, newOffset2] = item.read(bytes, offset);
@@ -1216,27 +1311,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
     });
   }
-  function readArrayLikeCodecSize(size, itemSize, bytes, offset) {
-    if (typeof size === "number") {
-      return [size, offset];
-    }
-    if (typeof size === "object") {
-      return size.read(bytes, offset);
-    }
-    if (size === "remainder") {
-      if (itemSize === null) {
-        throw new Error('Codecs of "remainder" size must have fixed-size items.');
-      }
-      const remainder = Math.max(0, bytes.length - offset);
-      if (remainder % itemSize !== 0) {
-        throw new Error(
-          `The remainder of the byte array (${remainder} bytes) cannot be split into chunks of ${itemSize} bytes. Codecs of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainder} modulo ${itemSize} should be equal to zero.`
-        );
-      }
-      return [remainder / itemSize, offset];
-    }
-    throw new Error(`Unrecognized array-like codec size: ${JSON.stringify(size)}`);
-  }
   function computeArrayLikeCodecSize(size, itemSize) {
     if (typeof size !== "number")
       return null;
@@ -1334,12 +1408,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
 
-  // ../functional/dist/index.browser.js
-  init_env_shim();
-  function pipe(init, ...fns) {
-    return fns.reduce((acc, fn) => fn(acc), init);
-  }
-
   // ../transactions/dist/index.browser.js
   function getUnsignedTransaction(transaction) {
     if ("signatures" in transaction) {
@@ -1536,6 +1604,151 @@ this.globalThis.solanaWeb3 = (function (exports) {
     Object.freeze(out);
     return out;
   }
+  function getAccountMetas(message) {
+    const { header } = message;
+    const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
+    const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
+    const accountMetas = [];
+    let accountIndex = 0;
+    for (let i = 0; i < numWritableSignerAccounts; i++) {
+      accountMetas.push({
+        address: message.staticAccounts[accountIndex],
+        role: AccountRole2.WRITABLE_SIGNER
+      });
+      accountIndex++;
+    }
+    for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
+      accountMetas.push({
+        address: message.staticAccounts[accountIndex],
+        role: AccountRole2.READONLY_SIGNER
+      });
+      accountIndex++;
+    }
+    for (let i = 0; i < numWritableNonSignerAccounts; i++) {
+      accountMetas.push({
+        address: message.staticAccounts[accountIndex],
+        role: AccountRole2.WRITABLE
+      });
+      accountIndex++;
+    }
+    for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
+      accountMetas.push({
+        address: message.staticAccounts[accountIndex],
+        role: AccountRole2.READONLY
+      });
+      accountIndex++;
+    }
+    return accountMetas;
+  }
+  function getAddressLookupMetas(compiledAddressTableLookups, addressesByLookupTableAddress) {
+    const compiledAddressTableLookupAddresses = compiledAddressTableLookups.map((l) => l.lookupTableAddress);
+    const missing = compiledAddressTableLookupAddresses.filter((a) => addressesByLookupTableAddress[a] === void 0);
+    if (missing.length > 0) {
+      const missingAddresses = missing.join(", ");
+      throw new Error(`Addresses not provided for lookup tables: [${missingAddresses}]`);
+    }
+    const readOnlyMetas = [];
+    const writableMetas = [];
+    for (const lookup of compiledAddressTableLookups) {
+      const addresses = addressesByLookupTableAddress[lookup.lookupTableAddress];
+      const highestIndex = Math.max(...lookup.readableIndices, ...lookup.writableIndices);
+      if (highestIndex >= addresses.length) {
+        throw new Error(
+          `Cannot look up index ${highestIndex} in lookup table [${lookup.lookupTableAddress}]. The lookup table may have been extended since the addresses provided were retrieved.`
+        );
+      }
+      const readOnlyForLookup = lookup.readableIndices.map((r) => ({
+        address: addresses[r],
+        addressIndex: r,
+        lookupTableAddress: lookup.lookupTableAddress,
+        role: AccountRole2.READONLY
+      }));
+      readOnlyMetas.push(...readOnlyForLookup);
+      const writableForLookup = lookup.writableIndices.map((w) => ({
+        address: addresses[w],
+        addressIndex: w,
+        lookupTableAddress: lookup.lookupTableAddress,
+        role: AccountRole2.WRITABLE
+      }));
+      writableMetas.push(...writableForLookup);
+    }
+    return [...writableMetas, ...readOnlyMetas];
+  }
+  function convertInstruction(instruction, accountMetas) {
+    var _a, _b;
+    const programAddress = (_a = accountMetas[instruction.programAddressIndex]) == null ? void 0 : _a.address;
+    if (!programAddress) {
+      throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
+    }
+    const accounts = (_b = instruction.accountIndices) == null ? void 0 : _b.map((accountIndex) => accountMetas[accountIndex]);
+    const { data } = instruction;
+    return {
+      programAddress,
+      ...accounts && accounts.length ? { accounts } : {},
+      ...data && data.length ? { data } : {}
+    };
+  }
+  function getLifetimeConstraint(messageLifetimeToken, firstInstruction, lastValidBlockHeight) {
+    if (!firstInstruction || !isAdvanceNonceAccountInstruction(firstInstruction)) {
+      return {
+        blockhash: messageLifetimeToken,
+        lastValidBlockHeight: lastValidBlockHeight != null ? lastValidBlockHeight : 2n ** 64n - 1n
+        // U64 MAX
+      };
+    } else {
+      const nonceAccountAddress = firstInstruction.accounts[0].address;
+      assertIsAddress(nonceAccountAddress);
+      const nonceAuthorityAddress = firstInstruction.accounts[2].address;
+      assertIsAddress(nonceAuthorityAddress);
+      return {
+        nonce: messageLifetimeToken,
+        nonceAccountAddress,
+        nonceAuthorityAddress
+      };
+    }
+  }
+  function convertSignatures(compiledTransaction) {
+    const {
+      compiledMessage: { staticAccounts },
+      signatures
+    } = compiledTransaction;
+    return signatures.reduce((acc, sig, index) => {
+      const allZeros = sig.every((byte) => byte === 0);
+      if (allZeros)
+        return acc;
+      const address2 = staticAccounts[index];
+      return { ...acc, [address2]: sig };
+    }, {});
+  }
+  function decompileTransaction(compiledTransaction, config) {
+    var _a;
+    const { compiledMessage } = compiledTransaction;
+    const feePayer = compiledMessage.staticAccounts[0];
+    if (!feePayer)
+      throw new Error("No fee payer set in CompiledTransaction");
+    const accountMetas = getAccountMetas(compiledMessage);
+    const accountLookupMetas = "addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups !== void 0 && compiledMessage.addressTableLookups.length > 0 ? getAddressLookupMetas(compiledMessage.addressTableLookups, (_a = config == null ? void 0 : config.addressesByLookupTableAddress) != null ? _a : {}) : [];
+    const transactionMetas = [...accountMetas, ...accountLookupMetas];
+    const instructions = compiledMessage.instructions.map(
+      (compiledInstruction) => convertInstruction(compiledInstruction, transactionMetas)
+    );
+    const firstInstruction = instructions[0];
+    const lifetimeConstraint = getLifetimeConstraint(
+      compiledMessage.lifetimeToken,
+      firstInstruction,
+      config == null ? void 0 : config.lastValidBlockHeight
+    );
+    const signatures = convertSignatures(compiledTransaction);
+    return pipe(
+      createTransaction({ version: compiledMessage.version }),
+      (tx) => setTransactionFeePayer(feePayer, tx),
+      (tx) => instructions.reduce((acc, instruction) => {
+        return appendTransactionInstruction(instruction, acc);
+      }, tx),
+      (tx) => "blockhash" in lifetimeConstraint ? setTransactionLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionLifetimeUsingDurableNonce(lifetimeConstraint, tx),
+      (tx) => Object.keys(signatures).length > 0 ? { ...tx, signatures } : tx
+    );
+  }
   function upsert(addressMap, address2, update) {
     var _a;
     addressMap[address2] = update((_a = addressMap[address2]) != null ? _a : { role: AccountRole2.READONLY });
@@ -2022,117 +2235,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       signatures
     };
   }
-  function getAccountMetas(message) {
-    const { header } = message;
-    const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
-    const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
-    const accountMetas = [];
-    let accountIndex = 0;
-    for (let i = 0; i < numWritableSignerAccounts; i++) {
-      accountMetas.push({
-        address: message.staticAccounts[accountIndex],
-        role: AccountRole2.WRITABLE_SIGNER
-      });
-      accountIndex++;
-    }
-    for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
-      accountMetas.push({
-        address: message.staticAccounts[accountIndex],
-        role: AccountRole2.READONLY_SIGNER
-      });
-      accountIndex++;
-    }
-    for (let i = 0; i < numWritableNonSignerAccounts; i++) {
-      accountMetas.push({
-        address: message.staticAccounts[accountIndex],
-        role: AccountRole2.WRITABLE
-      });
-      accountIndex++;
-    }
-    for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
-      accountMetas.push({
-        address: message.staticAccounts[accountIndex],
-        role: AccountRole2.READONLY
-      });
-      accountIndex++;
-    }
-    return accountMetas;
-  }
-  function convertInstruction(instruction, accountMetas) {
-    var _a, _b;
-    const programAddress = (_a = accountMetas[instruction.programAddressIndex]) == null ? void 0 : _a.address;
-    if (!programAddress) {
-      throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
-    }
-    const accounts = (_b = instruction.accountIndices) == null ? void 0 : _b.map((accountIndex) => accountMetas[accountIndex]);
-    const { data } = instruction;
-    return {
-      programAddress,
-      ...accounts && accounts.length ? { accounts } : {},
-      ...data && data.length ? { data } : {}
-    };
-  }
-  function getLifetimeConstraint(messageLifetimeToken, firstInstruction, lastValidBlockHeight) {
-    if (!firstInstruction || !isAdvanceNonceAccountInstruction(firstInstruction)) {
-      return {
-        blockhash: messageLifetimeToken,
-        lastValidBlockHeight: lastValidBlockHeight != null ? lastValidBlockHeight : 2n ** 64n - 1n
-        // U64 MAX
-      };
-    } else {
-      const nonceAccountAddress = firstInstruction.accounts[0].address;
-      assertIsAddress(nonceAccountAddress);
-      const nonceAuthorityAddress = firstInstruction.accounts[2].address;
-      assertIsAddress(nonceAuthorityAddress);
-      return {
-        nonce: messageLifetimeToken,
-        nonceAccountAddress,
-        nonceAuthorityAddress
-      };
-    }
-  }
-  function convertSignatures(compiledTransaction) {
-    const {
-      compiledMessage: { staticAccounts },
-      signatures
-    } = compiledTransaction;
-    return signatures.reduce((acc, sig, index) => {
-      const allZeros = sig.every((byte) => byte === 0);
-      if (allZeros)
-        return acc;
-      const address2 = staticAccounts[index];
-      return { ...acc, [address2]: sig };
-    }, {});
-  }
-  function decompileTransaction(compiledTransaction, lastValidBlockHeight) {
-    const { compiledMessage } = compiledTransaction;
-    if ("addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups.length > 0) {
-      throw new Error("Cannot convert transaction with addressTableLookups");
-    }
-    const feePayer = compiledMessage.staticAccounts[0];
-    if (!feePayer)
-      throw new Error("No fee payer set in CompiledTransaction");
-    const accountMetas = getAccountMetas(compiledMessage);
-    const instructions = compiledMessage.instructions.map(
-      (compiledInstruction) => convertInstruction(compiledInstruction, accountMetas)
-    );
-    const firstInstruction = instructions[0];
-    const lifetimeConstraint = getLifetimeConstraint(
-      compiledMessage.lifetimeToken,
-      firstInstruction,
-      lastValidBlockHeight
-    );
-    const signatures = convertSignatures(compiledTransaction);
-    return pipe(
-      createTransaction({ version: compiledMessage.version }),
-      (tx) => setTransactionFeePayer(feePayer, tx),
-      (tx) => instructions.reduce((acc, instruction) => {
-        return appendTransactionInstruction(instruction, acc);
-      }, tx),
-      (tx) => "blockhash" in lifetimeConstraint ? setTransactionLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionLifetimeUsingDurableNonce(lifetimeConstraint, tx),
-      (tx) => compiledTransaction.signatures.length ? { ...tx, signatures } : tx
-    );
-  }
   function getCompiledTransactionEncoder() {
     return getStructEncoder([
       ["signatures", getArrayEncoder(getBytesEncoder({ size: 64 }), { size: getShortU16Encoder() })],
@@ -2153,14 +2255,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function getTransactionEncoder() {
     return mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
   }
-  function getTransactionDecoder(lastValidBlockHeight) {
+  function getTransactionDecoder(config) {
     return mapDecoder(
       getCompiledTransactionDecoder(),
-      (compiledTransaction) => decompileTransaction(compiledTransaction, lastValidBlockHeight)
+      (compiledTransaction) => decompileTransaction(compiledTransaction, config)
     );
   }
-  function getTransactionCodec(lastValidBlockHeight) {
-    return combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
+  function getTransactionCodec(config) {
+    return combineCodec(getTransactionEncoder(), getTransactionDecoder(config));
   }
   var base58Decoder;
   function getSignatureFromTransaction(transaction) {
@@ -2206,11 +2308,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
       return (_b = (_a = i.accounts) == null ? void 0 : _a.filter((a) => isSignerRole2(a.role))) != null ? _b : [];
     }).map((a) => a.address);
     const requiredSigners = /* @__PURE__ */ new Set([transaction.feePayer, ...signerAddressesFromInstructions]);
+    const missingSigs = [];
     requiredSigners.forEach((address2) => {
       if (!transaction.signatures[address2]) {
-        throw new Error(`Transaction is missing signature for address \`${address2}\``);
+        missingSigs.push(address2);
       }
     });
+    if (missingSigs.length > 0) {
+      throw new Error("Transaction is missing signatures for addresses: " + missingSigs.join(", "));
+    }
   }
   function getBase64EncodedWireTransaction(transaction) {
     const wireTransactionBytes = getTransactionEncoder().encode(transaction);
@@ -3954,22 +4060,52 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // src/transaction-confirmation-strategy-blockheight.ts
   init_env_shim();
-  function createBlockHeightExceedencePromiseFactory(rpcSubscriptions) {
-    return async function getBlockHeightExceedencePromise({ abortSignal: callerAbortSignal, lastValidBlockHeight }) {
+  function createBlockHeightExceedencePromiseFactory({
+    rpc,
+    rpcSubscriptions
+  }) {
+    return async function getBlockHeightExceedencePromise({
+      abortSignal: callerAbortSignal,
+      commitment,
+      lastValidBlockHeight
+    }) {
       const abortController = new AbortController();
-      function handleAbort() {
+      const handleAbort = () => {
         abortController.abort();
-      }
+      };
       callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-      const slotNotifications = await rpcSubscriptions.slotNotifications().subscribe({ abortSignal: abortController.signal });
+      async function getBlockHeightAndDifferenceBetweenSlotHeightAndBlockHeight() {
+        const { absoluteSlot, blockHeight } = await rpc.getEpochInfo({ commitment }).send({ abortSignal: abortController.signal });
+        return {
+          blockHeight,
+          differenceBetweenSlotHeightAndBlockHeight: absoluteSlot - blockHeight
+        };
+      }
       try {
-        for await (const slotNotification of slotNotifications) {
-          if (slotNotification.slot > lastValidBlockHeight) {
-            throw new Error(
-              "The network has progressed past the last block for which this transaction could have committed."
-            );
+        const [slotNotifications, { blockHeight, differenceBetweenSlotHeightAndBlockHeight }] = await Promise.all([
+          rpcSubscriptions.slotNotifications().subscribe({ abortSignal: abortController.signal }),
+          getBlockHeightAndDifferenceBetweenSlotHeightAndBlockHeight()
+        ]);
+        if (blockHeight <= lastValidBlockHeight) {
+          let lastKnownDifferenceBetweenSlotHeightAndBlockHeight = differenceBetweenSlotHeightAndBlockHeight;
+          for await (const slotNotification of slotNotifications) {
+            const { slot } = slotNotification;
+            if (slot - lastKnownDifferenceBetweenSlotHeightAndBlockHeight > lastValidBlockHeight) {
+              const {
+                blockHeight: currentBlockHeight,
+                differenceBetweenSlotHeightAndBlockHeight: currentDifferenceBetweenSlotHeightAndBlockHeight
+              } = await getBlockHeightAndDifferenceBetweenSlotHeightAndBlockHeight();
+              if (currentBlockHeight > lastValidBlockHeight) {
+                break;
+              } else {
+                lastKnownDifferenceBetweenSlotHeightAndBlockHeight = currentDifferenceBetweenSlotHeightAndBlockHeight;
+              }
+            }
           }
         }
+        throw new Error(
+          "The network has progressed past the last block for which this transaction could have been committed."
+        );
       } finally {
         abortController.abort();
       }
@@ -4064,7 +4200,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     rpc,
     rpcSubscriptions
   }) {
-    const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory(rpcSubscriptions);
+    const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory({
+      rpc,
+      rpcSubscriptions
+    });
     const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
       rpc,
       rpcSubscriptions
@@ -4097,10 +4236,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
     await raceStrategies(
       getSignatureFromTransaction(config.transaction),
       config,
-      function getSpecificStrategiesForRace({ abortSignal, getBlockHeightExceedencePromise, transaction }) {
+      function getSpecificStrategiesForRace({
+        abortSignal,
+        commitment,
+        getBlockHeightExceedencePromise,
+        transaction
+      }) {
         return [
           getBlockHeightExceedencePromise({
             abortSignal,
+            commitment,
             lastValidBlockHeight: transaction.lifetimeConstraint.lastValidBlockHeight
           })
         ];
@@ -4223,8 +4368,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
 
   exports.AccountRole = AccountRole;
+  exports.BASE_ACCOUNT_SIZE = BASE_ACCOUNT_SIZE;
   exports.address = address;
   exports.appendTransactionInstruction = appendTransactionInstruction;
+  exports.assertAccountDecoded = assertAccountDecoded;
+  exports.assertAccountExists = assertAccountExists;
+  exports.assertAccountsDecoded = assertAccountsDecoded;
+  exports.assertAccountsExist = assertAccountsExist;
   exports.assertIsAddress = assertIsAddress;
   exports.assertIsBlockhash = assertIsBlockhash;
   exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
@@ -4254,8 +4404,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.createSolanaRpcSubscriptions = createSolanaRpcSubscriptions;
   exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
   exports.createTransaction = createTransaction;
+  exports.decodeAccount = decodeAccount;
+  exports.decompileTransaction = decompileTransaction;
   exports.downgradeRoleToNonSigner = downgradeRoleToNonSigner;
   exports.downgradeRoleToReadonly = downgradeRoleToReadonly;
+  exports.fetchEncodedAccount = fetchEncodedAccount;
+  exports.fetchEncodedAccounts = fetchEncodedAccounts;
+  exports.fetchJsonParsedAccount = fetchJsonParsedAccount;
+  exports.fetchJsonParsedAccounts = fetchJsonParsedAccounts;
   exports.generateKeyPair = generateKeyPair;
   exports.getAddressCodec = getAddressCodec;
   exports.getAddressComparator = getAddressComparator;
@@ -4266,6 +4422,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.getCompiledMessageCodec = getCompiledMessageCodec;
   exports.getCompiledMessageDecoder = getCompiledMessageDecoder;
   exports.getCompiledMessageEncoder = getCompiledMessageEncoder;
+  exports.getCompiledTransactionDecoder = getCompiledTransactionDecoder;
   exports.getProgramDerivedAddress = getProgramDerivedAddress;
   exports.getSignatureFromTransaction = getSignatureFromTransaction;
   exports.getTransactionCodec = getTransactionCodec;
@@ -4283,7 +4440,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.isWritableRole = isWritableRole;
   exports.lamports = lamports;
   exports.mergeRoles = mergeRoles;
+  exports.parseBase58RpcAccount = parseBase58RpcAccount;
+  exports.parseBase64RpcAccount = parseBase64RpcAccount;
+  exports.parseJsonRpcAccount = parseJsonRpcAccount;
   exports.partiallySignTransaction = partiallySignTransaction;
+  exports.pipe = pipe;
   exports.prependTransactionInstruction = prependTransactionInstruction;
   exports.requestAndConfirmAirdrop = requestAndConfirmAirdrop;
   exports.sendAndConfirmDurableNonceTransaction = sendAndConfirmDurableNonceTransaction;