@solana/web3.js 2.0.0-experimental.5e737f9 → 2.0.0-experimental.606040b

package/README.md

@@ -784,6 +784,8 @@ Solana’s codecs libraries are broken up into modular components so you only ne
 - `@solana/codecs-data-structures`: Codecs and serializers for structs
 - `@solana/options`: Designed to build codecs and serializers for types that mimic Rust’s enums, which can include embedded data within their variants such as values, tuples, and structs
 
+These packages are included in the main `@solana/web3.js` library but you may also import them from `@solana/codecs` if you only need the codecs.
+
 Here’s an example of encoding and decoding a custom struct with some strings and numbers:
 
 ```tsx

package/dist/index.browser.cjs

@@ -1,15 +1,20 @@
 'use strict';
 
+var accounts = require('@solana/accounts');
 var addresses = require('@solana/addresses');
+var codecs = require('@solana/codecs');
+var functional = require('@solana/functional');
 var instructions = require('@solana/instructions');
 var keys = require('@solana/keys');
+var programs = require('@solana/programs');
+var rpcParsedTypes = require('@solana/rpc-parsed-types');
 var rpcTypes = require('@solana/rpc-types');
+var signers = require('@solana/signers');
 var transactions = require('@solana/transactions');
-var functional = require('@solana/functional');
 var rpcCore = require('@solana/rpc-core');
 var rpcTransport = require('@solana/rpc-transport');
 var fastStableStringify = require('fast-stable-stringify');
-var codecsStrings = require('@solana/codecs-strings');
+var errors = require('@solana/errors');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -172,48 +177,74 @@ async function requestAndConfirmAirdrop({
   });
   return airdropTransactionSignature;
 }
-
-// src/rpc-integer-overflow-error.ts
-var SolanaJsonRpcIntegerOverflowError = class extends Error {
-  methodName;
-  keyPath;
-  value;
-  constructor(methodName, keyPath, value) {
-    let argumentLabel = "";
-    if (typeof keyPath[0] === "number") {
-      const argPosition = keyPath[0] + 1;
-      const lastDigit = argPosition % 10;
-      const lastTwoDigits = argPosition % 100;
-      if (lastDigit == 1 && lastTwoDigits != 11) {
-        argumentLabel = argPosition + "st";
-      } else if (lastDigit == 2 && lastTwoDigits != 12) {
-        argumentLabel = argPosition + "nd";
-      } else if (lastDigit == 3 && lastTwoDigits != 13) {
-        argumentLabel = argPosition + "rd";
-      } else {
-        argumentLabel = argPosition + "th";
-      }
+var compiledTransactionDecoder = void 0;
+async function fetchLookupTables(lookupTableAddresses, rpc, config) {
+  const fetchedLookupTables = await accounts.fetchJsonParsedAccounts(
+    rpc,
+    lookupTableAddresses,
+    config
+  );
+  accounts.assertAccountsDecoded(fetchedLookupTables);
+  accounts.assertAccountsExist(fetchedLookupTables);
+  return fetchedLookupTables.reduce((acc, lookup) => {
+    return {
+      ...acc,
+      [lookup.address]: lookup.data.addresses
+    };
+  }, {});
+}
+async function decodeTransaction(encodedTransaction, rpc, config) {
+  const { lastValidBlockHeight, ...fetchAccountsConfig } = config ?? {};
+  if (!compiledTransactionDecoder)
+    compiledTransactionDecoder = transactions.getCompiledTransactionDecoder();
+  const compiledTransaction = compiledTransactionDecoder.decode(encodedTransaction);
+  const { compiledMessage } = compiledTransaction;
+  const lookupTables = "addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups !== void 0 && compiledMessage.addressTableLookups.length > 0 ? compiledMessage.addressTableLookups : [];
+  const lookupTableAddresses = lookupTables.map((l) => l.lookupTableAddress);
+  const fetchedLookupTables = lookupTableAddresses.length > 0 ? await fetchLookupTables(lookupTableAddresses, rpc, fetchAccountsConfig) : {};
+  return transactions.decompileTransaction(compiledTransaction, {
+    addressesByLookupTableAddress: fetchedLookupTables,
+    lastValidBlockHeight
+  });
+}
+function createSolanaJsonRpcIntegerOverflowError(methodName, keyPath, value) {
+  let argumentLabel = "";
+  if (typeof keyPath[0] === "number") {
+    const argPosition = keyPath[0] + 1;
+    const lastDigit = argPosition % 10;
+    const lastTwoDigits = argPosition % 100;
+    if (lastDigit == 1 && lastTwoDigits != 11) {
+      argumentLabel = argPosition + "st";
+    } else if (lastDigit == 2 && lastTwoDigits != 12) {
+      argumentLabel = argPosition + "nd";
+    } else if (lastDigit == 3 && lastTwoDigits != 13) {
+      argumentLabel = argPosition + "rd";
     } else {
-      argumentLabel = `\`${keyPath[0].toString()}\``;
+      argumentLabel = argPosition + "th";
     }
-    const path = keyPath.length > 1 ? keyPath.slice(1).map((pathPart) => typeof pathPart === "number" ? `[${pathPart}]` : pathPart).join(".") : null;
-    super(
-      `The ${argumentLabel} argument to the \`${methodName}\` RPC method${path ? ` at path \`${path}\`` : ""} was \`${value}\`. This number is unsafe for use with the Solana JSON-RPC because it exceeds \`Number.MAX_SAFE_INTEGER\`.`
-    );
-    this.keyPath = keyPath;
-    this.methodName = methodName;
-    this.value = value;
+  } else {
+    argumentLabel = `\`${keyPath[0].toString()}\``;
   }
-  get name() {
-    return "SolanaJsonRpcIntegerOverflowError";
+  const path = keyPath.length > 1 ? keyPath.slice(1).map((pathPart) => typeof pathPart === "number" ? `[${pathPart}]` : pathPart).join(".") : void 0;
+  const error = new errors.SolanaError(errors.SOLANA_ERROR__RPC_INTEGER_OVERFLOW, {
+    argumentLabel,
+    keyPath,
+    methodName,
+    optionalPathLabel: path ? ` at path \`${path}\`` : "",
+    value,
+    ...path !== void 0 ? { path } : void 0
+  });
+  if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
+    Error.captureStackTrace(error, createSolanaJsonRpcIntegerOverflowError);
   }
-};
+  return error;
+}
 
 // src/rpc-default-config.ts
 var DEFAULT_RPC_CONFIG = {
   defaultCommitment: "confirmed",
   onIntegerOverflow(methodName, keyPath, value) {
-    throw new SolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
+    throw createSolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
   }
 };
 
@@ -406,9 +437,10 @@ function getRpcSubscriptionsWithSubscriptionCoalescing({
 
 // src/rpc.ts
 function createSolanaRpc(config) {
+  const api = rpcCore.createSolanaRpcApi(DEFAULT_RPC_CONFIG);
   return rpcTransport.createJsonRpc({
     ...config,
-    api: rpcCore.createSolanaRpcApi(DEFAULT_RPC_CONFIG)
+    api
   });
 }
 function createSolanaRpcSubscriptions(config) {
@@ -447,13 +479,23 @@ function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
     }
     if (coalescedRequestsByDeduplicationKey[deduplicationKey] == null) {
       const abortController = new AbortController();
+      const responsePromise = (async () => {
+        try {
+          return await transport({
+            ...config,
+            signal: abortController.signal
+          });
+        } catch (e) {
+          if (e && typeof e === "object" && "name" in e && e.name === "AbortError") {
+            return;
+          }
+          throw e;
+        }
+      })();
       coalescedRequestsByDeduplicationKey[deduplicationKey] = {
         abortController,
         numConsumers: 0,
-        responsePromise: transport({
-          ...config,
-          signal: abortController.signal
-        })
+        responsePromise
       };
     }
     const coalescedRequest = coalescedRequestsByDeduplicationKey[deduplicationKey];
@@ -520,7 +562,10 @@ var PING_PAYLOAD = {
   jsonrpc: "2.0",
   method: "ping"
 };
-function getWebSocketTransportWithAutoping({ intervalMs, transport }) {
+function getWebSocketTransportWithAutoping({
+  intervalMs,
+  transport
+}) {
   const pingableConnections = /* @__PURE__ */ new Map();
   return async (...args) => {
     const connection = await transport(...args);
@@ -582,7 +627,10 @@ function getWebSocketTransportWithAutoping({ intervalMs, transport }) {
 var NULL_SHARD_CACHE_KEY = Symbol(
   __DEV__ ? "Cache key to use when there is no connection sharding strategy" : void 0
 );
-function getWebSocketTransportWithConnectionSharding({ getShard, transport }) {
+function getWebSocketTransportWithConnectionSharding({
+  getShard,
+  transport
+}) {
   return getCachedAbortableIterableFactory({
     getAbortSignalFromInputArgs: ({ signal }) => signal,
     getCacheEntryMissingError(shardKey) {
@@ -618,22 +666,52 @@ function createDefaultRpcSubscriptionsTransport(config) {
 }
 
 // src/transaction-confirmation-strategy-blockheight.ts
-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();
     }
@@ -655,8 +733,8 @@ function createNonceInvalidationPromiseFactory(rpc, rpcSubscriptions) {
     }
     callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
     const accountNotifications = await rpcSubscriptions.accountNotifications(nonceAccountAddress, { commitment, encoding: "base64" }).subscribe({ abortSignal: abortController.signal });
-    const base58Decoder = codecsStrings.getBase58Decoder();
-    const base64Encoder = codecsStrings.getBase64Encoder();
+    const base58Decoder = codecs.getBase58Decoder();
+    const base64Encoder = codecs.getBase64Encoder();
     function getNonceFromAccountData([base64EncodedBytes]) {
       const data = base64Encoder.encode(base64EncodedBytes);
       const nonceValueBytes = data.slice(NONCE_VALUE_OFFSET, NONCE_VALUE_OFFSET + 32);
@@ -725,7 +803,10 @@ function createDefaultRecentTransactionConfirmer({
   rpc,
   rpcSubscriptions
 }) {
-  const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory(rpcSubscriptions);
+  const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory({
+    rpc,
+    rpcSubscriptions
+  });
   const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
     rpc,
     rpcSubscriptions
@@ -758,10 +839,16 @@ async function waitForRecentTransactionConfirmation(config) {
   await raceStrategies(
     transactions.getSignatureFromTransaction(config.transaction),
     config,
-    function getSpecificStrategiesForRace({ abortSignal, getBlockHeightExceedencePromise, transaction }) {
+    function getSpecificStrategiesForRace({
+      abortSignal,
+      commitment,
+      getBlockHeightExceedencePromise,
+      transaction
+    }) {
       return [
         getBlockHeightExceedencePromise({
           abortSignal,
+          commitment,
           lastValidBlockHeight: transaction.lifetimeConstraint.lastValidBlockHeight
         })
       ];
@@ -896,17 +983,36 @@ exports.createRecentSignatureConfirmationPromiseFactory = createRecentSignatureC
 exports.createSolanaRpc = createSolanaRpc;
 exports.createSolanaRpcSubscriptions = createSolanaRpcSubscriptions;
 exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
+exports.decodeTransaction = decodeTransaction;
 exports.requestAndConfirmAirdrop = requestAndConfirmAirdrop;
 exports.sendAndConfirmDurableNonceTransaction = sendAndConfirmDurableNonceTransaction;
 exports.sendAndConfirmTransaction = sendAndConfirmTransaction;
 exports.waitForDurableNonceTransactionConfirmation = waitForDurableNonceTransactionConfirmation;
 exports.waitForRecentTransactionConfirmation = waitForRecentTransactionConfirmation;
+Object.keys(accounts).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return accounts[k]; }
+  });
+});
 Object.keys(addresses).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
     get: function () { return addresses[k]; }
   });
 });
+Object.keys(codecs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return codecs[k]; }
+  });
+});
+Object.keys(functional).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return functional[k]; }
+  });
+});
 Object.keys(instructions).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
@@ -919,12 +1025,30 @@ Object.keys(keys).forEach(function (k) {
     get: function () { return keys[k]; }
   });
 });
+Object.keys(programs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return programs[k]; }
+  });
+});
+Object.keys(rpcParsedTypes).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return rpcParsedTypes[k]; }
+  });
+});
 Object.keys(rpcTypes).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
     get: function () { return rpcTypes[k]; }
   });
 });
+Object.keys(signers).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return signers[k]; }
+  });
+});
 Object.keys(transactions).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,