@talismn/chain-connectors 0.0.13 → 0.0.15

package/dist/{talismn-chain-connectors.esm.js → index.mjs}

@@ -1,25 +1,93 @@
-import { throwAfter, Deferred, sleep, isTruthy } from '@talismn/util';
-import anylogger from 'anylogger';
-import { RpcCoder } from '@polkadot/rpc-provider/coder';
-import { getWSErrorString } from '@polkadot/rpc-provider/ws/errors';
-import { isChildClass, isUndefined, isNull, objectSpread } from '@polkadot/util';
-import { xglobal } from '@polkadot/x-global';
-import { WebSocket } from '@polkadot/x-ws';
-import EventEmitter from 'eventemitter3';
-import { WsProvider } from '@polkadot/rpc-provider';
-import { fallback, http, createPublicClient, createWalletClient } from 'viem';
-import { fromPairs, toPairs, camelCase } from 'lodash-es';
-import * as viemChains from 'viem/chains';
-import { Connection } from '@solana/web3.js';
-
-var packageJson = {
-	name: "@talismn/chain-connectors"};
-
-var log = anylogger(packageJson.name);
+// src/dot/ChainConnectorDot.ts
+import { Deferred, isTruthy, sleep, throwAfter } from "@talismn/util";
+
+// src/log.ts
+import anylogger from "anylogger";
+
+// package.json
+var package_default = {
+  name: "@talismn/chain-connectors",
+  version: "0.0.15",
+  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.17.21",
+    viem: "^2.27.3"
+  },
+  devDependencies: {
+    "@polkadot/rpc-provider": "16.1.2",
+    "@polkadot/util": "13.5.3",
+    "@polkadot/x-global": "13.5.3",
+    "@polkadot/x-ws": "13.5.3",
+    "@talismn/tsconfig": "workspace:*",
+    typescript: "^5.6.3"
+  },
+  peerDependencies: {
+    "@polkadot/rpc-provider": "*",
+    "@polkadot/util": "*",
+    "@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"
+      }
+    }
+  }
+};
 
-const twoSecondsMs = 2 * 1000;
-const twoMinutesMs = 2 * 60 * 1000;
-class ExponentialBackoff {
+// 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 { isChildClass, isNull, isUndefined, objectSpread } from "@polkadot/util";
+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;
@@ -69,46 +137,25 @@ class ExponentialBackoff {
   #capMax(value) {
     return Math.min(this.#maxInterval, value);
   }
-}
-
-// to account for new requirement for generic arg in this type https://github.com/polkadot-js/api/commit/f4c2b150d3d69d43c56699613666b96dd0a763f4#diff-f87c17bc7fae027ec6d43bac5fc089614d9fa097f466aa2be333b44cee81f0fd
-// TODO incrementally replace 'unknown' with proper types where possible
+};
 
-const ALIASES = {
+// src/dot/Websocket.ts
+var ALIASES = {
   chain_finalisedHead: "chain_finalizedHead",
   chain_subscribeFinalisedHeads: "chain_subscribeFinalizedHeads",
   chain_unsubscribeFinalisedHeads: "chain_unsubscribeFinalizedHeads"
 };
-const DEFAULT_TIMEOUT_MS = 60 * 1000;
-const TIMEOUT_INTERVAL = 5_000;
+var DEFAULT_TIMEOUT_MS = 60 * 1e3;
+var TIMEOUT_INTERVAL = 5e3;
 function eraseRecord(record, cb) {
-  Object.keys(record).forEach(key => {
+  Object.keys(record).forEach((key) => {
     if (cb) {
       cb(record[key]);
     }
     delete record[key];
   });
 }
-
-/**
- * # @talismn/chain-connector/Websocket
- *
- * @name Websocket
- *
- * @description The WebSocket Provider allows sending requests using WebSocket to a WebSocket RPC server TCP port. Unlike the [[HttpProvider]], it does support subscriptions and allows listening to events such as new blocks or balance changes.
- *
- * @example
- * <BR>
- *
- * ```javascript
- * import { Websocket } from '@talismn/chain-connector';
- *
- * const provider = new Websocket('ws://127.0.0.1:9944');
- * ```
- *
- * @see [[HttpProvider]]
- */
-class Websocket {
+var Websocket = class _Websocket {
   #coder;
   #endpoints;
   #headers;
@@ -124,7 +171,6 @@ class Websocket {
   #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
@@ -135,9 +181,9 @@ class Websocket {
     if (endpoints.length === 0) {
       throw new Error("Websocket requires at least one Endpoint");
     }
-    endpoints.forEach(endpoint => {
-      if (!/^(wss|ws):\/\//.test(endpoint)) {
-        throw new Error(`Endpoint should start with 'ws://', received '${endpoint}'`);
+    endpoints.forEach((endpoint2) => {
+      if (!/^(wss|ws):\/\//.test(endpoint2)) {
+        throw new Error(`Endpoint should start with 'ws://', received '${endpoint2}'`);
       }
     });
     this.#eventemitter = new EventEmitter();
@@ -151,30 +197,26 @@ class Websocket {
     this.#timeout = timeout || DEFAULT_TIMEOUT_MS;
     if (this.#autoConnectBackoff.isActive) {
       this.connectWithRetry().catch(() => {
-        // does not throw
       });
     }
-    this.#isReadyPromise = new Promise(resolve => {
+    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
@@ -182,7 +224,6 @@ class Websocket {
   get isConnected() {
     return this.#isConnected;
   }
-
   /**
    * @description Promise that resolves the first time we are connected and loaded
    */
@@ -192,54 +233,46 @@ class Websocket {
   get endpoint() {
     return this.#endpoints[this.#endpointIndex];
   }
-
   /**
    * @description Returns a clone of the object
    */
   clone() {
-    return new Websocket(this.#endpoints);
+    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.
    */
-  // eslint-disable-next-line @typescript-eslint/require-await
   async connect() {
     if (this.#websocket) {
       throw new Error("WebSocket is already connected");
     }
     try {
       this.#endpointIndex = this.selectEndpointIndex(this.#endpoints);
-
-      // the as typeof WebSocket here is Deno-specific - not available on the globalThis
-      this.#websocket = typeof xglobal.WebSocket !== "undefined" && isChildClass(xglobal.WebSocket, WebSocket) ? new WebSocket(this.endpoint) :
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore - WS may be an instance of ws, which supports options
-      new WebSocket(this.endpoint, undefined, {
-        headers: this.#headers
-      });
+      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;
       }
-
-      // timeout any handlers that have not had a response
       this.#timeoutId = setInterval(() => this.#timeoutHandlers(), TIMEOUT_INTERVAL);
     } catch (error) {
-      log.error(error);
+      log_default.error(error);
       this.#emit("error", error);
       throw error;
     }
   }
-
   /**
    * @description Connect, never throwing an error, but rather forcing a retry
    */
@@ -247,48 +280,39 @@ class Websocket {
     if (!this.#autoConnectBackoff.isActive) return;
     try {
       await this.connect();
-    } catch (error) {
+    } catch {
       this.scheduleNextRetry();
     }
   }
   scheduleNextRetry() {
     if (!this.#autoConnectBackoff.isActive) return;
     const haveTriedAllEndpoints = this.#endpointsTriedSinceLastConnection > 0 && this.#endpointsTriedSinceLastConnection % this.#endpoints.length === 0;
-    setTimeout(() => {
-      this.connectWithRetry().catch(() => {
-        // does not throw
-      });
-    }, haveTriedAllEndpoints ? this.#autoConnectBackoff.next : 0);
-
-    // Increase backoff when we've tried all endpoints
+    setTimeout(
+      () => {
+        this.connectWithRetry().catch(() => {
+        });
+      },
+      haveTriedAllEndpoints ? this.#autoConnectBackoff.next : 0
+    );
     if (haveTriedAllEndpoints) this.#autoConnectBackoff.increase();
-
-    // Fire a stale-rpcs event when we've tried all endpoints in the list
-    // but haven't successfully connected to any of them
-    if (haveTriedAllEndpoints) this.#emit("stale-rpcs", {
-      nextBackoffInterval: this.#autoConnectBackoff.next
-    });
+    if (haveTriedAllEndpoints)
+      this.#emit("stale-rpcs", { nextBackoffInterval: this.#autoConnectBackoff.next });
   }
-
   /**
    * @description Manually disconnect from the connection, clearing auto-connect logic
    */
-  // eslint-disable-next-line @typescript-eslint/require-await
   async disconnect() {
-    // switch off autoConnect, we are in manual mode now
     this.#autoConnectBackoff.disable();
     try {
       if (this.#websocket) {
-        // 1000 - Normal closure; the connection successfully completed
-        this.#websocket.close(1000);
+        this.#websocket.close(1e3);
       }
     } catch (error) {
-      log.error(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
@@ -301,16 +325,14 @@ class Websocket {
       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)
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  send(method, params, /** @deprecated \@talismn/chain-connector doesn't implement a cache */
-  isCacheable, subscription) {
+  // 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;
@@ -324,9 +346,6 @@ class Websocket {
         const callback = (error, result) => {
           error ? reject(error) : resolve(result);
         };
-
-        // log.debug(() => ["calling", method, body])
-
         this.#handlers[id] = {
           callback,
           method,
@@ -340,7 +359,6 @@ class Websocket {
       }
     });
   }
-
   /**
    * @name subscribe
    * @summary Allows subscribing to a specific event.
@@ -360,42 +378,32 @@ class Websocket {
    * ```
    */
   subscribe(type, method, params, callback) {
-    return this.send(method, params, false, {
-      callback,
-      type
-    });
+    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}`;
-
-    // FIXME This now could happen with re-subscriptions. The issue is that with a re-sub
-    // the assigned id now does not match what the API user originally received. It has
-    // a slight complication in solving - since we cannot rely on the send id, but rather
-    // need to find the actual subscription id to map it
     if (isUndefined(this.#subscriptions[subscription])) {
-      // log.debug(() => `Unable to find active subscription=${subscription}`)
-
       return false;
     }
     delete this.#subscriptions[subscription];
     try {
       return this.isConnected && !isNull(this.#websocket) ? this.send(method, [id]) : true;
-    } catch (error) {
+    } 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)}`);
+  #onSocketClose = (event) => {
+    const error = new Error(
+      `disconnected from ${this.endpoint}: ${event.code}:: ${event.reason || getWSErrorString(event.code)}`
+    );
     if (this.#autoConnectBackoff.isActive) {
-      // 1000 is a normal closure and should not be logged as an error
-      if (event.code !== 1000) log.error(error.message);
+      if (event.code !== 1e3) log_default.error(error.message);
     }
     this.#isConnected = false;
     if (this.#websocket) {
@@ -409,52 +417,36 @@ class Websocket {
       clearInterval(this.#timeoutId);
       this.#timeoutId = null;
     }
-
-    // reject all hanging requests
-    eraseRecord(this.#handlers, h => {
+    eraseRecord(this.#handlers, (h) => {
       try {
-        h.callback(error, undefined);
+        h.callback(error, void 0);
       } catch (err) {
-        // does not throw
-        log.error(err);
+        log_default.error(err);
       }
     });
     eraseRecord(this.#waitingForId);
     this.#emit("disconnected");
     this.scheduleNextRetry();
   };
-  #onSocketError = error => {
-    // log.debug(() => ["socket error", error])
+  #onSocketError = (error) => {
     this.#emit("error", error);
   };
-  #onSocketMessage = message => {
-    // log.debug(() => ["received", message.data])
+  #onSocketMessage = (message) => {
     try {
       const response = JSON.parse(message.data);
       return isUndefined(response.method) ? this.#onSocketMessageResult(response) : this.#onSocketMessageSubscribe(response);
     } catch (e) {
-      this.#emit("error", new Error("Invalid websocket message received", {
-        cause: e
-      }));
+      this.#emit("error", new Error("Invalid websocket message received", { cause: e }));
     }
   };
-  #onSocketMessageResult = response => {
+  #onSocketMessageResult = (response) => {
     const handler = this.#handlers[response.id];
     if (!handler) {
-      // log.debug(() => `Unable to find handler for id=${response.id}`)
-
       return;
     }
     try {
-      const {
-        method,
-        params,
-        subscription
-      } = handler;
+      const { method, params, subscription } = handler;
       const result = this.#coder.decodeResponse(response);
-
-      // first send the result - in case of subs, we may have an update
-      // immediately if we have some queued results already
       handler.callback(null, result);
       if (subscription) {
         const subId = `${subscription.type}::${result}`;
@@ -462,46 +454,35 @@ class Websocket {
           method,
           params
         });
-
-        // if we have a result waiting for this subscription already
         if (this.#waitingForId[subId]) {
           this.#onSocketMessageSubscribe(this.#waitingForId[subId]);
         }
       }
     } catch (error) {
-      handler.callback(error, undefined);
+      handler.callback(error, void 0);
     }
     delete this.#handlers[response.id];
   };
-  #onSocketMessageSubscribe = response => {
+  #onSocketMessageSubscribe = (response) => {
     const method = ALIASES[response.method] || response.method || "invalid";
     const subId = `${method}::${response.params.subscription}`;
     const handler = this.#subscriptions[subId];
     if (!handler) {
-      // store the JSON, we could have out-of-order subid coming in
       this.#waitingForId[subId] = response;
-
-      // log.debug(() => `Unable to find handler for subscription=${subId}`)
-
       return;
     }
-
-    // housekeeping
     delete this.#waitingForId[subId];
     try {
       const result = this.#coder.decodeResponse(response);
       handler.callback(null, result);
     } catch (error) {
-      handler.callback(error, undefined);
+      handler.callback(error, void 0);
     }
   };
   #onSocketOpen = () => {
     if (this.#websocket === null) {
       throw new Error("WebSocket cannot be null in onOpen");
     }
-
-    // log.debug(() => ["connected to", this.endpoint])
-
     this.#isConnected = true;
     this.#endpointsTriedSinceLastConnection = 0;
     this.#autoConnectBackoff.reset();
@@ -512,26 +493,19 @@ class Websocket {
   #resubscribe = () => {
     const subscriptions = this.#subscriptions;
     this.#subscriptions = {};
-    Promise.all(Object.keys(subscriptions).map(async id => {
-      const {
-        callback,
-        method,
-        params,
-        type
-      } = subscriptions[id];
-
-      // only re-create subscriptions which are not in author (only area where
-      // transactions are created, i.e. submissions such as 'author_submitAndWatchExtrinsic'
-      // are not included (and will not be re-broadcast)
-      if (type.startsWith("author_")) {
-        return;
-      }
-      try {
-        await this.subscribe(type, method, params, callback);
-      } catch (error) {
-        log.error(error);
-      }
-    })).catch(log.error);
+    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();
@@ -540,63 +514,65 @@ class Websocket {
       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 / 1000}s`), undefined);
+          handler.callback(
+            new Error(`No response received from RPC endpoint in ${this.#timeout / 1e3}s`),
+            void 0
+          );
         } catch {
-          // ignore
         }
         delete this.#handlers[ids[i]];
       }
     }
   };
-}
+};
 
-// errors that require an rpc fallback
-// https://docs.blastapi.io/blast-documentation/things-you-need-to-know/error-reference
-const BAD_RPC_ERRORS = {
+// src/dot/ChainConnectorDot.ts
+var BAD_RPC_ERRORS = {
   "-32097": "Rate limit exceeded",
   "-32098": "Capacity exceeded"
 };
-class ChainConnectionError extends Error {
+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;
   }
-}
-class StaleRpcError extends Error {
+};
+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;
   }
-}
-class WebsocketAllocationExhaustedError extends Error {
+};
+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);
+    super(
+      `No websockets are available from the browser pool to connect to chain ${chainId}`,
+      options
+    );
     this.type = "WEBSOCKET_ALLOCATION_EXHAUSTED_ERROR";
     this.chainId = chainId;
   }
-}
-class CallerUnsubscribedError extends Error {
+};
+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;
   }
-}
-/**
- * ChainConnector provides an interface similar to WsProvider, 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 `WsProvider` per chain and ensures that all downstream requests to a chain share the one socket connection.
- * 3. Subscriptions return a callable `unsubscribe` method instead of an id.
- *
- * 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.
- */
-class ChainConnectorDot {
+};
+var ChainConnectorDot = class {
   #chaindataChainProvider;
   #connectionMetaDb;
   #socketConnections = {};
@@ -606,14 +582,12 @@ class ChainConnectorDot {
     this.#chaindataChainProvider = chaindataChainProvider;
     this.#connectionMetaDb = connectionMetaDb;
     if (this.#connectionMetaDb) {
-      this.#chaindataChainProvider.getNetworkIds("polkadot").then(chainIds => {
-        // tidy up connectionMeta for chains which no longer exist
+      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
@@ -621,7 +595,7 @@ class ChainConnectorDot {
    *   const api = new ApiPromise({ provider })
    */
   asProvider(chainId) {
-    const unsubHandler = new Map();
+    const unsubHandler = /* @__PURE__ */ new Map();
     const providerFacade = {
       hasSubscriptions: true,
       isClonable: false,
@@ -629,12 +603,15 @@ class ChainConnectorDot {
       clone: () => providerFacade,
       connect: () => Promise.resolve(),
       disconnect: () => Promise.resolve(),
-      on: () => () => {},
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      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();
+        const subscriptionId = this.getExclusiveRandomId(
+          [...unsubHandler.keys()].map(Number)
+        ).toString();
         unsubHandler.set(subscriptionId, unsubscribe);
         return subscriptionId;
       },
@@ -646,141 +623,122 @@ class ChainConnectorDot {
     };
     return providerFacade;
   }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  // biome-ignore lint/suspicious/noExplicitAny: legacy
   async send(chainId, method, params, isCacheable, extraOptions) {
     const talismanSub = this.getTalismanSub();
-    if (talismanSub !== undefined) {
+    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 { 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.warn(`Failed to make wallet-proxied send request for chain ${chainId}. Falling back to plain websocket`, error);
+        log_default.warn(
+          `Failed to make wallet-proxied send request for chain ${chainId}. Falling back to plain websocket`,
+          error
+        );
       }
     }
     try {
-      // eslint-disable-next-line no-var
       var [socketUserId, ws] = await this.connectChainSocket(chainId);
     } catch (error) {
-      throw new StaleRpcError(chainId, {
-        cause: error
-      });
+      throw new StaleRpcError(chainId, { cause: error });
     }
     try {
-      // wait for ws to be ready, but don't wait forever
-      const timeout = 15_000; // 15 seconds in milliseconds
+      const timeout = 15e3;
       await this.waitForWs(ws, timeout);
     } catch (error) {
       await this.disconnectChainSocket(chainId, socketUserId);
-      throw new ChainConnectionError(chainId, {
-        cause: error
-      });
+      throw new ChainConnectionError(chainId, { cause: error });
     }
     try {
-      const timeout = 30_000; // throw after 30 seconds if no response
-      // eslint-disable-next-line no-var
-      var response = await Promise.race([ws.send(method, params, isCacheable), throwAfter(timeout, "TIMEOUT")]);
+      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.error(`ChainConnector timeout`, {
-          chainId,
-          endpoint: ws.endpoint,
-          error
-        });
+        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.error(`ChainConnector ${badRpcError}`, {
-          error,
-          chainId,
-          endpoint: ws.endpoint
-        });
+        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.error(`Failed to send ${method} on chain ${chainId}\nparams: ${JSON.stringify(params)}`, {
-        error,
-        endpoint: ws.endpoint
-      });
+      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 = 30_000 // 30 seconds in milliseconds
-  ) {
+  async subscribe(chainId, subscribeMethod, responseMethod, params, callback, timeout = 3e4) {
     const talismanSub = this.getTalismanSub();
-    if (talismanSub !== undefined) {
+    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);
+        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.warn(`Failed to create wallet-proxied subscription for chain ${chainId}. Falling back to plain websocket`, error);
+        log_default.warn(
+          `Failed to create wallet-proxied subscription for chain ${chainId}. Falling back to plain websocket`,
+          error
+        );
       }
     }
     try {
-      // eslint-disable-next-line no-var
       var [socketUserId, ws] = await this.connectChainSocket(chainId);
     } catch (error) {
-      throw new StaleRpcError(chainId, {
-        cause: error
-      });
+      throw new StaleRpcError(chainId, { cause: error });
     }
-
-    // by using this `Deferred` promise
-    // (a promise which can be resolved or rejected by code outside of the scope of the promise's constructor)
-    // we can queue up our async cleanup on the promise and then immediately return an unsubscribe method to the caller
     const unsubDeferred = Deferred();
-    // we return this to the caller so that they can let us know when they're no longer interested in this subscription
-    const unsubscribe = unsubscribeMethod => unsubDeferred.reject(new CallerUnsubscribedError(chainId, unsubscribeMethod));
-    // we queue up our work to clean up our subscription when this promise rejects
+    const unsubscribe = (unsubscribeMethod) => unsubDeferred.reject(new CallerUnsubscribedError(chainId, unsubscribeMethod));
     const callerUnsubscribed = unsubDeferred.promise;
-
-    // used to detect when there are no more websockets available from the browser websocket pool
-    // in this scenario, we'll be waiting for ws.isReady until some existing sockets are closed
-    //
-    // while we're waiting, we'll send an error back to the caller so that they can show some useful
-    // info to the user
-    let noMoreSocketsTimeout = undefined
-
-    // create subscription asynchronously so that the caller can unsubscribe without waiting for
-    // the subscription to be created (which can take some time if e.g. the connection can't be established)
-    ;
+    let noMoreSocketsTimeout;
     (async () => {
-      // wait for ws to be ready, but don't wait forever
-      // if timeout is number, cancel when timeout is reached (or caller unsubscribes)
-      // if timeout is false, only cancel when the caller unsubscribes
       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 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);
         });
@@ -788,57 +746,58 @@ class ChainConnectorDot {
           unsubStale();
           unsubConnected();
         };
-        noMoreSocketsTimeout = setTimeout(() => callback(new WebsocketAllocationExhaustedError(chainId), null), 30_000 // 30 seconds in ms
+        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]);
+        if (timeout) await Promise.race([this.waitForWs(ws, timeout), callerUnsubscribed]);
+        else await Promise.race([ws.isReady, callerUnsubscribed]);
         clearTimeout(noMoreSocketsTimeout);
-      } catch (error) {
+      } catch {
         clearTimeout(noMoreSocketsTimeout);
-        unsubRpcStatus && unsubRpcStatus();
+        unsubRpcStatus?.();
         await this.disconnectChainSocket(chainId, socketUserId);
         return;
       }
-
-      // create subscription on ws
-      // handle the scenarios where the caller unsubscribes before the subscription has been created and:
-      // - the subscriptionId is already set
-      // - the subscriptionId is not set yet, but will be
       let subscriptionId = null;
       let disconnected = false;
-      let unsubscribeMethod = undefined;
+      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]);
+        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 && unsubRpcStatus();
+        unsubRpcStatus?.();
         disconnected = true;
-        if (subscriptionId !== null && unsubscribeMethod) await ws.unsubscribe(responseMethod, unsubscribeMethod, subscriptionId);
+        if (subscriptionId !== null && unsubscribeMethod)
+          await ws.unsubscribe(responseMethod, unsubscribeMethod, subscriptionId);
         await this.disconnectChainSocket(chainId, socketUserId);
         return;
       }
-
-      // unsubscribe from ws subscription when the caller has unsubscribed
-      callerUnsubscribed.catch(async error => {
-        let unsubscribeMethod = undefined;
-        if (error instanceof CallerUnsubscribedError) unsubscribeMethod = error.unsubscribeMethod;
-        unsubRpcStatus && unsubRpcStatus();
-        if (subscriptionId !== null && unsubscribeMethod) await ws.unsubscribe(responseMethod, unsubscribeMethod, subscriptionId);
+      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.warn(error));
+      }).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.info("ChainConnector reset", chainId);
+    log_default.info("ChainConnector reset", chainId);
     const ws = this.#socketConnections[chainId];
     if (!ws) return;
     try {
@@ -847,21 +806,18 @@ class ChainConnectorDot {
       delete this.#socketUsers[chainId];
       await ws.disconnect();
     } catch (error) {
-      log.warn(`Error occurred reseting socket ${chainId}`, 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 = 30_000 // 30 seconds in milliseconds
-  ) {
+  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
    *
@@ -870,42 +826,45 @@ class ChainConnectorDot {
   async connectChainSocket(chainId) {
     const rpcs = await this.getEndpoints(chainId);
     const socketUserId = this.addSocketUser(chainId);
-
-    // retrieve next rpc backoff interval from connection meta db (if one exists)
-    let nextBackoffInterval = undefined;
-    if (this.#connectionMetaDb) nextBackoffInterval = (await this.#connectionMetaDb.chainBackoffInterval.get(chainId))?.interval;
-
-    // NOTE: Make sure there are no calls to `await` between this check and the
-    // next step where we assign a `new Websocket` to `this.#socketConnections[chainId]`
-    //
-    // If there is an `await` between these two steps then there will be a race condition introduced.
-    // The result of this race condition will be the unnecessary creation of multiple instances of
-    // `Websocket` per chain, rather than the intended behaviour where every call to send/subscribe
-    // shares a single `Websocket` per chain.
+    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, undefined, undefined, nextBackoffInterval);else {
+    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}`);
     }
-
-    // on ws connected event, store current rpc as most recently connected rpc
     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.warn(`updateRpcPriority failed`, err));
+        this.updateRpcPriority(id, url, "first").catch(
+          (err) => log_default.warn(`updateRpcPriority failed`, err)
+        );
       });
     }
+    ;
     (async () => {
-      if (!this.#socketConnections[chainId]) return log.warn(`ignoring ${chainId} rpc ws healthcheck initialization: ws is not defined`);
+      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 = 10_000; // 10,000ms = 10s
+      if (this.#socketKeepAliveIntervals[chainId])
+        clearInterval(this.#socketKeepAliveIntervals[chainId]);
+      const intervalMs = 1e4;
       this.#socketKeepAliveIntervals[chainId] = setInterval(() => {
-        if (!this.#socketConnections[chainId]) return log.warn(`skipping ${chainId} rpc ws healthcheck: ws is not defined`);
-        if (!this.#socketConnections[chainId].isConnected) return log.warn(`skipping ${chainId} rpc ws healthcheck: ws is not connected`);
-        this.#socketConnections[chainId].send("system_health", []).catch(error => log.warn(`Failed keep-alive for socket ${chainId}`, error));
+        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]];
@@ -913,11 +872,12 @@ class ChainConnectorDot {
   async disconnectChainSocket(chainId, socketUserId) {
     this.removeSocketUser(chainId, socketUserId);
     if (this.#socketUsers[chainId].length > 0) return;
-    if (!this.#socketConnections[chainId]) return log.warn(`Failed to disconnect socket: socket ${chainId} not found`);
+    if (!this.#socketConnections[chainId])
+      return log_default.warn(`Failed to disconnect socket: socket ${chainId} not found`);
     try {
       this.#socketConnections[chainId].disconnect();
     } catch (error) {
-      log.warn(`Error occurred disconnecting socket ${chainId}`, error);
+      log_default.warn(`Error occurred disconnecting socket ${chainId}`, error);
     }
     delete this.#socketConnections[chainId];
     clearInterval(this.#socketKeepAliveIntervals[chainId]);
@@ -931,10 +891,12 @@ class ChainConnectorDot {
   }
   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(", ")}`);
+    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();
@@ -945,13 +907,10 @@ class ChainConnectorDot {
   }
   /** generates a random number */
   getRandomId() {
-    return Math.trunc(Math.random() * Math.pow(10, 8));
+    return Math.trunc(Math.random() * 10 ** 8);
   }
   getTalismanSub() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const talismanSub = typeof window !== "undefined" && window.talismanSub;
-
-    /* eslint-disable @typescript-eslint/no-unsafe-function-type */
     const rpcByGenesisHashSend = talismanSub?.rpcByGenesisHashSend;
     const rpcByGenesisHashSubscribe = talismanSub?.rpcByGenesisHashSubscribe;
     const rpcByGenesisHashUnsubscribe = talismanSub?.rpcByGenesisHashUnsubscribe;
@@ -959,9 +918,16 @@ class ChainConnectorDot {
     if (typeof rpcByGenesisHashSubscribe !== "function") return;
     if (typeof rpcByGenesisHashUnsubscribe !== "function") return;
     return {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      // 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),
+      subscribe: (genesisHash, subscribeMethod, responseMethod, params, callback, timeout) => rpcByGenesisHashSubscribe(
+        genesisHash,
+        subscribeMethod,
+        responseMethod,
+        params,
+        callback,
+        timeout
+      ),
       unsubscribe: (subscriptionId, unsubscribeMethod) => rpcByGenesisHashUnsubscribe(subscriptionId, unsubscribeMethod)
     };
   }
@@ -969,81 +935,86 @@ class ChainConnectorDot {
     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);
+    const urls = rpcs.filter((r) => r !== rpc);
     if (priority === "first") urls.unshift(rpc);
     if (priority === "last") urls.push(rpc);
     if (!isEqual(urls, rpcs)) {
-      // order may not change, especially if there is only one
-      await this.#connectionMetaDb.chainPriorityRpcs.put({
-        id: chainId,
-        urls
-      }, chainId);
+      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(); // clone to avoid mutating the original array
-    const priorityRpcs = this.#connectionMetaDb ? await this.#connectionMetaDb.chainPriorityRpcs.get(chainId) : undefined;
+    let rpcs = chain.rpcs.concat();
+    const priorityRpcs = this.#connectionMetaDb ? await this.#connectionMetaDb.chainPriorityRpcs.get(chainId) : void 0;
     if (priorityRpcs) {
-      // use existing priority list of rpcs that still exist, and include missing ones
-      rpcs = [...priorityRpcs.urls.filter(rpc => rpcs.includes(rpc)), ...rpcs.filter(rpc => !priorityRpcs.urls.includes(rpc))];
+      rpcs = [
+        ...priorityRpcs.urls.filter((rpc) => rpcs.includes(rpc)),
+        ...rpcs.filter((rpc) => !priorityRpcs.urls.includes(rpc))
+      ];
     }
     return rpcs;
   }
-}
-const isEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
-
-const AUTO_CONNECT_TIMEOUT = 3_000;
-const TIMEOUT = 10_000;
-class ChainConnectorDotStub {
+};
+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;
+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, undefined, TIMEOUT);
+    this.#provider = new WsProvider(network.rpcs, AUTO_CONNECT_TIMEOUT, void 0, TIMEOUT);
   }
   asProvider() {
     return this.#provider;
   }
-  async send(chainId, method, params, isCacheable) {
+  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) {
+  async subscribe(_chainId, subscribeMethod, responseMethod, params, callback, timeout) {
     await this.#provider.isReady;
-    const subId = await Promise.race([throwAfter(timeout || TIMEOUT, `Subscription timed out after ${timeout}ms`), this.#provider.subscribe(responseMethod, subscribeMethod, params, callback)]);
-    return unsubscribeMethod => {
+    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");
   }
-}
-
-// exclude zoraTestnet which uses Hyperliquid's chain id
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const {
-  zoraTestnet,
-  ...validViemChains
-} = viemChains;
+};
 
-// viem chains benefit from multicall config & other viem goodies
-const VIEM_CHAINS = Object.keys(validViemChains).reduce((acc, curr) => {
-  const chain = validViemChains[curr];
-  acc[chain.id] = chain;
-  return acc;
-}, {});
-const chainsCache = new Map();
-const clearChainsCache = networkId => {
-  if (networkId) chainsCache.delete(networkId);else chainsCache.clear();
+// 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();
 };
-const getChainFromEvmNetwork = network => {
-  const {
-    symbol,
-    decimals
-  } = network.nativeCurrency;
+var getChainFromEvmNetwork = (network) => {
+  const { symbol, decimals } = network.nativeCurrency;
   if (!chainsCache.has(network.id)) {
     const chainRpcs = network.rpcs ?? [];
     const viemChain = VIEM_CHAINS[Number(network.id)] ?? {};
@@ -1052,12 +1023,8 @@ const getChainFromEvmNetwork = network => {
       id: Number(network.id),
       name: network.name ?? `Ethereum Chain ${network.id}`,
       rpcUrls: {
-        public: {
-          http: chainRpcs
-        },
-        default: {
-          http: chainRpcs
-        }
+        public: { http: chainRpcs },
+        default: { http: chainRpcs }
       },
       nativeCurrency: {
         symbol,
@@ -1066,9 +1033,12 @@ const getChainFromEvmNetwork = network => {
       },
       contracts: {
         ...viemChain.contracts,
-        ...(network.contracts ? fromPairs(toPairs(network.contracts).map(([name, address]) => [camelCase(name), {
-          address
-        }])) : {})
+        ...network.contracts ? fromPairs(
+          toPairs(network.contracts).map(([name, address]) => [
+            camelCase(name),
+            { address }
+          ])
+        ) : {}
       }
     };
     chainsCache.set(network.id, chain);
@@ -1076,41 +1046,34 @@ const getChainFromEvmNetwork = network => {
   return chainsCache.get(network.id);
 };
 
-const getTransportForEvmNetwork = (evmNetwork, options = {}) => {
+// 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
-  });
+  const { batch } = options;
+  return fallback(
+    evmNetwork.rpcs.map((url) => http(url, { batch, retryCount: 0 })),
+    { retryCount: 0 }
+  );
 };
 
-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;
-
-// cache to reuse previously created public clients
-const publicClientCache = new Map();
-const clearPublicClientCache = evmNetworkId => {
+// 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();
+  if (evmNetworkId) publicClientCache.delete(evmNetworkId);
+  else publicClientCache.clear();
 };
-const getEvmNetworkPublicClient = network => {
+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
-      }
-    } : undefined;
+    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,
@@ -1118,26 +1081,28 @@ const getEvmNetworkPublicClient = network => {
       }
     };
     const transport = getTransportForEvmNetwork(network, transportOptions);
-    publicClientCache.set(network.id, createPublicClient({
-      chain,
-      transport,
-      batch
-    }));
+    publicClientCache.set(
+      network.id,
+      createPublicClient({
+        chain,
+        transport,
+        batch
+      })
+    );
   }
   return publicClientCache.get(network.id);
 };
 
-const getEvmNetworkWalletClient = (network, options = {}) => {
+// 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
-  });
+  return createWalletClient({ chain, transport, account: options.account });
 };
 
-class ChainConnectorEth {
+// src/eth/ChainConnectorEth.ts
+var ChainConnectorEth = class {
   #chaindataProvider;
   constructor(chaindataProvider) {
     this.#chaindataProvider = chaindataProvider;
@@ -1150,16 +1115,15 @@ class ChainConnectorEth {
   async getWalletClientForEvmNetwork(evmNetworkId, account) {
     const network = await this.#chaindataProvider.getNetworkById(evmNetworkId, "ethereum");
     if (!network) return null;
-    return getEvmNetworkWalletClient(network, {
-      account
-    });
+    return getEvmNetworkWalletClient(network, { account });
   }
   clearRpcProvidersCache(evmNetworkId) {
     clearPublicClientCache(evmNetworkId);
   }
-}
+};
 
-class ChainConnectorEthStub {
+// src/eth/ChainConnectorEthStub.ts
+var ChainConnectorEthStub = class {
   #network;
   constructor(network) {
     this.#network = network;
@@ -1167,24 +1131,23 @@ class ChainConnectorEthStub {
   async getPublicClientForEvmNetwork() {
     return getEvmNetworkPublicClient(this.#network);
   }
-  async getWalletClientForEvmNetwork(networkId, account) {
-    return getEvmNetworkWalletClient(this.#network, {
-      account
-    });
+  async getWalletClientForEvmNetwork(_networkId, account) {
+    return getEvmNetworkWalletClient(this.#network, { account });
   }
   clearRpcProvidersCache() {
-    // No-op for stub
   }
-}
+};
 
-// TODO leverage multiple rpcs with fallback
-const getSolConnection = (networkId, rpcs) => {
+// src/sol/getSolConnection.ts
+import { Connection } from "@solana/web3.js";
+var getSolConnection = (_networkId, rpcs) => {
   return new Connection(rpcs[0], {
     commitment: "confirmed"
   });
 };
 
-class ChainConnectorSol {
+// src/sol/ChainConnectorSol.ts
+var ChainConnectorSol = class {
   #chaindataProvider;
   constructor(chaindataProvider) {
     this.#chaindataProvider = chaindataProvider;
@@ -1194,16 +1157,28 @@ class ChainConnectorSol {
     if (!network) throw new Error(`Network not found: ${networkId}`);
     return getSolConnection(networkId, network.rpcs);
   }
-}
+};
 
-class ChainConnectorSolStub {
+// src/sol/ChainConnectorSolStub.ts
+import { Connection as Connection2 } from "@solana/web3.js";
+var ChainConnectorSolStub = class {
   #connection;
   constructor(networkOrConnection) {
-    this.#connection = networkOrConnection instanceof Connection ? networkOrConnection : getSolConnection(networkOrConnection.id, networkOrConnection.rpcs);
+    this.#connection = networkOrConnection instanceof Connection2 ? networkOrConnection : getSolConnection(networkOrConnection.id, networkOrConnection.rpcs);
   }
   async getConnection() {
     return this.#connection;
   }
-}
-
-export { ChainConnectionError, ChainConnectorDot, ChainConnectorDotStub, ChainConnectorEth, ChainConnectorEthStub, ChainConnectorSol, ChainConnectorSolStub, StaleRpcError, WebsocketAllocationExhaustedError };
+};
+export {
+  ChainConnectionError,
+  ChainConnectorDot,
+  ChainConnectorDotStub,
+  ChainConnectorEth,
+  ChainConnectorEthStub,
+  ChainConnectorSol,
+  ChainConnectorSolStub,
+  StaleRpcError,
+  WebsocketAllocationExhaustedError
+};
+//# sourceMappingURL=index.mjs.map