@multiplatform.one/web3 7.25.0 → 7.28.0

package/src/wagmi/driver.ts

@@ -0,0 +1,303 @@
+import {
+  connect,
+  getPublicClient,
+  getWalletClient,
+  switchConnection,
+  watchConnectors,
+  type Config,
+  type Connection,
+  type Connector,
+} from "@wagmi/core";
+import type { Address, PublicClient } from "viem";
+import { connectorAdapter } from "../clients/adapter";
+import { evmClient, type EvmClient, type EvmWalletClient } from "../clients/evm";
+import type { ChainClient } from "../clients/types";
+import type {
+  ConnectionDriver,
+  DriverAccount,
+  DriverConnectOptions,
+  DriverState,
+  WalletConnector,
+} from "../core/types";
+
+export interface WagmiDriverOptions {
+  /**
+   * Which of the config's connectors the driver offers. Defaults to the EVM
+   * ones: the Solana, Sui and Bitcoin shims the legacy config adds belong to
+   * their own families.
+   */
+  filter?: (connector: Connector) => boolean;
+  /**
+   * The chain id every connection reports, in place of wagmi's. A Solana,
+   * Sui or Bitcoin shim sits on a synthetic EVM chain id; its family reports
+   * its own (`solana:mainnet`).
+   */
+  chainId?: number | string;
+  /**
+   * The per-chain client for a connection, in place of the mpo EVM client.
+   * A shim's family builds its client over the adapter the shim carries.
+   */
+  client?: (
+    connector: Connector,
+    state: DriverState,
+  ) => ChainClient | null | Promise<ChainClient | null>;
+}
+
+const isEvm = (connector: Connector) => connectorAdapter(connector) === null;
+
+const idle: DriverState = Object.freeze({
+  status: "disconnected",
+  connectorId: null,
+  account: null,
+});
+
+const recency = new WeakMap<Config, string[]>();
+
+/**
+ * A config's connections by when they were last current, oldest first, so
+ * closing the current one falls back to the one current before it rather than
+ * wagmi's oldest, which a store would take for the user switching wallets.
+ * One subscription per config, however many drivers a remount builds on it.
+ */
+function recentlyCurrent(config: Config): string[] {
+  const known = recency.get(config);
+  if (known) return known;
+  const recent: string[] = [];
+  const touch = (uid: string | null) => {
+    if (!uid) return;
+    const index = recent.indexOf(uid);
+    if (index !== -1) recent.splice(index, 1);
+    recent.push(uid);
+  };
+  touch(config.state.current);
+  config.subscribe((state) => state.current, touch);
+  recency.set(config, recent);
+  return recent;
+}
+
+/**
+ * The EVM connection driver: wagmi and viem underneath, the core's
+ * ConnectionDriver on top. It works on the config the app already built
+ * (WalletProvider's, or `useConfig()`), so wagmi keeps its connectors,
+ * EIP-6963 discovery and storage.
+ *
+ * Two wagmi actions are avoided on purpose. `reconnect` replaces every open
+ * connection with the one it restores and returns nothing while another
+ * reconnect runs, so a restore is `connect` with `isReconnecting`.
+ * `disconnect` writes back the connections it read before awaiting the
+ * wallet, dropping one that landed meanwhile, and moves `current` off a
+ * connector it did not close, so a close updates wagmi's state itself. It
+ * lets go before asking the wallet, since MetaMask Connect emits its own
+ * "disconnect" while closing and a wallet may fail or never answer. The legacy `useDisconnect` still runs wagmi's action, so on a shared
+ * config an overlapping close there can restore a connection this one removed.
+ *
+ * A wallet that reports no authorised account, a locked MetaMask included,
+ * restores to null as it does under wagmi's own reconnect, which makes the
+ * store forget it.
+ */
+export function wagmiDriver(config: Config, options: WagmiDriverOptions = {}): ConnectionDriver {
+  const filter = options.filter ?? isEvm;
+  const accountOf = (connection: Connection): DriverAccount => ({
+    address: connection.accounts[0],
+    chainId: options.chainId ?? connection.chainId,
+  });
+  let listed: readonly Connector[] | null = null;
+  let snapshot: readonly WalletConnector[] = Object.freeze([]);
+  let state = idle;
+
+  const offered = () => config.connectors.filter(filter);
+  const find = (id: string) => offered().find((connector) => connector.id === id);
+  const connectionOf = (connector: Connector) => config.state.connections.get(connector.uid);
+
+  const held = () =>
+    [...config.state.connections.values()].filter((connection) => filter(connection.connector));
+
+  const recent = recentlyCurrent(config);
+
+  /** Takes a connection out of wagmi's state without asking the wallet anything. */
+  const forget = (connector: Connector) => {
+    const { events } = config._internal;
+    connector.emitter.off("change", events.change);
+    connector.emitter.off("disconnect", events.disconnect);
+    if (!connector.emitter.listenerCount("connect"))
+      connector.emitter.on("connect", events.connect);
+    config.setState((x) => {
+      if (!x.connections.has(connector.uid)) return x;
+      const connections = new Map(x.connections);
+      connections.delete(connector.uid);
+      const first = connections.values().next().value;
+      if (!first) return { ...x, connections, current: null, status: "disconnected" };
+      if (x.current && connections.has(x.current)) return { ...x, connections };
+      const previous = [...recent].reverse().find((uid) => connections.has(uid));
+      return { ...x, connections, current: previous ?? first.connector.uid };
+    });
+  };
+
+  /** Its own connection with an account that was current most recently. */
+  const latest = () => {
+    const live = held().filter((connection) => connection.accounts[0]);
+    const uid = [...recent]
+      .reverse()
+      .find((candidate) => live.some((connection) => connection.connector.uid === candidate));
+    return live.find((connection) => connection.connector.uid === uid) ?? live[0];
+  };
+
+  /** A connection wagmi registered with no account, as a locked wallet leaves one. */
+  const empty = (connector: Connector) => {
+    const connection = connectionOf(connector);
+    return connection !== undefined && !connection.accounts[0];
+  };
+
+  const opened = (connector: Connector, accounts: readonly string[], chainId: number) => {
+    const address = accounts[0];
+    if (address) return { address, chainId: options.chainId ?? chainId };
+    forget(connector);
+    throw new Error(`${connector.name} returned no account`);
+  };
+
+  const getState = (): DriverState => {
+    const { current, connections, status } = config.state;
+    const currentConnection = current ? connections.get(current) : undefined;
+    const connection =
+      currentConnection && filter(currentConnection.connector) && currentConnection.accounts[0]
+        ? currentConnection
+        : latest();
+    const next: DriverState = connection
+      ? {
+          status: "connected",
+          connectorId: connection.connector.id,
+          account: accountOf(connection),
+        }
+      : {
+          status: status === "connected" ? "disconnected" : status,
+          connectorId: null,
+          account: null,
+        };
+    if (
+      next.status !== state.status ||
+      next.connectorId !== state.connectorId ||
+      next.account?.address !== state.account?.address ||
+      next.account?.chainId !== state.account?.chainId
+    ) {
+      state = Object.freeze(next);
+    }
+    return state;
+  };
+
+  const connectorFor = (connectorId: string) => {
+    const connector = find(connectorId);
+    if (!connector) throw new Error(`wagmi has no connector ${connectorId}`);
+    return connector;
+  };
+
+  /** A connector wagmi already holds becomes the current one, with no prompt. */
+  const reuse = async (connector: Connector): Promise<DriverAccount | null> => {
+    const connection = connectionOf(connector);
+    if (!connection?.accounts[0]) return null;
+    if (config.state.current !== connector.uid) await switchConnection(config, { connector });
+    return accountOf(connection);
+  };
+
+  return {
+    connectors() {
+      const all = config.connectors;
+      if (all !== listed) {
+        listed = all;
+        snapshot = Object.freeze(
+          all.filter(filter).map((connector) =>
+            Object.freeze({
+              id: connector.id,
+              name: connector.name,
+              ...(connector.icon ? { icon: connector.icon } : {}),
+            }),
+          ),
+        );
+      }
+      return snapshot;
+    },
+    watchConnectors(listener) {
+      return watchConnectors(config, { onChange: () => listener() });
+    },
+    getState,
+    subscribe(listener) {
+      let seen = getState();
+      return config.subscribe(
+        (current) => current,
+        () => {
+          const next = getState();
+          if (next === seen) return;
+          seen = next;
+          listener();
+        },
+      );
+    },
+    async connect(connectorId, connectOptions: DriverConnectOptions = {}) {
+      const connector = connectorFor(connectorId);
+      const open = await reuse(connector);
+      if (open) return open;
+      if (empty(connector)) forget(connector);
+      const { onDisplayUri } = connectOptions;
+      const onMessage = ({ type, data }: { type: string; data?: unknown }) => {
+        if (type === "display_uri" && typeof data === "string") onDisplayUri?.(data);
+      };
+      if (onDisplayUri) connector.emitter.on("message", onMessage);
+      try {
+        const { accounts, chainId } = await connect(config, { connector });
+        return opened(connector, accounts, chainId);
+      } finally {
+        if (onDisplayUri) connector.emitter.off("message", onMessage);
+      }
+    },
+    async disconnect(connectorId) {
+      const closing = held().filter(
+        (connection) => connectorId === undefined || connection.connector.id === connectorId,
+      );
+      for (const connection of closing) forget(connection.connector);
+      const results = await Promise.allSettled(
+        closing.map((connection) => connection.connector.disconnect()),
+      );
+      const failed = results.find((result) => result.status === "rejected");
+      if (failed) throw failed.reason;
+    },
+    async reconnect(connectorId) {
+      const connector = connectorFor(connectorId);
+      const open = await reuse(connector);
+      if (open) return open;
+      const provider = await connector.getProvider().catch(() => undefined);
+      if (!provider) throw new Error(`${connectorId} has no provider yet`);
+      if (!(await connector.isAuthorized())) return null;
+      if (empty(connector)) forget(connector);
+      const { accounts, chainId } = await connect(config, {
+        connector,
+        isReconnecting: true,
+      } as { connector: Connector });
+      return opened(connector, accounts, chainId);
+    },
+    async client(current): Promise<ChainClient | null> {
+      if (!current.account || !current.connectorId) return null;
+      const connector = find(current.connectorId);
+      if (!connector) return null;
+      if (options.client) return options.client(connector, current);
+      return evmClientFor(connector, current);
+    },
+  };
+
+  async function evmClientFor(
+    connector: Connector,
+    current: DriverState,
+  ): Promise<EvmClient | null> {
+    if (!current.account) return null;
+    const chainId =
+      typeof current.account.chainId === "number" ? current.account.chainId : undefined;
+    const walletClient = await getWalletClient(config, {
+      connector,
+      chainId,
+      account: current.account.address as Address,
+    });
+    const publicClient = getPublicClient(config, { chainId });
+    return evmClient({
+      walletClient: walletClient as unknown as EvmWalletClient,
+      ...(publicClient ? { publicClient: publicClient as unknown as PublicClient } : {}),
+    });
+  }
+}