@talismn/chain-connectors 0.1.1 → 1.0.0

package/dist/index.mjs

@@ -1,1178 +1,616 @@
-// src/dot/ChainConnectorDot.ts
-import { Deferred, isTruthy, sleep, throwAfter } from "@talismn/util";
-
-// src/log.ts
+import { createClient } from "@polkadot-api/substrate-client";
+import { WsEvent, getWsProvider } from "@polkadot-api/ws-provider";
 import anylogger from "anylogger";
-
-// package.json
-var package_default = {
-  name: "@talismn/chain-connectors",
-  version: "0.1.1",
-  author: "Talisman",
-  homepage: "https://talisman.xyz",
-  license: "GPL-3.0-or-later",
-  publishConfig: {
-    access: "public"
-  },
-  repository: {
-    directory: "packages/chain-connectors",
-    type: "git",
-    url: "https://github.com/TalismanSociety/talisman.git"
-  },
-  main: "./dist/index.js",
-  module: "./dist/index.mjs",
-  files: [
-    "dist"
-  ],
-  engines: {
-    node: ">=20"
-  },
-  scripts: {
-    test: "vitest run",
-    clean: "rm -rf dist .turbo node_modules",
-    build: "tsup --silent",
-    typecheck: "tsc --noEmit"
-  },
-  dependencies: {
-    "@solana/web3.js": "^1.98.2",
-    "@talismn/chaindata-provider": "workspace:*",
-    "@talismn/connection-meta": "workspace:*",
-    "@talismn/util": "workspace:*",
-    anylogger: "^1.0.11",
-    eventemitter3: "^5.0.0",
-    "lodash-es": "4.18.1",
-    viem: "2.52.2"
-  },
-  devDependencies: {
-    "@polkadot/rpc-provider": "16.1.2",
-    "@polkadot/x-global": "13.5.3",
-    "@polkadot/x-ws": "13.5.3",
-    "@talismn/tsconfig": "workspace:*",
-    typescript: "^6.0.3"
-  },
-  peerDependencies: {
-    "@polkadot/rpc-provider": "*",
-    "@polkadot/x-global": "*",
-    "@polkadot/x-ws": "*"
-  },
-  types: "./dist/index.d.ts",
-  exports: {
-    ".": {
-      "@talismn/source": "./src/index.ts",
-      import: {
-        types: "./dist/index.d.mts",
-        default: "./dist/index.mjs"
-      },
-      require: {
-        types: "./dist/index.d.ts",
-        default: "./dist/index.js"
-      }
-    }
-  }
-};
-
-// src/log.ts
-var log_default = anylogger(package_default.name);
-
-// src/dot/Websocket.ts
-import { RpcCoder } from "@polkadot/rpc-provider/coder";
-import { getWSErrorString } from "@polkadot/rpc-provider/ws/errors";
-import { xglobal } from "@polkadot/x-global";
-import { WebSocket } from "@polkadot/x-ws";
-import EventEmitter from "eventemitter3";
-
-// src/dot/helpers.ts
-var twoSecondsMs = 2 * 1e3;
-var twoMinutesMs = 2 * 60 * 1e3;
-var ExponentialBackoff = class {
-  #minInterval;
-  #maxInterval;
-  #nextInterval = 0;
-  #active = true;
-  constructor(maxIntervalMs = twoMinutesMs, minIntervalMs = twoSecondsMs) {
-    this.#minInterval = minIntervalMs;
-    this.#maxInterval = maxIntervalMs;
-    this.reset();
-  }
-  enable() {
-    this.#active = true;
-  }
-  disable() {
-    this.#active = false;
-  }
-  increase() {
-    if (this.#nextInterval === 0) this.#nextInterval = 1;
-    this.#nextInterval = this.#capMax(this.#capMin(this.#nextInterval * 2));
-  }
-  decrease() {
-    this.#nextInterval = this.#capMax(this.#capMin(this.#nextInterval / 2));
-  }
-  reset() {
-    this.#nextInterval = this.#minInterval;
-  }
-  resetTo(nextInterval) {
-    this.#nextInterval = this.#capMax(this.#capMin(nextInterval));
-  }
-  resetToMax() {
-    this.#nextInterval = this.#maxInterval;
-  }
-  get isActive() {
-    return this.#active;
-  }
-  get next() {
-    return this.#nextInterval;
-  }
-  get isMin() {
-    return this.#nextInterval === this.#minInterval;
-  }
-  get isMax() {
-    return this.#nextInterval === this.#maxInterval;
-  }
-  #capMin(value) {
-    return Math.max(this.#minInterval, value);
-  }
-  #capMax(value) {
-    return Math.min(this.#maxInterval, value);
-  }
-};
-
-// src/dot/Websocket.ts
-var isChildClass = (Parent, Child) => Child != null && (Child === Parent || Child.prototype instanceof Parent);
-var ALIASES = {
-  chain_finalisedHead: "chain_finalizedHead",
-  chain_subscribeFinalisedHeads: "chain_subscribeFinalizedHeads",
-  chain_unsubscribeFinalisedHeads: "chain_unsubscribeFinalizedHeads"
-};
-var DEFAULT_TIMEOUT_MS = 60 * 1e3;
-var TIMEOUT_INTERVAL = 5e3;
-function eraseRecord(record, cb) {
-  Object.keys(record).forEach((key) => {
-    if (cb) {
-      cb(record[key]);
-    }
-    delete record[key];
-  });
-}
-var Websocket = class _Websocket {
-  #coder;
-  #endpoints;
-  #headers;
-  #eventemitter;
-  #handlers = {};
-  #isReadyPromise;
-  #waitingForId = {};
-  #autoConnectBackoff;
-  #endpointIndex;
-  #endpointsTriedSinceLastConnection = 0;
-  #isConnected = false;
-  #subscriptions = {};
-  #timeoutId = null;
-  #websocket;
-  #timeout;
-  /**
-   * @param {string | string[]}  endpoint    The endpoint url. Usually `ws://ip:9944` or `wss://ip:9944`, may provide an array of endpoint strings.
-   * @param {Record<string, string>} headers The headers provided to the underlying WebSocket
-   * @param {number} [timeout] Custom timeout value used per request . Defaults to `DEFAULT_TIMEOUT_MS`
-   */
-  constructor(endpoint, headers = {}, timeout, nextBackoffInterval) {
-    const endpoints = Array.isArray(endpoint) ? endpoint : [endpoint];
-    if (endpoints.length === 0) {
-      throw new Error("Websocket requires at least one Endpoint");
-    }
-    endpoints.forEach((endpoint2) => {
-      if (!/^(wss|ws):\/\//.test(endpoint2)) {
-        throw new Error(`Endpoint should start with 'ws://', received '${endpoint2}'`);
-      }
-    });
-    this.#eventemitter = new EventEmitter();
-    this.#autoConnectBackoff = new ExponentialBackoff();
-    if (nextBackoffInterval) this.#autoConnectBackoff.resetTo(nextBackoffInterval);
-    this.#coder = new RpcCoder();
-    this.#endpointIndex = -1;
-    this.#endpoints = endpoints;
-    this.#headers = headers;
-    this.#websocket = null;
-    this.#timeout = timeout || DEFAULT_TIMEOUT_MS;
-    if (this.#autoConnectBackoff.isActive) {
-      this.connectWithRetry().catch(() => {
-      });
-    }
-    this.#isReadyPromise = new Promise((resolve) => {
-      this.#eventemitter.once("connected", () => {
-        resolve(this);
-      });
-    });
-  }
-  /**
-   * @summary `true` when this provider supports subscriptions
-   */
-  get hasSubscriptions() {
-    return true;
-  }
-  /**
-   * @summary `true` when this provider supports clone()
-   */
-  get isClonable() {
-    return true;
-  }
-  /**
-   * @summary Whether the node is connected or not.
-   * @return {boolean} true if connected
-   */
-  get isConnected() {
-    return this.#isConnected;
-  }
-  /**
-   * @description Promise that resolves the first time we are connected and loaded
-   */
-  get isReady() {
-    return this.#isReadyPromise;
-  }
-  get endpoint() {
-    return this.#endpoints[this.#endpointIndex];
-  }
-  /**
-   * @description Returns a clone of the object
-   */
-  clone() {
-    return new _Websocket(this.#endpoints);
-  }
-  selectEndpointIndex(endpoints) {
-    this.#endpointsTriedSinceLastConnection += 1;
-    return (this.#endpointIndex + 1) % endpoints.length;
-  }
-  /**
-   * @summary Manually connect
-   * @description The [[Websocket]] connects automatically by default, however if you decided otherwise, you may
-   * connect manually using this method.
-   */
-  async connect() {
-    if (this.#websocket) {
-      throw new Error("WebSocket is already connected");
-    }
-    try {
-      this.#endpointIndex = this.selectEndpointIndex(this.#endpoints);
-      this.#websocket = typeof xglobal.WebSocket !== "undefined" && isChildClass(xglobal.WebSocket, WebSocket) ? new WebSocket(this.endpoint) : (
-        // @ts-expect-error - WS may be an instance of ws, which supports options
-        new WebSocket(this.endpoint, void 0, {
-          headers: this.#headers
-        })
-      );
-      if (this.#websocket) {
-        this.#websocket.onclose = this.#onSocketClose;
-        this.#websocket.onerror = this.#onSocketError;
-        this.#websocket.onmessage = this.#onSocketMessage;
-        this.#websocket.onopen = this.#onSocketOpen;
-      }
-      this.#timeoutId = setInterval(() => this.#timeoutHandlers(), TIMEOUT_INTERVAL);
-    } catch (error) {
-      log_default.error(error);
-      this.#emit("error", error);
-      throw error;
-    }
-  }
-  /**
-   * @description Connect, never throwing an error, but rather forcing a retry
-   */
-  async connectWithRetry() {
-    if (!this.#autoConnectBackoff.isActive) return;
-    try {
-      await this.connect();
-    } catch {
-      this.scheduleNextRetry();
-    }
-  }
-  scheduleNextRetry() {
-    if (!this.#autoConnectBackoff.isActive) return;
-    const haveTriedAllEndpoints = this.#endpointsTriedSinceLastConnection > 0 && this.#endpointsTriedSinceLastConnection % this.#endpoints.length === 0;
-    setTimeout(
-      () => {
-        this.connectWithRetry().catch(() => {
-        });
-      },
-      haveTriedAllEndpoints ? this.#autoConnectBackoff.next : 0
-    );
-    if (haveTriedAllEndpoints) this.#autoConnectBackoff.increase();
-    if (haveTriedAllEndpoints)
-      this.#emit("stale-rpcs", { nextBackoffInterval: this.#autoConnectBackoff.next });
-  }
-  /**
-   * @description Manually disconnect from the connection, clearing auto-connect logic
-   */
-  async disconnect() {
-    this.#autoConnectBackoff.disable();
-    try {
-      if (this.#websocket) {
-        this.#websocket.close(1e3);
-      }
-    } catch (error) {
-      log_default.error(error);
-      this.#emit("error", error);
-      throw error;
-    }
-  }
-  /**
-   * @summary Listens on events after having subscribed using the [[subscribe]] function.
-   * @param  {ProviderInterfaceEmitted} type Event
-   * @param  {ProviderInterfaceEmitCb}  sub  Callback
-   * @return unsubscribe function
-   */
-  on(type, sub) {
-    this.#eventemitter.on(type, sub);
-    return () => {
-      this.#eventemitter.removeListener(type, sub);
-    };
-  }
-  /**
-   * @summary Send JSON data using WebSockets to configured HTTP Endpoint or queue.
-   * @param method The RPC methods to execute
-   * @param params Encoded parameters as applicable for the method
-   * @param subscription Subscription details (internally used)
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: legacy
-  send(method, params, _isCacheable, subscription) {
-    const [id, body] = this.#coder.encodeJson(method, params);
-    const resultPromise = this.#send(id, body, method, params, subscription);
-    return resultPromise;
-  }
-  async #send(id, body, method, params, subscription) {
-    return new Promise((resolve, reject) => {
-      try {
-        if (!this.isConnected || this.#websocket === null) {
-          throw new Error("WebSocket is not connected");
-        }
-        const callback = (error, result) => {
-          error ? reject(error) : resolve(result);
-        };
-        this.#handlers[id] = {
-          callback,
-          method,
-          params,
-          start: Date.now(),
-          subscription
-        };
-        this.#websocket.send(body);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  /**
-   * @name subscribe
-   * @summary Allows subscribing to a specific event.
-   *
-   * @example
-   * <BR>
-   *
-   * ```javascript
-   * const provider = new Websocket('ws://127.0.0.1:9944');
-   * const rpc = new Rpc(provider);
-   *
-   * rpc.state.subscribeStorage([[storage.system.account, <Address>]], (_, values) => {
-   *   console.log(values)
-   * }).then((subscriptionId) => {
-   *   console.log('balance changes subscription id: ', subscriptionId)
-   * })
-   * ```
-   */
-  subscribe(type, method, params, callback) {
-    return this.send(method, params, false, { callback, type });
-  }
-  /**
-   * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
-   */
-  async unsubscribe(type, method, id) {
-    const subscription = `${type}::${id}`;
-    if (this.#subscriptions[subscription] === void 0) {
-      return false;
-    }
-    delete this.#subscriptions[subscription];
-    try {
-      return this.isConnected && this.#websocket !== null ? this.send(method, [id]) : true;
-    } catch {
-      return false;
-    }
-  }
-  #emit = (type, ...args) => {
-    this.#eventemitter.emit(type, ...args);
-  };
-  #onSocketClose = (event) => {
-    const error = new Error(
-      `disconnected from ${this.endpoint}: ${event.code}:: ${event.reason || getWSErrorString(event.code)}`
-    );
-    if (this.#autoConnectBackoff.isActive) {
-      if (event.code !== 1e3) log_default.error(error.message);
-    }
-    this.#isConnected = false;
-    if (this.#websocket) {
-      this.#websocket.onclose = null;
-      this.#websocket.onerror = null;
-      this.#websocket.onmessage = null;
-      this.#websocket.onopen = null;
-      this.#websocket = null;
-    }
-    if (this.#timeoutId) {
-      clearInterval(this.#timeoutId);
-      this.#timeoutId = null;
-    }
-    eraseRecord(this.#handlers, (h) => {
-      try {
-        h.callback(error, void 0);
-      } catch (err) {
-        log_default.error(err);
-      }
-    });
-    eraseRecord(this.#waitingForId);
-    this.#emit("disconnected");
-    this.scheduleNextRetry();
-  };
-  #onSocketError = (error) => {
-    this.#emit("error", error);
-  };
-  #onSocketMessage = (message) => {
-    try {
-      const response = JSON.parse(message.data);
-      return response.method === void 0 ? this.#onSocketMessageResult(response) : this.#onSocketMessageSubscribe(response);
-    } catch (e) {
-      this.#emit("error", new Error("Invalid websocket message received", { cause: e }));
-    }
-  };
-  #onSocketMessageResult = (response) => {
-    const handler = this.#handlers[response.id];
-    if (!handler) {
-      return;
-    }
-    try {
-      const { method, params, subscription } = handler;
-      const result = this.#coder.decodeResponse(response);
-      handler.callback(null, result);
-      if (subscription) {
-        const subId = `${subscription.type}::${result}`;
-        this.#subscriptions[subId] = { ...subscription, method, params };
-        if (this.#waitingForId[subId]) {
-          this.#onSocketMessageSubscribe(this.#waitingForId[subId]);
-        }
-      }
-    } catch (error) {
-      handler.callback(error, void 0);
-    }
-    delete this.#handlers[response.id];
-  };
-  #onSocketMessageSubscribe = (response) => {
-    const method = ALIASES[response.method] || response.method || "invalid";
-    const subId = `${method}::${response.params.subscription}`;
-    const handler = this.#subscriptions[subId];
-    if (!handler) {
-      this.#waitingForId[subId] = response;
-      return;
-    }
-    delete this.#waitingForId[subId];
-    try {
-      const result = this.#coder.decodeResponse(response);
-      handler.callback(null, result);
-    } catch (error) {
-      handler.callback(error, void 0);
-    }
-  };
-  #onSocketOpen = () => {
-    if (this.#websocket === null) {
-      throw new Error("WebSocket cannot be null in onOpen");
-    }
-    this.#isConnected = true;
-    this.#endpointsTriedSinceLastConnection = 0;
-    this.#autoConnectBackoff.reset();
-    this.#resubscribe();
-    this.#emit("connected");
-    return true;
-  };
-  #resubscribe = () => {
-    const subscriptions = this.#subscriptions;
-    this.#subscriptions = {};
-    Promise.all(
-      Object.keys(subscriptions).map(async (id) => {
-        const { callback, method, params, type } = subscriptions[id];
-        if (type.startsWith("author_")) {
-          return;
-        }
-        try {
-          await this.subscribe(type, method, params, callback);
-        } catch (error) {
-          log_default.error(error);
-        }
-      })
-    ).catch(log_default.error);
-  };
-  #timeoutHandlers = () => {
-    const now = Date.now();
-    const ids = Object.keys(this.#handlers);
-    for (let i = 0; i < ids.length; i++) {
-      const handler = this.#handlers[ids[i]];
-      if (now - handler.start > this.#timeout) {
-        try {
-          handler.callback(
-            new Error(`No response received from RPC endpoint in ${this.#timeout / 1e3}s`),
-            void 0
-          );
-        } catch {
-        }
-        delete this.#handlers[ids[i]];
-      }
-    }
-  };
-};
-
-// src/dot/ChainConnectorDot.ts
-var BAD_RPC_ERRORS = {
-  "-32097": "Rate limit exceeded",
-  "-32098": "Capacity exceeded"
+import { throwAfter } from "@talismn/util";
+import { createPublicClient, createWalletClient, fallback, http } from "viem";
+import { camelCase, fromPairs, toPairs } from "lodash-es";
+import * as viemChains from "viem/chains";
+import { createDefaultRpcTransport, createSolanaRpcFromTransport, isSolanaError } from "@solana/kit";
+//#endregion
+//#region src/log.ts
+var log_default = anylogger("@talismn/chain-connectors");
+//#endregion
+//#region src/dot/ChainConnectorDot.ts
+const BAD_RPC_ERRORS = {
+	"-32097": "Rate limit exceeded",
+	"-32098": "Capacity exceeded"
 };
+const RESPONSE_TIMEOUT = 3e4;
+const KEEP_ALIVE_INTERVAL = 2e4;
+/** in-flight requests reject with DestroyedError when a connection is torn down - expected, not worth logging */
+const isDestroyedError = (error) => error instanceof Error && error.name === "DestroyedError";
+const STALE_NOTIFY_TIMEOUT = 3e4;
 var ChainConnectionError = class extends Error {
-  type;
-  chainId;
-  constructor(chainId, options) {
-    super(`Unable to connect to chain ${chainId}`, options);
-    this.type = "CHAIN_CONNECTION_ERROR";
-    this.chainId = chainId;
-  }
+	type;
+	chainId;
+	constructor(chainId, options) {
+		super(`Unable to connect to chain ${chainId}`, options);
+		this.type = "CHAIN_CONNECTION_ERROR";
+		this.chainId = chainId;
+	}
 };
 var StaleRpcError = class extends Error {
-  type;
-  chainId;
-  constructor(chainId, options) {
-    super(`RPCs are stale/unavailable for chain ${chainId}`, options);
-    this.type = "STALE_RPC_ERROR";
-    this.chainId = chainId;
-  }
-};
-var WebsocketAllocationExhaustedError = class extends Error {
-  type;
-  chainId;
-  constructor(chainId, options) {
-    super(
-      `No websockets are available from the browser pool to connect to chain ${chainId}`,
-      options
-    );
-    this.type = "WEBSOCKET_ALLOCATION_EXHAUSTED_ERROR";
-    this.chainId = chainId;
-  }
-};
-var CallerUnsubscribedError = class extends Error {
-  type;
-  chainId;
-  unsubscribeMethod;
-  constructor(chainId, unsubscribeMethod, options) {
-    super(`Caller unsubscribed from ${chainId}`, options);
-    this.type = "CALLER_UNSUBSCRIBED_ERROR";
-    this.chainId = chainId;
-    this.unsubscribeMethod = unsubscribeMethod;
-  }
+	type;
+	chainId;
+	constructor(chainId, options) {
+		super(`RPCs are stale/unavailable for chain ${chainId}`, options);
+		this.type = "STALE_RPC_ERROR";
+		this.chainId = chainId;
+	}
 };
+/**
+* ChainConnector provides an interface similar to a websocket JSON-RPC provider, but with three points of difference:
+*
+* 1. ChainConnector methods all accept a `chainId` instead of an array of RPCs. RPCs are then fetched internally from chaindata.
+* 2. ChainConnector creates only one socket connection per chain (via polkadot-api's ws-provider, which handles
+*    endpoint rotation, reconnection and stale-socket detection) and ensures that all downstream requests to a chain
+*    share that connection.
+* 3. Subscriptions return a callable `unsubscribe` method instead of an id, and are automatically re-established
+*    when the provider reconnects (possibly to another endpoint).
+*
+* Additionally, when run on the clientside of a dapp where `window.talismanSub` is available, instead of spinning up new websocket
+* connections this class will forward all requests through to the wallet backend - where another instance of this class will
+* handle the websocket connections.
+*/
 var ChainConnectorDot = class {
-  #chaindataChainProvider;
-  #connectionMetaDb;
-  #socketConnections = {};
-  #socketKeepAliveIntervals = {};
-  #socketUsers = {};
-  constructor(chaindataChainProvider, connectionMetaDb) {
-    this.#chaindataChainProvider = chaindataChainProvider;
-    this.#connectionMetaDb = connectionMetaDb;
-    if (this.#connectionMetaDb) {
-      this.#chaindataChainProvider.getNetworkIds("polkadot").then((chainIds) => {
-        this.#connectionMetaDb?.chainPriorityRpcs.where("id").noneOf(chainIds).delete();
-        this.#connectionMetaDb?.chainBackoffInterval.where("id").noneOf(chainIds).delete();
-      });
-    }
-  }
-  /**
-   * Creates a facade over this ChainConnector which conforms to the PJS ProviderInterface
-   * @example // Using a chainConnector as a Provider for an ApiPromise
-   *   const provider = chainConnector.asProvider('polkadot')
-   *   const api = new ApiPromise({ provider })
-   */
-  asProvider(chainId) {
-    const unsubHandler = /* @__PURE__ */ new Map();
-    const providerFacade = {
-      hasSubscriptions: true,
-      isClonable: false,
-      isConnected: true,
-      clone: () => providerFacade,
-      connect: () => Promise.resolve(),
-      disconnect: () => Promise.resolve(),
-      on: () => () => {
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: legacy
-      send: async (method, params, isCacheable) => await this.send(chainId, method, params, isCacheable),
-      subscribe: async (type, method, params, cb) => {
-        const unsubscribe = await this.subscribe(chainId, method, type, params, cb);
-        const subscriptionId = this.getExclusiveRandomId(
-          [...unsubHandler.keys()].map(Number)
-        ).toString();
-        unsubHandler.set(subscriptionId, unsubscribe);
-        return subscriptionId;
-      },
-      unsubscribe: async (_type, unsubscribeMethod, subscriptionId) => {
-        unsubHandler.get(subscriptionId)?.(unsubscribeMethod);
-        unsubHandler.delete(subscriptionId);
-        return true;
-      }
-    };
-    return providerFacade;
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: legacy
-  async send(chainId, method, params, isCacheable, extraOptions) {
-    const talismanSub = this.getTalismanSub();
-    if (talismanSub !== void 0) {
-      try {
-        const chain = await this.#chaindataChainProvider.getNetworkById(chainId, "polkadot");
-        if (!chain) throw new Error(`Chain ${chainId} not found in store`);
-        const { genesisHash } = chain;
-        if (typeof genesisHash !== "string")
-          throw new Error(`Chain ${chainId} has no genesisHash in store`);
-        return await talismanSub.send(genesisHash, method, params);
-      } catch (error) {
-        log_default.warn(
-          `Failed to make wallet-proxied send request for chain ${chainId}. Falling back to plain websocket`,
-          error
-        );
-      }
-    }
-    try {
-      var [socketUserId, ws] = await this.connectChainSocket(chainId);
-    } catch (error) {
-      throw new StaleRpcError(chainId, { cause: error });
-    }
-    try {
-      const timeout = 15e3;
-      await this.waitForWs(ws, timeout);
-    } catch (error) {
-      await this.disconnectChainSocket(chainId, socketUserId);
-      throw new ChainConnectionError(chainId, { cause: error });
-    }
-    try {
-      const timeout = 3e4;
-      var response = await Promise.race([
-        ws.send(method, params, isCacheable),
-        throwAfter(timeout, "TIMEOUT")
-      ]);
-    } catch (err) {
-      const error = err;
-      if (error?.message === "TIMEOUT") {
-        log_default.error(`ChainConnector timeout`, { chainId, endpoint: ws.endpoint, error });
-        await this.updateRpcPriority(chainId, ws.endpoint, "last");
-        await this.reset(chainId);
-        throw new Error("Timeout");
-      }
-      const badRpcError = BAD_RPC_ERRORS[error?.code?.toString() ?? ""];
-      if (badRpcError) {
-        log_default.error(`ChainConnector ${badRpcError}`, { error, chainId, endpoint: ws.endpoint });
-        await this.updateRpcPriority(chainId, ws.endpoint, "last");
-        await this.reset(chainId);
-        throw new Error(badRpcError);
-      }
-      if (!extraOptions?.expectErrors)
-        log_default.error(
-          `Failed to send ${method} on chain ${chainId}
-params: ${JSON.stringify(params)}`,
-          {
-            error,
-            endpoint: ws.endpoint
-          }
-        );
-      await this.disconnectChainSocket(chainId, socketUserId);
-      throw error;
-    }
-    await this.disconnectChainSocket(chainId, socketUserId);
-    return response;
-  }
-  async subscribe(chainId, subscribeMethod, responseMethod, params, callback, timeout = 3e4) {
-    const talismanSub = this.getTalismanSub();
-    if (talismanSub !== void 0) {
-      try {
-        const chain = await this.#chaindataChainProvider.getNetworkById(chainId, "polkadot");
-        if (!chain) throw new Error(`Chain ${chainId} not found in store`);
-        const { genesisHash } = chain;
-        if (typeof genesisHash !== "string")
-          throw new Error(`Chain ${chainId} has no genesisHash in store`);
-        const subscriptionId = await talismanSub.subscribe(
-          genesisHash,
-          subscribeMethod,
-          responseMethod,
-          params,
-          callback,
-          timeout
-        );
-        return (unsubscribeMethod) => talismanSub.unsubscribe(subscriptionId, unsubscribeMethod);
-      } catch (error) {
-        log_default.warn(
-          `Failed to create wallet-proxied subscription for chain ${chainId}. Falling back to plain websocket`,
-          error
-        );
-      }
-    }
-    try {
-      var [socketUserId, ws] = await this.connectChainSocket(chainId);
-    } catch (error) {
-      throw new StaleRpcError(chainId, { cause: error });
-    }
-    const unsubDeferred = Deferred();
-    const unsubscribe = (unsubscribeMethod) => unsubDeferred.reject(new CallerUnsubscribedError(chainId, unsubscribeMethod));
-    const callerUnsubscribed = unsubDeferred.promise;
-    let noMoreSocketsTimeout;
-    (async () => {
-      let unsubRpcStatus = null;
-      try {
-        const unsubStale = ws.on(
-          "stale-rpcs",
-          ({ nextBackoffInterval } = {}) => {
-            callback(new StaleRpcError(chainId), null);
-            if (this.#connectionMetaDb && nextBackoffInterval) {
-              const id = chainId;
-              this.#connectionMetaDb.chainBackoffInterval.put(
-                { id, interval: nextBackoffInterval },
-                id
-              );
-            }
-          }
-        );
-        const unsubConnected = ws.on("connected", () => {
-          if (this.#connectionMetaDb) this.#connectionMetaDb.chainBackoffInterval.delete(chainId);
-        });
-        unsubRpcStatus = () => {
-          unsubStale();
-          unsubConnected();
-        };
-        noMoreSocketsTimeout = setTimeout(
-          () => callback(new WebsocketAllocationExhaustedError(chainId), null),
-          3e4
-          // 30 seconds in ms
-        );
-        if (timeout) await Promise.race([this.waitForWs(ws, timeout), callerUnsubscribed]);
-        else await Promise.race([ws.isReady, callerUnsubscribed]);
-        clearTimeout(noMoreSocketsTimeout);
-      } catch {
-        clearTimeout(noMoreSocketsTimeout);
-        unsubRpcStatus?.();
-        await this.disconnectChainSocket(chainId, socketUserId);
-        return;
-      }
-      let subscriptionId = null;
-      let disconnected = false;
-      let unsubscribeMethod;
-      try {
-        await Promise.race([
-          ws.subscribe(responseMethod, subscribeMethod, params, callback).then((id) => {
-            if (disconnected) {
-              unsubscribeMethod && ws.unsubscribe(responseMethod, unsubscribeMethod, id);
-            } else subscriptionId = id;
-          }),
-          callerUnsubscribed
-        ]);
-      } catch (error) {
-        if (error instanceof CallerUnsubscribedError) unsubscribeMethod = error.unsubscribeMethod;
-        unsubRpcStatus?.();
-        disconnected = true;
-        if (subscriptionId !== null && unsubscribeMethod)
-          await ws.unsubscribe(responseMethod, unsubscribeMethod, subscriptionId);
-        await this.disconnectChainSocket(chainId, socketUserId);
-        return;
-      }
-      callerUnsubscribed.catch(async (error) => {
-        let unsubscribeMethod2;
-        if (error instanceof CallerUnsubscribedError) unsubscribeMethod2 = error.unsubscribeMethod;
-        unsubRpcStatus?.();
-        if (subscriptionId !== null && unsubscribeMethod2)
-          await ws.unsubscribe(responseMethod, unsubscribeMethod2, subscriptionId);
-        await this.disconnectChainSocket(chainId, socketUserId);
-      }).catch((error) => log_default.warn(error));
-    })();
-    return unsubscribe;
-  }
-  /**
-   * Kills current websocket if any
-   * Useful after changing rpc order to make sure it's applied for futher requests
-   */
-  async reset(chainId) {
-    log_default.info("ChainConnector reset", chainId);
-    const ws = this.#socketConnections[chainId];
-    if (!ws) return;
-    try {
-      clearTimeout(this.#socketKeepAliveIntervals[chainId]);
-      delete this.#socketConnections[chainId];
-      delete this.#socketUsers[chainId];
-      await ws.disconnect();
-    } catch (error) {
-      log_default.warn(`Error occurred reseting socket ${chainId}`, error);
-    }
-  }
-  /**
-   * Wait for websocket to be ready, but don't wait forever
-   */
-  async waitForWs(ws, timeout = 3e4) {
-    const timer = timeout ? sleep(timeout).then(() => {
-      throw new Error(`RPC connect timeout reached: ${ws.endpoint}`);
-    }) : false;
-    await Promise.race([ws.isReady, timer].filter(isTruthy));
-  }
-  /**
-   * Connect to an RPC via chainId
-   *
-   * The caller must call disconnectChainSocket with the returned SocketUserId once they are finished with it
-   */
-  async connectChainSocket(chainId) {
-    const rpcs = await this.getEndpoints(chainId);
-    const socketUserId = this.addSocketUser(chainId);
-    let nextBackoffInterval;
-    if (this.#connectionMetaDb)
-      nextBackoffInterval = (await this.#connectionMetaDb.chainBackoffInterval.get(chainId))?.interval;
-    if (this.#socketConnections[chainId]) return [socketUserId, this.#socketConnections[chainId]];
-    if (rpcs.length)
-      this.#socketConnections[chainId] = new Websocket(
-        rpcs,
-        void 0,
-        void 0,
-        nextBackoffInterval
-      );
-    else {
-      throw new Error(`No healthy RPCs available for chain ${chainId}`);
-    }
-    if (this.#connectionMetaDb) {
-      this.#socketConnections[chainId].on("connected", () => {
-        if (!this.#connectionMetaDb) return;
-        const id = chainId;
-        const url = this.#socketConnections[chainId]?.endpoint;
-        if (!url) return;
-        this.updateRpcPriority(id, url, "first").catch(
-          (err) => log_default.warn(`updateRpcPriority failed`, err)
-        );
-      });
-    }
-    ;
-    (async () => {
-      if (!this.#socketConnections[chainId])
-        return log_default.warn(`ignoring ${chainId} rpc ws healthcheck initialization: ws is not defined`);
-      await this.#socketConnections[chainId].isReady;
-      if (this.#socketKeepAliveIntervals[chainId])
-        clearInterval(this.#socketKeepAliveIntervals[chainId]);
-      const intervalMs = 1e4;
-      this.#socketKeepAliveIntervals[chainId] = setInterval(() => {
-        if (!this.#socketConnections[chainId])
-          return log_default.warn(`skipping ${chainId} rpc ws healthcheck: ws is not defined`);
-        if (!this.#socketConnections[chainId].isConnected)
-          return log_default.warn(`skipping ${chainId} rpc ws healthcheck: ws is not connected`);
-        this.#socketConnections[chainId].send("system_health", []).catch((error) => log_default.warn(`Failed keep-alive for socket ${chainId}`, error));
-      }, intervalMs);
-    })();
-    return [socketUserId, this.#socketConnections[chainId]];
-  }
-  async disconnectChainSocket(chainId, socketUserId) {
-    this.removeSocketUser(chainId, socketUserId);
-    if (this.#socketUsers[chainId].length > 0) return;
-    if (!this.#socketConnections[chainId])
-      return log_default.warn(`Failed to disconnect socket: socket ${chainId} not found`);
-    try {
-      this.#socketConnections[chainId].disconnect();
-    } catch (error) {
-      log_default.warn(`Error occurred disconnecting socket ${chainId}`, error);
-    }
-    delete this.#socketConnections[chainId];
-    clearInterval(this.#socketKeepAliveIntervals[chainId]);
-    delete this.#socketKeepAliveIntervals[chainId];
-  }
-  addSocketUser(chainId) {
-    if (!Array.isArray(this.#socketUsers[chainId])) this.#socketUsers[chainId] = [];
-    const socketUserId = this.getExclusiveRandomId(this.#socketUsers[chainId]);
-    this.#socketUsers[chainId].push(socketUserId);
-    return socketUserId;
-  }
-  removeSocketUser(chainId, socketUserId) {
-    const userIndex = this.#socketUsers[chainId].indexOf(socketUserId);
-    if (userIndex === -1)
-      throw new Error(
-        `Can't remove user ${socketUserId} from socket ${chainId}: user not in list ${this.#socketUsers[chainId].join(", ")}`
-      );
-    this.#socketUsers[chainId].splice(userIndex, 1);
-  }
-  /** continues to generate a random number until it finds one which is not present in the exclude list */
-  getExclusiveRandomId(exclude = []) {
-    let id = this.getRandomId();
-    while (exclude.includes(id)) {
-      id = this.getRandomId();
-    }
-    return id;
-  }
-  /** generates a random number */
-  getRandomId() {
-    return Math.trunc(Math.random() * 10 ** 8);
-  }
-  getTalismanSub() {
-    const talismanSub = typeof window !== "undefined" && window.talismanSub;
-    const rpcByGenesisHashSend = talismanSub?.rpcByGenesisHashSend;
-    const rpcByGenesisHashSubscribe = talismanSub?.rpcByGenesisHashSubscribe;
-    const rpcByGenesisHashUnsubscribe = talismanSub?.rpcByGenesisHashUnsubscribe;
-    if (typeof rpcByGenesisHashSend !== "function") return;
-    if (typeof rpcByGenesisHashSubscribe !== "function") return;
-    if (typeof rpcByGenesisHashUnsubscribe !== "function") return;
-    return {
-      // biome-ignore lint/suspicious/noExplicitAny: legacy
-      send: (genesisHash, method, params) => rpcByGenesisHashSend(genesisHash, method, params),
-      subscribe: (genesisHash, subscribeMethod, responseMethod, params, callback, timeout) => rpcByGenesisHashSubscribe(
-        genesisHash,
-        subscribeMethod,
-        responseMethod,
-        params,
-        callback,
-        timeout
-      ),
-      unsubscribe: (subscriptionId, unsubscribeMethod) => rpcByGenesisHashUnsubscribe(subscriptionId, unsubscribeMethod)
-    };
-  }
-  async updateRpcPriority(chainId, rpc, priority) {
-    if (!this.#connectionMetaDb) return;
-    const rpcs = await this.getEndpoints(chainId);
-    if (!rpcs.includes(rpc)) throw new Error(`Unknown rpc for chain ${chainId} : ${rpc}`);
-    const urls = rpcs.filter((r) => r !== rpc);
-    if (priority === "first") urls.unshift(rpc);
-    if (priority === "last") urls.push(rpc);
-    if (!isEqual(urls, rpcs)) {
-      await this.#connectionMetaDb.chainPriorityRpcs.put({ id: chainId, urls }, chainId);
-    }
-  }
-  async getEndpoints(chainId) {
-    const chain = await this.#chaindataChainProvider.getNetworkById(chainId, "polkadot");
-    if (!chain) throw new Error(`Chain ${chainId} not found in store`);
-    let rpcs = chain.rpcs.concat();
-    const priorityRpcs = this.#connectionMetaDb ? await this.#connectionMetaDb.chainPriorityRpcs.get(chainId) : void 0;
-    if (priorityRpcs) {
-      rpcs = [
-        ...priorityRpcs.urls.filter((rpc) => rpcs.includes(rpc)),
-        ...rpcs.filter((rpc) => !priorityRpcs.urls.includes(rpc))
-      ];
-    }
-    return rpcs;
-  }
+	#chaindataChainProvider;
+	#connections = {};
+	#pendingConnections = {};
+	constructor(chaindataChainProvider) {
+		this.#chaindataChainProvider = chaindataChainProvider;
+	}
+	async send(chainId, method, params, _isCacheable, extraOptions) {
+		const talismanSub = this.getTalismanSub();
+		if (talismanSub !== void 0) try {
+			const genesisHash = await this.getGenesisHash(chainId);
+			return await talismanSub.send(genesisHash, method, params);
+		} catch (error) {
+			log_default.warn(`Failed to make wallet-proxied send request for chain ${chainId}. Falling back to plain websocket`, error);
+		}
+		let socketUserId;
+		let connection;
+		try {
+			[socketUserId, connection] = await this.acquireConnection(chainId);
+		} catch (error) {
+			throw new StaleRpcError(chainId, { cause: error });
+		}
+		try {
+			return await this.request(connection, method, params);
+		} catch (err) {
+			const error = err;
+			if (error?.message === "TIMEOUT") {
+				log_default.error(`ChainConnector timeout`, {
+					chainId,
+					error
+				});
+				connection.provider.switch();
+				throw new Error("Timeout");
+			}
+			const badRpcError = BAD_RPC_ERRORS[error?.code?.toString() ?? ""];
+			if (badRpcError) {
+				log_default.error(`ChainConnector ${badRpcError}`, {
+					error,
+					chainId
+				});
+				connection.provider.switch();
+				throw new Error(badRpcError);
+			}
+			if (!extraOptions?.expectErrors) log_default.error(`Failed to send ${method} on chain ${chainId}\nparams: ${JSON.stringify(params)}`, { error });
+			throw error;
+		} finally {
+			this.releaseConnection(chainId, socketUserId);
+		}
+	}
+	async subscribe(chainId, subscribeMethod, responseMethod, params, callback, timeout = 3e4) {
+		const talismanSub = this.getTalismanSub();
+		if (talismanSub !== void 0) try {
+			const genesisHash = await this.getGenesisHash(chainId);
+			const subscriptionId = await talismanSub.subscribe(genesisHash, subscribeMethod, responseMethod, params, callback, timeout);
+			return (unsubscribeMethod) => talismanSub.unsubscribe(subscriptionId, unsubscribeMethod);
+		} catch (error) {
+			log_default.warn(`Failed to create wallet-proxied subscription for chain ${chainId}. Falling back to plain websocket`, error);
+		}
+		let socketUserId;
+		let connection;
+		try {
+			[socketUserId, connection] = await this.acquireConnection(chainId);
+		} catch (error) {
+			throw new StaleRpcError(chainId, { cause: error });
+		}
+		const subscription = {
+			subscribeMethod,
+			params,
+			callback,
+			cancelRequest: null,
+			stopFollow: null,
+			serverSubId: null,
+			unsubscribed: false
+		};
+		connection.subscriptions.add(subscription);
+		if (timeout && !connection.wasConnected) {
+			const staleWarning = setTimeout(() => {
+				if (!subscription.unsubscribed && !connection.wasConnected) callback(new StaleRpcError(chainId), null);
+			}, timeout);
+			const clear = () => clearTimeout(staleWarning);
+			const originalCallback = subscription.callback;
+			subscription.callback = (error, result) => {
+				clear();
+				subscription.callback = originalCallback;
+				originalCallback(error, result);
+			};
+		}
+		this.startSubscription(connection, subscription);
+		return (unsubscribeMethod) => {
+			if (subscription.unsubscribed) return;
+			subscription.unsubscribed = true;
+			subscription.cancelRequest?.();
+			subscription.stopFollow?.();
+			const current = this.#connections[chainId];
+			const isLastUser = !!current && current.users.size === 1 && current.users.has(socketUserId);
+			if (subscription.serverSubId !== null && current && !isLastUser) try {
+				current.client.request(unsubscribeMethod, [subscription.serverSubId]).catch((error) => {
+					if (!isDestroyedError(error)) log_default.warn(`Failed to unsubscribe from ${chainId}`, error);
+				});
+			} catch (error) {
+				if (!isDestroyedError(error)) log_default.warn(`Failed to unsubscribe from ${chainId}`, error);
+			}
+			current?.subscriptions.delete(subscription);
+			this.releaseConnection(chainId, socketUserId);
+		};
+	}
+	/**
+	* Kills and recreates the connection for a chain, if any.
+	* Useful after changing a network's rpcs to make sure the new list is applied for further requests.
+	* Active subscriptions are automatically re-established on the new connection.
+	*/
+	async reset(chainId) {
+		log_default.info("ChainConnector reset", chainId);
+		const connection = this.#connections[chainId];
+		if (!connection) return;
+		this.destroyConnection(connection);
+		delete this.#connections[chainId];
+		if (connection.subscriptions.size) try {
+			const fresh = await this.createConnection(chainId);
+			fresh.users = connection.users;
+			fresh.subscriptions = connection.subscriptions;
+			this.#connections[chainId] = fresh;
+			for (const subscription of fresh.subscriptions) this.startSubscription(fresh, subscription);
+		} catch (error) {
+			log_default.warn(`Failed to recreate connection for ${chainId} after reset`, error);
+			for (const subscription of connection.subscriptions) subscription.callback(new StaleRpcError(chainId, { cause: error }), null);
+		}
+	}
+	/** Sends a request over a connection, throwing `Error("TIMEOUT")` if no response arrives in time */
+	request(connection, method, params, timeoutMs = RESPONSE_TIMEOUT) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				cancel();
+				reject(/* @__PURE__ */ new Error("TIMEOUT"));
+			}, timeoutMs);
+			const cancel = connection.client._request(method, params, {
+				onSuccess: (result) => {
+					clearTimeout(timer);
+					resolve(result);
+				},
+				onError: (error) => {
+					clearTimeout(timer);
+					reject(error);
+				}
+			});
+		});
+	}
+	/** Issues the subscribe request and routes notifications to the subscription callback */
+	startSubscription(connection, subscription) {
+		subscription.serverSubId = null;
+		subscription.stopFollow = null;
+		subscription.cancelRequest = connection.client._request(subscription.subscribeMethod, subscription.params, {
+			onSuccess: (serverSubId, follow) => {
+				subscription.cancelRequest = null;
+				if (subscription.unsubscribed) return;
+				subscription.serverSubId = serverSubId;
+				subscription.stopFollow = follow(serverSubId, {
+					next: (result) => subscription.callback(null, result),
+					error: (error) => subscription.callback(error, null)
+				});
+			},
+			onError: (error) => {
+				subscription.cancelRequest = null;
+				if (!subscription.unsubscribed) subscription.callback(error, null);
+			}
+		});
+	}
+	/**
+	* Get (or create) the shared connection for a chain.
+	*
+	* The caller must call releaseConnection with the returned SocketUserId once they are finished with it.
+	*/
+	async acquireConnection(chainId) {
+		let connection = this.#connections[chainId];
+		if (!connection) {
+			if (!this.#pendingConnections[chainId]) this.#pendingConnections[chainId] = this.createConnection(chainId).then((created) => {
+				this.#connections[chainId] = created;
+				return created;
+			}).finally(() => {
+				delete this.#pendingConnections[chainId];
+			});
+			connection = await this.#pendingConnections[chainId];
+		}
+		const socketUserId = this.getExclusiveRandomId([...connection.users]);
+		connection.users.add(socketUserId);
+		return [socketUserId, connection];
+	}
+	async createConnection(chainId) {
+		const chain = await this.#chaindataChainProvider.getNetworkById(chainId, "polkadot");
+		if (!chain) throw new Error(`Chain ${chainId} not found in store`);
+		const rpcs = chain.rpcs.concat();
+		if (!rpcs.length) throw new Error(`No healthy RPCs available for chain ${chainId}`);
+		let connection = null;
+		const provider = getWsProvider(rpcs, { onStatusChanged: (status) => this.handleStatusChange(connection, status) });
+		connection = {
+			chainId,
+			provider,
+			client: createClient(provider),
+			users: /* @__PURE__ */ new Set(),
+			subscriptions: /* @__PURE__ */ new Set(),
+			wasConnected: false,
+			keepAliveInterval: null,
+			staleTimeout: null
+		};
+		return connection;
+	}
+	handleStatusChange(connection, status) {
+		if (!connection) return;
+		if (this.#connections[connection.chainId] !== connection) return;
+		if (status.type === WsEvent.CONNECTED) {
+			if (connection.staleTimeout) {
+				clearTimeout(connection.staleTimeout);
+				connection.staleTimeout = null;
+			}
+			const isReconnect = connection.wasConnected;
+			connection.wasConnected = true;
+			if (connection.keepAliveInterval) clearInterval(connection.keepAliveInterval);
+			connection.keepAliveInterval = setInterval(() => {
+				this.request(connection, "system_health", [], KEEP_ALIVE_INTERVAL).catch((error) => {
+					if (!isDestroyedError(error)) log_default.warn(`Failed keep-alive for socket ${connection.chainId}`, error);
+				});
+			}, KEEP_ALIVE_INTERVAL);
+			if (isReconnect) for (const subscription of connection.subscriptions) {
+				if (subscription.unsubscribed) continue;
+				if (subscription.subscribeMethod.startsWith("author_")) continue;
+				subscription.stopFollow?.();
+				subscription.cancelRequest?.();
+				this.startSubscription(connection, subscription);
+			}
+		} else {
+			if (connection.keepAliveInterval) {
+				clearInterval(connection.keepAliveInterval);
+				connection.keepAliveInterval = null;
+			}
+			if (!connection.staleTimeout && connection.subscriptions.size) connection.staleTimeout = setTimeout(() => {
+				connection.staleTimeout = null;
+				for (const subscription of connection.subscriptions) if (!subscription.unsubscribed) subscription.callback(new StaleRpcError(connection.chainId), null);
+			}, STALE_NOTIFY_TIMEOUT);
+		}
+	}
+	releaseConnection(chainId, socketUserId) {
+		const connection = this.#connections[chainId];
+		if (!connection) return;
+		connection.users.delete(socketUserId);
+		if (connection.users.size > 0) return;
+		this.destroyConnection(connection);
+		delete this.#connections[chainId];
+	}
+	destroyConnection(connection) {
+		if (connection.keepAliveInterval) clearInterval(connection.keepAliveInterval);
+		if (connection.staleTimeout) clearTimeout(connection.staleTimeout);
+		connection.keepAliveInterval = null;
+		connection.staleTimeout = null;
+		for (const subscription of connection.subscriptions) {
+			subscription.stopFollow?.();
+			subscription.cancelRequest?.();
+			subscription.stopFollow = null;
+			subscription.cancelRequest = null;
+			subscription.serverSubId = null;
+		}
+		try {
+			connection.client.destroy();
+		} catch (error) {
+			log_default.warn(`Error occurred destroying connection ${connection.chainId}`, error);
+		}
+	}
+	async getGenesisHash(chainId) {
+		const chain = await this.#chaindataChainProvider.getNetworkById(chainId, "polkadot");
+		if (!chain) throw new Error(`Chain ${chainId} not found in store`);
+		const { genesisHash } = chain;
+		if (typeof genesisHash !== "string") throw new Error(`Chain ${chainId} has no genesisHash in store`);
+		return genesisHash;
+	}
+	/** continues to generate a random number until it finds one which is not present in the exclude list */
+	getExclusiveRandomId(exclude = []) {
+		let id = this.getRandomId();
+		while (exclude.includes(id)) id = this.getRandomId();
+		return id;
+	}
+	/** generates a random number */
+	getRandomId() {
+		return Math.trunc(Math.random() * 10 ** 8);
+	}
+	getTalismanSub() {
+		const talismanSub = typeof window !== "undefined" && window.talismanSub;
+		const rpcByGenesisHashSend = talismanSub?.rpcByGenesisHashSend;
+		const rpcByGenesisHashSubscribe = talismanSub?.rpcByGenesisHashSubscribe;
+		const rpcByGenesisHashUnsubscribe = talismanSub?.rpcByGenesisHashUnsubscribe;
+		if (typeof rpcByGenesisHashSend !== "function") return;
+		if (typeof rpcByGenesisHashSubscribe !== "function") return;
+		if (typeof rpcByGenesisHashUnsubscribe !== "function") return;
+		return {
+			send: (genesisHash, method, params) => rpcByGenesisHashSend(genesisHash, method, params),
+			subscribe: (genesisHash, subscribeMethod, responseMethod, params, callback, timeout) => rpcByGenesisHashSubscribe(genesisHash, subscribeMethod, responseMethod, params, callback, timeout),
+			unsubscribe: (subscriptionId, unsubscribeMethod) => rpcByGenesisHashUnsubscribe(subscriptionId, unsubscribeMethod)
+		};
+	}
 };
-var isEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
-
-// src/dot/ChainConnectorDotStub.ts
-import { WsProvider } from "@polkadot/rpc-provider";
-import { throwAfter as throwAfter2 } from "@talismn/util";
-var AUTO_CONNECT_TIMEOUT = 3e3;
-var TIMEOUT = 1e4;
+//#endregion
+//#region src/dot/ChainConnectorDotStub.ts
+const TIMEOUT = 1e4;
 var ChainConnectorDotStub = class {
-  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: legacy
-  #network;
-  #provider;
-  constructor(network) {
-    this.#network = network;
-    this.#provider = new WsProvider(network.rpcs, AUTO_CONNECT_TIMEOUT, void 0, TIMEOUT);
-  }
-  asProvider() {
-    return this.#provider;
-  }
-  async send(_chainId, method, params, isCacheable) {
-    await this.#provider.isReady;
-    return this.#provider.send(method, params, isCacheable);
-  }
-  async subscribe(_chainId, subscribeMethod, responseMethod, params, callback, timeout) {
-    await this.#provider.isReady;
-    const subId = await Promise.race([
-      throwAfter2(timeout || TIMEOUT, `Subscription timed out after ${timeout}ms`),
-      this.#provider.subscribe(responseMethod, subscribeMethod, params, callback)
-    ]);
-    return (unsubscribeMethod) => {
-      this.#provider.unsubscribe(responseMethod, unsubscribeMethod, subId);
-    };
-  }
-  reset() {
-    throw new Error("ChainConnectorDotStub does not implement reset");
-  }
+	#client;
+	constructor(network) {
+		this.#client = createClient(getWsProvider(network.rpcs.concat()));
+	}
+	async send(_chainId, method, params, _isCacheable) {
+		return await Promise.race([this.#client.request(method, params), throwAfter(TIMEOUT, `Request ${method} timed out after ${TIMEOUT}ms`)]);
+	}
+	async subscribe(_chainId, subscribeMethod, _responseMethod, params, callback, timeout) {
+		let stopFollow = null;
+		let unsubscribed = false;
+		const serverSubId = await Promise.race([new Promise((resolve, reject) => {
+			this.#client._request(subscribeMethod, params, {
+				onSuccess: (subId, follow) => {
+					stopFollow = follow(subId, {
+						next: (result) => callback(null, result),
+						error: (error) => callback(error, null)
+					});
+					resolve(subId);
+				},
+				onError: reject
+			});
+		}), throwAfter(timeout || TIMEOUT, `Subscription timed out after ${timeout || TIMEOUT}ms`)]);
+		return (unsubscribeMethod) => {
+			if (unsubscribed) return;
+			unsubscribed = true;
+			stopFollow?.();
+			this.#client.request(unsubscribeMethod, [serverSubId]).catch(() => {});
+		};
+	}
+	reset() {
+		throw new Error("ChainConnectorDotStub does not implement reset");
+	}
+	destroy() {
+		this.#client.destroy();
+	}
 };
-
-// src/eth/getEvmNetworkPublicClient.ts
-import { createPublicClient } from "viem";
-
-// src/eth/getChainFromEvmNetwork.ts
-import { camelCase, fromPairs, toPairs } from "lodash-es";
-import * as viemChains from "viem/chains";
-var { zoraTestnet, ...validViemChains } = viemChains;
-var VIEM_CHAINS = Object.keys(validViemChains).reduce(
-  (acc, curr) => {
-    const chain = validViemChains[curr];
-    acc[chain.id] = chain;
-    return acc;
-  },
-  {}
-);
-var chainsCache = /* @__PURE__ */ new Map();
-var clearChainsCache = (networkId) => {
-  if (networkId) chainsCache.delete(networkId);
-  else chainsCache.clear();
+//#endregion
+//#region src/eth/getChainFromEvmNetwork.ts
+const { zoraTestnet, ...validViemChains } = viemChains;
+const VIEM_CHAINS = Object.keys(validViemChains).reduce((acc, curr) => {
+	const chain = validViemChains[curr];
+	acc[chain.id] = chain;
+	return acc;
+}, {});
+const chainsCache = /* @__PURE__ */ new Map();
+const clearChainsCache = (networkId) => {
+	if (networkId) chainsCache.delete(networkId);
+	else chainsCache.clear();
 };
-var getChainFromEvmNetwork = (network) => {
-  const { symbol, decimals } = network.nativeCurrency;
-  if (!chainsCache.has(network.id)) {
-    const chainRpcs = network.rpcs ?? [];
-    const viemChain = VIEM_CHAINS[Number(network.id)] ?? {};
-    const chain = {
-      ...viemChain,
-      id: Number(network.id),
-      name: network.name ?? `Ethereum Chain ${network.id}`,
-      rpcUrls: {
-        public: { http: chainRpcs },
-        default: { http: chainRpcs }
-      },
-      nativeCurrency: {
-        symbol,
-        decimals,
-        name: symbol
-      },
-      contracts: {
-        ...viemChain.contracts,
-        ...network.contracts ? fromPairs(
-          toPairs(network.contracts).map(([name, address]) => [
-            camelCase(name),
-            { address }
-          ])
-        ) : {}
-      }
-    };
-    chainsCache.set(network.id, chain);
-  }
-  return chainsCache.get(network.id);
+const getChainFromEvmNetwork = (network) => {
+	const { symbol, decimals } = network.nativeCurrency;
+	if (!chainsCache.has(network.id)) {
+		const chainRpcs = network.rpcs ?? [];
+		const viemChain = VIEM_CHAINS[Number(network.id)] ?? {};
+		const chain = {
+			...viemChain,
+			id: Number(network.id),
+			name: network.name ?? `Ethereum Chain ${network.id}`,
+			rpcUrls: {
+				public: { http: chainRpcs },
+				default: { http: chainRpcs }
+			},
+			nativeCurrency: {
+				symbol,
+				decimals,
+				name: symbol
+			},
+			contracts: {
+				...viemChain.contracts,
+				...network.contracts ? fromPairs(toPairs(network.contracts).map(([name, address]) => [camelCase(name), { address }])) : {}
+			}
+		};
+		chainsCache.set(network.id, chain);
+	}
+	return chainsCache.get(network.id);
 };
-
-// src/eth/getTransportForEvmNetwork.ts
-import { fallback, http } from "viem";
-var getTransportForEvmNetwork = (evmNetwork, options = {}) => {
-  if (!evmNetwork.rpcs?.length) throw new Error("No RPCs found for EVM network");
-  const { batch } = options;
-  return fallback(
-    evmNetwork.rpcs.map((url) => http(url, { batch, retryCount: 0 })),
-    { retryCount: 0 }
-  );
+//#endregion
+//#region src/eth/getTransportForEvmNetwork.ts
+const getTransportForEvmNetwork = (evmNetwork, options = {}) => {
+	if (!evmNetwork.rpcs?.length) throw new Error("No RPCs found for EVM network");
+	const { batch } = options;
+	return fallback(evmNetwork.rpcs.map((url) => http(url, {
+		batch,
+		retryCount: 0
+	})), { retryCount: 0 });
 };
-
-// src/eth/getEvmNetworkPublicClient.ts
-var MUTLICALL_BATCH_WAIT = 25;
-var MUTLICALL_BATCH_SIZE = 100;
-var HTTP_BATCH_WAIT = 25;
-var HTTP_BATCH_SIZE_WITH_MULTICALL = 10;
-var HTTP_BATCH_SIZE_WITHOUT_MULTICALL = 30;
-var publicClientCache = /* @__PURE__ */ new Map();
-var clearPublicClientCache = (evmNetworkId) => {
-  clearChainsCache(evmNetworkId);
-  if (evmNetworkId) publicClientCache.delete(evmNetworkId);
-  else publicClientCache.clear();
+//#endregion
+//#region src/eth/getEvmNetworkPublicClient.ts
+const MUTLICALL_BATCH_WAIT = 25;
+const MUTLICALL_BATCH_SIZE = 100;
+const HTTP_BATCH_WAIT = 25;
+const HTTP_BATCH_SIZE_WITH_MULTICALL = 10;
+const HTTP_BATCH_SIZE_WITHOUT_MULTICALL = 30;
+const publicClientCache = /* @__PURE__ */ new Map();
+const clearPublicClientCache = (evmNetworkId) => {
+	clearChainsCache(evmNetworkId);
+	if (evmNetworkId) publicClientCache.delete(evmNetworkId);
+	else publicClientCache.clear();
 };
-var getEvmNetworkPublicClient = (network) => {
-  const chain = getChainFromEvmNetwork(network);
-  if (!publicClientCache.has(network.id)) {
-    if (!network.rpcs.length) throw new Error("No RPCs found for Ethereum network");
-    const batch = chain.contracts?.multicall3 ? { multicall: { wait: MUTLICALL_BATCH_WAIT, batchSize: MUTLICALL_BATCH_SIZE } } : void 0;
-    const transportOptions = {
-      batch: {
-        batchSize: chain.contracts?.multicall3 ? HTTP_BATCH_SIZE_WITH_MULTICALL : HTTP_BATCH_SIZE_WITHOUT_MULTICALL,
-        wait: HTTP_BATCH_WAIT
-      }
-    };
-    const transport = getTransportForEvmNetwork(network, transportOptions);
-    publicClientCache.set(
-      network.id,
-      createPublicClient({
-        chain,
-        transport,
-        batch
-      })
-    );
-  }
-  return publicClientCache.get(network.id);
+const getEvmNetworkPublicClient = (network) => {
+	const chain = getChainFromEvmNetwork(network);
+	if (!publicClientCache.has(network.id)) {
+		if (!network.rpcs.length) throw new Error("No RPCs found for Ethereum network");
+		const batch = chain.contracts?.multicall3 ? { multicall: {
+			wait: MUTLICALL_BATCH_WAIT,
+			batchSize: MUTLICALL_BATCH_SIZE
+		} } : void 0;
+		const transport = getTransportForEvmNetwork(network, { batch: {
+			batchSize: chain.contracts?.multicall3 ? HTTP_BATCH_SIZE_WITH_MULTICALL : HTTP_BATCH_SIZE_WITHOUT_MULTICALL,
+			wait: HTTP_BATCH_WAIT
+		} });
+		publicClientCache.set(network.id, createPublicClient({
+			chain,
+			transport,
+			batch
+		}));
+	}
+	return publicClientCache.get(network.id);
 };
-
-// src/eth/getEvmNetworkWalletClient.ts
-import { createWalletClient } from "viem";
-var getEvmNetworkWalletClient = (network, options = {}) => {
-  const chain = getChainFromEvmNetwork(network);
-  const transport = getTransportForEvmNetwork(network);
-  return createWalletClient({ chain, transport, account: options.account });
+//#endregion
+//#region src/eth/getEvmNetworkWalletClient.ts
+const getEvmNetworkWalletClient = (network, options = {}) => {
+	return createWalletClient({
+		chain: getChainFromEvmNetwork(network),
+		transport: getTransportForEvmNetwork(network),
+		account: options.account
+	});
 };
-
-// src/eth/ChainConnectorEth.ts
+//#endregion
+//#region src/eth/ChainConnectorEth.ts
 var ChainConnectorEth = class {
-  #chaindataProvider;
-  constructor(chaindataProvider) {
-    this.#chaindataProvider = chaindataProvider;
-  }
-  async getPublicClientForEvmNetwork(evmNetworkId) {
-    const network = await this.#chaindataProvider.getNetworkById(evmNetworkId, "ethereum");
-    if (!network) return null;
-    return getEvmNetworkPublicClient(network);
-  }
-  async getWalletClientForEvmNetwork(evmNetworkId, account) {
-    const network = await this.#chaindataProvider.getNetworkById(evmNetworkId, "ethereum");
-    if (!network) return null;
-    return getEvmNetworkWalletClient(network, { account });
-  }
-  clearRpcProvidersCache(evmNetworkId) {
-    clearPublicClientCache(evmNetworkId);
-  }
+	#chaindataProvider;
+	constructor(chaindataProvider) {
+		this.#chaindataProvider = chaindataProvider;
+	}
+	async getPublicClientForEvmNetwork(evmNetworkId) {
+		const network = await this.#chaindataProvider.getNetworkById(evmNetworkId, "ethereum");
+		if (!network) return null;
+		return getEvmNetworkPublicClient(network);
+	}
+	async getWalletClientForEvmNetwork(evmNetworkId, account) {
+		const network = await this.#chaindataProvider.getNetworkById(evmNetworkId, "ethereum");
+		if (!network) return null;
+		return getEvmNetworkWalletClient(network, { account });
+	}
+	clearRpcProvidersCache(evmNetworkId) {
+		clearPublicClientCache(evmNetworkId);
+	}
 };
-
-// src/eth/ChainConnectorEthStub.ts
+//#endregion
+//#region src/eth/ChainConnectorEthStub.ts
 var ChainConnectorEthStub = class {
-  #network;
-  constructor(network) {
-    this.#network = network;
-  }
-  async getPublicClientForEvmNetwork() {
-    return getEvmNetworkPublicClient(this.#network);
-  }
-  async getWalletClientForEvmNetwork(_networkId, account) {
-    return getEvmNetworkWalletClient(this.#network, { account });
-  }
-  clearRpcProvidersCache() {
-  }
+	#network;
+	constructor(network) {
+		this.#network = network;
+	}
+	async getPublicClientForEvmNetwork() {
+		return getEvmNetworkPublicClient(this.#network);
+	}
+	async getWalletClientForEvmNetwork(_networkId, account) {
+		return getEvmNetworkWalletClient(this.#network, { account });
+	}
+	clearRpcProvidersCache() {}
 };
-
-// src/sol/getSolConnection.ts
-import { Connection } from "@solana/web3.js";
-var getSolConnection = (_networkId, rpcs) => {
-  return new Connection(rpcs[0], {
-    commitment: "confirmed"
-  });
+//#endregion
+//#region src/sol/getSolRpc.ts
+const MAX_429_RETRIES = 5;
+const BASE_BACKOFF_MS = 500;
+/** Returns the delay to wait before retrying, or `null` if the error is not a retryable 429. */
+const get429RetryDelay = (error, attempt) => {
+	if (!isSolanaError(error)) return null;
+	const context = error.context;
+	if (context.statusCode !== 429) return null;
+	const retryAfter = Number(context.headers?.get("retry-after"));
+	if (Number.isFinite(retryAfter) && retryAfter > 0) return retryAfter * 1e3;
+	return BASE_BACKOFF_MS * 2 ** attempt;
 };
-
-// src/sol/ChainConnectorSol.ts
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) return reject(signal.reason);
+	const onAbort = () => {
+		clearTimeout(timeout);
+		reject(signal?.reason);
+	};
+	const timeout = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+/**
+* Wraps a transport so HTTP 429 responses are retried with backoff. Solana RPC requests are
+* idempotent (`sendTransaction` is keyed by signature), so replaying a rate-limited request is safe.
+*/
+const withRetryOn429 = (transport) => {
+	const wrapped = async (config) => {
+		for (let attempt = 0;; attempt++) try {
+			return await transport(config);
+		} catch (error) {
+			const delay = attempt < MAX_429_RETRIES ? get429RetryDelay(error, attempt) : null;
+			if (delay === null) throw error;
+			await sleep(delay, config.signal);
+		}
+	};
+	return wrapped;
+};
+const getSolTransport = (_networkId, rpcs) => withRetryOn429(createDefaultRpcTransport({ url: rpcs[0] }));
+const getSolRpc = (networkId, rpcs) => createSolanaRpcFromTransport(getSolTransport(networkId, rpcs));
+//#endregion
+//#region src/sol/ChainConnectorSol.ts
 var ChainConnectorSol = class {
-  #chaindataProvider;
-  constructor(chaindataProvider) {
-    this.#chaindataProvider = chaindataProvider;
-  }
-  async getConnection(networkId) {
-    const network = await this.#chaindataProvider.getNetworkById(networkId, "solana");
-    if (!network) throw new Error(`Network not found: ${networkId}`);
-    return getSolConnection(networkId, network.rpcs);
-  }
+	#chaindataProvider;
+	#transports = /* @__PURE__ */ new Map();
+	#rpcs = /* @__PURE__ */ new Map();
+	constructor(chaindataProvider) {
+		this.#chaindataProvider = chaindataProvider;
+	}
+	async #getNetworkRpcs(networkId) {
+		const network = await this.#chaindataProvider.getNetworkById(networkId, "solana");
+		if (!network) throw new Error(`Network not found: ${networkId}`);
+		return network.rpcs;
+	}
+	async getTransport(networkId) {
+		if (!this.#transports.has(networkId)) this.#transports.set(networkId, getSolTransport(networkId, await this.#getNetworkRpcs(networkId)));
+		return this.#transports.get(networkId);
+	}
+	async getRpc(networkId) {
+		if (!this.#rpcs.has(networkId)) this.#rpcs.set(networkId, createSolanaRpcFromTransport(await this.getTransport(networkId)));
+		return this.#rpcs.get(networkId);
+	}
+	/** Drops cached transports/rpcs so the next call re-reads the network's rpcs from chaindata */
+	clearRpcProvidersCache(networkId) {
+		if (networkId) {
+			this.#transports.delete(networkId);
+			this.#rpcs.delete(networkId);
+		} else {
+			this.#transports.clear();
+			this.#rpcs.clear();
+		}
+	}
 };
-
-// src/sol/ChainConnectorSolStub.ts
+//#endregion
+//#region src/sol/ChainConnectorSolStub.ts
 var ChainConnectorSolStub = class {
-  #connection;
-  constructor(networkOrConnection) {
-    this.#connection = "rpcs" in networkOrConnection ? getSolConnection(networkOrConnection.id, networkOrConnection.rpcs) : networkOrConnection;
-  }
-  async getConnection() {
-    return this.#connection;
-  }
-};
-export {
-  ChainConnectionError,
-  ChainConnectorDot,
-  ChainConnectorDotStub,
-  ChainConnectorEth,
-  ChainConnectorEthStub,
-  ChainConnectorSol,
-  ChainConnectorSolStub,
-  StaleRpcError,
-  WebsocketAllocationExhaustedError
+	#transport;
+	#rpc;
+	constructor(network) {
+		this.#transport = getSolTransport(network.id, network.rpcs);
+		this.#rpc = createSolanaRpcFromTransport(this.#transport);
+	}
+	async getRpc() {
+		return this.#rpc;
+	}
+	async getTransport() {
+		return this.#transport;
+	}
 };
+//#endregion
+export { ChainConnectionError, ChainConnectorDot, ChainConnectorDotStub, ChainConnectorEth, ChainConnectorEthStub, ChainConnectorSol, ChainConnectorSolStub, StaleRpcError, getSolRpc, getSolTransport };
+
 //# sourceMappingURL=index.mjs.map