@solana/web3.js 2.0.0-experimental.dc614af → 2.0.0-experimental.e0b865d

package/dist/index.development.js

@@ -125,13 +125,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
   // ../addresses/dist/index.browser.js
   init_env_shim();
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/index.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/index.mjs
   init_env_shim();
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/index.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/index.mjs
   init_env_shim();
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/bytes.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/bytes.mjs
   init_env_shim();
   var mergeBytes = (bytesArr) => {
     const totalLength = bytesArr.reduce((total, arr) => total + arr.length, 0);
@@ -152,7 +152,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   };
   var fixBytes = (bytes2, length) => padBytes(bytes2.slice(0, length), length);
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/errors.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/errors.mjs
   init_env_shim();
   var DeserializingEmptyBufferError = class extends Error {
     constructor(serializer) {
@@ -174,7 +174,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/fixSerializer.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/fixSerializer.mjs
   init_env_shim();
   function fixSerializer(serializer, fixedBytes, description) {
     return {
@@ -196,7 +196,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/mapSerializer.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/mapSerializer.mjs
   init_env_shim();
   function mapSerializer(serializer, unmap, map) {
     return {
@@ -211,13 +211,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/index.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/index.mjs
   init_env_shim();
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
   init_env_shim();
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
   init_env_shim();
   var InvalidBaseStringError = class extends Error {
     constructor(value, base, cause) {
@@ -228,7 +228,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
   var baseX = (alphabet) => {
     const base = alphabet.length;
     const baseBigInt = BigInt(base);
@@ -282,18 +282,18 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
   init_env_shim();
   var base58 = baseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/nullCharacters.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/nullCharacters.mjs
   init_env_shim();
   var removeNullCharacters = (value) => (
     // eslint-disable-next-line no-control-regex
     value.replace(/\u0000/g, "")
   );
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/utf8.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/utf8.mjs
   init_env_shim();
   var utf8 = {
     description: "utf8",
@@ -308,10 +308,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/index.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/index.mjs
   init_env_shim();
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/common.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/common.mjs
   init_env_shim();
   var Endian;
   (function(Endian2) {
@@ -319,7 +319,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     Endian2["Big"] = "be";
   })(Endian || (Endian = {}));
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/errors.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/errors.mjs
   init_env_shim();
   var NumberOutOfRangeError = class extends RangeError {
     constructor(serializer, min, max, actual) {
@@ -328,7 +328,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/utils.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/utils.mjs
   init_env_shim();
   function numberFactory(input) {
     let littleEndian;
@@ -373,7 +373,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u8.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u8.mjs
   init_env_shim();
   var u8 = (options = {}) => numberFactory({
     name: "u8",
@@ -384,7 +384,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     options
   });
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
   init_env_shim();
   var u32 = (options = {}) => numberFactory({
     name: "u32",
@@ -395,7 +395,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     options
   });
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/shortU16.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/shortU16.mjs
   init_env_shim();
   var shortU16 = (options = {}) => ({
     description: options.description ?? "shortU16",
@@ -433,10 +433,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   });
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/array.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/array.mjs
   init_env_shim();
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/errors.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/errors.mjs
   init_env_shim();
   var InvalidNumberOfItemsError = class extends Error {
     constructor(serializer, expected, actual) {
@@ -457,16 +457,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
   init_env_shim();
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/sumSerializerSizes.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/sumSerializerSizes.mjs
   init_env_shim();
   function sumSerializerSizes(sizes) {
     return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
   function getResolvedSize(size, childrenSizes, bytes2, offset) {
     if (typeof size === "number") {
       return [size, offset];
@@ -502,7 +502,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return typeof size === "object" ? size.serialize(realSize) : new Uint8Array();
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/array.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/array.mjs
   function array(item, options = {}) {
     const size = options.size ?? u32();
     if (size === "remainder" && item.fixedSize === null) {
@@ -535,7 +535,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/bytes.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/bytes.mjs
   init_env_shim();
   function bytes(options = {}) {
     const size = options.size ?? "variable";
@@ -583,7 +583,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/string.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/string.mjs
   init_env_shim();
   function string(options = {}) {
     const size = options.size ?? u32();
@@ -625,7 +625,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/struct.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/struct.mjs
   init_env_shim();
   function struct(fields, options = {}) {
     const fieldDescriptions = fields.map(([name, serializer]) => `${String(name)}: ${serializer.description}`).join(", ");
@@ -715,6 +715,21 @@ this.globalThis.solanaWeb3 = (function (exports) {
       throw new Error("No signature verification implementation could be found");
     }
   }
+  function isBase58EncodedAddress(putativeBase58EncodedAddress) {
+    if (
+      // Lowest address (32 bytes of zeroes)
+      putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
+      putativeBase58EncodedAddress.length > 44
+    ) {
+      return false;
+    }
+    const bytes2 = base58.serialize(putativeBase58EncodedAddress);
+    const numBytes = bytes2.byteLength;
+    if (numBytes !== 32) {
+      return false;
+    }
+    return true;
+  }
   function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
     try {
       if (
@@ -729,12 +744,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
       if (numBytes !== 32) {
         throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
       }
-    } catch (e2) {
+    } catch (e3) {
       throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-        cause: e2
+        cause: e3
       });
     }
   }
+  function address(putativeBase58EncodedAddress) {
+    assertIsBase58EncodedAddress(putativeBase58EncodedAddress);
+    return putativeBase58EncodedAddress;
+  }
   function getBase58EncodedAddressCodec(config) {
     return string({
       description: config?.description ?? ("A 32-byte account address" ),
@@ -903,16 +922,37 @@ this.globalThis.solanaWeb3 = (function (exports) {
             seeds: [...seeds, new Uint8Array([bumpSeed])]
           })
         };
-      } catch (e2) {
-        if (e2 instanceof PointOnCurveError) {
+      } catch (e3) {
+        if (e3 instanceof PointOnCurveError) {
           bumpSeed--;
         } else {
-          throw e2;
+          throw e3;
         }
       }
     }
     throw new Error("Unable to find a viable program address bump seed");
   }
+  async function createAddressWithSeed({
+    baseAddress,
+    programAddress,
+    seed
+  }) {
+    const { serialize: serialize4, deserialize: deserialize2 } = getBase58EncodedAddressCodec();
+    const seedBytes = typeof seed === "string" ? new TextEncoder().encode(seed) : seed;
+    if (seedBytes.byteLength > MAX_SEED_LENGTH) {
+      throw new Error(`The seed exceeds the maximum length of 32 bytes`);
+    }
+    const programAddressBytes = serialize4(programAddress);
+    if (programAddressBytes.length >= PDA_MARKER_BYTES.length && programAddressBytes.slice(-PDA_MARKER_BYTES.length).every((byte, index) => byte === PDA_MARKER_BYTES[index])) {
+      throw new Error(`programAddress cannot end with the PDA marker`);
+    }
+    const addressBytesBuffer = await crypto.subtle.digest(
+      "SHA-256",
+      new Uint8Array([...serialize4(baseAddress), ...seedBytes, ...programAddressBytes])
+    );
+    const addressBytes = new Uint8Array(addressBytesBuffer);
+    return deserialize2(addressBytes)[0];
+  }
   async function getAddressFromPublicKey(publicKey) {
     await assertKeyExporterIsAvailable();
     if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") {
@@ -1014,9 +1054,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
       if (numBytes !== 32) {
         throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
       }
-    } catch (e2) {
+    } catch (e3) {
       throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-        cause: e2
+        cause: e3
       });
     }
   }
@@ -1146,8 +1186,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     Object.freeze(out);
     return out;
   }
-  function upsert(addressMap, address, update) {
-    addressMap[address] = update(addressMap[address] ?? { role: AccountRole2.READONLY });
+  function upsert(addressMap, address2, update) {
+    addressMap[address2] = update(addressMap[address2] ?? { role: AccountRole2.READONLY });
   }
   var TYPE = Symbol("AddressMapTypeProperty");
   function getAddressMapFromInstructions(feePayer, instructions) {
@@ -1312,8 +1352,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
       } else {
         return addressComparator(leftAddress, rightAddress);
       }
-    }).map(([address, addressMeta]) => ({
-      address,
+    }).map(([address2, addressMeta]) => ({
+      address: address2,
       ...addressMeta
     }));
     return orderedAccounts;
@@ -1376,7 +1416,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return instructions.map(({ accounts, data, programAddress }) => {
       return {
         programAddressIndex: accountIndex[programAddress],
-        ...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
+        ...accounts ? { accountIndices: accounts.map(({ address: address2 }) => accountIndex[address2]) } : null,
         ...data ? { data } : null
       };
     });
@@ -1390,7 +1430,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function getCompiledStaticAccounts(orderedAccounts) {
     const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
     const orderedStaticAccounts = firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);
-    return orderedStaticAccounts.map(({ address }) => address);
+    return orderedStaticAccounts.map(({ address: address2 }) => address2);
   }
   function compileMessage(transaction) {
     const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);
@@ -1640,16 +1680,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const signature = await signBytes(secretKey, wireMessageBytes);
     return signature;
   }
-  async function signTransaction(keyPair, transaction) {
+  async function signTransaction(keyPairs, transaction) {
     const compiledMessage = compileMessage(transaction);
-    const [signerPublicKey, signature] = await Promise.all([
-      getAddressFromPublicKey(keyPair.publicKey),
-      getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
-    ]);
-    const nextSignatures = {
-      ..."signatures" in transaction ? transaction.signatures : null,
-      ...{ [signerPublicKey]: signature }
-    };
+    const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
+    const publicKeySignaturePairs = await Promise.all(
+      keyPairs.map(
+        (keyPair) => Promise.all([
+          getAddressFromPublicKey(keyPair.publicKey),
+          getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
+        ])
+      )
+    );
+    for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
+      nextSignatures[signerPublicKey] = signature;
+    }
     const out = {
       ...transaction,
       signatures: nextSignatures
@@ -1708,6 +1752,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
   // src/rpc.ts
   init_env_shim();
 
+  // ../functional/dist/index.browser.js
+  init_env_shim();
+  function pipe(init, ...fns) {
+    return fns.reduce((acc, fn) => fn(acc), init);
+  }
+
   // ../rpc-core/dist/index.browser.js
   init_env_shim();
   function visitNode(value, keyPath, onIntegerOverflow) {
@@ -1736,9 +1786,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return visitNode(params, [], onIntegerOverflow);
   }
   var KEYPATH_WILDCARD = {};
-  var memoizedKeypaths;
-  function getAllowedNumericKeypaths() {
-    if (!memoizedKeypaths) {
+  var memoizedNotificationKeypaths;
+  var memoizedResponseKeypaths;
+  function getAllowedNumericKeypathsForNotification() {
+    if (!memoizedNotificationKeypaths) {
+      memoizedNotificationKeypaths = {};
+    }
+    return memoizedNotificationKeypaths;
+  }
+  function getAllowedNumericKeypathsForResponse() {
+    if (!memoizedResponseKeypaths) {
       const jsonParsedTokenAccountsConfigs = [
         // parsed Token/Token22 token account
         ["data", "parsed", "info", "tokenAmount", "decimals"],
@@ -1791,8 +1848,97 @@ this.globalThis.solanaWeb3 = (function (exports) {
         ["data", "parsed", "info", "commission"],
         ["data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
       ];
-      memoizedKeypaths = {
+      memoizedResponseKeypaths = {
         getAccountInfo: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+        getBlock: [
+          ["blockTime"],
+          ["transactions", KEYPATH_WILDCARD, "meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+          [
+            "transactions",
+            KEYPATH_WILDCARD,
+            "meta",
+            "preTokenBalances",
+            KEYPATH_WILDCARD,
+            "uiTokenAmount",
+            "decimals"
+          ],
+          ["transactions", KEYPATH_WILDCARD, "meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+          [
+            "transactions",
+            KEYPATH_WILDCARD,
+            "meta",
+            "postTokenBalances",
+            KEYPATH_WILDCARD,
+            "uiTokenAmount",
+            "decimals"
+          ],
+          ["transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+          ["transactions", KEYPATH_WILDCARD, "meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
+          [
+            "transactions",
+            KEYPATH_WILDCARD,
+            "meta",
+            "innerInstructions",
+            KEYPATH_WILDCARD,
+            "instructions",
+            KEYPATH_WILDCARD,
+            "programIdIndex"
+          ],
+          [
+            "transactions",
+            KEYPATH_WILDCARD,
+            "meta",
+            "innerInstructions",
+            KEYPATH_WILDCARD,
+            "instructions",
+            KEYPATH_WILDCARD,
+            "accounts",
+            KEYPATH_WILDCARD
+          ],
+          [
+            "transactions",
+            KEYPATH_WILDCARD,
+            "transaction",
+            "message",
+            "addressTableLookups",
+            KEYPATH_WILDCARD,
+            "writableIndexes",
+            KEYPATH_WILDCARD
+          ],
+          [
+            "transactions",
+            KEYPATH_WILDCARD,
+            "transaction",
+            "message",
+            "addressTableLookups",
+            KEYPATH_WILDCARD,
+            "readonlyIndexes",
+            KEYPATH_WILDCARD
+          ],
+          [
+            "transactions",
+            KEYPATH_WILDCARD,
+            "transaction",
+            "message",
+            "instructions",
+            KEYPATH_WILDCARD,
+            "programIdIndex"
+          ],
+          [
+            "transactions",
+            KEYPATH_WILDCARD,
+            "transaction",
+            "message",
+            "instructions",
+            KEYPATH_WILDCARD,
+            "accounts",
+            KEYPATH_WILDCARD
+          ],
+          ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numReadonlySignedAccounts"],
+          ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numReadonlyUnsignedAccounts"],
+          ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numRequiredSignatures"],
+          ["rewards", KEYPATH_WILDCARD, "commission"]
+        ],
         getBlockTime: [[]],
         getClusterNodes: [
           [KEYPATH_WILDCARD, "featureSet"],
@@ -1874,10 +2020,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
         getVoteAccounts: [
           ["current", KEYPATH_WILDCARD, "commission"],
           ["delinquent", KEYPATH_WILDCARD, "commission"]
-        ]
+        ],
+        simulateTransaction: jsonParsedAccountsConfigs.map((c) => ["value", "accounts", KEYPATH_WILDCARD, ...c])
       };
     }
-    return memoizedKeypaths;
+    return memoizedResponseKeypaths;
   }
   function getNextAllowedKeypaths(keyPaths, property) {
     return keyPaths.filter((keyPath) => keyPath[0] === KEYPATH_WILDCARD && typeof property === "number" || keyPath[0] === property).map((keyPath) => keyPath.slice(1));
@@ -1905,7 +2052,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   }
   function patchResponseForSolanaLabsRpc(rawResponse, methodName) {
-    const allowedKeypaths = methodName ? getAllowedNumericKeypaths()[methodName] : void 0;
+    const allowedKeypaths = methodName ? getAllowedNumericKeypathsForResponse()[methodName] : void 0;
+    return visitNode2(rawResponse, allowedKeypaths ?? []);
+  }
+  function patchResponseForSolanaLabsRpcSubscriptions(rawResponse, methodName) {
+    const allowedKeypaths = methodName ? getAllowedNumericKeypathsForNotification()[methodName] : void 0;
     return visitNode2(rawResponse, allowedKeypaths ?? []);
   }
   function createSolanaRpcApi(config) {
@@ -1934,6 +2085,36 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
     });
   }
+  function createSolanaRpcSubscriptionsApi(config) {
+    return new Proxy({}, {
+      defineProperty() {
+        return false;
+      },
+      deleteProperty() {
+        return false;
+      },
+      get(...args) {
+        const [_, p] = args;
+        const notificationName = p.toString();
+        return function(...rawParams) {
+          const handleIntegerOverflow = config?.onIntegerOverflow;
+          const params = patchParamsForSolanaLabsRpc(
+            rawParams,
+            handleIntegerOverflow ? (keyPath, value) => handleIntegerOverflow(notificationName, keyPath, value) : void 0
+          );
+          return {
+            params,
+            responseProcessor: (rawResponse) => patchResponseForSolanaLabsRpcSubscriptions(rawResponse, notificationName),
+            subscribeMethodName: notificationName.replace(/Notifications$/, "Subscribe"),
+            unsubscribeMethodName: notificationName.replace(/Notifications$/, "Unsubscribe")
+          };
+        };
+      }
+    });
+  }
+  function createSolanaRpcSubscriptionsApi_UNSTABLE(config) {
+    return createSolanaRpcSubscriptionsApi(config);
+  }
 
   // ../rpc-transport/dist/index.browser.js
   init_env_shim();
@@ -2000,6 +2181,100 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function createJsonRpc(rpcConfig) {
     return makeProxy(rpcConfig);
   }
+  function registerIterableCleanup(iterable, cleanupFn) {
+    (async () => {
+      try {
+        for await (const _ of iterable)
+          ;
+      } catch {
+      } finally {
+        cleanupFn();
+      }
+    })();
+  }
+  function createPendingRpcSubscription(rpcConfig, { params, subscribeMethodName, unsubscribeMethodName, responseProcessor }) {
+    return {
+      async subscribe({ abortSignal }) {
+        abortSignal.throwIfAborted();
+        let subscriptionId;
+        function handleCleanup() {
+          if (subscriptionId !== void 0) {
+            const payload = createJsonRpcMessage(unsubscribeMethodName, [subscriptionId]);
+            connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload).finally(() => {
+              connectionAbortController.abort();
+            });
+          } else {
+            connectionAbortController.abort();
+          }
+        }
+        abortSignal.addEventListener("abort", handleCleanup);
+        const connectionAbortController = new AbortController();
+        const subscribeMessage = createJsonRpcMessage(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 new SolanaJsonRpcError(message.error);
+            } else {
+              subscriptionId = message.result;
+              break;
+            }
+          }
+        }
+        if (subscriptionId == null) {
+          throw new Error("Failed to obtain a subscription id from the server");
+        }
+        return {
+          async *[Symbol.asyncIterator]() {
+            for await (const message of connection) {
+              if (!("params" in message) || message.params.subscription !== subscriptionId) {
+                continue;
+              }
+              const notification = message.params.result;
+              yield responseProcessor ? responseProcessor(notification) : notification;
+            }
+          }
+        };
+      }
+    };
+  }
+  function makeProxy2(rpcConfig) {
+    return new Proxy(rpcConfig.api, {
+      defineProperty() {
+        return false;
+      },
+      deleteProperty() {
+        return false;
+      },
+      get(target, p, receiver) {
+        return function(...rawParams) {
+          const methodName = p.toString();
+          const createRpcSubscription = Reflect.get(target, methodName, receiver);
+          if (p.toString().endsWith("Notifications") === false && !createRpcSubscription) {
+            throw new Error(
+              "Either the notification name must end in 'Notifications' or the API must supply a subscription creator function to map between the notification name and the subscribe/unsubscribe method names."
+            );
+          }
+          const newRequest = createRpcSubscription ? createRpcSubscription(...rawParams) : {
+            params: rawParams,
+            subscribeMethodName: methodName.replace(/Notifications$/, "Subscribe"),
+            unsubscribeMethodName: methodName.replace(/Notifications$/, "Unsubscribe")
+          };
+          return createPendingRpcSubscription(rpcConfig, newRequest);
+        };
+      }
+    });
+  }
+  function createJsonSubscriptionRpc(rpcConfig) {
+    return makeProxy2(rpcConfig);
+  }
   var e = globalThis.fetch;
   var SolanaHttpError = class extends Error {
     constructor(details) {
@@ -2098,6 +2373,175 @@ this.globalThis.solanaWeb3 = (function (exports) {
       return await response.json();
     };
   }
+  var e2 = globalThis.WebSocket;
+  var EXPLICIT_ABORT_TOKEN = Symbol(
+    "This symbol is thrown from a socket's iterator when the connection is explicity aborted by the user" 
+  );
+  async function createWebSocketConnection({
+    sendBufferHighWatermark,
+    signal,
+    url
+  }) {
+    return 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 {
+          }
+        });
+      }
+      function handleAbort() {
+        errorAndClearAllIteratorStates(EXPLICIT_ABORT_TOKEN);
+        if (webSocket.readyState !== e2.CLOSED && webSocket.readyState !== e2.CLOSING) {
+          webSocket.close(1e3);
+        }
+      }
+      function handleClose(ev) {
+        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(
+            // TODO: Coded error
+            new Error("WebSocket failed to connect", { cause: ev })
+          );
+        }
+      }
+      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;
+                  clearInterval(intervalId);
+                  reject2(
+                    // TODO: Coded error
+                    new Error("WebSocket was closed before payload could be sent")
+                  );
+                };
+              });
+              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 Error("Invariant: WebSocket message iterator is missing state storage");
+                }
+                if (state.__hasPolled) {
+                  throw new Error(
+                    "Invariant: WebSocket message iterator state is corrupt; iterated without first 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 (e3) {
+                    if (e3 === EXPLICIT_ABORT_TOKEN) {
+                      return;
+                    } else {
+                      throw new Error("WebSocket connection closed", { cause: e3 });
+                    }
+                  }
+                }
+              }
+            } finally {
+              iteratorState.delete(iteratorKey);
+            }
+          }
+        });
+      }
+      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);
+          }
+        });
+      }
+      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?.throwIfAborted();
+      const connection = await createWebSocketConnection({
+        sendBufferHighWatermark,
+        signal,
+        url
+      });
+      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)
+      };
+    };
+  }
+
+  // src/rpc.ts
+  var import_fast_stable_stringify = __toESM(require_fast_stable_stringify(), 1);
 
   // src/rpc-default-config.ts
   init_env_shim();
@@ -2139,6 +2583,197 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
+  // src/rpc-subscription-coalescer.ts
+  init_env_shim();
+
+  // src/cached-abortable-iterable.ts
+  init_env_shim();
+  function registerIterableCleanup2(iterable, cleanupFn) {
+    (async () => {
+      try {
+        for await (const _ of iterable)
+          ;
+      } catch {
+      } finally {
+        cleanupFn();
+      }
+    })();
+  }
+  function getCachedAbortableIterableFactory({
+    getAbortSignalFromInputArgs,
+    getCacheEntryMissingError,
+    getCacheKeyFromInputArgs,
+    onCacheHit,
+    onCreateIterable
+  }) {
+    const cache = /* @__PURE__ */ new Map();
+    function getCacheEntryOrThrow(cacheKey) {
+      const currentCacheEntry = cache.get(cacheKey);
+      if (!currentCacheEntry) {
+        throw getCacheEntryMissingError(cacheKey);
+      }
+      return currentCacheEntry;
+    }
+    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();
+            }
+          });
+        }
+        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
+          };
+          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;
+      }
+    };
+  }
+
+  // src/rpc-subscription-coalescer.ts
+  var EXPLICIT_ABORT_TOKEN2 = Symbol(
+    "This symbol is thrown from a subscription's iterator when the subscription is explicitly aborted by the user" 
+  );
+  function registerIterableCleanup3(iterable, cleanupFn) {
+    (async () => {
+      try {
+        for await (const _ of iterable)
+          ;
+      } catch {
+      } finally {
+        cleanupFn();
+      }
+    })();
+  }
+  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,
+            getCacheEntryMissingError(deduplicationKey2) {
+              return new Error(
+                `Found no cache entry for subscription with deduplication key \`${deduplicationKey2?.toString()}\``
+              );
+            },
+            getCacheKeyFromInputArgs: () => deduplicationKey,
+            async onCacheHit(_iterable, _config) {
+            },
+            async onCreateIterable(abortSignal, config) {
+              const pendingSubscription2 = subscriptionMethod(
+                ...rawParams
+              );
+              const iterable = await pendingSubscription2.subscribe({
+                ...config,
+                abortSignal
+              });
+              registerIterableCleanup3(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_TOKEN2) : new Promise((_, reject) => {
+                    abortSignal.addEventListener("abort", () => {
+                      reject(EXPLICIT_ABORT_TOKEN2);
+                    });
+                  }));
+                  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_TOKEN2) {
+                      return;
+                    }
+                    cache.delete(deduplicationKey);
+                    throw e3;
+                  }
+                }
+              };
+            }
+          };
+          cache.set(deduplicationKey, pendingSubscription);
+          return pendingSubscription;
+        };
+      }
+    });
+  }
+
   // src/rpc.ts
   function createSolanaRpc(config) {
     return createJsonRpc({
@@ -2146,6 +2781,24 @@ this.globalThis.solanaWeb3 = (function (exports) {
       api: createSolanaRpcApi(DEFAULT_RPC_CONFIG)
     });
   }
+  function createSolanaRpcSubscriptions(config) {
+    return pipe(
+      createJsonSubscriptionRpc({
+        ...config,
+        api: createSolanaRpcSubscriptionsApi(DEFAULT_RPC_CONFIG)
+      }),
+      (rpcSubscriptions) => getRpcSubscriptionsWithSubscriptionCoalescing({
+        getDeduplicationKey: (...args) => (0, import_fast_stable_stringify.default)(args),
+        rpcSubscriptions
+      })
+    );
+  }
+  function createSolanaRpcSubscriptions_UNSTABLE(config) {
+    return createJsonSubscriptionRpc({
+      ...config,
+      api: createSolanaRpcSubscriptionsApi_UNSTABLE(DEFAULT_RPC_CONFIG)
+    });
+  }
 
   // src/rpc-transport.ts
   init_env_shim();
@@ -2182,14 +2835,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
       if (signal) {
         const responsePromise = coalescedRequest.responsePromise;
         return await new Promise((resolve, reject) => {
-          const handleAbort = (e2) => {
+          const handleAbort = (e3) => {
             signal.removeEventListener("abort", handleAbort);
             coalescedRequest.numConsumers -= 1;
             if (coalescedRequest.numConsumers === 0) {
               const abortController = coalescedRequest.abortController;
               abortController.abort();
             }
-            const abortError = new DOMException(e2.target.reason, "AbortError");
+            const abortError = new DOMException(e3.target.reason, "AbortError");
             reject(abortError);
           };
           signal.addEventListener("abort", handleAbort);
@@ -2205,14 +2858,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // src/rpc-request-deduplication.ts
   init_env_shim();
-  var import_fast_stable_stringify = __toESM(require_fast_stable_stringify(), 1);
-  function getSolanaRpcPayloadDeduplicationKey(payload) {
+  var import_fast_stable_stringify2 = __toESM(require_fast_stable_stringify(), 1);
+  function isJsonRpcPayload(payload) {
     if (payload == null || typeof payload !== "object" || Array.isArray(payload)) {
-      return;
-    }
-    if ("jsonrpc" in payload && payload.jsonrpc === "2.0" && "method" in payload && "params" in payload) {
-      return (0, import_fast_stable_stringify.default)([payload.method, payload.params]);
+      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) ? (0, import_fast_stable_stringify2.default)([payload.method, payload.params]) : void 0;
   }
 
   // src/rpc-transport.ts
@@ -2224,7 +2878,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return out;
   }
   function createDefaultRpcTransport(config) {
-    return getRpcTransportWithRequestCoalescing(
+    return pipe(
       createHttpTransport({
         ...config,
         headers: {
@@ -2235,17 +2889,129 @@ this.globalThis.solanaWeb3 = (function (exports) {
           }
         }
       }),
-      getSolanaRpcPayloadDeduplicationKey
+      (transport) => getRpcTransportWithRequestCoalescing(transport, getSolanaRpcPayloadDeduplicationKey)
+    );
+  }
+
+  // src/rpc-websocket-transport.ts
+  init_env_shim();
+
+  // src/rpc-websocket-autopinger.ts
+  init_env_shim();
+  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);
+          }
+        });
+        (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);
+            }
+          }
+        })();
+        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);
+    };
+  }
+
+  // src/rpc-websocket-connection-sharding.ts
+  init_env_shim();
+  var NULL_SHARD_CACHE_KEY = Symbol(
+    "Cache key to use when there is no connection sharding strategy" 
+  );
+  function getWebSocketTransportWithConnectionSharding({ getShard, transport }) {
+    return getCachedAbortableIterableFactory({
+      getAbortSignalFromInputArgs: ({ signal }) => signal,
+      getCacheEntryMissingError(shardKey) {
+        return new Error(`Found no cache entry for connection with shard key \`${shardKey?.toString()}\``);
+      },
+      getCacheKeyFromInputArgs: ({ payload }) => getShard ? getShard(payload) : NULL_SHARD_CACHE_KEY,
+      onCacheHit: (connection, { payload }) => connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload),
+      onCreateIterable: (abortSignal, config) => transport({
+        ...config,
+        signal: abortSignal
+      })
+    });
+  }
+
+  // src/rpc-websocket-transport.ts
+  function createDefaultRpcSubscriptionsTransport(config) {
+    const { getShard, intervalMs, ...rest } = config;
+    return pipe(
+      createWebSocketTransport({
+        ...rest,
+        sendBufferHighWatermark: config.sendBufferHighWatermark ?? // Let 128KB of data into the WebSocket buffer before buffering it in the app.
+        131072
+      }),
+      (transport) => getWebSocketTransportWithAutoping({
+        intervalMs: intervalMs ?? 5e3,
+        transport
+      }),
+      (transport) => getWebSocketTransportWithConnectionSharding({
+        getShard,
+        transport
+      })
     );
   }
 
   exports.AccountRole = AccountRole;
+  exports.address = address;
   exports.appendTransactionInstruction = appendTransactionInstruction;
   exports.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress;
   exports.assertIsBlockhash = assertIsBlockhash;
   exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
+  exports.createAddressWithSeed = createAddressWithSeed;
+  exports.createDefaultRpcSubscriptionsTransport = createDefaultRpcSubscriptionsTransport;
   exports.createDefaultRpcTransport = createDefaultRpcTransport;
   exports.createSolanaRpc = createSolanaRpc;
+  exports.createSolanaRpcSubscriptions = createSolanaRpcSubscriptions;
+  exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
   exports.createTransaction = createTransaction;
   exports.downgradeRoleToNonSigner = downgradeRoleToNonSigner;
   exports.downgradeRoleToReadonly = downgradeRoleToReadonly;
@@ -2255,6 +3021,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.getBase58EncodedAddressComparator = getBase58EncodedAddressComparator;
   exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
   exports.getProgramDerivedAddress = getProgramDerivedAddress;
+  exports.isBase58EncodedAddress = isBase58EncodedAddress;
   exports.isSignerRole = isSignerRole;
   exports.isWritableRole = isWritableRole;
   exports.mergeRoles = mergeRoles;