@solana/web3.js 2.0.0-rc.0 → 2.0.0-rc.2

package/dist/index.development.js

@@ -60,6 +60,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__SUBTLE_CRYPTO__GENERATE_FUNCTION_UNIMPLEMENTED = 3610004;
   var SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED = 3610005;
   var SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED = 3610006;
+  var SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY = 3610007;
   var SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED = 3611e3;
   var SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH = 3704e3;
   var SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH = 3704001;
@@ -155,6 +156,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES = 5663016;
   var SOLANA_ERROR__TRANSACTION__MESSAGE_SIGNATURES_MISMATCH = 5663017;
   var SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT = 5663018;
+  var SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT = 5663019;
   var SOLANA_ERROR__TRANSACTION_ERROR__UNKNOWN = 705e4;
   var SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_IN_USE = 7050001;
   var SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_LOADED_TWICE = 7050002;
@@ -218,15 +220,17 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__RPC__INTEGER_OVERFLOW = 81e5;
   var SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN = 8100001;
   var SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR = 8100002;
-  var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_REQUEST = 819e4;
+  var SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD = 8100003;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN = 819e4;
   var SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID = 8190001;
-  var SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CLOSED_BEFORE_MESSAGE_BUFFERED = 8190002;
-  var SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CONNECTION_CLOSED = 8190003;
-  var SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_FAILED_TO_CONNECT = 8190004;
-  var SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_STATE_MISSING = 99e5;
-  var SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE = 9900001;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED = 8190002;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED = 8190003;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT = 8190004;
+  var SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING = 99e5;
+  var SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE = 9900001;
   var SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING = 9900002;
   var SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE = 9900003;
+  var SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED = 9900004;
   var SolanaErrorMessages = {
     [SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND]: "Account not found at address: $address",
     [SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED]: "Not all accounts were decoded. Encoded accounts found at addresses: $addresses.",
@@ -331,9 +335,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__INVALID_BLOCKHASH_BYTE_LENGTH]: "Expected base58 encoded blockhash to decode to a byte array of length 32. Actual length: $actualLength.",
     [SOLANA_ERROR__INVALID_NONCE]: "The nonce `$expectedNonceValue` is no longer valid. It has advanced to `$actualNonceValue`",
     [SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING]: "Invariant violation: Found no abortable iterable cache entry for key `$cacheKey`. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+    [SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED]: "Invariant violation: This data publisher does not publish to the channel named `$channelName`. Supported channels include $supportedChannelNames.",
+    [SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE]: "Invariant violation: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+    [SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING]: "Invariant violation: WebSocket message iterator is missing state storage. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
     [SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE]: "Invariant violation: Switch statement non-exhaustive. Received unexpected value `$unexpectedValue`. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
-    [SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE]: "Invariant violation: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
-    [SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_STATE_MISSING]: "Invariant violation: WebSocket message iterator is missing state storage. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
     [SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR]: "JSON-RPC error: Internal JSON-RPC error ($__serverMessage)",
     [SOLANA_ERROR__JSON_RPC__INVALID_PARAMS]: "JSON-RPC error: Invalid method parameter(s) ($__serverMessage)",
     [SOLANA_ERROR__JSON_RPC__INVALID_REQUEST]: "JSON-RPC error: The JSON sent is not a valid `Request` object ($__serverMessage)",
@@ -364,11 +369,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__MALFORMED_BIGINT_STRING]: "`$value` cannot be parsed as a `BigInt`",
     [SOLANA_ERROR__MALFORMED_NUMBER_STRING]: "`$value` cannot be parsed as a `Number`",
     [SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND]: "No nonce account could be found at address `$nonceAccountAddress`",
-    [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_REQUEST]: "Either the notification name must end in 'Notifications' or the API must supply a subscription creator function for the notification '$notificationName' to map between the notification name and the subscribe/unsubscribe method names.",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN]: "The notification name must end in 'Notifications' and the API must supply a subscription plan creator function for the notification '$notificationName'.",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED]: "WebSocket was closed before payload could be added to the send buffer",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED]: "WebSocket connection closed",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT]: "WebSocket failed to connect",
     [SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID]: "Failed to obtain a subscription id from the server",
-    [SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CLOSED_BEFORE_MESSAGE_BUFFERED]: "WebSocket was closed before payload could be added to the send buffer",
-    [SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CONNECTION_CLOSED]: "WebSocket connection closed",
-    [SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_FAILED_TO_CONNECT]: "WebSocket failed to connect",
+    [SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD]: "Could not find an API plan for RPC method: `$method`",
     [SOLANA_ERROR__RPC__INTEGER_OVERFLOW]: "The $argumentLabel argument to the `$methodName` RPC method$optionalPathLabel was `$value`. This number is unsafe for use with the Solana JSON-RPC because it exceeds `Number.MAX_SAFE_INTEGER`.",
     [SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR]: "HTTP error ($statusCode): $message",
     [SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN]: "HTTP header(s) forbidden: $headers. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.",
@@ -384,6 +390,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS]: "More than one `TransactionSendingSigner` was identified.",
     [SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING]: "No `TransactionSendingSigner` was identified. Please provide a valid `ITransactionWithSingleSendingSigner` transaction.",
     [SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED]: "Wallet account signers do not support signing multiple messages/transactions in a single operation",
+    [SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY]: "Cannot export a non-extractable key.",
     [SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED]: "No digest implementation could be found.",
     [SOLANA_ERROR__SUBTLE_CRYPTO__DISALLOWED_IN_INSECURE_CONTEXT]: "Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts.",
     [SOLANA_ERROR__SUBTLE_CRYPTO__ED25519_ALGORITHM_UNIMPLEMENTED]: "This runtime does not support the generation of Ed25519 key pairs.\n\nInstall @solana/webcrypto-ed25519-polyfill and call its `install` function before generating keys in environments that do not support Ed25519.\n\nFor a list of runtimes that currently support Ed25519 operations, visit https://github.com/WICG/webcrypto-secure-curves/issues/20.",
@@ -391,7 +398,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__SUBTLE_CRYPTO__GENERATE_FUNCTION_UNIMPLEMENTED]: "No key generation implementation could be found.",
     [SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED]: "No signing implementation could be found.",
     [SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED]: "No key export implementation could be found.",
-    [SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE]: "Timestamp value must be in the range [-8.64e15, 8.64e15]. `$value` given",
+    [SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE]: "Timestamp value must be in the range [-(2n ** 63n), (2n ** 63n) - 1]. `$value` given",
     [SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_BORROW_OUTSTANDING]: "Transaction processing left an account with an outstanding borrowed reference",
     [SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_IN_USE]: "Account in use",
     [SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_LOADED_TWICE]: "Account loaded twice",
@@ -439,6 +446,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_FEE_PAYER_MISSING]: "No fee payer set in CompiledTransaction",
     [SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND]: "Could not find program address at index $index",
     [SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT]: "Failed to estimate the compute unit consumption for this transaction message. This is likely because simulating the transaction failed. Inspect the `cause` property of this error to learn more",
+    [SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT]: "Transaction failed when it was simulated in order to estimate the compute unit consumption. The compute unit estimate provided is for a transaction that failed when simulated and may not be representative of the compute units this transaction would consume if successful. Inspect the `cause` property of this error to learn more",
     [SOLANA_ERROR__TRANSACTION__FEE_PAYER_MISSING]: "Transaction is missing a fee payer.",
     [SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING]: "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer.",
     [SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE]: "Transaction first instruction is not advance nonce account instruction.",
@@ -1415,7 +1423,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
         getSizeFromValue: (value) => {
           try {
             return atob(value).length;
-          } catch (e22) {
+          } catch {
             throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
               alphabet: alphabet3,
               base: 64,
@@ -1428,7 +1436,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
             const bytesToAdd = atob(value).split("").map((c) => c.charCodeAt(0));
             bytes.set(bytesToAdd, offset);
             return bytesToAdd.length + offset;
-          } catch (e22) {
+          } catch {
             throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
               alphabet: alphabet3,
               base: 64,
@@ -1488,7 +1496,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
         return encodedAccount;
       }
       return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });
-    } catch (e3) {
+    } catch {
       throw new SolanaError(SOLANA_ERROR__ACCOUNTS__FAILED_TO_DECODE_ACCOUNT, {
         address: encodedAccount.address
       });
@@ -1585,10 +1593,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
           /* extractable */
           false,
           ["sign", "verify"]
-        ).catch(() => {
-          resolve(cachedEd25519Decision = false);
-        }).then(() => {
+        ).then(() => {
           resolve(cachedEd25519Decision = true);
+        }).catch(() => {
+          resolve(cachedEd25519Decision = false);
         });
       });
     }
@@ -1662,12 +1670,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
       return false;
     }
     const base58Encoder2 = getMemoizedBase58Encoder();
-    const bytes = base58Encoder2.encode(putativeAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
+    try {
+      return base58Encoder2.encode(putativeAddress).byteLength === 32;
+    } catch {
       return false;
     }
-    return true;
   }
   function assertIsAddress(putativeAddress) {
     if (
@@ -2562,9 +2569,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var getDataEnumDecoder = getDiscriminatedUnionDecoder;
   var getDataEnumCodec = getDiscriminatedUnionCodec;
   function getEnumStats(constructor) {
-    const numericalValues = [
-      ...new Set(Object.values(constructor).filter((v) => typeof v === "number"))
-    ].sort();
+    const numericalValues = [...new Set(Object.values(constructor).filter((v) => typeof v === "number"))].sort();
     const enumRecord = Object.fromEntries(Object.entries(constructor).slice(numericalValues.length));
     const enumKeys = Object.keys(enumRecord);
     const enumValues = Object.values(enumRecord);
@@ -3093,6 +3098,26 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
     return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, "Ed25519", extractable != null ? extractable : false, ["sign"]);
   }
+  async function getPublicKeyFromPrivateKey(privateKey, extractable = false) {
+    assertKeyExporterIsAvailable();
+    if (privateKey.extractable === false) {
+      throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY, { key: privateKey });
+    }
+    const jwk = await crypto.subtle.exportKey("jwk", privateKey);
+    return await crypto.subtle.importKey(
+      "jwk",
+      {
+        crv: "Ed25519",
+        ext: extractable,
+        key_ops: ["verify"],
+        kty: "OKP",
+        x: jwk.x
+      },
+      "Ed25519",
+      extractable,
+      ["verify"]
+    );
+  }
   var base58Encoder;
   function assertIsSignature(putativeSignature) {
     if (!base58Encoder) base58Encoder = getBase58Encoder();
@@ -3181,6 +3206,27 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
     return { privateKey, publicKey };
   }
+  async function createKeyPairFromPrivateKeyBytes(bytes, extractable = false) {
+    const privateKeyPromise = createPrivateKeyFromBytes(bytes, extractable);
+    const [publicKey, privateKey] = await Promise.all([
+      // This nested promise makes things efficient by
+      // creating the public key in parallel with the
+      // second private key creation, if it is needed.
+      (extractable ? privateKeyPromise : createPrivateKeyFromBytes(
+        bytes,
+        true
+        /* extractable */
+      )).then(
+        async (privateKey2) => await getPublicKeyFromPrivateKey(
+          privateKey2,
+          true
+          /* extractable */
+        )
+      ),
+      privateKeyPromise
+    ]);
+    return { privateKey, publicKey };
+  }
 
   // ../programs/dist/index.browser.mjs
   function isProgramError(error, transactionMessage, programAddress, code) {
@@ -3196,20 +3242,90 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
 
   // ../rpc-spec-types/dist/index.browser.mjs
+  function parseJsonWithBigInts(json) {
+    return JSON.parse(wrapIntegersInBigIntValueObject(json), (_, value) => {
+      return isBigIntValueObject(value) ? unwrapBigIntValueObject(value) : value;
+    });
+  }
+  function wrapIntegersInBigIntValueObject(json) {
+    const out = [];
+    let inQuote = false;
+    for (let ii = 0; ii < json.length; ii++) {
+      let isEscaped = false;
+      if (json[ii] === "\\") {
+        out.push(json[ii++]);
+        isEscaped = !isEscaped;
+      }
+      if (json[ii] === '"') {
+        out.push(json[ii]);
+        if (!isEscaped) {
+          inQuote = !inQuote;
+        }
+        continue;
+      }
+      if (!inQuote) {
+        const consumedNumber = consumeNumber(json, ii);
+        if (consumedNumber == null ? void 0 : consumedNumber.length) {
+          ii += consumedNumber.length - 1;
+          if (consumedNumber.match(/\.|[eE]-/)) {
+            out.push(consumedNumber);
+          } else {
+            out.push(wrapBigIntValueObject(consumedNumber));
+          }
+          continue;
+        }
+      }
+      out.push(json[ii]);
+    }
+    return out.join("");
+  }
+  function consumeNumber(json, ii) {
+    var _a;
+    const JSON_NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+    if (!((_a = json[ii]) == null ? void 0 : _a.match(/[-\d]/))) {
+      return null;
+    }
+    const numberMatch = json.slice(ii).match(JSON_NUMBER_REGEX);
+    return numberMatch ? numberMatch[0] : null;
+  }
+  function wrapBigIntValueObject(value) {
+    return `{"$n":"${value}"}`;
+  }
+  function unwrapBigIntValueObject({ $n }) {
+    if ($n.match(/[eE]/)) {
+      const [units, exponent] = $n.split(/[eE]/);
+      return BigInt(units) * BigInt(10) ** BigInt(exponent);
+    }
+    return BigInt($n);
+  }
+  function isBigIntValueObject(value) {
+    return !!value && typeof value === "object" && "$n" in value && typeof value.$n === "string";
+  }
   var _nextMessageId = 0;
   function getNextMessageId() {
     const id = _nextMessageId;
     _nextMessageId = (_nextMessageId + 1) % Number.MAX_SAFE_INTEGER;
     return id;
   }
-  function createRpcMessage(method, params) {
+  function createRpcMessage(request) {
     return {
       id: getNextMessageId(),
       jsonrpc: "2.0",
-      method,
-      params
+      method: request.methodName,
+      params: request.params
     };
   }
+  function stringifyJsonWithBigints(value, space) {
+    return unwrapBigIntValueObject2(
+      JSON.stringify(value, (_, v) => typeof v === "bigint" ? wrapBigIntValueObject2(v) : v, space)
+    );
+  }
+  function wrapBigIntValueObject2(value) {
+    return { $n: `${value}` };
+  }
+  function unwrapBigIntValueObject2(value) {
+    return value.replace(/\{\s*"\$n"\s*:\s*"(-?\d+)"\s*\}/g, "$1");
+  }
 
   // ../rpc-spec/dist/index.browser.mjs
   function createRpc(rpcConfig) {
@@ -3226,27 +3342,27 @@ this.globalThis.solanaWeb3 = (function (exports) {
       get(target, p, receiver) {
         return function(...rawParams) {
           const methodName = p.toString();
-          const createRpcRequest = Reflect.get(target, methodName, receiver);
-          const newRequest = createRpcRequest ? createRpcRequest(...rawParams) : { methodName, params: rawParams };
-          return createPendingRpcRequest(rpcConfig, newRequest);
+          const getApiPlan = Reflect.get(target, methodName, receiver);
+          if (!getApiPlan) {
+            throw new SolanaError(SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD, {
+              method: methodName,
+              params: rawParams
+            });
+          }
+          const apiPlan = getApiPlan(...rawParams);
+          return createPendingRpcRequest(rpcConfig, apiPlan);
         };
       }
     });
   }
-  function createPendingRpcRequest(rpcConfig, pendingRequest) {
+  function createPendingRpcRequest({ transport }, plan) {
     return {
       async send(options) {
-        const { methodName, params, responseTransformer } = pendingRequest;
-        const payload = createRpcMessage(methodName, params);
-        const response = await rpcConfig.transport({
-          payload,
-          signal: options == null ? void 0 : options.abortSignal
-        });
-        return responseTransformer ? responseTransformer(response, methodName) : response;
+        return await plan.execute({ signal: options == null ? void 0 : options.abortSignal, transport });
       }
     };
   }
-  function createRpcApi(config) {
+  function createJsonRpcApi(config) {
     return new Proxy({}, {
       defineProperty() {
         return false;
@@ -3258,19 +3374,106 @@ this.globalThis.solanaWeb3 = (function (exports) {
         const [_, p] = args;
         const methodName = p.toString();
         return function(...rawParams) {
-          const params = (config == null ? void 0 : config.parametersTransformer) ? config == null ? void 0 : config.parametersTransformer(rawParams, methodName) : rawParams;
-          const responseTransformer = (config == null ? void 0 : config.responseTransformer) ? config == null ? void 0 : config.responseTransformer : (rawResponse) => rawResponse;
-          return {
-            methodName,
-            params,
-            responseTransformer
-          };
+          const rawRequest = Object.freeze({ methodName, params: rawParams });
+          const request = (config == null ? void 0 : config.requestTransformer) ? config == null ? void 0 : config.requestTransformer(rawRequest) : rawRequest;
+          return Object.freeze({
+            execute: async ({ signal, transport }) => {
+              const payload = createRpcMessage(request);
+              const response = await transport({ payload, signal });
+              if (!(config == null ? void 0 : config.responseTransformer)) {
+                return response;
+              }
+              return config.responseTransformer(response, request);
+            }
+          });
         };
       }
     });
   }
+  function isJsonRpcPayload(payload) {
+    if (payload == null || typeof payload !== "object" || Array.isArray(payload)) {
+      return false;
+    }
+    return "jsonrpc" in payload && payload.jsonrpc === "2.0" && "method" in payload && typeof payload.method === "string" && "params" in payload;
+  }
 
   // ../rpc-transformers/dist/index.browser.mjs
+  var KEYPATH_WILDCARD = {};
+  function getTreeWalker(visitors) {
+    return function traverse(node, state) {
+      if (Array.isArray(node)) {
+        return node.map((element, ii) => {
+          const nextState = {
+            ...state,
+            keyPath: [...state.keyPath, ii]
+          };
+          return traverse(element, nextState);
+        });
+      } else if (typeof node === "object" && node !== null) {
+        const out = {};
+        for (const propName in node) {
+          if (!Object.prototype.hasOwnProperty.call(node, propName)) {
+            continue;
+          }
+          const nextState = {
+            ...state,
+            keyPath: [...state.keyPath, propName]
+          };
+          out[propName] = traverse(node[propName], nextState);
+        }
+        return out;
+      } else {
+        return visitors.reduce((acc, visitNode) => visitNode(acc, state), node);
+      }
+    };
+  }
+  function getTreeWalkerRequestTransformer(visitors, initialState) {
+    return (request) => {
+      const traverse = getTreeWalker(visitors);
+      return Object.freeze({
+        ...request,
+        params: traverse(request.params, initialState)
+      });
+    };
+  }
+  function getTreeWalkerResponseTransformer(visitors, initialState) {
+    return (json) => getTreeWalker(visitors)(json, initialState);
+  }
+  function getBigIntDowncastRequestTransformer() {
+    return getTreeWalkerRequestTransformer([downcastNodeToNumberIfBigint], { keyPath: [] });
+  }
+  function downcastNodeToNumberIfBigint(value) {
+    return typeof value === "bigint" ? (
+      // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana
+      // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely
+      // downcasting `bigints` to `numbers`.
+      Number(value)
+    ) : value;
+  }
+  function getDefaultCommitmentRequestTransformer({
+    defaultCommitment,
+    optionsObjectPositionByMethod
+  }) {
+    return (request) => {
+      const { params, methodName } = request;
+      if (!Array.isArray(params)) {
+        return request;
+      }
+      const optionsObjectPositionInParams = optionsObjectPositionByMethod[methodName];
+      if (optionsObjectPositionInParams == null) {
+        return request;
+      }
+      return Object.freeze({
+        methodName,
+        params: applyDefaultCommitment({
+          commitmentPropertyName: methodName === "sendTransaction" ? "preflightCommitment" : "commitment",
+          optionsObjectPositionInParams,
+          overrideCommitment: defaultCommitment,
+          params
+        })
+      });
+    };
+  }
   function applyDefaultCommitment({
     commitmentPropertyName,
     params,
@@ -3316,13 +3519,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
     return params;
   }
-  function downcastNodeToNumberIfBigint(value) {
-    return typeof value === "bigint" ? (
-      // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana
-      // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely
-      // downcasting `bigints` to `numbers`.
-      Number(value)
-    ) : value;
+  function getIntegerOverflowRequestTransformer(onIntegerOverflow) {
+    return (request) => {
+      const transformer = getTreeWalkerRequestTransformer(
+        [getIntegerOverflowNodeVisitor((...args) => onIntegerOverflow(request, ...args))],
+        { keyPath: [] }
+      );
+      return transformer(request);
+    };
   }
   function getIntegerOverflowNodeVisitor(onIntegerOverflow) {
     return (value, { keyPath }) => {
@@ -3344,15 +3548,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     getBlockProduction: 0,
     getBlocks: 2,
     getBlocksWithLimit: 2,
-    getConfirmedBlock: 1,
-    getConfirmedBlocks: 1,
-    getConfirmedBlocksWithLimit: 2,
-    getConfirmedSignaturesForAddress2: 1,
-    getConfirmedTransaction: 1,
     getEpochInfo: 0,
-    getFeeCalculatorForBlockhash: 1,
     getFeeForMessage: 1,
-    getFees: 1,
     getInflationGovernor: 0,
     getInflationReward: 1,
     getLargestAccounts: 0,
@@ -3361,11 +3558,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     getMinimumBalanceForRentExemption: 1,
     getMultipleAccounts: 1,
     getProgramAccounts: 1,
-    getRecentBlockhash: 1,
     getSignaturesForAddress: 1,
     getSlot: 0,
     getSlotLeader: 0,
-    getStakeActivation: 1,
     getStakeMinimumDelegation: 0,
     getSupply: 0,
     getTokenAccountBalance: 1,
@@ -3384,73 +3579,33 @@ this.globalThis.solanaWeb3 = (function (exports) {
     signatureNotifications: 1,
     simulateTransaction: 1
   };
-  var KEYPATH_WILDCARD = {};
-  function getTreeWalker(visitors) {
-    return function traverse(node, state) {
-      if (Array.isArray(node)) {
-        return node.map((element, ii) => {
-          const nextState = {
-            ...state,
-            keyPath: [...state.keyPath, ii]
-          };
-          return traverse(element, nextState);
-        });
-      } else if (typeof node === "object" && node !== null) {
-        const out = {};
-        for (const propName in node) {
-          if (!Object.prototype.hasOwnProperty.call(node, propName)) {
-            continue;
-          }
-          const nextState = {
-            ...state,
-            keyPath: [...state.keyPath, propName]
-          };
-          out[propName] = traverse(node[propName], nextState);
-        }
-        return out;
-      } else {
-        return visitors.reduce((acc, visitNode) => visitNode(acc, state), node);
-      }
-    };
-  }
-  function getDefaultParamsTransformerForSolanaRpc(config) {
-    const defaultCommitment = config == null ? void 0 : config.defaultCommitment;
+  function getDefaultRequestTransformerForSolanaRpc(config) {
     const handleIntegerOverflow = config == null ? void 0 : config.onIntegerOverflow;
-    return (rawParams, methodName) => {
-      const traverse = getTreeWalker([
-        ...handleIntegerOverflow ? [getIntegerOverflowNodeVisitor((...args) => handleIntegerOverflow(methodName, ...args))] : [],
-        downcastNodeToNumberIfBigint
-      ]);
-      const initialState = {
-        keyPath: []
-      };
-      const patchedParams = traverse(rawParams, initialState);
-      if (!Array.isArray(patchedParams)) {
-        return patchedParams;
-      }
-      const optionsObjectPositionInParams = OPTIONS_OBJECT_POSITION_BY_METHOD[methodName];
-      if (optionsObjectPositionInParams == null) {
-        return patchedParams;
-      }
+    return (request) => {
       return pipe(
-        patchedParams,
-        (params) => applyDefaultCommitment({
-          commitmentPropertyName: methodName === "sendTransaction" ? "preflightCommitment" : "commitment",
-          optionsObjectPositionInParams,
-          overrideCommitment: defaultCommitment,
-          params
-        }),
-        // FIXME Remove when https://github.com/anza-xyz/agave/pull/483 is deployed.
-        (params) => methodName === "sendTransaction" ? applyFixForIssue479(params) : params
+        request,
+        handleIntegerOverflow ? getIntegerOverflowRequestTransformer(handleIntegerOverflow) : (r) => r,
+        getBigIntDowncastRequestTransformer(),
+        getDefaultCommitmentRequestTransformer({
+          defaultCommitment: config == null ? void 0 : config.defaultCommitment,
+          optionsObjectPositionByMethod: OPTIONS_OBJECT_POSITION_BY_METHOD
+        })
       );
     };
   }
-  function applyFixForIssue479(params) {
-    var _a;
-    if (((_a = params[1]) == null ? void 0 : _a.skipPreflight) !== true) {
-      return params;
-    }
-    return [params[0], { ...params[1], preflightCommitment: "processed" }, ...params.slice(2)];
+  function getBigIntUpcastResponseTransformer(allowedNumericKeyPaths) {
+    return getTreeWalkerResponseTransformer([getBigIntUpcastVisitor(allowedNumericKeyPaths)], { keyPath: [] });
+  }
+  function getBigIntUpcastVisitor(allowedNumericKeyPaths) {
+    return function upcastNodeToBigIntIfNumber(value, { keyPath }) {
+      const isInteger = typeof value === "number" && Number.isInteger(value) || typeof value === "bigint";
+      if (!isInteger) return value;
+      if (keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths)) {
+        return Number(value);
+      } else {
+        return BigInt(value);
+      }
+    };
   }
   function keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths) {
     return allowedNumericKeyPaths.some((prohibitedKeyPath) => {
@@ -3467,26 +3622,35 @@ this.globalThis.solanaWeb3 = (function (exports) {
       return true;
     });
   }
-  function getBigIntUpcastVisitor(allowedNumericKeyPaths) {
-    return function upcastNodeToBigIntIfNumber(value, { keyPath }) {
-      if (typeof value === "number" && Number.isInteger(value) && !keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths)) {
-        return BigInt(value);
-      } else {
-        return value;
+  function getResultResponseTransformer() {
+    return (json) => json.result;
+  }
+  function getThrowSolanaErrorResponseTransformer() {
+    return (json) => {
+      const jsonRpcResponse = json;
+      if ("error" in jsonRpcResponse) {
+        throw getSolanaErrorFromJsonRpcError(jsonRpcResponse.error);
       }
+      return jsonRpcResponse;
     };
   }
   function getDefaultResponseTransformerForSolanaRpc(config) {
-    return (rawResponse, methodName) => {
-      if ("error" in rawResponse) {
-        throw getSolanaErrorFromJsonRpcError(rawResponse.error);
-      }
+    return (response, request) => {
+      const methodName = request.methodName;
       const keyPaths = (config == null ? void 0 : config.allowedNumericKeyPaths) && methodName ? config.allowedNumericKeyPaths[methodName] : void 0;
-      const traverse = getTreeWalker([getBigIntUpcastVisitor(keyPaths != null ? keyPaths : [])]);
-      const initialState = {
-        keyPath: []
-      };
-      return traverse(rawResponse.result, initialState);
+      return pipe(
+        response,
+        (r) => getThrowSolanaErrorResponseTransformer()(r, request),
+        (r) => getResultResponseTransformer()(r, request),
+        (r) => getBigIntUpcastResponseTransformer(keyPaths != null ? keyPaths : [])(r, request)
+      );
+    };
+  }
+  function getDefaultResponseTransformerForSolanaRpcSubscriptions(config) {
+    return (response, request) => {
+      const methodName = request.methodName;
+      const keyPaths = (config == null ? void 0 : config.allowedNumericKeyPaths) && methodName ? config.allowedNumericKeyPaths[methodName] : void 0;
+      return pipe(response, (r) => getBigIntUpcastResponseTransformer(keyPaths != null ? keyPaths : [])(r, request));
     };
   }
   var jsonParsedTokenAccountsConfigs = [
@@ -3542,8 +3706,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // ../rpc-api/dist/index.browser.mjs
   function createSolanaRpcApi(config) {
-    return createRpcApi({
-      parametersTransformer: getDefaultParamsTransformerForSolanaRpc(config),
+    return createJsonRpcApi({
+      requestTransformer: getDefaultRequestTransformerForSolanaRpc(config),
       responseTransformer: getDefaultResponseTransformerForSolanaRpc({
         allowedNumericKeyPaths: getAllowedNumericKeypaths()
       })
@@ -3555,7 +3719,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       memoizedKeypaths = {
         getAccountInfo: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
         getBlock: [
-          ["blockTime"],
           ["transactions", KEYPATH_WILDCARD, "meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
           [
             "transactions",
@@ -3588,7 +3751,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
           ...messageConfig.map((c) => ["transactions", KEYPATH_WILDCARD, "transaction", "message", ...c]),
           ["rewards", KEYPATH_WILDCARD, "commission"]
         ],
-        getBlockTime: [[]],
         getClusterNodes: [
           [KEYPATH_WILDCARD, "featureSet"],
           [KEYPATH_WILDCARD, "shredVersion"]
@@ -3655,31 +3817,33 @@ this.globalThis.solanaWeb3 = (function (exports) {
     "content-length": true,
     "content-type": true
   };
-  var FORBIDDEN_HEADERS = {
-    "accept-charset": true,
-    "accept-encoding": true,
-    "access-control-request-headers": true,
-    "access-control-request-method": true,
-    connection: true,
-    "content-length": true,
-    cookie: true,
-    date: true,
-    dnt: true,
-    expect: true,
-    host: true,
-    "keep-alive": true,
-    origin: true,
-    "permissions-policy": true,
-    // Prefix matching is implemented in code, below.
-    // 'proxy-': true,
-    // 'sec-': true,
-    referer: true,
-    te: true,
-    trailer: true,
-    "transfer-encoding": true,
-    upgrade: true,
-    via: true
-  };
+  var FORBIDDEN_HEADERS = /* @__PURE__ */ Object.assign(
+    {
+      "accept-charset": true,
+      "access-control-request-headers": true,
+      "access-control-request-method": true,
+      connection: true,
+      "content-length": true,
+      cookie: true,
+      date: true,
+      dnt: true,
+      expect: true,
+      host: true,
+      "keep-alive": true,
+      origin: true,
+      "permissions-policy": true,
+      // Prefix matching is implemented in code, below.
+      // 'proxy-': true,
+      // 'sec-': true,
+      referer: true,
+      te: true,
+      trailer: true,
+      "transfer-encoding": true,
+      upgrade: true,
+      via: true
+    },
+    { "accept-encoding": true }
+  );
   function assertIsAllowedHttpRequestHeaders(headers) {
     const badHeaders = Object.keys(headers).filter((headerName) => {
       const lowercaseHeaderName = headerName.toLowerCase();
@@ -3712,7 +3876,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     if ("dispatcher_NODE_ONLY" in config) {
       warnDispatcherWasSuppliedInNonNodeEnvironment();
     }
-    const { headers, url } = config;
+    const { fromJson, headers, toJson, url } = config;
     if (headers) {
       assertIsAllowedHttpRequestHeaders(headers);
     }
@@ -3722,7 +3886,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       payload,
       signal
     }) {
-      const body = JSON.stringify(payload);
+      const body = toJson ? toJson(payload) : JSON.stringify(payload);
       const requestInfo = {
         ...dispatcherConfig,
         body,
@@ -3743,9 +3907,87 @@ this.globalThis.solanaWeb3 = (function (exports) {
           statusCode: response.status
         });
       }
+      if (fromJson) {
+        return fromJson(await response.text(), payload);
+      }
       return await response.json();
     };
   }
+  var SOLANA_RPC_METHODS = [
+    "getAccountInfo",
+    "getBalance",
+    "getBlock",
+    "getBlockCommitment",
+    "getBlockHeight",
+    "getBlockProduction",
+    "getBlocks",
+    "getBlocksWithLimit",
+    "getBlockTime",
+    "getClusterNodes",
+    "getEpochInfo",
+    "getEpochSchedule",
+    "getFeeForMessage",
+    "getFirstAvailableBlock",
+    "getGenesisHash",
+    "getHealth",
+    "getHighestSnapshotSlot",
+    "getIdentity",
+    "getInflationGovernor",
+    "getInflationRate",
+    "getInflationReward",
+    "getLargestAccounts",
+    "getLatestBlockhash",
+    "getLeaderSchedule",
+    "getMaxRetransmitSlot",
+    "getMaxShredInsertSlot",
+    "getMinimumBalanceForRentExemption",
+    "getMultipleAccounts",
+    "getProgramAccounts",
+    "getRecentPerformanceSamples",
+    "getRecentPrioritizationFees",
+    "getSignaturesForAddress",
+    "getSignatureStatuses",
+    "getSlot",
+    "getSlotLeader",
+    "getSlotLeaders",
+    "getStakeMinimumDelegation",
+    "getSupply",
+    "getTokenAccountBalance",
+    "getTokenAccountsByDelegate",
+    "getTokenAccountsByOwner",
+    "getTokenLargestAccounts",
+    "getTokenSupply",
+    "getTransaction",
+    "getTransactionCount",
+    "getVersion",
+    "getVoteAccounts",
+    "index",
+    "isBlockhashValid",
+    "minimumLedgerSlot",
+    "requestAirdrop",
+    "sendTransaction",
+    "simulateTransaction"
+  ];
+  function isSolanaRequest(payload) {
+    return isJsonRpcPayload(payload) && SOLANA_RPC_METHODS.includes(payload.method);
+  }
+  function createHttpTransportForSolanaRpc(config) {
+    return createHttpTransport({
+      ...config,
+      fromJson: (rawResponse, payload) => {
+        if (!isSolanaRequest(payload)) return JSON.parse(rawResponse);
+        const response = parseJsonWithBigInts(rawResponse);
+        if (isErrorResponse(response)) {
+          return { ...response, error: { ...response.error, code: Number(response.error.code) } };
+        }
+        return response;
+      },
+      toJson: (payload) => isSolanaRequest(payload) ? stringifyJsonWithBigints(payload) : JSON.stringify(payload)
+    });
+  }
+  function isErrorResponse(value) {
+    return !!value && typeof value === "object" && "error" in value && !!value.error && typeof value.error === "object" && "code" in value.error;
+  }
 
   // ../fast-stable-stringify/dist/index.browser.mjs
   var objToString = Object.prototype.toString;
@@ -3854,8 +4096,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   var DEFAULT_RPC_CONFIG = {
     defaultCommitment: "confirmed",
-    onIntegerOverflow(methodName, keyPath, value) {
-      throw createSolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
+    onIntegerOverflow(request, keyPath, value) {
+      throw createSolanaJsonRpcIntegerOverflowError(request.methodName, keyPath, value);
     }
   };
   var EXPLICIT_ABORT_TOKEN;
@@ -3866,14 +4108,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
     let coalescedRequestsByDeduplicationKey;
-    return async function makeCoalescedHttpRequest(config) {
-      const { payload, signal } = config;
+    return async function makeCoalescedHttpRequest(request) {
+      const { payload, signal } = request;
       const deduplicationKey = getDeduplicationKey(payload);
       if (deduplicationKey === void 0) {
-        return await transport(config);
+        return await transport(request);
       }
       if (!coalescedRequestsByDeduplicationKey) {
-        Promise.resolve().then(() => {
+        queueMicrotask(() => {
           coalescedRequestsByDeduplicationKey = void 0;
         });
         coalescedRequestsByDeduplicationKey = {};
@@ -3883,7 +4125,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
         const responsePromise = (async () => {
           try {
             return await transport({
-              ...config,
+              ...request,
               signal: abortController.signal
             });
           } catch (e3) {
@@ -3907,7 +4149,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
           const handleAbort = (e3) => {
             signal.removeEventListener("abort", handleAbort);
             coalescedRequest.numConsumers -= 1;
-            Promise.resolve().then(() => {
+            queueMicrotask(() => {
               if (coalescedRequest.numConsumers === 0) {
                 const abortController = coalescedRequest.abortController;
                 abortController.abort(EXPLICIT_ABORT_TOKEN || (EXPLICIT_ABORT_TOKEN = createExplicitAbortToken()));
@@ -3925,12 +4167,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
     };
   }
-  function isJsonRpcPayload(payload) {
-    if (payload == null || typeof payload !== "object" || Array.isArray(payload)) {
-      return false;
-    }
-    return "jsonrpc" in payload && payload.jsonrpc === "2.0" && "method" in payload && typeof payload.method === "string" && "params" in payload;
-  }
   function getSolanaRpcPayloadDeduplicationKey(payload) {
     return isJsonRpcPayload(payload) ? src_default([payload.method, payload.params]) : void 0;
   }
@@ -3942,15 +4178,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return out;
   }
   function createDefaultRpcTransport(config) {
-    var _a;
     return pipe(
-      createHttpTransport({
+      createHttpTransportForSolanaRpc({
         ...config,
         headers: {
+          ...false,
           ...config.headers ? normalizeHeaders2(config.headers) : void 0,
           ...{
             // Keep these headers lowercase so they will override any user-supplied headers above.
-            "solana-client": (_a = `js/${"2.0.0-rc.0"}`) != null ? _a : "UNKNOWN"
+            "solana-client": `js/${"2.0.0-rc.2"}`
           }
         }
       }),
@@ -3967,98 +4203,285 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
 
-  // ../rpc-subscriptions-spec/dist/index.browser.mjs
-  function createSubscriptionRpc(rpcConfig) {
-    return makeProxy2(rpcConfig);
+  // ../subscribable/dist/index.browser.mjs
+  var EXPLICIT_ABORT_TOKEN2;
+  function createExplicitAbortToken2() {
+    return Symbol(
+      "This symbol is thrown from a socket's iterator when the connection is explicitly aborted by the user" 
+    );
   }
-  function makeProxy2(rpcConfig) {
-    return new Proxy(rpcConfig.api, {
-      defineProperty() {
-        return false;
-      },
-      deleteProperty() {
-        return false;
-      },
-      get(target, p, receiver) {
-        return function(...rawParams) {
-          const notificationName = p.toString();
-          const createRpcSubscription = Reflect.get(target, notificationName, receiver);
-          if (p.toString().endsWith("Notifications") === false && !createRpcSubscription) {
-            throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_REQUEST, {
-              notificationName
-            });
-          }
-          const newRequest = createRpcSubscription ? createRpcSubscription(...rawParams) : {
-            params: rawParams,
-            subscribeMethodName: notificationName.replace(/Notifications$/, "Subscribe"),
-            unsubscribeMethodName: notificationName.replace(/Notifications$/, "Unsubscribe")
-          };
-          return createPendingRpcSubscription(rpcConfig, newRequest);
-        };
+  var UNINITIALIZED = Symbol();
+  function createAsyncIterableFromDataPublisher({
+    abortSignal,
+    dataChannelName,
+    dataPublisher,
+    errorChannelName
+  }) {
+    const iteratorState = /* @__PURE__ */ new Map();
+    function publishErrorToAllIterators(reason) {
+      for (const [iteratorKey, state] of iteratorState.entries()) {
+        if (state.__hasPolled) {
+          iteratorState.delete(iteratorKey);
+          state.onError(reason);
+        } else {
+          state.publishQueue.push({
+            __type: 1,
+            err: reason
+          });
+        }
       }
+    }
+    const abortController = new AbortController();
+    abortSignal.addEventListener("abort", () => {
+      abortController.abort();
+      publishErrorToAllIterators(EXPLICIT_ABORT_TOKEN2 || (EXPLICIT_ABORT_TOKEN2 = createExplicitAbortToken2()));
     });
-  }
-  function registerIterableCleanup(iterable, cleanupFn) {
-    (async () => {
-      try {
-        for await (const _ of iterable) ;
-      } catch {
-      } finally {
-        cleanupFn();
-      }
-    })();
-  }
-  function createPendingRpcSubscription(rpcConfig, { params, subscribeMethodName, unsubscribeMethodName, responseTransformer }) {
-    return {
-      async subscribe({ abortSignal }) {
-        abortSignal.throwIfAborted();
-        let subscriptionId;
-        function handleCleanup() {
-          if (subscriptionId !== void 0) {
-            const payload = createRpcMessage(unsubscribeMethodName, [subscriptionId]);
-            connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload).finally(() => {
-              connectionAbortController.abort();
-            });
+    const options = { signal: abortController.signal };
+    let firstError = UNINITIALIZED;
+    dataPublisher.on(
+      errorChannelName,
+      (err) => {
+        if (firstError === UNINITIALIZED) {
+          firstError = err;
+          abortController.abort();
+          publishErrorToAllIterators(err);
+        }
+      },
+      options
+    );
+    dataPublisher.on(
+      dataChannelName,
+      (data) => {
+        iteratorState.forEach((state, iteratorKey) => {
+          if (state.__hasPolled) {
+            const { onData } = state;
+            iteratorState.set(iteratorKey, { __hasPolled: false, publishQueue: [] });
+            onData(data);
           } else {
-            connectionAbortController.abort();
+            state.publishQueue.push({
+              __type: 0,
+              data
+            });
           }
-        }
-        abortSignal.addEventListener("abort", handleCleanup);
-        const connectionAbortController = new AbortController();
-        const subscribeMessage = createRpcMessage(subscribeMethodName, params);
-        const connection = await rpcConfig.transport({
-          payload: subscribeMessage,
-          signal: connectionAbortController.signal
         });
-        function handleConnectionCleanup() {
-          abortSignal.removeEventListener("abort", handleCleanup);
-        }
-        registerIterableCleanup(connection, handleConnectionCleanup);
-        for await (const message of connection) {
-          if ("id" in message && message.id === subscribeMessage.id) {
-            if ("error" in message) {
-              throw getSolanaErrorFromJsonRpcError(message.error);
-            } else {
-              subscriptionId = message.result;
-              break;
+      },
+      options
+    );
+    return {
+      async *[Symbol.asyncIterator]() {
+        if (abortSignal.aborted) {
+          return;
+        }
+        if (firstError !== UNINITIALIZED) {
+          throw firstError;
+        }
+        const iteratorKey = Symbol();
+        iteratorState.set(iteratorKey, { __hasPolled: false, publishQueue: [] });
+        try {
+          while (true) {
+            const state = iteratorState.get(iteratorKey);
+            if (!state) {
+              throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING);
+            }
+            if (state.__hasPolled) {
+              throw new SolanaError(
+                SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE
+              );
+            }
+            const publishQueue = state.publishQueue;
+            try {
+              if (publishQueue.length) {
+                state.publishQueue = [];
+                for (const item of publishQueue) {
+                  if (item.__type === 0) {
+                    yield item.data;
+                  } else {
+                    throw item.err;
+                  }
+                }
+              } else {
+                yield await new Promise((resolve, reject) => {
+                  iteratorState.set(iteratorKey, {
+                    __hasPolled: true,
+                    onData: resolve,
+                    onError: reject
+                  });
+                });
+              }
+            } catch (e3) {
+              if (e3 === (EXPLICIT_ABORT_TOKEN2 || (EXPLICIT_ABORT_TOKEN2 = createExplicitAbortToken2()))) {
+                return;
+              } else {
+                throw e3;
+              }
             }
           }
+        } finally {
+          iteratorState.delete(iteratorKey);
         }
-        if (subscriptionId == null) {
-          throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID);
+      }
+    };
+  }
+  function getDataPublisherFromEventEmitter(eventEmitter) {
+    return {
+      on(channelName, subscriber, options) {
+        function innerListener(ev) {
+          if (ev instanceof CustomEvent) {
+            const data = ev.detail;
+            subscriber(data);
+          } else {
+            subscriber();
+          }
         }
-        return {
-          async *[Symbol.asyncIterator]() {
-            for await (const message of connection) {
-              if (!("params" in message) || message.params.subscription !== subscriptionId) {
-                continue;
-              }
-              const notification = message.params;
-              yield responseTransformer ? responseTransformer(notification, subscribeMethodName) : notification;
+        eventEmitter.addEventListener(channelName, innerListener, options);
+        return () => {
+          eventEmitter.removeEventListener(channelName, innerListener);
+        };
+      }
+    };
+  }
+  function demultiplexDataPublisher(publisher, sourceChannelName, messageTransformer) {
+    let innerPublisherState;
+    const eventTarget = new EventTarget();
+    const demultiplexedDataPublisher = getDataPublisherFromEventEmitter(eventTarget);
+    return {
+      ...demultiplexedDataPublisher,
+      on(channelName, subscriber, options) {
+        if (!innerPublisherState) {
+          const innerPublisherUnsubscribe = publisher.on(sourceChannelName, (sourceMessage) => {
+            const transformResult = messageTransformer(sourceMessage);
+            if (!transformResult) {
+              return;
             }
+            const [destinationChannelName, message] = transformResult;
+            eventTarget.dispatchEvent(
+              new CustomEvent(destinationChannelName, {
+                detail: message
+              })
+            );
+          });
+          innerPublisherState = {
+            dispose: innerPublisherUnsubscribe,
+            numSubscribers: 0
+          };
+        }
+        innerPublisherState.numSubscribers++;
+        const unsubscribe = demultiplexedDataPublisher.on(channelName, subscriber, options);
+        let isActive = true;
+        function handleUnsubscribe() {
+          if (!isActive) {
+            return;
+          }
+          isActive = false;
+          options == null ? void 0 : options.signal.removeEventListener("abort", handleUnsubscribe);
+          innerPublisherState.numSubscribers--;
+          if (innerPublisherState.numSubscribers === 0) {
+            innerPublisherState.dispose();
+            innerPublisherState = void 0;
+          }
+          unsubscribe();
+        }
+        options == null ? void 0 : options.signal.addEventListener("abort", handleUnsubscribe);
+        return handleUnsubscribe;
+      }
+    };
+  }
+
+  // ../promises/dist/index.browser.mjs
+  function isObject(value) {
+    return value !== null && (typeof value === "object" || typeof value === "function");
+  }
+  function addRaceContender(contender) {
+    const deferreds = /* @__PURE__ */ new Set();
+    const record = { deferreds, settled: false };
+    Promise.resolve(contender).then(
+      (value) => {
+        for (const { resolve } of deferreds) {
+          resolve(value);
+        }
+        deferreds.clear();
+        record.settled = true;
+      },
+      (err) => {
+        for (const { reject } of deferreds) {
+          reject(err);
+        }
+        deferreds.clear();
+        record.settled = true;
+      }
+    );
+    return record;
+  }
+  var wm = /* @__PURE__ */ new WeakMap();
+  async function safeRace(contenders) {
+    let deferred;
+    const result = new Promise((resolve, reject) => {
+      deferred = { reject, resolve };
+      for (const contender of contenders) {
+        if (!isObject(contender)) {
+          Promise.resolve(contender).then(resolve, reject);
+          continue;
+        }
+        let record = wm.get(contender);
+        if (record === void 0) {
+          record = addRaceContender(contender);
+          record.deferreds.add(deferred);
+          wm.set(contender, record);
+        } else if (record.settled) {
+          Promise.resolve(contender).then(resolve, reject);
+        } else {
+          record.deferreds.add(deferred);
+        }
+      }
+    });
+    return await result.finally(() => {
+      for (const contender of contenders) {
+        if (isObject(contender)) {
+          const record = wm.get(contender);
+          record.deferreds.delete(deferred);
+        }
+      }
+    });
+  }
+
+  // ../rpc-subscriptions-spec/dist/index.browser.mjs
+  function createSubscriptionRpc(rpcConfig) {
+    return new Proxy(rpcConfig.api, {
+      defineProperty() {
+        return false;
+      },
+      deleteProperty() {
+        return false;
+      },
+      get(target, p, receiver) {
+        return function(...rawParams) {
+          const notificationName = p.toString();
+          const createRpcSubscriptionPlan = Reflect.get(target, notificationName, receiver);
+          if (!createRpcSubscriptionPlan) {
+            throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN, {
+              notificationName
+            });
           }
+          const subscriptionPlan = createRpcSubscriptionPlan(...rawParams);
+          return createPendingRpcSubscription(rpcConfig.transport, subscriptionPlan);
         };
       }
+    });
+  }
+  function createPendingRpcSubscription(transport, subscriptionsPlan) {
+    return {
+      async subscribe({ abortSignal }) {
+        const notificationsDataPublisher = await transport({
+          signal: abortSignal,
+          ...subscriptionsPlan
+        });
+        return createAsyncIterableFromDataPublisher({
+          abortSignal,
+          dataChannelName: "notification",
+          dataPublisher: notificationsDataPublisher,
+          errorChannelName: "error"
+        });
+      }
     };
   }
   function createRpcSubscriptionsApi(config) {
@@ -4071,32 +4494,206 @@ this.globalThis.solanaWeb3 = (function (exports) {
       },
       get(...args) {
         const [_, p] = args;
-        const notificationName = p.toString();
-        return function(...rawParams) {
-          const params = (config == null ? void 0 : config.parametersTransformer) ? config == null ? void 0 : config.parametersTransformer(rawParams, notificationName) : rawParams;
-          const responseTransformer = (config == null ? void 0 : config.responseTransformer) ? config == null ? void 0 : config.responseTransformer : (rawResponse) => rawResponse;
-          const subscribeMethodName = (config == null ? void 0 : config.subscribeNotificationNameTransformer) ? config == null ? void 0 : config.subscribeNotificationNameTransformer(notificationName) : notificationName;
-          const unsubscribeMethodName = (config == null ? void 0 : config.unsubscribeNotificationNameTransformer) ? config == null ? void 0 : config.unsubscribeNotificationNameTransformer(notificationName) : notificationName;
+        const methodName = p.toString();
+        return function(...params) {
+          const rawRequest = { methodName, params };
+          const request = config.requestTransformer ? config.requestTransformer(rawRequest) : rawRequest;
           return {
-            params,
-            responseTransformer,
-            subscribeMethodName,
-            unsubscribeMethodName
+            execute(planConfig) {
+              return config.planExecutor({ ...planConfig, request });
+            },
+            request
           };
         };
       }
     });
   }
+  function transformChannelInboundMessages(channel, transform) {
+    return Object.freeze({
+      ...channel,
+      on(type, subscriber, options) {
+        if (type !== "message") {
+          return channel.on(
+            type,
+            subscriber,
+            options
+          );
+        }
+        return channel.on(
+          "message",
+          (message) => subscriber(transform(message)),
+          options
+        );
+      }
+    });
+  }
+  function transformChannelOutboundMessages(channel, transform) {
+    return Object.freeze({
+      ...channel,
+      send: (message) => channel.send(transform(message))
+    });
+  }
+  var subscriberCountBySubscriptionIdByChannel = /* @__PURE__ */ new WeakMap();
+  function decrementSubscriberCountAndReturnNewCount(channel, subscriptionId) {
+    return augmentSubscriberCountAndReturnNewCount(-1, channel, subscriptionId);
+  }
+  function incrementSubscriberCount(channel, subscriptionId) {
+    augmentSubscriberCountAndReturnNewCount(1, channel, subscriptionId);
+  }
+  function augmentSubscriberCountAndReturnNewCount(amount, channel, subscriptionId) {
+    if (subscriptionId === void 0) {
+      return;
+    }
+    let subscriberCountBySubscriptionId = subscriberCountBySubscriptionIdByChannel.get(channel);
+    if (!subscriberCountBySubscriptionId && amount > 0) {
+      subscriberCountBySubscriptionIdByChannel.set(
+        channel,
+        subscriberCountBySubscriptionId = { [subscriptionId]: 0 }
+      );
+    }
+    if ((subscriberCountBySubscriptionId == null ? void 0 : subscriberCountBySubscriptionId[subscriptionId]) !== void 0) {
+      return subscriberCountBySubscriptionId[subscriptionId] = amount + subscriberCountBySubscriptionId[subscriptionId];
+    }
+  }
+  var cache = /* @__PURE__ */ new WeakMap();
+  function getMemoizedDemultiplexedNotificationPublisherFromChannelAndResponseTransformer(channel, subscribeRequest, responseTransformer) {
+    let publisherByResponseTransformer = cache.get(channel);
+    if (!publisherByResponseTransformer) {
+      cache.set(channel, publisherByResponseTransformer = /* @__PURE__ */ new WeakMap());
+    }
+    const responseTransformerKey = responseTransformer != null ? responseTransformer : channel;
+    let publisher = publisherByResponseTransformer.get(responseTransformerKey);
+    if (!publisher) {
+      publisherByResponseTransformer.set(
+        responseTransformerKey,
+        publisher = demultiplexDataPublisher(channel, "message", (rawMessage) => {
+          const message = rawMessage;
+          if (!("method" in message)) {
+            return;
+          }
+          const transformedNotification = responseTransformer ? responseTransformer(message.params.result, subscribeRequest) : message.params.result;
+          return [`notification:${message.params.subscription}`, transformedNotification];
+        })
+      );
+    }
+    return publisher;
+  }
+  async function executeRpcPubSubSubscriptionPlan({
+    channel,
+    responseTransformer,
+    signal,
+    subscribeRequest,
+    unsubscribeMethodName
+  }) {
+    let subscriptionId;
+    channel.on(
+      "error",
+      () => {
+        subscriptionId = void 0;
+        subscriberCountBySubscriptionIdByChannel.delete(channel);
+      },
+      { signal }
+    );
+    const abortPromise = new Promise((_, reject) => {
+      function handleAbort() {
+        if (decrementSubscriberCountAndReturnNewCount(channel, subscriptionId) === 0) {
+          const unsubscribePayload = createRpcMessage({
+            methodName: unsubscribeMethodName,
+            params: [subscriptionId]
+          });
+          subscriptionId = void 0;
+          channel.send(unsubscribePayload).catch(() => {
+          });
+        }
+        reject(this.reason);
+      }
+      if (signal.aborted) {
+        handleAbort.call(signal);
+      } else {
+        signal.addEventListener("abort", handleAbort);
+      }
+    });
+    const subscribePayload = createRpcMessage(subscribeRequest);
+    await channel.send(subscribePayload);
+    const subscriptionIdPromise = new Promise((resolve, reject) => {
+      const abortController = new AbortController();
+      signal.addEventListener("abort", abortController.abort.bind(abortController));
+      const options = { signal: abortController.signal };
+      channel.on(
+        "error",
+        (err) => {
+          abortController.abort();
+          reject(err);
+        },
+        options
+      );
+      channel.on(
+        "message",
+        (message) => {
+          if (message && typeof message === "object" && "id" in message && message.id === subscribePayload.id) {
+            abortController.abort();
+            if ("error" in message) {
+              reject(getSolanaErrorFromJsonRpcError(message.error));
+            } else {
+              resolve(message.result);
+            }
+          }
+        },
+        options
+      );
+    });
+    subscriptionId = await safeRace([abortPromise, subscriptionIdPromise]);
+    if (subscriptionId == null) {
+      throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID);
+    }
+    incrementSubscriberCount(channel, subscriptionId);
+    const notificationPublisher = getMemoizedDemultiplexedNotificationPublisherFromChannelAndResponseTransformer(
+      channel,
+      subscribeRequest,
+      responseTransformer
+    );
+    const notificationKey = `notification:${subscriptionId}`;
+    return {
+      on(type, listener, options) {
+        switch (type) {
+          case "notification":
+            return notificationPublisher.on(
+              notificationKey,
+              listener,
+              options
+            );
+          case "error":
+            return channel.on(
+              "error",
+              listener,
+              options
+            );
+          default:
+            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED, {
+              channelName: type,
+              supportedChannelNames: ["notification", "error"]
+            });
+        }
+      }
+    };
+  }
 
   // ../rpc-subscriptions-api/dist/index.browser.mjs
   function createSolanaRpcSubscriptionsApi_INTERNAL(config) {
+    const requestTransformer = getDefaultRequestTransformerForSolanaRpc(config);
+    const responseTransformer = getDefaultResponseTransformerForSolanaRpcSubscriptions({
+      allowedNumericKeyPaths: getAllowedNumericKeypaths2()
+    });
     return createRpcSubscriptionsApi({
-      parametersTransformer: getDefaultParamsTransformerForSolanaRpc(config),
-      responseTransformer: getDefaultResponseTransformerForSolanaRpc({
-        allowedNumericKeyPaths: getAllowedNumericKeypaths2()
-      }),
-      subscribeNotificationNameTransformer: (notificationName) => notificationName.replace(/Notifications$/, "Subscribe"),
-      unsubscribeNotificationNameTransformer: (notificationName) => notificationName.replace(/Notifications$/, "Unsubscribe")
+      planExecutor({ request, ...rest }) {
+        return executeRpcPubSubSubscriptionPlan({
+          ...rest,
+          responseTransformer,
+          subscribeRequest: { ...request, methodName: request.methodName.replace(/Notifications$/, "Subscribe") },
+          unsubscribeMethodName: request.methodName.replace(/Notifications$/, "Unsubscribe")
+        });
+      },
+      requestTransformer
     });
   }
   function createSolanaRpcSubscriptionsApi(config) {
@@ -4113,7 +4710,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       memoizedKeypaths2 = {
         accountNotifications: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
         blockNotifications: [
-          ["value", "block", "blockTime"],
           [
             "value",
             "block",
@@ -4280,184 +4876,133 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return memoizedKeypaths2;
   }
 
-  // ../rpc-subscriptions-transport-websocket/dist/index.browser.mjs
+  // ../rpc-subscriptions-channel-websocket/dist/index.browser.mjs
   var e2 = globalThis.WebSocket;
-  var EXPLICIT_ABORT_TOKEN2;
-  function createExplicitAbortToken2() {
-    return Symbol(
-      "This symbol is thrown from a socket's iterator when the connection is explicitly aborted by the user" 
-    );
-  }
-  async function createWebSocketConnection({
+  var NORMAL_CLOSURE_CODE = 1e3;
+  function createWebSocketChannel({
     sendBufferHighWatermark,
     signal,
     url
   }) {
-    return await new Promise((resolve, reject) => {
-      signal.addEventListener("abort", handleAbort, { once: true });
-      const iteratorState = /* @__PURE__ */ new Map();
-      function errorAndClearAllIteratorStates(reason) {
-        const errorCallbacks = [...iteratorState.values()].filter((state) => state.__hasPolled).map(({ onError }) => onError);
-        iteratorState.clear();
-        errorCallbacks.forEach((cb) => {
-          try {
-            cb(reason);
-          } catch {
-          }
-        });
+    if (signal.aborted) {
+      return Promise.reject(signal.reason);
+    }
+    let bufferDrainWatcher;
+    let hasConnected = false;
+    const listenerRemovers = /* @__PURE__ */ new Set();
+    function cleanupListeners() {
+      listenerRemovers.forEach((r) => {
+        r();
+      });
+      listenerRemovers.clear();
+    }
+    function handleAbort() {
+      cleanupListeners();
+      if (!hasConnected) {
+        rejectOpen(signal.reason);
+      }
+      if (webSocket.readyState !== e2.CLOSED && webSocket.readyState !== e2.CLOSING) {
+        webSocket.close(NORMAL_CLOSURE_CODE);
+      }
+    }
+    function handleClose(ev) {
+      cleanupListeners();
+      bufferDrainWatcher == null ? void 0 : bufferDrainWatcher.onCancel();
+      signal.removeEventListener("abort", handleAbort);
+      webSocket.removeEventListener("close", handleClose);
+      webSocket.removeEventListener("error", handleError);
+      webSocket.removeEventListener("message", handleMessage);
+      webSocket.removeEventListener("open", handleOpen);
+      if (!signal.aborted && !(ev.wasClean && ev.code === NORMAL_CLOSURE_CODE)) {
+        eventTarget.dispatchEvent(
+          new CustomEvent("error", {
+            detail: new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED, {
+              cause: ev
+            })
+          })
+        );
       }
-      function handleAbort() {
-        errorAndClearAllIteratorStates(EXPLICIT_ABORT_TOKEN2 || (EXPLICIT_ABORT_TOKEN2 = createExplicitAbortToken2()));
-        if (webSocket.readyState !== e2.CLOSED && webSocket.readyState !== e2.CLOSING) {
-          webSocket.close(1e3);
-        }
+    }
+    function handleError(ev) {
+      if (signal.aborted) {
+        return;
       }
-      function handleClose(ev) {
-        bufferDrainWatcher == null ? void 0 : bufferDrainWatcher.onCancel();
-        signal.removeEventListener("abort", handleAbort);
-        webSocket.removeEventListener("close", handleClose);
-        webSocket.removeEventListener("error", handleError);
-        webSocket.removeEventListener("open", handleOpen);
-        webSocket.removeEventListener("message", handleMessage);
-        errorAndClearAllIteratorStates(ev);
-      }
-      function handleError(ev) {
-        if (!hasConnected) {
-          reject(
-            new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_FAILED_TO_CONNECT, {
-              errorEvent: ev
-            })
-          );
-        }
+      if (!hasConnected) {
+        const failedToConnectError = new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT, {
+          errorEvent: ev
+        });
+        rejectOpen(failedToConnectError);
+        eventTarget.dispatchEvent(
+          new CustomEvent("error", {
+            detail: failedToConnectError
+          })
+        );
       }
-      let hasConnected = false;
-      let bufferDrainWatcher;
-      function handleOpen() {
-        hasConnected = true;
-        resolve({
-          async send(payload) {
-            const message = JSON.stringify(payload);
-            if (!bufferDrainWatcher && webSocket.readyState === e2.OPEN && webSocket.bufferedAmount > sendBufferHighWatermark) {
-              let onCancel;
-              const promise = new Promise((resolve2, reject2) => {
-                const intervalId = setInterval(() => {
-                  if (webSocket.readyState !== e2.OPEN || !(webSocket.bufferedAmount > sendBufferHighWatermark)) {
-                    clearInterval(intervalId);
-                    bufferDrainWatcher = void 0;
-                    resolve2();
-                  }
-                }, 16);
-                onCancel = () => {
-                  bufferDrainWatcher = void 0;
+    }
+    function handleMessage(ev) {
+      if (signal.aborted) {
+        return;
+      }
+      eventTarget.dispatchEvent(new CustomEvent("message", { detail: ev.data }));
+    }
+    const eventTarget = new EventTarget();
+    const dataPublisher = getDataPublisherFromEventEmitter(eventTarget);
+    function handleOpen() {
+      hasConnected = true;
+      resolveOpen({
+        ...dataPublisher,
+        async send(message) {
+          if (webSocket.readyState !== e2.OPEN) {
+            throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED);
+          }
+          if (!bufferDrainWatcher && webSocket.bufferedAmount > sendBufferHighWatermark) {
+            let onCancel;
+            const promise = new Promise((resolve, reject) => {
+              const intervalId = setInterval(() => {
+                if (webSocket.readyState !== e2.OPEN || !(webSocket.bufferedAmount > sendBufferHighWatermark)) {
                   clearInterval(intervalId);
-                  reject2(
-                    new SolanaError(
-                      SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CLOSED_BEFORE_MESSAGE_BUFFERED
-                    )
-                  );
-                };
-              });
-              bufferDrainWatcher = {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
-                onCancel,
-                promise
-              };
-            }
-            if (bufferDrainWatcher) {
-              await bufferDrainWatcher.promise;
-            }
-            webSocket.send(message);
-          },
-          async *[Symbol.asyncIterator]() {
-            const iteratorKey = Symbol();
-            iteratorState.set(iteratorKey, { __hasPolled: false, queuedMessages: [] });
-            try {
-              while (true) {
-                const state = iteratorState.get(iteratorKey);
-                if (!state) {
-                  throw new SolanaError(
-                    SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_STATE_MISSING
-                  );
-                }
-                if (state.__hasPolled) {
-                  throw new SolanaError(
-                    SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE
-                  );
-                }
-                const queuedMessages = state.queuedMessages;
-                if (queuedMessages.length) {
-                  state.queuedMessages = [];
-                  yield* queuedMessages;
-                } else {
-                  try {
-                    yield await new Promise((resolve2, reject2) => {
-                      iteratorState.set(iteratorKey, {
-                        __hasPolled: true,
-                        onError: reject2,
-                        onMessage: resolve2
-                      });
-                    });
-                  } catch (e22) {
-                    if (e22 === (EXPLICIT_ABORT_TOKEN2 || (EXPLICIT_ABORT_TOKEN2 = createExplicitAbortToken2()))) {
-                      return;
-                    } else {
-                      throw new SolanaError(
-                        SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CONNECTION_CLOSED,
-                        {
-                          cause: e22
-                        }
-                      );
-                    }
-                  }
+                  bufferDrainWatcher = void 0;
+                  resolve();
                 }
-              }
-            } finally {
-              iteratorState.delete(iteratorKey);
-            }
+              }, 16);
+              onCancel = () => {
+                bufferDrainWatcher = void 0;
+                clearInterval(intervalId);
+                reject(
+                  new SolanaError(
+                    SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED
+                  )
+                );
+              };
+            });
+            bufferDrainWatcher = {
+              onCancel,
+              promise
+            };
           }
-        });
-      }
-      function handleMessage({ data }) {
-        const message = JSON.parse(data);
-        iteratorState.forEach((state, iteratorKey) => {
-          if (state.__hasPolled) {
-            const { onMessage } = state;
-            iteratorState.set(iteratorKey, { __hasPolled: false, queuedMessages: [] });
-            onMessage(message);
-          } else {
-            state.queuedMessages.push(message);
+          if (bufferDrainWatcher) {
+            if (ArrayBuffer.isView(message) && !(message instanceof DataView)) {
+              const TypedArrayConstructor = message.constructor;
+              message = new TypedArrayConstructor(message);
+            }
+            await bufferDrainWatcher.promise;
           }
-        });
-      }
-      const webSocket = new e2(url);
-      webSocket.addEventListener("close", handleClose);
-      webSocket.addEventListener("error", handleError);
-      webSocket.addEventListener("open", handleOpen);
-      webSocket.addEventListener("message", handleMessage);
-    });
-  }
-  function createWebSocketTransport({ sendBufferHighWatermark, url }) {
-    if (/^wss?:/i.test(url) === false) {
-      const protocolMatch = url.match(/^([^:]+):/);
-      throw new DOMException(
-        protocolMatch ? `Failed to construct 'WebSocket': The URL's scheme must be either 'ws' or 'wss'. '${protocolMatch[1]}:' is not allowed.` : `Failed to construct 'WebSocket': The URL '${url}' is invalid.`
-      );
-    }
-    return async function sendWebSocketMessage({ payload, signal }) {
-      signal == null ? void 0 : signal.throwIfAborted();
-      const connection = await createWebSocketConnection({
-        sendBufferHighWatermark,
-        signal,
-        url
+          webSocket.send(message);
+        }
       });
-      signal == null ? void 0 : signal.throwIfAborted();
-      await connection.send(payload);
-      return {
-        [Symbol.asyncIterator]: connection[Symbol.asyncIterator].bind(connection),
-        send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: connection.send.bind(connection)
-      };
-    };
+    }
+    const webSocket = new e2(url);
+    signal.addEventListener("abort", handleAbort);
+    webSocket.addEventListener("close", handleClose);
+    webSocket.addEventListener("error", handleError);
+    webSocket.addEventListener("message", handleMessage);
+    webSocket.addEventListener("open", handleOpen);
+    let rejectOpen;
+    let resolveOpen;
+    return new Promise((resolve, reject) => {
+      rejectOpen = reject;
+      resolveOpen = resolve;
+    });
   }
 
   // ../rpc-subscriptions/dist/index.browser.mjs
@@ -4493,317 +5038,302 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   var DEFAULT_RPC_SUBSCRIPTIONS_CONFIG = {
     defaultCommitment: "confirmed",
-    onIntegerOverflow(methodName, keyPath, value) {
-      throw createSolanaJsonRpcIntegerOverflowError2(methodName, keyPath, value);
+    onIntegerOverflow(request, keyPath, value) {
+      throw createSolanaJsonRpcIntegerOverflowError2(request.methodName, keyPath, value);
     }
   };
-  function registerIterableCleanup2(iterable, cleanupFn) {
-    (async () => {
-      try {
-        for await (const _ of iterable) ;
-      } catch {
-      } finally {
-        cleanupFn();
-      }
-    })();
-  }
-  function getCachedAbortableIterableFactory({
-    getAbortSignalFromInputArgs,
-    getCacheKeyFromInputArgs,
-    onCacheHit,
-    onCreateIterable
+  var PING_PAYLOAD = {
+    jsonrpc: "2.0",
+    method: "ping"
+  };
+  function getRpcSubscriptionsChannelWithAutoping({
+    abortSignal: callerAbortSignal,
+    channel,
+    intervalMs
   }) {
-    const cache = /* @__PURE__ */ new Map();
-    function getCacheEntryOrThrow(cacheKey) {
-      const currentCacheEntry = cache.get(cacheKey);
-      if (!currentCacheEntry) {
-        throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING, {
-          cacheKey: cacheKey.toString()
-        });
-      }
-      return currentCacheEntry;
+    let intervalId;
+    function sendPing() {
+      channel.send(PING_PAYLOAD).catch((e3) => {
+        if (isSolanaError(e3, SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED)) {
+          pingerAbortController.abort();
+        }
+      });
     }
-    return async (...args) => {
-      const cacheKey = getCacheKeyFromInputArgs(...args);
-      const signal = getAbortSignalFromInputArgs(...args);
-      if (cacheKey === void 0) {
-        return await onCreateIterable(signal, ...args);
-      }
-      const cleanup = () => {
-        cache.delete(cacheKey);
-        signal.removeEventListener("abort", handleAbort);
-      };
-      const handleAbort = () => {
-        const cacheEntry = getCacheEntryOrThrow(cacheKey);
-        if (cacheEntry.purgeScheduled !== true) {
-          cacheEntry.purgeScheduled = true;
-          globalThis.queueMicrotask(() => {
-            cacheEntry.purgeScheduled = false;
-            if (cacheEntry.referenceCount === 0) {
-              cacheEntry.abortController.abort();
-              cleanup();
-            }
-          });
+    function restartPingTimer() {
+      clearInterval(intervalId);
+      intervalId = setInterval(sendPing, intervalMs);
+    }
+    const pingerAbortController = new AbortController();
+    pingerAbortController.signal.addEventListener("abort", () => {
+      clearInterval(intervalId);
+    });
+    callerAbortSignal.addEventListener("abort", () => {
+      pingerAbortController.abort();
+    });
+    channel.on(
+      "error",
+      () => {
+        pingerAbortController.abort();
+      },
+      { signal: pingerAbortController.signal }
+    );
+    channel.on("message", restartPingTimer, { signal: pingerAbortController.signal });
+    if (globalThis.navigator.onLine) {
+      restartPingTimer();
+    }
+    {
+      globalThis.window.addEventListener(
+        "offline",
+        function handleOffline() {
+          clearInterval(intervalId);
+        },
+        { signal: pingerAbortController.signal }
+      );
+      globalThis.window.addEventListener(
+        "online",
+        function handleOnline() {
+          sendPing();
+          restartPingTimer();
+        },
+        { signal: pingerAbortController.signal }
+      );
+    }
+    return {
+      ...channel,
+      send(...args) {
+        if (!pingerAbortController.signal.aborted) {
+          restartPingTimer();
         }
-        cacheEntry.referenceCount--;
-      };
-      signal.addEventListener("abort", handleAbort);
-      try {
-        const cacheEntry = cache.get(cacheKey);
-        if (!cacheEntry) {
-          const singletonAbortController = new AbortController();
-          const newIterablePromise = onCreateIterable(singletonAbortController.signal, ...args);
-          const newCacheEntry = {
-            abortController: singletonAbortController,
-            iterable: newIterablePromise,
-            purgeScheduled: false,
-            referenceCount: 1
+        return channel.send(...args);
+      }
+    };
+  }
+  function createChannelPool() {
+    return {
+      entries: [],
+      freeChannelIndex: -1
+    };
+  }
+  function getChannelPoolingChannelCreator(createChannel, { maxSubscriptionsPerChannel, minChannels }) {
+    const pool = createChannelPool();
+    function recomputeFreeChannelIndex() {
+      var _a;
+      if (pool.entries.length < minChannels) {
+        pool.freeChannelIndex = -1;
+        return;
+      }
+      let mostFreeChannel;
+      for (let ii = 0; ii < pool.entries.length; ii++) {
+        const nextPoolIndex = (pool.freeChannelIndex + ii + 2) % pool.entries.length;
+        const nextPoolEntry = (
+          // Start from the item two positions after the current item. This way, the
+          // search will finish on the item after the current one. This ensures that, if
+          // any channels tie for having the most capacity, the one that will be chosen is
+          // the one immediately to the current one's right (wrapping around).
+          pool.entries[nextPoolIndex]
+        );
+        if (nextPoolEntry.subscriptionCount < maxSubscriptionsPerChannel && (!mostFreeChannel || mostFreeChannel.subscriptionCount >= nextPoolEntry.subscriptionCount)) {
+          mostFreeChannel = {
+            poolIndex: nextPoolIndex,
+            subscriptionCount: nextPoolEntry.subscriptionCount
           };
-          cache.set(cacheKey, newCacheEntry);
-          const newIterable = await newIterablePromise;
-          registerIterableCleanup2(newIterable, cleanup);
-          newCacheEntry.iterable = newIterable;
-          return newIterable;
-        } else {
-          cacheEntry.referenceCount++;
-          const iterableOrIterablePromise = cacheEntry.iterable;
-          const cachedIterable = "then" in iterableOrIterablePromise ? await iterableOrIterablePromise : iterableOrIterablePromise;
-          await onCacheHit(cachedIterable, ...args);
-          return cachedIterable;
         }
-      } catch (e3) {
-        cleanup();
-        throw e3;
       }
+      pool.freeChannelIndex = (_a = mostFreeChannel == null ? void 0 : mostFreeChannel.poolIndex) != null ? _a : -1;
+    }
+    return function getExistingChannelWithMostCapacityOrCreateChannel({ abortSignal }) {
+      let poolEntry;
+      function destroyPoolEntry() {
+        const index = pool.entries.findIndex((entry) => entry === poolEntry);
+        pool.entries.splice(index, 1);
+        poolEntry.dispose();
+        recomputeFreeChannelIndex();
+      }
+      if (pool.freeChannelIndex === -1) {
+        const abortController = new AbortController();
+        const newChannelPromise = createChannel({ abortSignal: abortController.signal });
+        newChannelPromise.then((newChannel) => {
+          newChannel.on("error", destroyPoolEntry, { signal: abortController.signal });
+        }).catch(destroyPoolEntry);
+        poolEntry = {
+          channel: newChannelPromise,
+          dispose() {
+            abortController.abort();
+          },
+          subscriptionCount: 0
+        };
+        pool.entries.push(poolEntry);
+      } else {
+        poolEntry = pool.entries[pool.freeChannelIndex];
+      }
+      poolEntry.subscriptionCount++;
+      abortSignal.addEventListener("abort", function destroyConsumer() {
+        poolEntry.subscriptionCount--;
+        if (poolEntry.subscriptionCount === 0) {
+          destroyPoolEntry();
+        } else if (pool.freeChannelIndex !== -1) {
+          pool.freeChannelIndex--;
+          recomputeFreeChannelIndex();
+        }
+      });
+      recomputeFreeChannelIndex();
+      return poolEntry.channel;
     };
   }
-  var EXPLICIT_ABORT_TOKEN3;
-  function createExplicitAbortToken3() {
-    return Symbol(
-      "This symbol is thrown from a subscription's iterator when the subscription is explicitly aborted by the user" 
+  function getRpcSubscriptionsChannelWithJSONSerialization(channel) {
+    return pipe(
+      channel,
+      (c) => transformChannelInboundMessages(c, JSON.parse),
+      (c) => transformChannelOutboundMessages(c, JSON.stringify)
     );
   }
-  function registerIterableCleanup22(iterable, cleanupFn) {
-    (async () => {
-      try {
-        for await (const _ of iterable) ;
-      } catch {
-      } finally {
-        cleanupFn();
-      }
-    })();
+  function getRpcSubscriptionsChannelWithBigIntJSONSerialization(channel) {
+    return pipe(
+      channel,
+      (c) => transformChannelInboundMessages(c, parseJsonWithBigInts),
+      (c) => transformChannelOutboundMessages(c, stringifyJsonWithBigints)
+    );
   }
-  function getRpcSubscriptionsWithSubscriptionCoalescing({
-    getDeduplicationKey,
-    rpcSubscriptions
-  }) {
-    const cache = /* @__PURE__ */ new Map();
-    return new Proxy(rpcSubscriptions, {
-      defineProperty() {
-        return false;
-      },
-      deleteProperty() {
-        return false;
-      },
-      get(target, p, receiver) {
-        const subscriptionMethod = Reflect.get(target, p, receiver);
-        if (typeof subscriptionMethod !== "function") {
-          return subscriptionMethod;
-        }
-        return function(...rawParams) {
-          const deduplicationKey = getDeduplicationKey(p, rawParams);
-          if (deduplicationKey === void 0) {
-            return subscriptionMethod(...rawParams);
-          }
-          if (cache.has(deduplicationKey)) {
-            return cache.get(deduplicationKey);
-          }
-          const iterableFactory = getCachedAbortableIterableFactory({
-            getAbortSignalFromInputArgs: ({ abortSignal }) => abortSignal,
-            getCacheKeyFromInputArgs: () => deduplicationKey,
-            async onCacheHit(_iterable, _config) {
-            },
-            async onCreateIterable(abortSignal, config) {
-              const pendingSubscription2 = subscriptionMethod(
-                ...rawParams
-              );
-              const iterable = await pendingSubscription2.subscribe({
-                ...config,
-                abortSignal
-              });
-              registerIterableCleanup22(iterable, () => {
-                cache.delete(deduplicationKey);
-              });
-              return iterable;
-            }
-          });
-          const pendingSubscription = {
-            async subscribe(...args) {
-              const iterable = await iterableFactory(...args);
-              const { abortSignal } = args[0];
-              let abortPromise;
-              return {
-                ...iterable,
-                async *[Symbol.asyncIterator]() {
-                  abortPromise || (abortPromise = abortSignal.aborted ? Promise.reject(EXPLICIT_ABORT_TOKEN3 || (EXPLICIT_ABORT_TOKEN3 = createExplicitAbortToken3())) : new Promise((_, reject) => {
-                    abortSignal.addEventListener("abort", () => {
-                      reject(EXPLICIT_ABORT_TOKEN3 || (EXPLICIT_ABORT_TOKEN3 = createExplicitAbortToken3()));
-                    });
-                  }));
-                  try {
-                    const iterator = iterable[Symbol.asyncIterator]();
-                    while (true) {
-                      const iteratorResult = await Promise.race([iterator.next(), abortPromise]);
-                      if (iteratorResult.done) {
-                        return;
-                      } else {
-                        yield iteratorResult.value;
-                      }
-                    }
-                  } catch (e3) {
-                    if (e3 === (EXPLICIT_ABORT_TOKEN3 || (EXPLICIT_ABORT_TOKEN3 = createExplicitAbortToken3()))) {
-                      return;
-                    }
-                    cache.delete(deduplicationKey);
-                    throw e3;
-                  }
-                }
-              };
-            }
-          };
-          cache.set(deduplicationKey, pendingSubscription);
-          return pendingSubscription;
-        };
-      }
+  function createDefaultSolanaRpcSubscriptionsChannelCreator(config) {
+    return createDefaultRpcSubscriptionsChannelCreatorImpl({
+      ...config,
+      jsonSerializer: getRpcSubscriptionsChannelWithBigIntJSONSerialization
     });
   }
-  var PING_PAYLOAD = {
-    jsonrpc: "2.0",
-    method: "ping"
-  };
-  function getWebSocketTransportWithAutoping({
-    intervalMs,
-    transport
-  }) {
-    const pingableConnections = /* @__PURE__ */ new Map();
-    return async (...args) => {
-      const connection = await transport(...args);
-      let intervalId;
-      function sendPing() {
-        connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(PING_PAYLOAD);
-      }
-      function restartPingTimer() {
-        clearInterval(intervalId);
-        intervalId = setInterval(sendPing, intervalMs);
-      }
-      if (pingableConnections.has(connection) === false) {
-        pingableConnections.set(connection, {
-          [Symbol.asyncIterator]: connection[Symbol.asyncIterator].bind(connection),
-          send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: (...args2) => {
-            restartPingTimer();
-            return connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(...args2);
-          }
+  function createDefaultRpcSubscriptionsChannelCreator(config) {
+    return createDefaultRpcSubscriptionsChannelCreatorImpl({
+      ...config,
+      jsonSerializer: getRpcSubscriptionsChannelWithJSONSerialization
+    });
+  }
+  function createDefaultRpcSubscriptionsChannelCreatorImpl(config) {
+    var _a, _b;
+    if (/^wss?:/i.test(config.url) === false) {
+      const protocolMatch = config.url.match(/^([^:]+):/);
+      throw new DOMException(
+        protocolMatch ? `Failed to construct 'WebSocket': The URL's scheme must be either 'ws' or 'wss'. '${protocolMatch[1]}:' is not allowed.` : `Failed to construct 'WebSocket': The URL '${config.url}' is invalid.`
+      );
+    }
+    const { intervalMs, ...rest } = config;
+    const createDefaultRpcSubscriptionsChannel = ({ abortSignal }) => {
+      var _a2;
+      return createWebSocketChannel({
+        ...rest,
+        sendBufferHighWatermark: (_a2 = config.sendBufferHighWatermark) != null ? _a2 : (
+          // Let 128KB of data into the WebSocket buffer before buffering it in the app.
+          131072
+        ),
+        signal: abortSignal
+      }).then(config.jsonSerializer).then(
+        (channel) => getRpcSubscriptionsChannelWithAutoping({
+          abortSignal,
+          channel,
+          intervalMs: intervalMs != null ? intervalMs : 5e3
+        })
+      );
+    };
+    return getChannelPoolingChannelCreator(createDefaultRpcSubscriptionsChannel, {
+      maxSubscriptionsPerChannel: (_a = config.maxSubscriptionsPerChannel) != null ? _a : (
+        /**
+        * A note about this default. The idea here is that, because some RPC providers impose
+        * an upper limit on the number of subscriptions you can make per channel, we must
+        * choose a number low enough to avoid hitting that limit. Without knowing what provider
+        * a given person is using, or what their limit is, we have to choose the lowest of all
+        * known limits. As of this writing (October 2024) that is the public mainnet RPC node
+        * (api.mainnet-beta.solana.com) at 100 subscriptions.
+        */
+        100
+      ),
+      minChannels: (_b = config.minChannels) != null ? _b : 1
+    });
+  }
+  function getRpcSubscriptionsTransportWithSubscriptionCoalescing(transport) {
+    const cache2 = /* @__PURE__ */ new Map();
+    return function rpcSubscriptionsTransportWithSubscriptionCoalescing(config) {
+      const { request, signal } = config;
+      const subscriptionConfigurationHash = src_default([request.methodName, request.params]);
+      let cachedDataPublisherPromise = cache2.get(subscriptionConfigurationHash);
+      if (!cachedDataPublisherPromise) {
+        const abortController = new AbortController();
+        const dataPublisherPromise = transport({
+          ...config,
+          signal: abortController.signal
         });
-        (async () => {
-          try {
-            for await (const _ of connection) {
-              restartPingTimer();
-            }
-          } catch {
-          } finally {
-            pingableConnections.delete(connection);
-            clearInterval(intervalId);
-            if (handleOffline) {
-              globalThis.window.removeEventListener("offline", handleOffline);
-            }
-            if (handleOnline) {
-              globalThis.window.removeEventListener("online", handleOnline);
-            }
+        dataPublisherPromise.then((dataPublisher) => {
+          dataPublisher.on(
+            "error",
+            () => {
+              cache2.delete(subscriptionConfigurationHash);
+              abortController.abort();
+            },
+            { signal: abortController.signal }
+          );
+        }).catch(() => {
+        });
+        cache2.set(
+          subscriptionConfigurationHash,
+          cachedDataPublisherPromise = {
+            abortController,
+            dataPublisherPromise,
+            numSubscribers: 0
           }
-        })();
-        if (globalThis.navigator.onLine) {
-          restartPingTimer();
-        }
-        let handleOffline;
-        let handleOnline;
-        {
-          handleOffline = () => {
-            clearInterval(intervalId);
-          };
-          handleOnline = () => {
-            sendPing();
-            restartPingTimer();
-          };
-          globalThis.window.addEventListener("offline", handleOffline);
-          globalThis.window.addEventListener("online", handleOnline);
-        }
+        );
       }
-      return pingableConnections.get(connection);
+      cachedDataPublisherPromise.numSubscribers++;
+      signal.addEventListener(
+        "abort",
+        () => {
+          cachedDataPublisherPromise.numSubscribers--;
+          if (cachedDataPublisherPromise.numSubscribers === 0) {
+            queueMicrotask(() => {
+              if (cachedDataPublisherPromise.numSubscribers === 0) {
+                cache2.delete(subscriptionConfigurationHash);
+                cachedDataPublisherPromise.abortController.abort();
+              }
+            });
+          }
+        },
+        { signal: cachedDataPublisherPromise.abortController.signal }
+      );
+      return cachedDataPublisherPromise.dataPublisherPromise;
     };
   }
-  var NULL_SHARD_CACHE_KEY;
-  function createNullShardCacheKey() {
-    return Symbol("Cache key to use when there is no connection sharding strategy" );
-  }
-  function getWebSocketTransportWithConnectionSharding({
-    getShard,
-    transport
+  function createDefaultRpcSubscriptionsTransport({
+    createChannel
   }) {
-    return getCachedAbortableIterableFactory({
-      getAbortSignalFromInputArgs: ({ signal }) => signal,
-      getCacheKeyFromInputArgs: ({ payload }) => getShard ? getShard(payload) : NULL_SHARD_CACHE_KEY || (NULL_SHARD_CACHE_KEY = createNullShardCacheKey()),
-      onCacheHit: (connection, { payload }) => connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload),
-      onCreateIterable: (abortSignal, config) => transport({
-        ...config,
-        signal: abortSignal
-      })
-    });
-  }
-  function createDefaultRpcSubscriptionsTransport(config) {
-    var _a;
-    const { getShard, intervalMs, ...rest } = config;
     return pipe(
-      createWebSocketTransport({
-        ...rest,
-        sendBufferHighWatermark: (_a = config.sendBufferHighWatermark) != null ? _a : (
-          // Let 128KB of data into the WebSocket buffer before buffering it in the app.
-          131072
-        )
-      }),
-      (transport) => getWebSocketTransportWithAutoping({
-        intervalMs: intervalMs != null ? intervalMs : 5e3,
-        transport
-      }),
-      (transport) => getWebSocketTransportWithConnectionSharding({
-        getShard,
-        transport
-      })
+      createRpcSubscriptionsTransportFromChannelCreator(
+        createChannel
+      ),
+      (transport) => getRpcSubscriptionsTransportWithSubscriptionCoalescing(transport)
     );
   }
-  function createSolanaRpcSubscriptions(clusterUrl, config) {
-    const transport = createDefaultRpcSubscriptionsTransport({ url: clusterUrl, ...config });
+  function createRpcSubscriptionsTransportFromChannelCreator(createChannel) {
+    return async ({ execute, signal }) => {
+      const channel = await createChannel({ abortSignal: signal });
+      return await execute({ channel, signal });
+    };
+  }
+  function createSolanaRpcSubscriptionsImpl(clusterUrl, config) {
+    const transport = createDefaultRpcSubscriptionsTransport({
+      createChannel: createDefaultSolanaRpcSubscriptionsChannelCreator({ ...config, url: clusterUrl })
+    });
     return createSolanaRpcSubscriptionsFromTransport(transport);
   }
+  function createSolanaRpcSubscriptions(clusterUrl, config) {
+    return createSolanaRpcSubscriptionsImpl(clusterUrl, config);
+  }
   function createSolanaRpcSubscriptions_UNSTABLE(clusterUrl, config) {
-    return createSolanaRpcSubscriptions(
+    return createSolanaRpcSubscriptionsImpl(
       clusterUrl,
       config
     );
   }
   function createSolanaRpcSubscriptionsFromTransport(transport) {
-    return pipe(
-      createSubscriptionRpc({
-        api: createSolanaRpcSubscriptionsApi(DEFAULT_RPC_SUBSCRIPTIONS_CONFIG),
-        transport
-      }),
-      (rpcSubscriptions) => getRpcSubscriptionsWithSubscriptionCoalescing({
-        getDeduplicationKey: (...args) => src_default(args),
-        rpcSubscriptions
-      })
-    );
-  }
-  function createSolanaRpcSubscriptionsFromTransport_UNSTABLE(transport) {
-    return createSolanaRpcSubscriptionsFromTransport(transport);
+    return createSubscriptionRpc({
+      api: createSolanaRpcSubscriptionsApi(DEFAULT_RPC_SUBSCRIPTIONS_CONFIG),
+      transport
+    });
   }
 
   // ../rpc-types/dist/index.browser.mjs
@@ -4955,7 +5485,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     try {
       BigInt(putativeBigInt);
       return true;
-    } catch (_) {
+    } catch {
       return false;
     }
   }
@@ -4986,14 +5516,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
     assertIsStringifiedNumber(putativeNumber);
     return putativeNumber;
   }
+  var maxI64Value = 9223372036854775807n;
+  var minI64Value = -9223372036854775808n;
   function isUnixTimestamp(putativeTimestamp) {
-    if (putativeTimestamp > 864e13 || putativeTimestamp < -864e13) {
-      return false;
-    }
-    return true;
+    return putativeTimestamp >= minI64Value && putativeTimestamp <= maxI64Value;
   }
   function assertIsUnixTimestamp(putativeTimestamp) {
-    if (putativeTimestamp > 864e13 || putativeTimestamp < -864e13) {
+    if (putativeTimestamp < minI64Value || putativeTimestamp > maxI64Value) {
       throw new SolanaError(SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE, {
         value: putativeTimestamp
       });
@@ -5578,7 +6107,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return orderedStaticAccounts.map(({ address: address2 }) => address2);
   }
   function compileTransactionMessage(transaction) {
-    const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);
+    const addressMap = getAddressMapFromInstructions(transaction.feePayer.address, transaction.instructions);
     const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
     return {
       ...transaction.version !== "legacy" ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) } : null,
@@ -5717,17 +6246,21 @@ this.globalThis.solanaWeb3 = (function (exports) {
       })
     });
   }
-  function setTransactionMessageFeePayer(feePayer, transaction) {
-    if ("feePayer" in transaction && feePayer === transaction.feePayer) {
-      return transaction;
+  function setTransactionMessageFeePayer(feePayer, transactionMessage) {
+    var _a;
+    if ("feePayer" in transactionMessage && feePayer === ((_a = transactionMessage.feePayer) == null ? void 0 : _a.address) && isAddressOnlyFeePayer(transactionMessage.feePayer)) {
+      return transactionMessage;
     }
     const out = {
-      ...transaction,
-      feePayer
+      ...transactionMessage,
+      feePayer: Object.freeze({ address: feePayer })
     };
     Object.freeze(out);
     return out;
   }
+  function isAddressOnlyFeePayer(feePayer) {
+    return !!feePayer && "address" in feePayer && typeof feePayer.address === "string" && Object.keys(feePayer).length === 1;
+  }
   function appendTransactionMessageInstruction(instruction, transaction) {
     return appendTransactionMessageInstructions([instruction], transaction);
   }
@@ -5961,9 +6494,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function compileTransaction(transactionMessage) {
     const compiledMessage = compileTransactionMessage(transactionMessage);
-    const messageBytes = getCompiledTransactionMessageEncoder().encode(
-      compiledMessage
-    );
+    const messageBytes = getCompiledTransactionMessageEncoder().encode(compiledMessage);
     const transactionSigners = compiledMessage.staticAccounts.slice(0, compiledMessage.header.numSignerAccounts);
     const signatures = {};
     for (const signerAddress of transactionSigners) {
@@ -6080,6 +6611,46 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
     return Object.values(deduplicated);
   }
+  function isTransactionModifyingSigner(value) {
+    return "modifyAndSignTransactions" in value && typeof value.modifyAndSignTransactions === "function";
+  }
+  function assertIsTransactionModifyingSigner(value) {
+    if (!isTransactionModifyingSigner(value)) {
+      throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER, {
+        address: value.address
+      });
+    }
+  }
+  function isTransactionPartialSigner(value) {
+    return "signTransactions" in value && typeof value.signTransactions === "function";
+  }
+  function assertIsTransactionPartialSigner(value) {
+    if (!isTransactionPartialSigner(value)) {
+      throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER, {
+        address: value.address
+      });
+    }
+  }
+  function isTransactionSendingSigner(value) {
+    return "signAndSendTransactions" in value && typeof value.signAndSendTransactions === "function";
+  }
+  function assertIsTransactionSendingSigner(value) {
+    if (!isTransactionSendingSigner(value)) {
+      throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER, {
+        address: value.address
+      });
+    }
+  }
+  function isTransactionSigner(value) {
+    return isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value);
+  }
+  function assertIsTransactionSigner(value) {
+    if (!isTransactionSigner(value)) {
+      throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER, {
+        address: value.address
+      });
+    }
+  }
   function getSignersFromInstruction(instruction) {
     var _a;
     return deduplicateSigners(
@@ -6088,7 +6659,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function getSignersFromTransactionMessage(transaction) {
     return deduplicateSigners([
-      ...transaction.feePayerSigner ? [transaction.feePayerSigner] : [],
+      ...transaction.feePayer && isTransactionSigner(transaction.feePayer) ? [transaction.feePayer] : [],
       ...transaction.instructions.flatMap(getSignersFromInstruction)
     ]);
   }
@@ -6117,19 +6688,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
       instructions: transactionMessage.instructions.map((instruction) => addSignersToInstruction(signers, instruction))
     });
   }
-  function setTransactionMessageFeePayerSigner(feePayerSigner, transactionMessage) {
-    if ("feePayer" in transactionMessage && feePayerSigner.address === transactionMessage.feePayer) {
-      if ("feePayerSigner" in transactionMessage)
-        return transactionMessage;
-      const out2 = { ...transactionMessage, feePayerSigner };
-      Object.freeze(out2);
-      return out2;
-    }
-    const out = {
-      ...transactionMessage,
-      feePayer: feePayerSigner.address,
-      feePayerSigner
-    };
+  function setTransactionMessageFeePayerSigner(feePayer, transactionMessage) {
+    Object.freeze(feePayer);
+    const out = { ...transactionMessage, feePayer };
     Object.freeze(out);
     return out;
   }
@@ -6143,16 +6704,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       });
     }
   }
-  function isTransactionPartialSigner(value) {
-    return "signTransactions" in value && typeof value.signTransactions === "function";
-  }
-  function assertIsTransactionPartialSigner(value) {
-    if (!isTransactionPartialSigner(value)) {
-      throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER, {
-        address: value.address
-      });
-    }
-  }
   function isKeyPairSigner(value) {
     return "keyPair" in value && typeof value.keyPair === "object" && isMessagePartialSigner(value) && isTransactionPartialSigner(value);
   }
@@ -6188,6 +6739,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   async function createKeyPairSignerFromBytes(bytes, extractable) {
     return await createSignerFromKeyPair(await createKeyPairFromBytes(bytes, extractable));
   }
+  async function createKeyPairSignerFromPrivateKeyBytes(bytes, extractable) {
+    return await createSignerFromKeyPair(await createKeyPairFromPrivateKeyBytes(bytes, extractable));
+  }
   function isMessageModifyingSigner(value) {
     return isAddress(value.address) && "modifyAndSignMessages" in value && typeof value.modifyAndSignMessages === "function";
   }
@@ -6216,36 +6770,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
     return Object.freeze(out);
   }
-  function isTransactionModifyingSigner(value) {
-    return "modifyAndSignTransactions" in value && typeof value.modifyAndSignTransactions === "function";
-  }
-  function assertIsTransactionModifyingSigner(value) {
-    if (!isTransactionModifyingSigner(value)) {
-      throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER, {
-        address: value.address
-      });
-    }
-  }
-  function isTransactionSendingSigner(value) {
-    return "signAndSendTransactions" in value && typeof value.signAndSendTransactions === "function";
-  }
-  function assertIsTransactionSendingSigner(value) {
-    if (!isTransactionSendingSigner(value)) {
-      throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER, {
-        address: value.address
-      });
-    }
-  }
-  function isTransactionSigner(value) {
-    return isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value);
-  }
-  function assertIsTransactionSigner(value) {
-    if (!isTransactionSigner(value)) {
-      throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER, {
-        address: value.address
-      });
-    }
-  }
   function isTransactionMessageWithSingleSendingSigner(transaction) {
     try {
       assertIsTransactionMessageWithSingleSendingSigner(transaction);
@@ -6381,6 +6905,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       commitment,
       lastValidBlockHeight
     }) {
+      callerAbortSignal.throwIfAborted();
       const abortController = new AbortController();
       const handleAbort = () => {
         abortController.abort();
@@ -6398,6 +6923,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
           rpcSubscriptions.slotNotifications().subscribe({ abortSignal: abortController.signal }),
           getBlockHeightAndDifferenceBetweenSlotHeightAndBlockHeight()
         ]);
+        callerAbortSignal.throwIfAborted();
         let currentBlockHeight = initialBlockHeight;
         if (currentBlockHeight <= lastValidBlockHeight) {
           let lastKnownDifferenceBetweenSlotHeightAndBlockHeight = differenceBetweenSlotHeightAndBlockHeight;
@@ -6417,6 +6943,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
             }
           }
         }
+        callerAbortSignal.throwIfAborted();
         throw new SolanaError(SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED, {
           currentBlockHeight,
           lastValidBlockHeight
@@ -6490,7 +7017,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
         }
       })();
       try {
-        return await Promise.race([nonceAccountDidAdvancePromise, nonceIsAlreadyInvalidPromise]);
+        return await safeRace([nonceAccountDidAdvancePromise, nonceIsAlreadyInvalidPromise]);
       } finally {
         abortController.abort();
       }
@@ -6531,7 +7058,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
         }
       })();
       try {
-        return await Promise.race([signatureDidCommitPromise, signatureStatusLookupPromise]);
+        return await safeRace([signatureDidCommitPromise, signatureStatusLookupPromise]);
       } finally {
         abortController.abort();
       }
@@ -6573,7 +7100,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
         ...config,
         abortSignal: abortController.signal
       });
-      return await Promise.race([
+      return await safeRace([
         getRecentSignatureConfirmationPromise({
           abortSignal: abortController.signal,
           commitment,
@@ -6742,7 +7269,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const wireTransactionBytes = getBase64EncodedWireTransaction(compiledTransaction);
     try {
       const {
-        value: { unitsConsumed }
+        value: { err: transactionError, unitsConsumed }
       } = await rpc.simulateTransaction(wireTransactionBytes, {
         ...simulateConfig,
         encoding: "base64",
@@ -6753,8 +7280,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
         throw new SolanaError(SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT);
       }
       const downcastUnitsConsumed = unitsConsumed > 4294967295n ? 4294967295 : Number(unitsConsumed);
+      if (transactionError) {
+        throw new SolanaError(SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT, {
+          cause: transactionError,
+          unitsConsumed: downcastUnitsConsumed
+        });
+      }
       return downcastUnitsConsumed;
     } catch (e3) {
+      if (isSolanaError(e3, SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT)) throw e3;
       throw new SolanaError(SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT, {
         cause: e3
       });
@@ -6774,7 +7308,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // src/decode-transaction-message.ts
+  // src/decompile-transaction-message-fetching-lookup-tables.ts
   async function fetchLookupTables(lookupTableAddresses, rpc, config) {
     const fetchedLookupTables = await fetchJsonParsedAccounts(
       rpc,
@@ -6790,7 +7324,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       };
     }, {});
   }
-  async function decodeTransactionMessage(compiledTransactionMessage, rpc, config) {
+  async function decompileTransactionMessageFetchingLookupTables(compiledTransactionMessage, rpc, config) {
     const lookupTables = "addressTableLookups" in compiledTransactionMessage && compiledTransactionMessage.addressTableLookups !== void 0 && compiledTransactionMessage.addressTableLookups.length > 0 ? compiledTransactionMessage.addressTableLookups : [];
     const lookupTableAddresses = lookupTables.map((l) => l.lookupTableAddress);
     const { lastValidBlockHeight, ...fetchAccountsConfig } = config != null ? config : {};
@@ -7059,9 +7593,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.SOLANA_ERROR__INVALID_BLOCKHASH_BYTE_LENGTH = SOLANA_ERROR__INVALID_BLOCKHASH_BYTE_LENGTH;
   exports.SOLANA_ERROR__INVALID_NONCE = SOLANA_ERROR__INVALID_NONCE;
   exports.SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING = SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING;
+  exports.SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED = SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED;
+  exports.SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE = SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE;
+  exports.SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING = SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING;
   exports.SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE = SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE;
-  exports.SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE = SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE;
-  exports.SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_STATE_MISSING = SOLANA_ERROR__INVARIANT_VIOLATION__WEBSOCKET_MESSAGE_ITERATOR_STATE_MISSING;
   exports.SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR = SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR;
   exports.SOLANA_ERROR__JSON_RPC__INVALID_PARAMS = SOLANA_ERROR__JSON_RPC__INVALID_PARAMS;
   exports.SOLANA_ERROR__JSON_RPC__INVALID_REQUEST = SOLANA_ERROR__JSON_RPC__INVALID_REQUEST;
@@ -7092,11 +7627,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.SOLANA_ERROR__MALFORMED_BIGINT_STRING = SOLANA_ERROR__MALFORMED_BIGINT_STRING;
   exports.SOLANA_ERROR__MALFORMED_NUMBER_STRING = SOLANA_ERROR__MALFORMED_NUMBER_STRING;
   exports.SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND = SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND;
-  exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_REQUEST = SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_REQUEST;
+  exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN = SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN;
+  exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED = SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED;
+  exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED = SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED;
+  exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT = SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT;
   exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID = SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID;
-  exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CLOSED_BEFORE_MESSAGE_BUFFERED = SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CLOSED_BEFORE_MESSAGE_BUFFERED;
-  exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CONNECTION_CLOSED = SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_CONNECTION_CLOSED;
-  exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_FAILED_TO_CONNECT = SOLANA_ERROR__RPC_SUBSCRIPTIONS__TRANSPORT_FAILED_TO_CONNECT;
+  exports.SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD = SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD;
   exports.SOLANA_ERROR__RPC__INTEGER_OVERFLOW = SOLANA_ERROR__RPC__INTEGER_OVERFLOW;
   exports.SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR = SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR;
   exports.SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN = SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN;
@@ -7112,6 +7648,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS = SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS;
   exports.SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING = SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING;
   exports.SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED = SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED;
+  exports.SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY = SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY;
   exports.SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED = SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED;
   exports.SOLANA_ERROR__SUBTLE_CRYPTO__DISALLOWED_IN_INSECURE_CONTEXT = SOLANA_ERROR__SUBTLE_CRYPTO__DISALLOWED_IN_INSECURE_CONTEXT;
   exports.SOLANA_ERROR__SUBTLE_CRYPTO__ED25519_ALGORITHM_UNIMPLEMENTED = SOLANA_ERROR__SUBTLE_CRYPTO__ED25519_ALGORITHM_UNIMPLEMENTED;
@@ -7167,6 +7704,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_FEE_PAYER_MISSING = SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_FEE_PAYER_MISSING;
   exports.SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND = SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND;
   exports.SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT = SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT;
+  exports.SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT = SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT;
   exports.SOLANA_ERROR__TRANSACTION__FEE_PAYER_MISSING = SOLANA_ERROR__TRANSACTION__FEE_PAYER_MISSING;
   exports.SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING = SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING;
   exports.SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE = SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE;
@@ -7234,16 +7772,22 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.createAddressWithSeed = createAddressWithSeed;
   exports.createCodec = createCodec;
   exports.createDecoder = createDecoder;
+  exports.createDefaultRpcSubscriptionsChannelCreator = createDefaultRpcSubscriptionsChannelCreator;
   exports.createDefaultRpcSubscriptionsTransport = createDefaultRpcSubscriptionsTransport;
   exports.createDefaultRpcTransport = createDefaultRpcTransport;
+  exports.createDefaultSolanaRpcSubscriptionsChannelCreator = createDefaultSolanaRpcSubscriptionsChannelCreator;
   exports.createEncoder = createEncoder;
+  exports.createJsonRpcApi = createJsonRpcApi;
   exports.createKeyPairFromBytes = createKeyPairFromBytes;
+  exports.createKeyPairFromPrivateKeyBytes = createKeyPairFromPrivateKeyBytes;
   exports.createKeyPairSignerFromBytes = createKeyPairSignerFromBytes;
+  exports.createKeyPairSignerFromPrivateKeyBytes = createKeyPairSignerFromPrivateKeyBytes;
   exports.createNoopSigner = createNoopSigner;
   exports.createPrivateKeyFromBytes = createPrivateKeyFromBytes;
   exports.createRpc = createRpc;
-  exports.createRpcApi = createRpcApi;
+  exports.createRpcMessage = createRpcMessage;
   exports.createRpcSubscriptionsApi = createRpcSubscriptionsApi;
+  exports.createRpcSubscriptionsTransportFromChannelCreator = createRpcSubscriptionsTransportFromChannelCreator;
   exports.createSignableMessage = createSignableMessage;
   exports.createSignerFromKeyPair = createSignerFromKeyPair;
   exports.createSolanaRpc = createSolanaRpc;
@@ -7253,16 +7797,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.createSolanaRpcSubscriptionsApi = createSolanaRpcSubscriptionsApi;
   exports.createSolanaRpcSubscriptionsApi_UNSTABLE = createSolanaRpcSubscriptionsApi_UNSTABLE;
   exports.createSolanaRpcSubscriptionsFromTransport = createSolanaRpcSubscriptionsFromTransport;
-  exports.createSolanaRpcSubscriptionsFromTransport_UNSTABLE = createSolanaRpcSubscriptionsFromTransport_UNSTABLE;
   exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
   exports.createSubscriptionRpc = createSubscriptionRpc;
   exports.createTransactionMessage = createTransactionMessage;
   exports.decodeAccount = decodeAccount;
-  exports.decodeTransactionMessage = decodeTransactionMessage;
   exports.decompileTransactionMessage = decompileTransactionMessage;
+  exports.decompileTransactionMessageFetchingLookupTables = decompileTransactionMessageFetchingLookupTables;
   exports.devnet = devnet;
   exports.downgradeRoleToNonSigner = downgradeRoleToNonSigner;
   exports.downgradeRoleToReadonly = downgradeRoleToReadonly;
+  exports.executeRpcPubSubSubscriptionPlan = executeRpcPubSubSubscriptionPlan;
   exports.fetchEncodedAccount = fetchEncodedAccount;
   exports.fetchEncodedAccounts = fetchEncodedAccounts;
   exports.fetchJsonParsedAccount = fetchJsonParsedAccount;
@@ -7373,6 +7917,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.getOptionDecoder = getOptionDecoder;
   exports.getOptionEncoder = getOptionEncoder;
   exports.getProgramDerivedAddress = getProgramDerivedAddress;
+  exports.getPublicKeyFromPrivateKey = getPublicKeyFromPrivateKey;
+  exports.getRpcSubscriptionsChannelWithJSONSerialization = getRpcSubscriptionsChannelWithJSONSerialization;
   exports.getScalarEnumCodec = getScalarEnumCodec;
   exports.getScalarEnumDecoder = getScalarEnumDecoder;
   exports.getScalarEnumEncoder = getScalarEnumEncoder;
@@ -7432,6 +7978,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.isInstructionForProgram = isInstructionForProgram;
   exports.isInstructionWithAccounts = isInstructionWithAccounts;
   exports.isInstructionWithData = isInstructionWithData;
+  exports.isJsonRpcPayload = isJsonRpcPayload;
   exports.isKeyPairSigner = isKeyPairSigner;
   exports.isLamports = isLamports;
   exports.isMessageModifyingSigner = isMessageModifyingSigner;
@@ -7504,6 +8051,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.stringifiedBigInt = stringifiedBigInt;
   exports.stringifiedNumber = stringifiedNumber;
   exports.testnet = testnet;
+  exports.transformChannelInboundMessages = transformChannelInboundMessages;
+  exports.transformChannelOutboundMessages = transformChannelOutboundMessages;
   exports.transformCodec = transformCodec;
   exports.transformDecoder = transformDecoder;
   exports.transformEncoder = transformEncoder;