@solana/rpc-subscriptions 2.0.0-rc.0 → 2.0.0-rc.2

package/README.md

@@ -6,12 +6,57 @@
 
 [code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
 [code-style-prettier-url]: https://github.com/prettier/prettier
-[npm-downloads-image]: https://img.shields.io/npm/dm/@solana/rpc-subscriptions/experimental.svg?style=flat
-[npm-image]: https://img.shields.io/npm/v/@solana/rpc-subscriptions/experimental.svg?style=flat
-[npm-url]: https://www.npmjs.com/package/@solana/rpc-subscriptions/v/experimental
+[npm-downloads-image]: https://img.shields.io/npm/dm/@solana/rpc-subscriptions/rc.svg?style=flat
+[npm-image]: https://img.shields.io/npm/v/@solana/rpc-subscriptions/rc.svg?style=flat
+[npm-url]: https://www.npmjs.com/package/@solana/rpc-subscriptions/v/rc
 [semantic-release-image]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
 [semantic-release-url]: https://github.com/semantic-release/semantic-release
 
 # @solana/rpc-subscriptions
 
-TODO
+This package contains types that implement RPC subscriptions as required by the Solana RPC. Additionally, it incorporates some useful defaults that make working with subscriptions easier, more performant, and more reliable. It can be used standalone, but it is also exported as part of the Solana JavaScript SDK [`@solana/web3.js@rc`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/library).
+
+## Functions
+
+### `createDefaultRpcSubscriptionsChannelCreator(config)`
+
+Creates a function that returns new subscription channels when called.
+
+### `createDefaultSolanaRpcSubscriptionsChannelCreator(config)`
+
+Similar to `createDefaultRpcSubscriptionsChannelCreator` with some Solana-specific defaults. For instance, it safely handles `BigInt` values in JSON messages since Solana RPC servers accept and return integers larger than `Number.MAX_SAFE_INTEGER`.
+
+#### Arguments
+
+A config object with the following properties:
+
+-   `intervalMs`: The number of milliseconds to wait since the last message sent or received over the channel before sending a ping message to keep the channel open.
+-   `maxSubscriptionsPerChannel`: The number of subscribers that may share a channel before a new channel must be created (default: 100). It is important that you set this to the maximum number of subscriptions that your RPC provider recommends making over a single connection; the default is set deliberately low, so as to comply with the restrictive limits of the public mainnet RPC node.
+-   `minChannels`: The number of channels to create before reusing a channel for a new subscription.
+-   `sendBufferHighWatermark`: The number of bytes of data to admint into the `WebSocket` buffer before buffering data on the client. -`url`: The URL of the web socket server. Must use the `ws` or `wss` protocols.
+
+### `getChannelPoolingChannelCreator(createChannel, { maxSubscriptionsPerChannel, minChannels })`
+
+Given a channel creator, will return a new channel creator with the following behavior.
+
+1. When called, returns an `RpcSubscriptionsChannel`. Adds that channel to a pool.
+2. When called again, creates and returns new `RpcSubscriptionChannels` up to the number specified by `minChannels`.
+3. When `minChannels` channels have been created, subsequent calls vend whichever existing channel from the pool has the fewest subscribers, or the next one in rotation in the event of a tie.
+4. Once all channels carry the number of subscribers specified by the number `maxSubscriptionsPerChannel`, new channels in excess of `minChannel` will be created, returned, and added to the pool.
+5. A channel will be destroyed once all of its subscribers' abort signals fire.
+
+### `getRpcSubscriptionsChannelWithJSONSerialization(channel)`
+
+Given an `RpcSubscriptionsChannel`, will return a new channel that parses data published to the `'message'` channel as JSON, and JSON-stringifies messages sent via the `send(message)` method.
+
+### `getRpcSubscriptionsChannelWithBigIntJSONSerialization(channel)`
+
+Similarly, to `getRpcSubscriptionsChannelWithJSONSerialization`, this function will stringify and parse JSON message to and from the given `string` channel. However, this function parses any integer value as a `BigInt` in order to safely handle numbers that exceed the JavaScript `Number.MAX_SAFE_INTEGER` value.
+
+### `getRpcSubscriptionsChannelWithAutoping(channel)`
+
+Given an `RpcSubscriptionsChannel`, will return a new channel that sends a ping message to the inner channel if a message has not been sent or received in the last `intervalMs`. In web browsers, this implementation sends no ping when the network is down, and sends a ping immediately upon the network coming back up.
+
+### `getRpcSubscriptionsTransportWithSubscriptionCoalescing(transport)`
+
+Given an `RpcSubscriptionsTransport`, will return a new transport that coalesces identical subscriptions into a single subscription request to the server. The determination of whether a subscription is the same as another is based on the `rpcRequest` returned by its `RpcSubscriptionsPlan`. The subscription will only be aborted once all subscribers abort, or there is an error.

package/dist/index.browser.cjs

@@ -3,9 +3,10 @@
 var rpcSubscriptionsApi = require('@solana/rpc-subscriptions-api');
 var rpcSubscriptionsSpec = require('@solana/rpc-subscriptions-spec');
 var errors = require('@solana/errors');
-var fastStableStringify = require('@solana/fast-stable-stringify');
+var rpcSubscriptionsChannelWebsocket = require('@solana/rpc-subscriptions-channel-websocket');
 var functional = require('@solana/functional');
-var rpcSubscriptionsTransportWebsocket = require('@solana/rpc-subscriptions-transport-websocket');
+var rpcSpecTypes = require('@solana/rpc-spec-types');
+var fastStableStringify = require('@solana/fast-stable-stringify');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -46,332 +47,316 @@ function createSolanaJsonRpcIntegerOverflowError(methodName, keyPath, value) {
 // src/rpc-default-config.ts
 var DEFAULT_RPC_SUBSCRIPTIONS_CONFIG = {
   defaultCommitment: "confirmed",
-  onIntegerOverflow(methodName, keyPath, value) {
-    throw createSolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
+  onIntegerOverflow(request, keyPath, value) {
+    throw createSolanaJsonRpcIntegerOverflowError(request.methodName, keyPath, value);
   }
 };
-function registerIterableCleanup(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 errors.SolanaError(errors.SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING, {
-        cacheKey: cacheKey.toString()
-      });
-    }
-    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();
-          }
-        });
+  let intervalId;
+  function sendPing() {
+    channel.send(PING_PAYLOAD).catch((e) => {
+      if (errors.isSolanaError(e, errors.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED)) {
+        pingerAbortController.abort();
       }
-      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;
-        registerIterableCleanup(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;
+    });
+  }
+  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();
       }
-    } catch (e) {
-      cleanup();
-      throw e;
+      return channel.send(...args);
     }
   };
 }
 
-// src/rpc-subscriptions-coalescer.ts
-var EXPLICIT_ABORT_TOKEN;
-function createExplicitAbortToken() {
-  return Symbol(
-    process.env.NODE_ENV !== "production" ? "This symbol is thrown from a subscription's iterator when the subscription is explicitly aborted by the user" : void 0
-  );
+// src/rpc-subscriptions-channel-pool-internal.ts
+function createChannelPool() {
+  return {
+    entries: [],
+    freeChannelIndex: -1
+  };
 }
-function registerIterableCleanup2(iterable, cleanupFn) {
-  (async () => {
-    try {
-      for await (const _ of iterable) ;
-    } catch {
-    } finally {
-      cleanupFn();
+
+// src/rpc-subscriptions-channel-pool.ts
+function getChannelPoolingChannelCreator(createChannel, { maxSubscriptionsPerChannel, minChannels }) {
+  const pool = createChannelPool();
+  function recomputeFreeChannelIndex() {
+    if (pool.entries.length < minChannels) {
+      pool.freeChannelIndex = -1;
+      return;
     }
-  })();
-}
-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
-            });
-            registerIterableCleanup2(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 ||= abortSignal.aborted ? Promise.reject(EXPLICIT_ABORT_TOKEN ||= createExplicitAbortToken()) : new Promise((_, reject) => {
-                  abortSignal.addEventListener("abort", () => {
-                    reject(EXPLICIT_ABORT_TOKEN ||= createExplicitAbortToken());
-                  });
-                });
-                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 (e) {
-                  if (e === (EXPLICIT_ABORT_TOKEN ||= createExplicitAbortToken())) {
-                    return;
-                  }
-                  cache.delete(deduplicationKey);
-                  throw e;
-                }
-              }
-            };
-          }
+    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(deduplicationKey, pendingSubscription);
-        return pendingSubscription;
-      };
+      }
     }
-  });
-}
-
-// src/rpc-subscriptions-autopinger.ts
-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);
+    pool.freeChannelIndex = mostFreeChannel?.poolIndex ?? -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();
     }
-    function restartPingTimer() {
-      clearInterval(intervalId);
-      intervalId = setInterval(sendPing, intervalMs);
+    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];
     }
-    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();
+    poolEntry.subscriptionCount++;
+    abortSignal.addEventListener("abort", function destroyConsumer() {
+      poolEntry.subscriptionCount--;
+      if (poolEntry.subscriptionCount === 0) {
+        destroyPoolEntry();
+      } else if (pool.freeChannelIndex !== -1) {
+        pool.freeChannelIndex--;
+        recomputeFreeChannelIndex();
       }
-      let handleOffline;
-      let handleOnline;
-      {
-        handleOffline = () => {
-          clearInterval(intervalId);
-        };
-        handleOnline = () => {
-          sendPing();
-          restartPingTimer();
-        };
-        globalThis.window.addEventListener("offline", handleOffline);
-        globalThis.window.addEventListener("online", handleOnline);
-      }
-    }
-    return pingableConnections.get(connection);
+    });
+    recomputeFreeChannelIndex();
+    return poolEntry.channel;
   };
 }
+function getRpcSubscriptionsChannelWithJSONSerialization(channel) {
+  return functional.pipe(
+    channel,
+    (c) => rpcSubscriptionsSpec.transformChannelInboundMessages(c, JSON.parse),
+    (c) => rpcSubscriptionsSpec.transformChannelOutboundMessages(c, JSON.stringify)
+  );
+}
+function getRpcSubscriptionsChannelWithBigIntJSONSerialization(channel) {
+  return functional.pipe(
+    channel,
+    (c) => rpcSubscriptionsSpec.transformChannelInboundMessages(c, rpcSpecTypes.parseJsonWithBigInts),
+    (c) => rpcSubscriptionsSpec.transformChannelOutboundMessages(c, rpcSpecTypes.stringifyJsonWithBigints)
+  );
+}
 
-// src/rpc-subscriptions-connection-sharding.ts
-var NULL_SHARD_CACHE_KEY;
-function createNullShardCacheKey() {
-  return Symbol(process.env.NODE_ENV !== "production" ? "Cache key to use when there is no connection sharding strategy" : void 0);
+// src/rpc-subscriptions-channel.ts
+function createDefaultSolanaRpcSubscriptionsChannelCreator(config) {
+  return createDefaultRpcSubscriptionsChannelCreatorImpl({
+    ...config,
+    jsonSerializer: getRpcSubscriptionsChannelWithBigIntJSONSerialization
+  });
 }
-function getWebSocketTransportWithConnectionSharding({
-  getShard,
-  transport
-}) {
-  return getCachedAbortableIterableFactory({
-    getAbortSignalFromInputArgs: ({ signal }) => signal,
-    getCacheKeyFromInputArgs: ({ payload }) => getShard ? getShard(payload) : NULL_SHARD_CACHE_KEY ||= createNullShardCacheKey(),
-    onCacheHit: (connection, { payload }) => connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload),
-    onCreateIterable: (abortSignal, config) => transport({
-      ...config,
+function createDefaultRpcSubscriptionsChannelCreator(config) {
+  return createDefaultRpcSubscriptionsChannelCreatorImpl({
+    ...config,
+    jsonSerializer: getRpcSubscriptionsChannelWithJSONSerialization
+  });
+}
+function createDefaultRpcSubscriptionsChannelCreatorImpl(config) {
+  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 }) => {
+    return rpcSubscriptionsChannelWebsocket.createWebSocketChannel({
+      ...rest,
+      sendBufferHighWatermark: config.sendBufferHighWatermark ?? // 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 ?? 5e3
+      })
+    );
+  };
+  return getChannelPoolingChannelCreator(createDefaultRpcSubscriptionsChannel, {
+    maxSubscriptionsPerChannel: config.maxSubscriptionsPerChannel ?? /**
+     * 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: config.minChannels ?? 1
   });
 }
+function getRpcSubscriptionsTransportWithSubscriptionCoalescing(transport) {
+  const cache = /* @__PURE__ */ new Map();
+  return function rpcSubscriptionsTransportWithSubscriptionCoalescing(config) {
+    const { request, signal } = config;
+    const subscriptionConfigurationHash = fastStableStringify__default.default([request.methodName, request.params]);
+    let cachedDataPublisherPromise = cache.get(subscriptionConfigurationHash);
+    if (!cachedDataPublisherPromise) {
+      const abortController = new AbortController();
+      const dataPublisherPromise = transport({
+        ...config,
+        signal: abortController.signal
+      });
+      dataPublisherPromise.then((dataPublisher) => {
+        dataPublisher.on(
+          "error",
+          () => {
+            cache.delete(subscriptionConfigurationHash);
+            abortController.abort();
+          },
+          { signal: abortController.signal }
+        );
+      }).catch(() => {
+      });
+      cache.set(
+        subscriptionConfigurationHash,
+        cachedDataPublisherPromise = {
+          abortController,
+          dataPublisherPromise,
+          numSubscribers: 0
+        }
+      );
+    }
+    cachedDataPublisherPromise.numSubscribers++;
+    signal.addEventListener(
+      "abort",
+      () => {
+        cachedDataPublisherPromise.numSubscribers--;
+        if (cachedDataPublisherPromise.numSubscribers === 0) {
+          queueMicrotask(() => {
+            if (cachedDataPublisherPromise.numSubscribers === 0) {
+              cache.delete(subscriptionConfigurationHash);
+              cachedDataPublisherPromise.abortController.abort();
+            }
+          });
+        }
+      },
+      { signal: cachedDataPublisherPromise.abortController.signal }
+    );
+    return cachedDataPublisherPromise.dataPublisherPromise;
+  };
+}
 
 // src/rpc-subscriptions-transport.ts
-function createDefaultRpcSubscriptionsTransport(config) {
-  const { getShard, intervalMs, ...rest } = config;
+function createDefaultRpcSubscriptionsTransport({
+  createChannel
+}) {
   return functional.pipe(
-    rpcSubscriptionsTransportWebsocket.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
-    })
+    createRpcSubscriptionsTransportFromChannelCreator(
+      createChannel
+    ),
+    (transport) => getRpcSubscriptionsTransportWithSubscriptionCoalescing(transport)
   );
 }
+function createRpcSubscriptionsTransportFromChannelCreator(createChannel) {
+  return async ({ execute, signal }) => {
+    const channel = await createChannel({ abortSignal: signal });
+    return await execute({ channel, signal });
+  };
+}
 
 // src/rpc-subscriptions.ts
-function createSolanaRpcSubscriptions(clusterUrl, config) {
-  const transport = createDefaultRpcSubscriptionsTransport({ url: clusterUrl, ...config });
+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 functional.pipe(
-    rpcSubscriptionsSpec.createSubscriptionRpc({
-      api: rpcSubscriptionsApi.createSolanaRpcSubscriptionsApi(DEFAULT_RPC_SUBSCRIPTIONS_CONFIG),
-      transport
-    }),
-    (rpcSubscriptions) => getRpcSubscriptionsWithSubscriptionCoalescing({
-      getDeduplicationKey: (...args) => fastStableStringify__default.default(args),
-      rpcSubscriptions
-    })
-  );
-}
-function createSolanaRpcSubscriptionsFromTransport_UNSTABLE(transport) {
-  return createSolanaRpcSubscriptionsFromTransport(transport);
+  return rpcSubscriptionsSpec.createSubscriptionRpc({
+    api: rpcSubscriptionsApi.createSolanaRpcSubscriptionsApi(DEFAULT_RPC_SUBSCRIPTIONS_CONFIG),
+    transport
+  });
 }
 
 exports.DEFAULT_RPC_SUBSCRIPTIONS_CONFIG = DEFAULT_RPC_SUBSCRIPTIONS_CONFIG;
+exports.createDefaultRpcSubscriptionsChannelCreator = createDefaultRpcSubscriptionsChannelCreator;
 exports.createDefaultRpcSubscriptionsTransport = createDefaultRpcSubscriptionsTransport;
+exports.createDefaultSolanaRpcSubscriptionsChannelCreator = createDefaultSolanaRpcSubscriptionsChannelCreator;
+exports.createRpcSubscriptionsTransportFromChannelCreator = createRpcSubscriptionsTransportFromChannelCreator;
 exports.createSolanaRpcSubscriptions = createSolanaRpcSubscriptions;
 exports.createSolanaRpcSubscriptionsFromTransport = createSolanaRpcSubscriptionsFromTransport;
-exports.createSolanaRpcSubscriptionsFromTransport_UNSTABLE = createSolanaRpcSubscriptionsFromTransport_UNSTABLE;
 exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
+exports.getRpcSubscriptionsChannelWithJSONSerialization = getRpcSubscriptionsChannelWithJSONSerialization;
 Object.keys(rpcSubscriptionsApi).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,