@multiplatform.one/web3 7.26.0 → 7.28.0

package/src/keycloak/useWalletLogin.ts

@@ -3,6 +3,8 @@ import { useCallback, useContext, useEffect, useRef } from "react";
 import { useAccount } from "wagmi";
 import { useConnectorLauncher } from "../connectkit/openConnector";
 import { SIWEContext, StatusState } from "../connectkit/siwe/SIWEContext";
+import { useOptionalConnection } from "../core/react";
+import { useOptionalSignIn } from "../core/signIn";
 import { hasUserActivation, isMobileBrowser } from "./device";
 
 export interface UseWalletLoginOptions {
@@ -13,7 +15,10 @@ export interface UseWalletLoginOptions {
 }
 
 export interface UseWalletLoginResult {
-  /** Connect if needed, then sign through SIWEProvider. One press, no Continue step. */
+  /**
+   * Connect if needed, then sign through the SignInProvider (or a deprecated
+   * SIWEProvider). One press, no Continue step.
+   */
   login(): Promise<void>;
   status: StatusState;
   isConnected: boolean;
@@ -50,25 +55,37 @@ function writeIntent(key: string, value: string | null) {
  * Only a fresh mark drives it, so a wallet that reconnects on a later visit
  * never signs unasked. A phone browser opens the wallet for a signature only
  * from a tap, so without one the user presses again.
+ *
+ * Under a SignInProvider it runs on the connection store: connected means the
+ * store holds a connection, of any family, and that connection signs. Under
+ * only a SIWEProvider it reads wagmi's account, as before.
  */
 export function useWalletLogin(opts: UseWalletLoginOptions = {}): UseWalletLoginResult {
   const { intentKey = "mpo:wallet-login-intent", intentTtlMs = 90_000 } = opts;
+  const signIn = useOptionalSignIn();
   const siwe = useContext(SIWEContext);
   const { setOpen } = useModal();
   const launcher = useConnectorLauncher();
-  const { address, isConnected } = useAccount();
+  const wagmiAccount = useAccount();
+  const connection = useOptionalConnection();
+  const onStore = signIn !== null && connection !== null;
+  const isConnected = onStore ? connection.status === "connected" : wagmiAccount.isConnected;
+  const address = onStore ? (connection.address ?? undefined) : wagmiAccount.address;
   const signingRef = useRef(false);
 
   const sign = useCallback(async () => {
-    if (!siwe) throw new Error("useWalletLogin must be used inside a SIWEProvider");
+    const signer = signIn ?? siwe;
+    if (!signer) {
+      throw new Error("useWalletLogin must be used inside a SignInProvider or SIWEProvider");
+    }
     if (signingRef.current) return;
     signingRef.current = true;
     try {
-      await siwe.signIn();
+      await signer.signIn();
     } finally {
       signingRef.current = false;
     }
-  }, [siwe]);
+  }, [signIn, siwe]);
 
   const login = useCallback(async () => {
     if (isConnected) {
@@ -92,7 +109,8 @@ export function useWalletLogin(opts: UseWalletLoginOptions = {}): UseWalletLogin
 
   return {
     login,
-    status: siwe?.status ?? StatusState.ERROR,
+    // SignInStatus holds StatusState's values, string for string.
+    status: signIn ? (signIn.status as StatusState) : (siwe?.status ?? StatusState.ERROR),
     isConnected,
     address,
   };

package/src/light/drivers.spec.ts

@@ -0,0 +1,330 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { bitcoinDriver, solanaDriver, suiDriver } from "./drivers";
+
+type Listener = (...args: unknown[]) => void;
+
+function events() {
+  const map = new Map<string, Set<Listener>>();
+  return {
+    on(event: string, listener: Listener) {
+      let set = map.get(event);
+      if (!set) {
+        set = new Set();
+        map.set(event, set);
+      }
+      set.add(listener);
+    },
+    off(event: string, listener: Listener) {
+      map.get(event)?.delete(listener);
+    },
+    emit(event: string, ...args: unknown[]) {
+      for (const listener of map.get(event) ?? []) listener(...args);
+    },
+    count: (event: string) => map.get(event)?.size ?? 0,
+  };
+}
+
+const key = (value: string) => ({ toString: () => value });
+const globals: string[] = [];
+const install = (name: string, value: unknown) => {
+  globals.push(name);
+  (window as unknown as Record<string, unknown>)[name] = value;
+};
+
+afterEach(() => {
+  for (const name of globals.splice(0)) Reflect.deleteProperty(window, name);
+});
+
+function phantom(address = "7EcDhSYGxXyscszYEp35KHN8vvw3svAuLKTzXwCFLtV") {
+  const bus = events();
+  const provider = {
+    isPhantom: true,
+    trusted: false,
+    publicKey: null as ReturnType<typeof key> | null,
+    prompts: 0,
+    connect: vi.fn(async (options?: { onlyIfTrusted?: boolean }) => {
+      if (options?.onlyIfTrusted) {
+        if (!provider.trusted)
+          throw Object.assign(new Error("User rejected the request."), { code: 4001 });
+      } else provider.prompts++;
+      provider.trusted = true;
+      provider.publicKey = key(address);
+      return { publicKey: provider.publicKey };
+    }),
+    disconnect: vi.fn(async () => {
+      provider.publicKey = null;
+      bus.emit("disconnect");
+    }),
+    signMessage: vi.fn(async () => ({ signature: new Uint8Array([0, 0, 1, 2, 3]) })),
+    on: bus.on,
+    off: bus.off,
+    emit: bus.emit,
+    count: bus.count,
+  };
+  install("phantom", { solana: provider });
+  return provider;
+}
+
+describe("solanaDriver", () => {
+  it("lists the injected Solana wallet and connects it on the mainnet chain", async () => {
+    const provider = phantom();
+    const driver = solanaDriver();
+    expect(driver.connectors()).toEqual([{ id: "wallet:solana:phantom", name: "Phantom" }]);
+    expect(await driver.connect("wallet:solana:phantom")).toEqual({
+      address: "7EcDhSYGxXyscszYEp35KHN8vvw3svAuLKTzXwCFLtV",
+      chainId: "solana:mainnet",
+    });
+    expect(provider.prompts).toBe(1);
+    const client = await driver.client?.(driver.getState());
+    expect(client).toMatchObject({ family: "solana", chainId: "solana:mainnet" });
+    expect(await client?.signMessage("hi")).toBe("11Ldp");
+  });
+
+  it("names the cluster it was given", async () => {
+    phantom();
+    const driver = solanaDriver({ chain: "solana:devnet" });
+    expect((await driver.connect("wallet:solana:phantom")).chainId).toBe("solana:devnet");
+  });
+
+  it("restores a trusting wallet silently after a reload, and resolves null otherwise", async () => {
+    const provider = phantom();
+    expect(await solanaDriver().reconnect("wallet:solana:phantom")).toBeNull();
+    provider.trusted = true;
+    const account = await solanaDriver().reconnect("wallet:solana:phantom");
+    expect(account?.address).toBe("7EcDhSYGxXyscszYEp35KHN8vvw3svAuLKTzXwCFLtV");
+    expect(provider.connect).toHaveBeenLastCalledWith({ onlyIfTrusted: true });
+    expect(provider.prompts).toBe(0);
+  });
+
+  it("rejects a restore the wallet fails for another reason, so the store keeps it", async () => {
+    const provider = phantom();
+    provider.connect.mockRejectedValueOnce(
+      Object.assign(new Error("Unexpected error"), { code: -32603 }),
+    );
+    await expect(solanaDriver().reconnect("wallet:solana:phantom")).rejects.toThrow(/Unexpected/);
+  });
+
+  it("rejects a restore while the wallet has not injected itself yet", async () => {
+    await expect(solanaDriver().reconnect("wallet:solana:phantom")).rejects.toThrow();
+  });
+
+  it("follows the wallet's account switches and disconnects, and stops listening after", async () => {
+    const provider = phantom();
+    const driver = solanaDriver();
+    await driver.connect("wallet:solana:phantom");
+    provider.emit("accountChanged", key("9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin"));
+    expect(driver.getState().account?.address).toBe("9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin");
+    provider.emit("accountChanged", null);
+    expect(driver.getState()).toMatchObject({ status: "disconnected", account: null });
+    expect(provider.count("accountChanged")).toBe(0);
+    await driver.connect("wallet:solana:phantom");
+    provider.emit("disconnect");
+    expect(driver.getState().account).toBeNull();
+    expect(provider.count("disconnect")).toBe(0);
+  });
+});
+
+function suiWallet(address = "0x5a1d3c0f") {
+  const bus = events();
+  const wallet = {
+    name: "Slush",
+    accounts: [] as { address: string }[],
+    trusted: false,
+    prompts: 0,
+    features: {
+      "standard:connect": {
+        connect: vi.fn(async (input?: { silent?: boolean }) => {
+          if (input?.silent && !wallet.trusted) return { accounts: [] };
+          if (!input?.silent) wallet.prompts++;
+          wallet.trusted = true;
+          wallet.accounts = [{ address }];
+          return { accounts: wallet.accounts };
+        }),
+      },
+      "standard:disconnect": { disconnect: vi.fn(async () => {}) },
+      "standard:events": {
+        on: (event: string, listener: Listener) => {
+          bus.on(event, listener);
+          return () => bus.off(event, listener);
+        },
+      },
+      "sui:signPersonalMessage": {
+        signPersonalMessage: vi.fn(async () => ({ signature: "c3VpLXNpZw==", bytes: "" })),
+      },
+    },
+    emit: bus.emit,
+    count: bus.count,
+  };
+  return wallet;
+}
+
+function registerSui(wallet: ReturnType<typeof suiWallet>) {
+  const onReady = (event: Event) => {
+    (event as CustomEvent<{ register(wallet: unknown): void }>).detail.register(wallet);
+  };
+  window.addEventListener("wallet-standard:app-ready", onReady);
+  return () => window.removeEventListener("wallet-standard:app-ready", onReady);
+}
+
+describe("suiDriver", () => {
+  it("lists the Wallet Standard Sui wallet, connects it and signs", async () => {
+    const wallet = suiWallet();
+    const unregister = registerSui(wallet);
+    const driver = suiDriver();
+    expect(driver.connectors()).toEqual([{ id: "wallet:sui", name: "Slush" }]);
+    expect(await driver.connect("wallet:sui")).toEqual({
+      address: "0x5a1d3c0f",
+      chainId: "sui:mainnet",
+    });
+    const client = await driver.client?.(driver.getState());
+    expect(await client?.signMessage("hi")).toBe("c3VpLXNpZw==");
+    unregister();
+  });
+
+  it("restores silently only for a wallet that still trusts the page", async () => {
+    const wallet = suiWallet();
+    const unregister = registerSui(wallet);
+    expect(await suiDriver().reconnect("wallet:sui")).toBeNull();
+    wallet.trusted = true;
+    expect((await suiDriver().reconnect("wallet:sui"))?.address).toBe("0x5a1d3c0f");
+    expect(wallet.prompts).toBe(0);
+    unregister();
+  });
+
+  it("resolves null for a silent connect the wallet refuses, and rejects any other failure", async () => {
+    const wallet = suiWallet();
+    const unregister = registerSui(wallet);
+    const connect = wallet.features["standard:connect"].connect;
+    connect.mockRejectedValueOnce(Object.assign(new Error("User rejected"), { code: 4001 }));
+    expect(await suiDriver().reconnect("wallet:sui")).toBeNull();
+    connect.mockRejectedValueOnce(new Error("wallet crashed"));
+    await expect(suiDriver().reconnect("wallet:sui")).rejects.toThrow(/crashed/);
+    unregister();
+  });
+
+  it("follows the wallet's change events", async () => {
+    const wallet = suiWallet();
+    const unregister = registerSui(wallet);
+    const driver = suiDriver();
+    await driver.connect("wallet:sui");
+    wallet.emit("change", { chains: ["sui:testnet"] });
+    expect(driver.getState().account?.address).toBe("0x5a1d3c0f");
+    wallet.emit("change", { accounts: [{ address: "0x77" }] });
+    expect(driver.getState().account?.address).toBe("0x77");
+    wallet.emit("change", { accounts: [] });
+    expect(driver.getState()).toMatchObject({ status: "disconnected", account: null });
+    expect(wallet.count("change")).toBe(0);
+    unregister();
+  });
+
+  it("hears a wallet that registers late, in the order registerWallet runs", async () => {
+    const driver = suiDriver();
+    const seen: number[] = [];
+    const unwatch = driver.watchConnectors?.(() => seen.push(driver.connectors().length));
+    expect(driver.connectors()).toEqual([]);
+    const wallet = suiWallet();
+    window.dispatchEvent(new CustomEvent("wallet-standard:register-wallet", { detail: () => {} }));
+    const unregister = registerSui(wallet);
+    await Promise.resolve();
+    expect(seen).toEqual([1]);
+    expect(driver.connectors()).toEqual([{ id: "wallet:sui", name: "Slush" }]);
+    unwatch?.();
+    window.dispatchEvent(new CustomEvent("wallet-standard:register-wallet", { detail: () => {} }));
+    await Promise.resolve();
+    expect(seen).toEqual([1]);
+    unregister();
+  });
+});
+
+function unisat(address = "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq") {
+  const bus = events();
+  const provider = {
+    trusted: false,
+    prompts: 0,
+    requestAccounts: vi.fn(async () => {
+      provider.prompts++;
+      provider.trusted = true;
+      return [address];
+    }),
+    getAccounts: vi.fn(async () => (provider.trusted ? [address] : [])),
+    signMessage: vi.fn(async () => "YmlwMzIy"),
+    on: bus.on,
+    removeListener: bus.off,
+    emit: bus.emit,
+    count: bus.count,
+  };
+  install("unisat", provider);
+  return provider;
+}
+
+describe("bitcoinDriver", () => {
+  it("lists UniSat, connects it and signs BIP-322", async () => {
+    unisat();
+    const driver = bitcoinDriver();
+    expect(driver.connectors()).toEqual([{ id: "wallet:bitcoin:unisat", name: "UniSat" }]);
+    expect(await driver.connect("wallet:bitcoin:unisat")).toEqual({
+      address: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
+      chainId: "bitcoin",
+    });
+    const client = await driver.client?.(driver.getState());
+    expect(await client?.signMessage("hi")).toBe("YmlwMzIy");
+  });
+
+  it("restores UniSat through getAccounts without prompting", async () => {
+    const provider = unisat();
+    expect(await bitcoinDriver().reconnect("wallet:bitcoin:unisat")).toBeNull();
+    provider.trusted = true;
+    expect((await bitcoinDriver().reconnect("wallet:bitcoin:unisat"))?.address).toBe(
+      "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
+    );
+    expect(provider.prompts).toBe(0);
+  });
+
+  it("cannot restore Phantom's Bitcoin wallet silently, so it resolves null", async () => {
+    install("phantom", {
+      bitcoin: { requestAccounts: vi.fn(), signMessage: vi.fn() },
+    });
+    expect(await bitcoinDriver().reconnect("wallet:bitcoin:phantom")).toBeNull();
+  });
+
+  it("follows Phantom's Bitcoin account switches, keeping the payment account", async () => {
+    const bus = events();
+    const accounts = [
+      {
+        address: "bc1p5d7rjq7g6rdk2yhzks9smlaqtedr4dekq08ge8ztwac72sfr9rusxg3297",
+        purpose: "ordinals",
+      },
+      { address: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq", purpose: "payment" },
+    ];
+    install("phantom", {
+      bitcoin: {
+        requestAccounts: vi.fn(async () => accounts),
+        signMessage: vi.fn(),
+        on: bus.on,
+        off: bus.off,
+      },
+    });
+    const driver = bitcoinDriver();
+    await driver.connect("wallet:bitcoin:phantom");
+    expect(driver.getState().account?.address).toBe("bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq");
+    bus.emit("accountsChanged", [
+      { address: "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh", purpose: "payment" },
+    ]);
+    expect(driver.getState().account?.address).toBe("bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh");
+    bus.emit("accountsChanged", []);
+    expect(driver.getState().account).toBeNull();
+    expect(bus.count("accountsChanged")).toBe(0);
+  });
+
+  it("follows UniSat's account switches", async () => {
+    const provider = unisat();
+    const driver = bitcoinDriver();
+    await driver.connect("wallet:bitcoin:unisat");
+    provider.emit("accountsChanged", ["bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh"]);
+    expect(driver.getState().account?.address).toBe("bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh");
+    provider.emit("accountsChanged", []);
+    expect(driver.getState().account).toBeNull();
+    expect(provider.count("accountsChanged")).toBe(0);
+  });
+});

package/src/light/drivers.ts

@@ -0,0 +1,54 @@
+import { bitcoinClient } from "../clients/bitcoin";
+import { solanaMessageClient, type SolanaChain } from "../clients/solanaMessage";
+import { suiClient } from "../clients/sui";
+import { discoverWallets, type WalletEcosystem } from "../connectkit/adapters/discover";
+import { lightDriver, type LightWallet } from "../core/lightDriver";
+import type { ConnectionDriver } from "../core/types";
+
+const walletsFor = (ecosystem: WalletEcosystem) => (): LightWallet[] =>
+  discoverWallets()
+    .filter((entry) => entry.ecosystem === ecosystem)
+    .map(({ id, name, adapter }) => ({ id, name, adapter }));
+
+export interface SolanaDriverOptions {
+  /** The cluster accounts are on. Defaults to `solana:mainnet`. */
+  chain?: SolanaChain;
+}
+
+/** The injected Solana wallet (Phantom, or any `window.solana`) on the light driver. */
+export function solanaDriver(options: SolanaDriverOptions = {}): ConnectionDriver {
+  const chain = options.chain ?? "solana:mainnet";
+  return lightDriver({
+    wallets: walletsFor("solana"),
+    chainId: chain,
+    client: (wallet) => solanaMessageClient(wallet.adapter, chain),
+  });
+}
+
+/** The first Wallet Standard Sui wallet on the light driver. Hears wallets that register late. */
+export function suiDriver(): ConnectionDriver {
+  return lightDriver({
+    wallets: walletsFor("sui"),
+    watchWallets(listener) {
+      if (typeof window === "undefined" || typeof window.addEventListener !== "function") {
+        return () => {};
+      }
+      // registerWallet dispatches this before it listens for app-ready, so a
+      // list read inside the event would miss the wallet; read it just after.
+      const announced = () => queueMicrotask(listener);
+      window.addEventListener("wallet-standard:register-wallet", announced);
+      return () => window.removeEventListener("wallet-standard:register-wallet", announced);
+    },
+    chainId: "sui:mainnet",
+    client: (wallet) => suiClient(wallet.adapter),
+  });
+}
+
+/** The injected Bitcoin wallet (UniSat, OKX or Phantom) on the light driver. */
+export function bitcoinDriver(): ConnectionDriver {
+  return lightDriver({
+    wallets: walletsFor("bitcoin"),
+    chainId: "bitcoin",
+    client: (wallet) => bitcoinClient(wallet.adapter),
+  });
+}

package/src/light/index.ts

@@ -0,0 +1 @@
+export { bitcoinDriver, solanaDriver, suiDriver, type SolanaDriverOptions } from "./drivers";

package/src/light/native.spec.ts

@@ -0,0 +1,22 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { bitcoinDriver, solanaDriver, suiDriver } from "./drivers";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("the light drivers on React Native", () => {
+  it("list nothing and watch nothing where window has no DOM events", () => {
+    vi.stubGlobal("window", {});
+    for (const driver of [solanaDriver(), suiDriver(), bitcoinDriver()]) {
+      expect(driver.connectors()).toEqual([]);
+      const unwatch = driver.watchConnectors?.(() => {});
+      unwatch?.();
+    }
+  });
+
+  it("list nothing where there is no window at all", () => {
+    expect(solanaDriver().connectors()).toEqual([]);
+    expect(suiDriver().connectors()).toEqual([]);
+  });
+});