@multiplatform.one/web3 7.18.0 → 7.20.0

package/src/bundler/metaMaskConnectTimeouts.spec.ts

@@ -0,0 +1,390 @@
+import { mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runInThisContext } from "node:vm";
+
+import type { Plugin as EsbuildPlugin } from "esbuild";
+import {
+  build,
+  type InlineConfig,
+  optimizeDeps,
+  type Plugin,
+  type Rolldown,
+  resolveConfig,
+} from "vite";
+import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
+
+import { metaMaskConnectTimeoutsEsbuild } from "../esbuild";
+import { metaMaskConnectTimeouts } from "../vite";
+import {
+  createMetaMaskConnectTimeoutTracker,
+  patchMetaMaskConnectTimeouts,
+} from "./metaMaskConnectTimeouts";
+
+const web3Root = fileURLToPath(new URL("../..", import.meta.url));
+const requireHere = createRequire(import.meta.url);
+
+const multichainPkg = "@metamask/connect-multichain";
+const dappClientPkg = "@metamask/mobile-wallet-protocol-dapp-client";
+
+/** Every JS file a package's root export can resolve to, whatever the bundler's conditions. */
+function exportedFiles(pkgDir: string): string[] {
+  const { exports } = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
+  const files = new Set<string>();
+  const walk = (node: unknown) => {
+    if (typeof node === "string") {
+      if (/\.[cm]?js$/.test(node)) files.add(join(pkgDir, node));
+    } else if (node && typeof node === "object") Object.values(node).forEach(walk);
+  };
+  walk(exports["."]);
+  return [...files];
+}
+
+const multichainDir = dirname(requireHere.resolve(`${multichainPkg}/package.json`));
+const dappClientDir = join(dirname(requireHere.resolve(dappClientPkg)), "..");
+const connectEvmEntry = requireHere.resolve("@metamask/connect-evm");
+const multichainFiles = exportedFiles(multichainDir);
+const dappClientFiles = exportedFiles(dappClientDir);
+const read = (file: string) => readFileSync(file, "utf8");
+
+const pageLoadResume =
+  /resumeSession_fn = function\(session, options\)[\s\S]*?isContinuingPriorAttempt \? this\.options\.resumeTimeout : options \? this\.options\.connectionTimeout : 120 \* 1e3/;
+const stockConnectionTimer =
+  /isContinuingPriorAttempt \? this\.options\.resumeTimeout : this\.options\.connectionTimeout/g;
+
+describe("the timer patches on the installed MetaMask Connect", () => {
+  it("finds every entry file the bundlers can pick", () => {
+    expect(multichainFiles.length).toBeGreaterThanOrEqual(4);
+    expect(dappClientFiles.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("raises the request timer to 600 s and the handshake timer to 540 s", () => {
+    for (const file of multichainFiles) {
+      const tracker = createMetaMaskConnectTimeoutTracker();
+      tracker.see(connectEvmEntry);
+      const code = read(file);
+      expect(code).toMatch(/DEFAULT_REQUEST_TIMEOUT\d* = 60 \* 1e3;\s+CONNECTION_GRACE_PERIOD =/);
+      const patched = tracker.patch(file, code)!.code;
+      expect(patched).toMatch(
+        /DEFAULT_REQUEST_TIMEOUT\d* = 600 \* 1e3;\s+CONNECTION_GRACE_PERIOD = 60 \* 1e3;/,
+      );
+      for (const dapp of dappClientFiles) tracker.patch(dapp, read(dapp));
+      expect(tracker.problem()).toBeUndefined();
+    }
+    for (const file of dappClientFiles) {
+      const code = read(file);
+      expect(code).toContain("HANDSHAKE_TIMEOUT = 60 * 1e3;");
+      const patched = patchMetaMaskConnectTimeouts(file, code)!.code;
+      expect(patched).toContain("HANDSHAKE_TIMEOUT = 540 * 1e3;");
+      expect(patched).not.toContain("HANDSHAKE_TIMEOUT = 60 * 1e3;");
+    }
+  });
+
+  it("gives only the option-less page-load resume the stock 120 s", () => {
+    for (const file of multichainFiles) {
+      const code = read(file);
+      expect(code.match(stockConnectionTimer)).toHaveLength(2);
+      const patched = patchMetaMaskConnectTimeouts(file, code)!.code;
+      expect(patched).toMatch(pageLoadResume);
+      // startSession (a new connect) keeps the long connection timer.
+      expect(patched.match(stockConnectionTimer)).toHaveLength(1);
+      expect(patched.indexOf("startSession_fn = function")).toBeLessThan(
+        patched.search(stockConnectionTimer),
+      );
+    }
+  });
+
+  it("fails the build when a package renames the marker it looks for", () => {
+    const [multichain] = multichainFiles;
+    const [dappClient] = dappClientFiles;
+
+    const renamedGrace = createMetaMaskConnectTimeoutTracker();
+    renamedGrace.see(connectEvmEntry);
+    expect(
+      renamedGrace.patch(
+        multichain!,
+        read(multichain!).replaceAll("CONNECTION_GRACE_PERIOD", "CONNECTION_GRACE_MS"),
+      ),
+    ).toBeUndefined();
+    renamedGrace.patch(dappClient!, read(dappClient!));
+    expect(renamedGrace.problem()).toMatch(
+      /left the timers in @metamask\/connect-multichain unpatched/,
+    );
+
+    const renamedHandshake = createMetaMaskConnectTimeoutTracker();
+    renamedHandshake.see(connectEvmEntry);
+    renamedHandshake.patch(multichain!, read(multichain!));
+    renamedHandshake.patch(
+      dappClient!,
+      read(dappClient!).replaceAll("HANDSHAKE_TIMEOUT", "HANDSHAKE_GRACE"),
+    );
+    expect(renamedHandshake.problem()).toMatch(
+      /left the timers in @metamask\/mobile-wallet-protocol-dapp-client unpatched/,
+    );
+  });
+
+  it("throws when a timer changed its value", () => {
+    const [multichain] = multichainFiles;
+    const [dappClient] = dappClientFiles;
+    const code = read(multichain!);
+
+    expect(() =>
+      patchMetaMaskConnectTimeouts(
+        multichain!,
+        code.replace(/(DEFAULT_REQUEST_TIMEOUT\d*) = 60 \* 1e3;/, "$1 = 90 * 1e3;"),
+      ),
+    ).toThrow(/timer DEFAULT_REQUEST_TIMEOUT not found/);
+    expect(() =>
+      patchMetaMaskConnectTimeouts(
+        dappClient!,
+        read(dappClient!).replace("HANDSHAKE_TIMEOUT = 60 * 1e3;", "HANDSHAKE_TIMEOUT = 45 * 1e3;"),
+      ),
+    ).toThrow(/timer HANDSHAKE_TIMEOUT not found/);
+    // A resume that no longer reads the connection timer must not send the
+    // rewrite on to startSession's copy of the expression.
+    expect(() =>
+      patchMetaMaskConnectTimeouts(
+        multichain!,
+        code.replace(stockConnectionTimer, (match, offset: number) =>
+          offset < code.indexOf("startSession_fn = function")
+            ? "isContinuingPriorAttempt ? this.options.resumeTimeout : this.options.handshakeTimeout"
+            : match,
+        ),
+      ),
+    ).toThrow(/timer the page-load session resume not found/);
+  });
+});
+
+type MWPTransportClass = new (
+  dappClient: unknown,
+  kvstore: unknown,
+) => {
+  options: { requestTimeout: number; connectionTimeout: number; resumeTimeout: number };
+  getActiveSession(): Promise<unknown>;
+  connect(options?: { scopes: string[]; caipAccountIds: string[] }): Promise<void>;
+};
+
+/** connect-multichain's MWPTransport from its node build, with the timer patch applied. */
+function loadPatchedMWPTransport() {
+  const file = requireHere.resolve(multichainPkg);
+  const code = patchMetaMaskConnectTimeouts(file, read(file))!.code;
+  const requireThere = createRequire(file);
+  const wrapper = runInThisContext(
+    `(function (module, exports, require, __filename, __dirname) {${code}\nreturn (init_mwp(), MWPTransport);\n})`,
+    { filename: file },
+  );
+  const module = { exports: {} };
+  const MWPTransport: MWPTransportClass = wrapper(
+    module,
+    module.exports,
+    requireThere,
+    file,
+    dirname(file),
+  );
+  const { TransportTimeoutError } = requireThere("@metamask/multichain-api-client");
+  return { MWPTransport, TransportTimeoutError: TransportTimeoutError as new () => Error };
+}
+
+describe("the patched MetaMask Connect transport", () => {
+  const { MWPTransport, TransportTimeoutError } = loadPatchedMWPTransport();
+
+  function transport(storedSession: boolean) {
+    // A relay that never answers: nothing resumes, nothing connects.
+    const dappClient = {
+      state: "DISCONNECTED",
+      on: vi.fn(),
+      off: vi.fn(),
+      once: vi.fn(),
+      resume: () => new Promise(() => undefined),
+      connect: () => new Promise(() => undefined),
+      disconnect: vi.fn(async () => undefined),
+      sendRequest: vi.fn(async () => undefined),
+    };
+    const store = new Map<string, string>();
+    const kvstore = {
+      get: async (key: string) => store.get(key) ?? null,
+      set: async (key: string, value: string) => void store.set(key, value),
+      delete: async (key: string) => void store.delete(key),
+    };
+    const mwp = new MWPTransport(dappClient, kvstore);
+    mwp.getActiveSession = async () => (storedSession ? { id: "stored" } : undefined);
+    return mwp;
+  }
+
+  function settle(promise: Promise<unknown>) {
+    const state: { error?: unknown; settled: boolean } = { settled: false };
+    promise.then(
+      () => Object.assign(state, { settled: true }),
+      (error) => Object.assign(state, { settled: true, error }),
+    );
+    return state;
+  }
+
+  afterEach(() => vi.useRealTimers());
+
+  it("waits 600 s for a reply and 660 s for a connection", () => {
+    expect(transport(false).options).toMatchObject({
+      requestTimeout: 600_000,
+      connectionTimeout: 660_000,
+    });
+  });
+
+  it("gives up on resuming a stored session on page load after 120 s", async () => {
+    vi.useFakeTimers();
+    const pageLoad = settle(transport(true).connect());
+    await vi.advanceTimersByTimeAsync(119_999);
+    expect(pageLoad.settled).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(pageLoad.error).toBeInstanceOf(TransportTimeoutError);
+  });
+
+  it("keeps a connect on a stored session open for 660 s", async () => {
+    vi.useFakeTimers();
+    const connect = settle(transport(true).connect({ scopes: ["eip155:1"], caipAccountIds: [] }));
+    await vi.advanceTimersByTimeAsync(659_999);
+    expect(connect.settled).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connect.error).toBeInstanceOf(TransportTimeoutError);
+  });
+
+  it("keeps a new connect open for 660 s", async () => {
+    vi.useFakeTimers();
+    const connect = settle(transport(false).connect({ scopes: ["eip155:1"], caipAccountIds: [] }));
+    await vi.advanceTimersByTimeAsync(659_999);
+    expect(connect.settled).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connect.error).toBeInstanceOf(TransportTimeoutError);
+  });
+});
+
+const entryId = "mpo-web3-timer-entry";
+const entrySource = 'export { createEVMClient } from "@metamask/connect-evm";';
+
+const entry: Plugin = {
+  name: "entry",
+  enforce: "pre",
+  resolveId: (id) => (id === entryId ? `\0${entryId}` : null),
+  load: (id) => (id === `\0${entryId}` ? entrySource : null),
+};
+
+/** Stands in for a MetaMask Connect release that renamed the marker the patch looks for. */
+const renameGracePeriod: Plugin = {
+  name: "rename-grace-period",
+  enforce: "pre",
+  transform: (code, id) =>
+    id.replace(/\\/g, "/").includes(`/${multichainPkg}/`)
+      ? code.replaceAll("CONNECTION_GRACE_PERIOD", "CONNECTION_GRACE_MS")
+      : null,
+};
+
+function expectLongTimers(code: string) {
+  expect(code).toMatch(/DEFAULT_REQUEST_TIMEOUT[\w$]* = 600 \* 1e3;\s+CONNECTION_GRACE_PERIOD/);
+  expect(code).toMatch(/HANDSHAKE_TIMEOUT[\w$]* = 540 \* 1e3;/);
+  expect(code).toMatch(/resumeTimeout : [\w$]+ \? this\.options\.connectionTimeout : 120 \* 1e3/);
+  expect(code).not.toMatch(/DEFAULT_REQUEST_TIMEOUT[\w$]* = 60 \* 1e3;\s+CONNECTION_GRACE_PERIOD/);
+  expect(code).not.toMatch(/HANDSHAKE_TIMEOUT[\w$]* = 60 \* 1e3;/);
+}
+
+function viteBuild(plugins: Plugin[]) {
+  return build({
+    configFile: false,
+    logLevel: "silent",
+    root: web3Root,
+    publicDir: false,
+    plugins,
+    build: {
+      write: false,
+      minify: false,
+      rolldownOptions: { input: entryId, preserveEntrySignatures: "exports-only" },
+    },
+  }) as Promise<Rolldown.RolldownOutput>;
+}
+
+describe("the bundler plugins", () => {
+  const cacheDirs: string[] = [];
+  afterAll(() => {
+    for (const dir of cacheDirs) rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("ships the long timers in a vite build", async () => {
+    const output = await viteBuild([entry, metaMaskConnectTimeouts()]);
+    expectLongTimers(output.output.map((chunk) => ("code" in chunk ? chunk.code : "")).join("\n"));
+  }, 120_000);
+
+  it("fails a vite build that bundles MetaMask Connect with a marker gone", async () => {
+    await expect(viteBuild([entry, renameGracePeriod, metaMaskConnectTimeouts()])).rejects.toThrow(
+      /left the timers in @metamask\/connect-multichain unpatched/,
+    );
+  }, 120_000);
+
+  async function preBundle(extra: Plugin[]) {
+    const cacheDir = mkdtempSync(join(tmpdir(), "mpo-web3-timers-"));
+    cacheDirs.push(cacheDir);
+    const inline: InlineConfig = {
+      configFile: false,
+      logLevel: "silent",
+      root: web3Root,
+      cacheDir,
+      optimizeDeps: {
+        include: ["@metamask/connect-evm"],
+        noDiscovery: true,
+        rolldownOptions: { plugins: extra },
+      },
+      plugins: [metaMaskConnectTimeouts()],
+    };
+    await optimizeDeps(await resolveConfig(inline, "serve"), true);
+    const deps = join(cacheDir, "deps");
+    return readdirSync(deps)
+      .filter((file) => file.endsWith(".js"))
+      .map((file) => readFileSync(join(deps, file), "utf8"))
+      .join("\n");
+  }
+
+  it("ships the long timers in the dev server's dependency pre-bundle", async () => {
+    expectLongTimers(await preBundle([]));
+  }, 120_000);
+
+  it("fails the dev server's pre-bundle when a marker is gone", async () => {
+    await expect(preBundle([renameGracePeriod])).rejects.toThrow(
+      /left the timers in @metamask\/connect-multichain unpatched/,
+    );
+  }, 120_000);
+
+  async function esbuildBundle(before: EsbuildPlugin[] = []) {
+    const esbuild = await import("esbuild");
+    const result = await esbuild.build({
+      stdin: { contents: entrySource, resolveDir: web3Root },
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "browser",
+      logLevel: "silent",
+      plugins: [...before, metaMaskConnectTimeoutsEsbuild()],
+    });
+    return result.outputFiles.map((file) => file.text).join("\n");
+  }
+
+  it("ships the long timers in an esbuild bundle", async () => {
+    expectLongTimers(await esbuildBundle());
+  }, 120_000);
+
+  it("fails an esbuild bundle when a marker is gone", async () => {
+    const renamed: EsbuildPlugin = {
+      name: "rename-grace-period",
+      setup(build) {
+        build.onLoad(
+          { filter: /[\\/]@metamask[\\/]connect-multichain[\\/].*\.[cm]?js$/ },
+          (args) => ({
+            contents: read(args.path).replaceAll("CONNECTION_GRACE_PERIOD", "CONNECTION_GRACE_MS"),
+            loader: "js",
+          }),
+        );
+      },
+    };
+    await expect(esbuildBundle([renamed])).rejects.toThrow(
+      /left the timers in @metamask\/connect-multichain unpatched/,
+    );
+  }, 120_000);
+});

package/src/bundler/metaMaskConnectTimeouts.ts

@@ -0,0 +1,126 @@
+// MetaMask Connect gives up on the wallet after fixed timers it has no option
+// for: a request's reply after 60 s, and the connect handshake 60 s after its
+// 60 s session request expires. Both are module constants (connect-multichain
+// builds its MWPTransport without options), so the only way to move them is to
+// rewrite the constant in the bundled source. On Android 16 the browser has no
+// network while MetaMask is in front, so the wallet's answer waits in the relay
+// until the user switches back; a user who lingered in MetaMask lost the request
+// to those timers. Both become ten minutes (540 s + the 60 s session expiry).
+//
+// The connection timer is the request timer plus 60 s, so it grows to 660 s with
+// it. That is right for a connect the user is approving in MetaMask, but the same
+// timer bounds resuming a stored session on page load, where nobody is in
+// MetaMask and connector calls wait on the resume. The resume made without
+// connect options (the page-load one) keeps the stock 120 s.
+//
+// A pattern that stops matching fails the build instead of quietly shipping the
+// short timers again.
+
+export type MetaMaskConnectTimerRewrite = {
+  /** The timer, as a build error names it. */
+  timer: string;
+  pattern: RegExp;
+  replacement: string;
+};
+
+export type MetaMaskConnectTimeoutPatch = {
+  pkg: string;
+  marker: string;
+  rewrites: readonly MetaMaskConnectTimerRewrite[];
+};
+
+export const metaMaskConnectTimeoutPatches: readonly MetaMaskConnectTimeoutPatch[] = [
+  {
+    pkg: "@metamask/connect-multichain",
+    marker: "CONNECTION_GRACE_PERIOD",
+    rewrites: [
+      {
+        timer: "DEFAULT_REQUEST_TIMEOUT",
+        pattern: /(DEFAULT_REQUEST_TIMEOUT\d*) = 60 \* 1e3;(\s+CONNECTION_GRACE_PERIOD =)/,
+        replacement: "$1 = 600 * 1e3;$2",
+      },
+      {
+        timer: "the page-load session resume",
+        pattern:
+          /(resumeSession_fn = function\((\w+), (\w+)\)(?:(?!startSession_fn)[\s\S])*?isContinuingPriorAttempt \? this\.options\.resumeTimeout : )this\.options\.connectionTimeout/,
+        replacement: "$1$3 ? this.options.connectionTimeout : 120 * 1e3",
+      },
+    ],
+  },
+  {
+    pkg: "@metamask/mobile-wallet-protocol-dapp-client",
+    marker: "HANDSHAKE_TIMEOUT",
+    rewrites: [
+      {
+        timer: "HANDSHAKE_TIMEOUT",
+        pattern: /(HANDSHAKE_TIMEOUT) = 60 \* 1e3;/,
+        replacement: "$1 = 540 * 1e3;",
+      },
+    ],
+  },
+];
+
+const metaMaskConnectPkg = "@metamask/connect-evm";
+
+const normalize = (id: string) => id.replace(/\\/g, "/");
+
+/** Which timer patch a module needs, or undefined when it carries none. */
+export function metaMaskConnectTimeoutPatchFor(
+  id: string,
+  code: string,
+): MetaMaskConnectTimeoutPatch | undefined {
+  const path = normalize(id);
+  return metaMaskConnectTimeoutPatches.find(
+    (patch) => path.includes(`/${patch.pkg}/`) && code.includes(patch.marker),
+  );
+}
+
+/**
+ * Raise the timers in one module's source. Returns undefined for a module that
+ * holds no timer, and throws when a module holds one the patterns no longer match.
+ */
+export function patchMetaMaskConnectTimeouts(
+  id: string,
+  code: string,
+): { pkg: string; code: string } | undefined {
+  const patch = metaMaskConnectTimeoutPatchFor(id, code);
+  if (!patch) return undefined;
+  let patched = code;
+  for (const rewrite of patch.rewrites) {
+    if (!rewrite.pattern.test(patched))
+      throw new Error(
+        `MetaMask Connect timer ${rewrite.timer} not found in ${id}: ${patch.pkg} changed its source, so the long Android timers cannot be applied`,
+      );
+    patched = patched.replace(rewrite.pattern, rewrite.replacement);
+  }
+  return { pkg: patch.pkg, code: patched };
+}
+
+/**
+ * Counts what one build patched, so the build can refuse to ship MetaMask Connect
+ * with a timer left short (a package renamed the marker the patch looks for).
+ */
+export function createMetaMaskConnectTimeoutTracker() {
+  const patched = new Map<string, number>();
+  let bundlesMetaMaskConnect = false;
+  return {
+    see(id: string) {
+      if (normalize(id).includes(`/${metaMaskConnectPkg}/`)) bundlesMetaMaskConnect = true;
+    },
+    patch(id: string, code: string) {
+      this.see(id);
+      const result = patchMetaMaskConnectTimeouts(id, code);
+      if (result) patched.set(result.pkg, (patched.get(result.pkg) ?? 0) + 1);
+      return result;
+    },
+    /** Error text when the build bundles MetaMask Connect with a timer left unpatched. */
+    problem(): string | undefined {
+      if (!bundlesMetaMaskConnect) return undefined;
+      const missing = metaMaskConnectTimeoutPatches
+        .map((patch) => patch.pkg)
+        .filter((pkg) => !patched.get(pkg));
+      if (!missing.length) return undefined;
+      return `the build bundles ${metaMaskConnectPkg} but left the timers in ${missing.join(", ")} unpatched`;
+    },
+  };
+}

package/src/clients/adapter.ts

@@ -0,0 +1,13 @@
+import type { Ecosystem } from "@multiplatform.one/connectkit";
+import type { WalletAdapter } from "../connectkit/adapters/types";
+
+/** The wallet adapter a non-EVM shim connector carries (see walletAdapterConnector), or null. */
+export function connectorAdapter(
+  connector: unknown,
+  ecosystem?: Exclude<Ecosystem, "evm">,
+): WalletAdapter | null {
+  const c = connector as { adapter?: WalletAdapter; ecosystem?: Ecosystem } | null | undefined;
+  if (!c?.adapter || !c.ecosystem || c.ecosystem === "evm") return null;
+  if (ecosystem && c.ecosystem !== ecosystem) return null;
+  return c.adapter;
+}

package/src/clients/bitcoin.ts

@@ -0,0 +1,42 @@
+import type { WalletAdapter } from "../connectkit/adapters/types";
+import { UnsupportedClientMethodError, type ChainClient, type ClientCapability } from "./types";
+
+type MessageAdapter = Pick<WalletAdapter, "address" | "signMessage">;
+
+const txTodo =
+  "needs PSBT signing through the wallet (Unisat/OKX signPsbt, Phantom's bitcoin signPSBT) and a broadcast endpoint";
+
+/**
+ * Bitcoin client. Message signing only (BIP-322 simple), over the connected
+ * Bitcoin adapter. The transaction methods are the shape the PSBT work will
+ * fill in; until then they reject with UnsupportedClientMethodError.
+ */
+export interface BitcoinClient extends ChainClient<"bitcoin"> {
+  readonly address: string;
+  readonly chainId: "bitcoin";
+  /** BIP-322 simple signature, base64. */
+  signMessage(message: string): Promise<string>;
+  /** Not implemented yet: will take a base64 PSBT and return it signed. */
+  signPsbt(psbt: string): Promise<never>;
+  /** Not implemented yet: will send `satoshis` to `to` and return the txid. */
+  sendBitcoin(to: string, satoshis: bigint): Promise<never>;
+}
+
+const capabilities: readonly ClientCapability[] = ["signMessage"];
+
+export function bitcoinClient(adapter: MessageAdapter): BitcoinClient {
+  if (!adapter.address) throw new Error("bitcoinClient: connect a Bitcoin wallet first");
+  return {
+    family: "bitcoin",
+    address: adapter.address,
+    chainId: "bitcoin",
+    capabilities,
+    signMessage: (message) => adapter.signMessage(message),
+    signPsbt: async () => {
+      throw new UnsupportedClientMethodError("bitcoin", "signPsbt", txTodo);
+    },
+    sendBitcoin: async () => {
+      throw new UnsupportedClientMethodError("bitcoin", "sendBitcoin", txTodo);
+    },
+  };
+}

package/src/clients/connector.spec.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi } from "vitest";
+import { getBase58Decoder } from "@solana/kit";
+import { bitcoinClient } from "./bitcoin";
+import { connectorAdapter } from "./adapter";
+import { clientForConnector } from "./connector";
+import { suiClient } from "./sui";
+import { UnsupportedClientMethodError } from "./types";
+
+const solanaAddress = getBase58Decoder().decode(new Uint8Array(32).fill(7));
+
+const adapter = (address: string | null, signature = "native-signature") => ({
+  address,
+  signMessage: vi.fn(async () => signature),
+});
+
+const shim = (ecosystem: string, a: ReturnType<typeof adapter>) => ({
+  id: `wallet:${ecosystem}`,
+  type: "wallet",
+  ecosystem,
+  adapter: a,
+});
+
+describe("clientForConnector", () => {
+  it("is null for EVM connectors and disconnected wallets", () => {
+    expect(clientForConnector({ id: "metaMask", type: "injected" })).toBeNull();
+    expect(clientForConnector(shim("sui", adapter(null)))).toBeNull();
+    expect(clientForConnector(undefined)).toBeNull();
+  });
+
+  it.each([
+    ["sui", "0xsui", "sui:mainnet"],
+    ["bitcoin", "bc1qexample", "bitcoin"],
+    ["solana", solanaAddress, "solana:mainnet"],
+  ])(
+    "builds the %s client and signs the exact message through its adapter",
+    async (eco, address, chainId) => {
+      const a = adapter(address, eco === "solana" ? "1112" : "native-signature");
+      const client = clientForConnector(shim(eco, a));
+      expect(client?.family).toBe(eco);
+      expect(client?.address).toBe(address);
+      expect(client?.chainId).toBe(chainId);
+      const message = `example.com wants you to sign in with your account:\n${address}\n\nNonce: abc`;
+      const signature = await client?.signMessage(message);
+      expect(a.signMessage).toHaveBeenCalledWith(message);
+      expect(signature).toBe(eco === "solana" ? "1112" : "native-signature");
+    },
+  );
+
+  it("reads the adapter only for the asked ecosystem", () => {
+    const a = adapter("0xsui");
+    expect(connectorAdapter(shim("sui", a), "sui")).toBe(a);
+    expect(connectorAdapter(shim("sui", a), "bitcoin")).toBeNull();
+    expect(connectorAdapter({ ecosystem: "evm", adapter: a })).toBeNull();
+  });
+});
+
+describe("message-only clients", () => {
+  it("Sui signs messages and rejects transactions with a clear TODO", async () => {
+    const client = suiClient(adapter("0xsui"));
+    expect(client.capabilities).toEqual(["signMessage"]);
+    await expect(client.signMessage("m")).resolves.toBe("native-signature");
+    await expect(client.signTransaction({})).rejects.toBeInstanceOf(UnsupportedClientMethodError);
+    await expect(client.signAndExecuteTransaction({})).rejects.toThrow(/@mysten\/sui/);
+  });
+
+  it("Bitcoin signs messages and rejects PSBTs with a clear TODO", async () => {
+    const client = bitcoinClient(adapter("bc1q"));
+    expect(client.capabilities).toEqual(["signMessage"]);
+    await expect(client.signMessage("m")).resolves.toBe("native-signature");
+    await expect(client.signPsbt("cHNidP8=")).rejects.toBeInstanceOf(UnsupportedClientMethodError);
+    await expect(client.sendBitcoin("bc1q", 1n)).rejects.toThrow(/PSBT/);
+  });
+
+  it("refuse a disconnected adapter", () => {
+    expect(() => suiClient(adapter(null))).toThrow(/connect a Sui wallet/);
+    expect(() => bitcoinClient(adapter(null))).toThrow(/connect a Bitcoin wallet/);
+  });
+});

package/src/clients/connector.ts

@@ -0,0 +1,36 @@
+import type { Ecosystem } from "@multiplatform.one/connectkit";
+import { connectorAdapter } from "./adapter";
+import { bitcoinClient, type BitcoinClient } from "./bitcoin";
+import { solanaMessageClient, type SolanaChain, type SolanaMessageClient } from "./solanaMessage";
+import { suiClient, type SuiClient } from "./sui";
+
+type NonEvm = Exclude<Ecosystem, "evm">;
+
+export interface ConnectorClientOptions {
+  solanaChain?: SolanaChain;
+}
+
+export type NonEvmClient = SolanaMessageClient | SuiClient | BitcoinClient;
+
+/**
+ * The signing client for a connected non-EVM wallet, built over the adapter
+ * its shim connector carries. Sign-in uses it, so it stays free of
+ * @solana/kit. Null for an EVM connector or one that is not connected.
+ */
+export function clientForConnector(
+  connector: unknown,
+  options: ConnectorClientOptions = {},
+): NonEvmClient | null {
+  const adapter = connectorAdapter(connector);
+  if (!adapter?.address) return null;
+  switch ((connector as { ecosystem: NonEvm }).ecosystem) {
+    case "solana":
+      return solanaMessageClient(adapter, options.solanaChain);
+    case "sui":
+      return suiClient(adapter);
+    case "bitcoin":
+      return bitcoinClient(adapter);
+    default:
+      return null;
+  }
+}