@multiplatform.one/web3 7.18.0 → 7.20.0

package/src/connectkit/connectors/aaveAccountConnector.ts

@@ -0,0 +1,43 @@
+// @aave/account's own aaveAccountConnector() builds its EthereumProvider while the
+// wagmi config is built. That constructor mounts Aave's hidden iframe and calls
+// AaveAccountSdk.connect() on every page load, and when the connect does not
+// finish the SDK rejects unhandled: "Aave Account is not connected" on every
+// Keycloak login page (MPO-378). This builds the provider only when the user picks
+// Aave Account, or when wagmi reconnects the Aave Account it connected last.
+import { EthereumProvider, type EthereumProviderOptions } from "@aave/account";
+import { injected } from "@wagmi/connectors/injected";
+import type { CreateConnectorFn } from "wagmi";
+
+export const aaveAccountConnectorId = "aaveAccountProvider";
+
+export function aaveAccountConnector(options?: EthereumProviderOptions): CreateConnectorFn {
+  let provider: EthereumProvider | undefined;
+  const ensureProvider = () => (provider ??= new EthereumProvider(options));
+  const base = injected({
+    shimDisconnect: false,
+    target: () => ({
+      id: aaveAccountConnectorId,
+      name: "Aave Account",
+      provider: () => provider as never,
+    }),
+  });
+
+  return (config) => {
+    const connector = base(config);
+    return {
+      ...connector,
+      async connect(parameters) {
+        ensureProvider();
+        return connector.connect.call(this, parameters);
+      },
+      async getProvider(parameters) {
+        if (
+          !provider &&
+          (await config.storage?.getItem("recentConnectorId")) === aaveAccountConnectorId
+        )
+          ensureProvider();
+        return connector.getProvider.call(this, parameters);
+      },
+    } as ReturnType<typeof base>;
+  };
+}

package/src/connectkit/connectors/embeddedDesktop.spec.ts

@@ -23,21 +23,21 @@ describe("metaMaskOptionsForEmbeddedDesktop", () => {
     window.open = originalOpen;
   });
 
-  it("disables deeplink navigation and SDK modal", () => {
+  it("disables deeplink navigation and the MetaMask Connect modal", () => {
     const opts = metaMaskOptionsForEmbeddedDesktop();
     expect(opts.useDeeplink).toBe(false);
     expect(opts.headless).toBe(true);
   });
 
-  it("openDeeplink opens https in a new window and ignores custom schemes", () => {
+  it("preferredOpenLink opens https in a new window and ignores custom schemes", () => {
     const open = vi.fn();
     window.open = open;
-    const { openDeeplink } = metaMaskOptionsForEmbeddedDesktop();
+    const { preferredOpenLink } = metaMaskOptionsForEmbeddedDesktop();
 
-    openDeeplink("metamask://connect?channelId=abc");
+    preferredOpenLink("metamask://connect?channelId=abc");
     expect(open).not.toHaveBeenCalled();
 
-    openDeeplink("https://metamask.app.link/connect?channelId=abc");
+    preferredOpenLink("https://metamask.app.link/connect?channelId=abc");
     expect(open).toHaveBeenCalledWith(
       "https://metamask.app.link/connect?channelId=abc",
       "_blank",

package/src/connectkit/connectors/embeddedDesktop.ts

@@ -1,6 +1,6 @@
 /**
  * Tauri (and similar) desktop shells load the *web* bundle inside a native
- * WebView. Browser extensions never inject there, so MetaMask must use the SDK
+ * WebView. Browser extensions never inject there, so MetaMask must use the
  * remote/QR path — never `window.location.href = metamask://…`, which would
  * navigate the whole WebView away from the app.
  *
@@ -22,21 +22,21 @@ export function isEmbeddedDesktopWebview(
 export type MetaMaskEmbeddedDesktopOptions = {
   /** Prefer https://metamask.app.link over metamask:// in the QR payload. */
   useDeeplink: false;
-  /** Suppress SDK InstallModal custom-elements (WKWebView-hostile); ConnectKit renders QR. */
+  /** Suppress MetaMask Connect's install modal (WKWebView-hostile); ConnectKit renders QR. */
   headless: true;
   /**
    * Never assign location.href for custom schemes. https universal links may
    * open in the system browser via window.open; custom schemes are ignored.
    */
-  openDeeplink: (url: string) => void;
+  preferredOpenLink: (url: string) => void;
 };
 
-/** MetaMask SDK options that are safe inside Tauri/WebView2/WKWebView. */
+/** MetaMask Connect options that are safe inside Tauri/WebView2/WKWebView. */
 export function metaMaskOptionsForEmbeddedDesktop(): MetaMaskEmbeddedDesktopOptions {
   return {
     useDeeplink: false,
     headless: true,
-    openDeeplink: (url: string) => {
+    preferredOpenLink: (url: string) => {
       if (typeof window === "undefined") return;
       // Custom schemes (metamask://) must not navigate the WebView.
       if (!/^https?:\/\//i.test(url)) return;

package/src/connectkit/connectors/metaMaskConnectConnector.spec.ts

@@ -0,0 +1,230 @@
+import type { EventHandlers } from "@metamask/connect-evm";
+import { connect, createConfig, http, reconnect } from "@wagmi/core";
+import { createEmitter } from "@wagmi/core/internal";
+import type { Chain } from "viem";
+import { getAddress, SwitchChainError } from "viem";
+import { base, mainnet, polygon } from "viem/chains";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  metaMaskConnect,
+  metaMaskConnectChainIds,
+  metaMaskNetworks,
+  resetMetaMaskConnectClient,
+} from "./metaMaskConnectConnector";
+import {
+  BITCOIN_CHAIN_ID,
+  SOLANA_CHAIN_ID,
+  SUI_CHAIN_ID,
+  syntheticChains,
+} from "./syntheticChains";
+
+const { createEVMClient, client } = vi.hoisted(() => {
+  const client = {
+    accounts: [] as string[],
+    getChainId: vi.fn(() => "0x2105"),
+    connect: vi.fn(async (_options: { chainIds: string[] }) => ({
+      accounts: ["0x0000000000000000000000000000000000000001"],
+      chainId: "0x2105",
+    })),
+    switchChain: vi.fn(async () => undefined),
+    disconnect: vi.fn(async () => undefined),
+    getProvider: vi.fn(() => ({ request: vi.fn() })),
+  };
+  return { client, createEVMClient: vi.fn(async (_options: unknown) => client) };
+});
+
+vi.mock("@metamask/connect-evm", () => ({ createEVMClient }));
+
+const synthetic = [SOLANA_CHAIN_ID, SUI_CHAIN_ID, BITCOIN_CHAIN_ID];
+const hex = (id: number) => `0x${id.toString(16)}`;
+
+function build(chains: readonly Chain[]) {
+  const transports = Object.fromEntries(chains.map((chain) => [chain.id, http()]));
+  return metaMaskConnect({ dapp: { name: "test", url: "https://example.test" } })({
+    chains: chains as [Chain, ...Chain[]],
+    emitter: createEmitter("metaMaskSDK"),
+    transports,
+  } as never);
+}
+
+describe("metaMaskNetworks", () => {
+  it("drops the synthetic non-EVM chains", () => {
+    const networks = metaMaskNetworks([mainnet, polygon, ...syntheticChains]);
+    expect(Object.keys(networks)).toEqual([hex(mainnet.id), hex(polygon.id)]);
+    for (const id of synthetic) expect(networks).not.toHaveProperty(hex(id));
+  });
+
+  it("drops a chain with no usable RPC URL", () => {
+    const broken = { ...base, rpcUrls: { default: { http: [""] } } } as Chain;
+    expect(Object.keys(metaMaskNetworks([mainnet, broken]))).toEqual([hex(mainnet.id)]);
+  });
+
+  it("prefers the transport's URL over the chain's default", () => {
+    const networks = metaMaskNetworks([mainnet], {
+      [mainnet.id]: http("https://rpc.example.test"),
+    });
+    expect(networks[hex(mainnet.id) as `0x${string}`]).toBe("https://rpc.example.test");
+  });
+});
+
+describe("metaMaskConnectChainIds", () => {
+  const networks = metaMaskNetworks([mainnet, polygon, base]);
+
+  it("puts the requested chain first", () => {
+    expect(metaMaskConnectChainIds(networks, base.id)).toEqual([
+      hex(base.id),
+      hex(mainnet.id),
+      hex(polygon.id),
+    ]);
+  });
+
+  it("ignores a requested synthetic chain", () => {
+    expect(metaMaskConnectChainIds(networks, SOLANA_CHAIN_ID)).toEqual(Object.keys(networks));
+  });
+});
+
+describe("metaMaskConnect", () => {
+  beforeEach(() => {
+    resetMetaMaskConnectClient();
+    vi.clearAllMocks();
+    client.accounts = [];
+  });
+
+  afterEach(() => resetMetaMaskConnectClient());
+
+  it("keeps the metaMaskSDK id existing consumers key off", () => {
+    expect(build([mainnet]).id).toBe("metaMaskSDK");
+  });
+
+  it("never tells MetaMask about a synthetic chain id", async () => {
+    const connector = build([mainnet, polygon, ...syntheticChains]);
+    await connector.setup?.();
+    await connector.connect({ chainId: SOLANA_CHAIN_ID });
+
+    const options = createEVMClient.mock.calls[0]![0] as {
+      api: { supportedNetworks: Record<string, string> };
+    };
+    const supported = Object.keys(options.api.supportedNetworks);
+    const requested = client.connect.mock.calls[0]![0].chainIds;
+    for (const id of synthetic) {
+      expect(supported).not.toContain(hex(id));
+      expect(requested).not.toContain(hex(id));
+    }
+    expect(supported).toEqual([hex(mainnet.id), hex(polygon.id)]);
+    expect(requested).toEqual([hex(mainnet.id), hex(polygon.id)]);
+  });
+
+  it("asks for the requested EVM chain first and reports the wallet's chain", async () => {
+    const connector = build([mainnet, polygon, ...syntheticChains]);
+    const result = await connector.connect({ chainId: polygon.id });
+    expect(client.connect.mock.calls[0]![0].chainIds[0]).toBe(hex(polygon.id));
+    expect(result.chainId).toBe(base.id);
+  });
+
+  it("refuses to switch MetaMask to a synthetic chain", async () => {
+    const connector = build([mainnet, ...syntheticChains]);
+    await expect(connector.switchChain!({ chainId: SUI_CHAIN_ID })).rejects.toBeInstanceOf(
+      SwitchChainError,
+    );
+    expect(client.switchChain).not.toHaveBeenCalled();
+  });
+
+  it("builds one client per page across rebuilt configs", async () => {
+    await build([mainnet]).setup?.();
+    await build([mainnet]).setup?.();
+    expect(createEVMClient).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("metaMaskConnect under wagmi", () => {
+  const first = "0x00000000000000000000000000000000000000aa";
+  const second = "0x00000000000000000000000000000000000000bb";
+
+  beforeEach(() => {
+    resetMetaMaskConnectClient();
+    vi.clearAllMocks();
+    client.accounts = [];
+  });
+
+  afterEach(() => resetMetaMaskConnectClient());
+
+  function wagmiConfig() {
+    return createConfig({
+      chains: [base, mainnet],
+      connectors: [metaMaskConnect({ dapp: { name: "test", url: "https://example.test" } })],
+      transports: { [base.id]: http(), [mainnet.id]: http() },
+      multiInjectedProviderDiscovery: false,
+      storage: null,
+    });
+  }
+
+  async function clientEvents() {
+    await vi.waitFor(() => expect(createEVMClient).toHaveBeenCalledTimes(1));
+    return (createEVMClient.mock.calls[0]![0] as { eventHandlers: EventHandlers }).eventHandlers;
+  }
+
+  it("sends display_uri to the connector being connected, not the newest one built", async () => {
+    const before = wagmiConfig();
+    const used = wagmiConfig();
+    const newest = wagmiConfig();
+    const events = await clientEvents();
+    const seen = new Map([before, used, newest].map((config) => [config, [] as unknown[]]));
+    for (const [config, uris] of seen)
+      config.connectors[0]!.emitter.on("message", ({ type, data }) => {
+        if (type === "display_uri") uris.push(data);
+      });
+
+    client.connect.mockImplementationOnce(async () => {
+      events.displayUri("metamask://connect?id=1");
+      return { accounts: [first], chainId: "0x2105" };
+    });
+    await connect(used, { connector: used.connectors[0]! });
+
+    expect(seen.get(used)).toEqual(["metamask://connect?id=1"]);
+    expect(seen.get(before)).toEqual([]);
+    expect(seen.get(newest)).toEqual([]);
+  });
+
+  it("keeps account changes flowing to the config wagmi reconnects", async () => {
+    const cached = wagmiConfig();
+    const events = await clientEvents();
+    await connect(cached, { connector: cached.connectors[0]! });
+    const other = wagmiConfig();
+    await connect(other, { connector: other.connectors[0]! });
+
+    // The provider switches back to the cached config and reconnects it.
+    client.accounts = [first];
+    await reconnect(cached);
+    events.accountsChanged([second]);
+
+    const connector = cached.connectors[0]!;
+    expect(cached.state.connections.get(connector.uid)?.accounts).toEqual([getAddress(second)]);
+  });
+
+  it("connects wagmi to a session approved outside connect()", async () => {
+    const config = wagmiConfig();
+    const events = await clientEvents();
+    expect(config.state.status).toBe("disconnected");
+
+    events.connect({ chainId: "0x2105", accounts: [first] });
+
+    const connector = config.connectors[0]!;
+    expect(config.state.status).toBe("connected");
+    expect(config.state.current).toBe(connector.uid);
+    expect(config.state.connections.get(connector.uid)).toMatchObject({
+      accounts: [getAddress(first)],
+      chainId: base.id,
+    });
+
+    events.accountsChanged([second]);
+    expect(config.state.connections.get(connector.uid)?.accounts).toEqual([getAddress(second)]);
+  });
+
+  it("ignores a connect that carries no account", async () => {
+    const config = wagmiConfig();
+    const events = await clientEvents();
+    events.connect({ chainId: "0x2105", accounts: [] });
+    expect(config.state.status).toBe("disconnected");
+  });
+});

package/src/connectkit/connectors/metaMaskConnectConnector.ts

@@ -0,0 +1,272 @@
+// wagmi connector for MetaMask over MetaMask Connect (@metamask/connect-evm, the
+// Mobile Wallet Protocol relay). It replaces the classic @metamask/sdk connector,
+// whose socket.io relay never re-delivered a reply that arrived while Android 16
+// had cut the browser's network (5-6 s after MetaMask takes focus). The MWP relay
+// keeps each channel's history and the page recovers it when it resubscribes, so
+// the reply lands as soon as the user switches back. Proven on Android 16 in
+// PROMA-36 with the relay timers raised by `metaMaskConnectTimeouts` (see
+// ../../vite.ts); without them a user who lingers in MetaMask past 60 s loses
+// the request.
+//
+// The id stays `metaMaskSDK`: isMetaMaskConnector(), useWallets' EIP-6963 dedupe
+// and ConnectWithInjector's display_uri listener all key off it, and so does
+// every consumer's persisted "recent connector".
+import type { EIP1193Provider, MetamaskConnectEVM } from "@metamask/connect-evm";
+import {
+  ChainNotConfiguredError,
+  type CreateConnectorFn,
+  createConnector,
+  extractRpcUrls,
+} from "@wagmi/core";
+import {
+  type Address,
+  type Chain,
+  getAddress,
+  type Hex,
+  numberToHex,
+  ResourceUnavailableRpcError,
+  SwitchChainError,
+  UserRejectedRequestError,
+} from "viem";
+
+import { isSyntheticChainId } from "./syntheticChains";
+
+export type MetaMaskConnectParameters = {
+  dapp: { name: string; url?: string; iconUrl?: string };
+  /** Run without MetaMask Connect's own install/QR modal (the modal renders `display_uri`). */
+  headless?: boolean;
+  /** Opens MetaMask's deeplink. Embedded desktop webviews must not navigate away. */
+  preferredOpenLink?: (deeplink: string, target?: string) => void;
+  /** `metamask://` instead of the https://metamask.app.link universal link. */
+  useDeeplink?: boolean;
+  debug?: boolean;
+};
+
+type ConnectorConfig = Parameters<CreateConnectorFn>[0];
+type Emitter = ConnectorConfig["emitter"];
+
+/**
+ * The chains MetaMask may be told about. Non-EVM wallets ride synthetic chain ids
+ * (syntheticChains.ts) that no EVM network carries, and a chain with no usable
+ * RPC URL fails MetaMask Connect's `new URL()` check in createEVMClient, which
+ * kills connect() before it ever emits `display_uri`.
+ */
+export function metaMaskNetworks(
+  chains: readonly Chain[],
+  transports?: ConnectorConfig["transports"],
+): Record<Hex, string> {
+  const networks: Record<Hex, string> = {};
+  for (const chain of chains) {
+    if (isSyntheticChainId(chain.id)) continue;
+    const url = extractRpcUrls({ chain, transports })?.[0] ?? chain.rpcUrls.default?.http[0];
+    if (url && isUrl(url)) networks[numberToHex(chain.id)] = url;
+  }
+  return networks;
+}
+
+function isUrl(value: string): boolean {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The chain ids a connect asks MetaMask for, the requested one first (it becomes the active chain). */
+export function metaMaskConnectChainIds(networks: Record<Hex, string>, chainId?: number): Hex[] {
+  const ids = Object.keys(networks) as Hex[];
+  if (!chainId || isSyntheticChainId(chainId)) return ids;
+  const first = numberToHex(chainId);
+  return ids.includes(first) ? [first, ...ids.filter((id) => id !== first)] : ids;
+}
+
+// One client per page. Its session lives in localStorage, and consumers rebuild
+// the wagmi config (and so this connector) on re-render, so a client per
+// connector instance would race itself over the same session. The events it
+// raises go to the connector wagmi last drove: StrictMode and config caches
+// build connectors that wagmi never uses, and one of those may be the newest.
+let client: Promise<MetamaskConnectEVM> | undefined;
+let owner: Emitter | undefined;
+
+function getClient(
+  parameters: MetaMaskConnectParameters,
+  networks: Record<Hex, string>,
+): Promise<MetamaskConnectEVM> {
+  if (client) return client;
+  client = import("@metamask/connect-evm").then(({ createEVMClient }) =>
+    createEVMClient({
+      dapp: {
+        name: parameters.dapp.name,
+        url:
+          parameters.dapp.url ??
+          (typeof window !== "undefined" ? window.location.origin : "https://multiplatform.one"),
+        ...(parameters.dapp.iconUrl ? { iconUrl: parameters.dapp.iconUrl } : {}),
+      },
+      api: { supportedNetworks: networks },
+      analytics: { enabled: false },
+      skipAutoAnnounce: true,
+      debug: parameters.debug,
+      ...(parameters.headless ? { ui: { headless: true } } : {}),
+      ...(parameters.preferredOpenLink || parameters.useDeeplink !== undefined
+        ? {
+            mobile: {
+              ...(parameters.preferredOpenLink
+                ? { preferredOpenLink: parameters.preferredOpenLink }
+                : {}),
+              ...(parameters.useDeeplink !== undefined
+                ? { useDeeplink: parameters.useDeeplink }
+                : {}),
+            },
+          }
+        : {}),
+      eventHandlers: {
+        // A session approved outside connect(), in another tab say. wagmi drops
+        // `change` for a connector it has no connection for, so only `connect`
+        // brings it in.
+        connect: ({ accounts, chainId }) => {
+          if (accounts.length)
+            owner?.emit("connect", {
+              accounts: accounts.map((a) => getAddress(a)),
+              chainId: Number(chainId),
+            });
+        },
+        accountsChanged: (accounts) => {
+          if (accounts.length === 0) owner?.emit("disconnect");
+          else owner?.emit("change", { accounts: accounts.map((a) => getAddress(a)) });
+        },
+        chainChanged: (chainId) => owner?.emit("change", { chainId: Number(chainId) }),
+        disconnect: () => owner?.emit("disconnect"),
+        displayUri: (uri) => owner?.emit("message", { type: "display_uri", data: uri }),
+      },
+    }),
+  );
+  client.catch(() => {
+    client = undefined;
+  });
+  return client;
+}
+
+/** Test seam: forget the page's client so the next connector builds a fresh one. */
+export function resetMetaMaskConnectClient(): void {
+  client = undefined;
+  owner = undefined;
+}
+
+function rethrow(err: unknown): never {
+  const code = (err as { code?: number })?.code;
+  if (code === UserRejectedRequestError.code) throw new UserRejectedRequestError(err as Error);
+  if (code === ResourceUnavailableRpcError.code)
+    throw new ResourceUnavailableRpcError(err as Error);
+  throw err;
+}
+
+metaMaskConnect.type = "metaMask" as const;
+export function metaMaskConnect(parameters: MetaMaskConnectParameters) {
+  return createConnector<EIP1193Provider>((config) => {
+    owner ??= config.emitter;
+    const networks = metaMaskNetworks(config.chains, config.transports);
+    const fallbackChainId = Number(Object.keys(networks)[0] ?? 1);
+    const instance = () => getClient(parameters, networks);
+    // Every call wagmi makes on the connector it uses claims the client's events;
+    // setup() runs for every built config, so it does not.
+    const claim = () => {
+      owner = config.emitter;
+      return instance();
+    };
+    const accountsOf = (mm: MetamaskConnectEVM): Address[] => mm.accounts.map((a) => getAddress(a));
+    const chainIdOf = (mm: MetamaskConnectEVM) => {
+      const hex = mm.getChainId();
+      return hex ? Number(hex) : fallbackChainId;
+    };
+
+    return {
+      id: "metaMaskSDK",
+      name: "MetaMask",
+      rdns: ["io.metamask", "io.metamask.mobile"],
+      type: metaMaskConnect.type,
+      async setup() {
+        // Build the client before the tap: mobile Chrome opens the MetaMask deeplink
+        // only inside the tap's short user activation, which a cold import outlasts.
+        await instance().catch(() => undefined);
+      },
+      async connect({ chainId, isReconnecting } = {}) {
+        // No separate chain switch: the requested chain leads the permission request
+        // and becomes the active chain, so connecting stays one wallet round trip.
+        const mm = await claim();
+        try {
+          let accounts = isReconnecting ? accountsOf(mm) : [];
+          if (!accounts.length) {
+            const result = await mm.connect({
+              chainIds: metaMaskConnectChainIds(networks, chainId),
+            });
+            accounts = result.accounts.map((a) => getAddress(a));
+          }
+          return { accounts: accounts as never, chainId: chainIdOf(mm) };
+        } catch (err) {
+          rethrow(err);
+        }
+      },
+      async disconnect() {
+        await (await claim()).disconnect();
+      },
+      async getAccounts() {
+        return accountsOf(await claim());
+      },
+      async getChainId() {
+        return chainIdOf(await claim());
+      },
+      async getProvider() {
+        return (await claim()).getProvider();
+      },
+      async isAuthorized() {
+        // createEVMClient has already resumed a stored session, so its cached
+        // accounts answer without a relay round trip that could sit on the long
+        // request timeout.
+        try {
+          return accountsOf(await claim()).length > 0;
+        } catch {
+          return false;
+        }
+      },
+      async switchChain({ addEthereumChainParameter, chainId }) {
+        const chain = config.chains.find((c) => c.id === chainId);
+        if (!chain || !networks[numberToHex(chainId)])
+          throw new SwitchChainError(new ChainNotConfiguredError());
+        try {
+          await (
+            await claim()
+          ).switchChain({
+            chainId: numberToHex(chainId),
+            chainConfiguration: {
+              chainId: numberToHex(chainId),
+              chainName: addEthereumChainParameter?.chainName ?? chain.name,
+              nativeCurrency: addEthereumChainParameter?.nativeCurrency ?? chain.nativeCurrency,
+              rpcUrls: addEthereumChainParameter?.rpcUrls
+                ? [...addEthereumChainParameter.rpcUrls]
+                : [networks[numberToHex(chainId)]],
+              ...(chain.blockExplorers?.default.url
+                ? { blockExplorerUrls: [chain.blockExplorers.default.url] }
+                : {}),
+            },
+          });
+          return chain;
+        } catch (err) {
+          if ((err as { code?: number })?.code === UserRejectedRequestError.code)
+            throw new UserRejectedRequestError(err as Error);
+          throw new SwitchChainError(err as Error);
+        }
+      },
+      onAccountsChanged(accounts) {
+        if (accounts.length === 0) config.emitter.emit("disconnect");
+        else config.emitter.emit("change", { accounts: accounts.map((a) => getAddress(a)) });
+      },
+      onChainChanged(chain) {
+        config.emitter.emit("change", { chainId: Number(chain) });
+      },
+      onDisconnect() {
+        config.emitter.emit("disconnect");
+      },
+    };
+  });
+}

package/src/connectkit/connectors/walletAdapterConnector.ts

@@ -71,6 +71,8 @@ export function walletAdapterConnector(entry: WalletConnectorEntry) {
       icon: entry.icon,
       // custom tag read by getConnectorEcosystem()/WalletProps.ecosystem
       ecosystem: entry.ecosystem,
+      // read by clientForConnector() to build the per-chain client
+      adapter: entry.adapter,
 
       async getProvider() {
         return provider;

package/src/connectkit/defaultConfig.ts

@@ -1,7 +1,7 @@
 import { http } from "wagmi";
 import { type CreateConfigParameters } from "@wagmi/core";
 import { mainnet, polygon, optimism, arbitrum } from "wagmi/chains";
-import { CoinbaseWalletParameters } from "wagmi/connectors";
+import type { CoinbaseWalletParameters } from "@wagmi/connectors/coinbaseWallet";
 import { EthereumProviderOptions as AaveAccountOptions } from "@aave/account";
 
 import { setAppMeta } from "@multiplatform.one/connectkit";
@@ -9,8 +9,8 @@ import defaultConnectors from "./defaultConnectors";
 import { getWalletConnectors } from "./connectors/getWalletConnectors";
 import { syntheticChains } from "./connectors/syntheticChains";
 
-// App name/icon now live in connectkit's agnostic appMeta module (the modal reads
-// them for the WalletConnect og:title hint); re-exported here for back-compat.
+// App name/icon now live in connectkit's agnostic appMeta module; re-exported here
+// for back-compat.
 export { getAppName, getAppIcon } from "@multiplatform.one/connectkit";
 
 type DefaultConfigProps = {
@@ -19,8 +19,8 @@ type DefaultConfigProps = {
   appDescription?: string;
   appUrl?: string;
 
-  // WC 2.0 requires a project ID (get one here: https://cloud.walletconnect.com/sign-in)
-  walletConnectProjectId: string;
+  /** @deprecated Ignored: no connector needs a project id. Removed in the next major. */
+  walletConnectProjectId?: string;
   // Coinbase Wallet preference
   coinbaseWalletPreference?: CoinbaseWalletParameters<"4">["preference"];
   // Aave Account options
@@ -31,6 +31,15 @@ type DefaultConfigProps = {
   enableWallet?: boolean;
 } & Partial<CreateConfigParameters>;
 
+let warnedProjectId = false;
+function warnIgnoredProjectId() {
+  if (warnedProjectId) return;
+  warnedProjectId = true;
+  console.warn(
+    "@multiplatform.one/web3: walletConnectProjectId is ignored and will be removed in the next major.",
+  );
+}
+
 const defaultConfig = ({
   appName = "ConnectKit",
   appIcon,
@@ -40,12 +49,13 @@ const defaultConfig = ({
   coinbaseWalletPreference,
   chains = [mainnet, polygon, optimism, arbitrum],
   client,
-  enableAaveAccount = true,
+  enableAaveAccount = false,
   aaveAccountOptions,
   enableWallet = true,
   ...props
 }: DefaultConfigProps): CreateConfigParameters => {
   setAppMeta(appName, appIcon);
+  if (walletConnectProjectId) warnIgnoredProjectId();
 
   // Register the wallet synthetic chains so wagmi can resolve a `chain` object for a
   // connected non-EVM account — ConnectKit's SIWE signIn reads `chain.id`, which is
@@ -66,7 +76,6 @@ const defaultConfig = ({
         description: appDescription,
         url: appUrl,
       },
-      walletConnectProjectId,
       coinbaseWalletPreference,
       enableAaveAccount,
       aaveAccountOptions,