@multiplatform.one/web3 7.36.0 → 7.38.0

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

@@ -0,0 +1,206 @@
+import { IDBFactory } from "fake-indexeddb";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  metaMaskConnectKV,
+  multichainBrowserBuild,
+  SessionStore,
+  storedSession,
+} from "../../../tests/fixtures/metaMaskConnectStore";
+import {
+  forgetStoredSessions,
+  MetaMaskSessionLostError,
+  metaMaskConnectSessionStore,
+  type PageLike,
+  type RestoredSessionTimeout,
+  untilSilent,
+} from "./restoredSession";
+
+const timeout: RestoredSessionTimeout = { afterReturnMs: 20_000, withoutTripMs: 45_000 };
+
+function page(): PageLike & { show(state: "hidden" | "visible"): void } {
+  const listeners = new Set<() => void>();
+  const p = {
+    visibilityState: "visible",
+    addEventListener: (_: "visibilitychange", listener: () => void) => void listeners.add(listener),
+    removeEventListener: (_: "visibilitychange", listener: () => void) =>
+      void listeners.delete(listener),
+    show(state: "hidden" | "visible") {
+      p.visibilityState = state;
+      for (const listener of [...listeners]) listener();
+    },
+  };
+  return p;
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+function track<T>(promise: Promise<T>) {
+  const state: { value?: T; error?: unknown; settled: boolean } = { settled: false };
+  promise.then(
+    (value) => Object.assign(state, { value, settled: true }),
+    (error: unknown) => Object.assign(state, { error, settled: true }),
+  );
+  return state;
+}
+
+describe("untilSilent", () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  it("drops the session once the page has been back from MetaMask for afterReturnMs with no answer", async () => {
+    const tab = page();
+    const drop = vi.fn(async () => undefined);
+    const result = track(untilSilent(deferred().promise, timeout, drop, tab));
+
+    tab.show("hidden");
+    await vi.advanceTimersByTimeAsync(120_000);
+    tab.show("visible");
+    await vi.advanceTimersByTimeAsync(timeout.afterReturnMs - 1);
+    expect(drop).not.toHaveBeenCalled();
+    expect(result.settled).toBe(false);
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(drop).toHaveBeenCalledOnce();
+    expect(result.error).toBeInstanceOf(MetaMaskSessionLostError);
+    expect(result.error).toMatchObject({ code: 4900 });
+  });
+
+  it("drops it after withoutTripMs when the page never left for MetaMask", async () => {
+    const drop = vi.fn(async () => undefined);
+    const result = track(untilSilent(deferred().promise, timeout, drop, page()));
+
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs - 1);
+    expect(drop).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(drop).toHaveBeenCalledOnce();
+    expect(result.error).toBeInstanceOf(MetaMaskSessionLostError);
+  });
+
+  it("restarts the wait when the user goes back to MetaMask", async () => {
+    const tab = page();
+    const drop = vi.fn(async () => undefined);
+    untilSilent(deferred().promise, timeout, drop, tab).catch(() => undefined);
+
+    tab.show("hidden");
+    tab.show("visible");
+    await vi.advanceTimersByTimeAsync(timeout.afterReturnMs - 5_000);
+    tab.show("hidden");
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(drop).not.toHaveBeenCalled();
+    tab.show("visible");
+    await vi.advanceTimersByTimeAsync(timeout.afterReturnMs - 1);
+    expect(drop).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(drop).toHaveBeenCalledOnce();
+  });
+
+  it("passes the wallet's answer through and drops nothing", async () => {
+    const tab = page();
+    const answer = deferred<string>();
+    const drop = vi.fn(async () => undefined);
+    const result = track(untilSilent(answer.promise, timeout, drop, tab));
+
+    tab.show("hidden");
+    tab.show("visible");
+    answer.resolve("0x5167");
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs * 2);
+    expect(result.value).toBe("0x5167");
+    expect(drop).not.toHaveBeenCalled();
+  });
+
+  it("passes the wallet's rejection through", async () => {
+    const answer = deferred<string>();
+    const result = track(untilSilent(answer.promise, timeout, vi.fn(), page()));
+    const rejected = Object.assign(new Error("User rejected the request."), { code: 4001 });
+    answer.reject(rejected);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(result.error).toBe(rejected);
+  });
+
+  it("still rejects when dropping the session fails", async () => {
+    const drop = vi.fn(async () => {
+      throw new Error("relay gone");
+    });
+    const result = track(untilSilent(deferred().promise, timeout, drop, page()));
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs);
+    expect(result.error).toBeInstanceOf(MetaMaskSessionLostError);
+  });
+
+  it("with no document, waits withoutTripMs", async () => {
+    const drop = vi.fn(async () => undefined);
+    const result = track(untilSilent(deferred().promise, timeout, drop));
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs);
+    expect(result.error).toBeInstanceOf(MetaMaskSessionLostError);
+  });
+});
+
+describe("forgetStoredSessions", () => {
+  it("deletes every session MetaMask Connect could resume, and nothing else it stored", async () => {
+    const idb = new IDBFactory();
+    const kv = metaMaskConnectKV(idb);
+    const sessions = await SessionStore.create(kv);
+    await sessions.set(storedSession("stale"));
+    await sessions.set(storedSession("older"));
+    await kv.set("multichain-transport", "mwp");
+    await kv.set("cache_eth_accounts", '["0xaa"]');
+    expect((await sessions.list()).map((s) => s.id)).toEqual(["stale", "older"]);
+
+    await forgetStoredSessions(idb);
+
+    expect(await (await SessionStore.create(kv)).list()).toEqual([]);
+    expect(await kv.get("session:stale")).toBeNull();
+    expect(await kv.get("multichain-transport")).toBe("mwp");
+    expect(await kv.get("cache_eth_accounts")).toBe('["0xaa"]');
+    await kv.close();
+  });
+
+  it("creates no database where MetaMask Connect has none", async () => {
+    const idb = new IDBFactory();
+    await forgetStoredSessions(idb);
+    expect(await idb.databases()).toEqual([]);
+  });
+
+  it("settles when IndexedDB fails inside its callbacks", async () => {
+    const open: { result?: unknown; onsuccess?: () => void } = {};
+    const idb = { open: () => open } as unknown as IDBFactory;
+    const forgotten = forgetStoredSessions(idb);
+    open.result = {
+      objectStoreNames: {
+        contains() {
+          throw new Error("InvalidStateError");
+        },
+      },
+      close: () => undefined,
+    };
+    open.onsuccess?.();
+    await expect(forgotten).resolves.toBeUndefined();
+  });
+
+  it("does nothing without IndexedDB", async () => {
+    await expect(forgetStoredSessions(undefined)).resolves.toBeUndefined();
+  });
+
+  it("names the store the installed MetaMask Connect keeps and resumes its sessions from", () => {
+    // StoreAdapterWeb opens `${DB_NAME}${dbNameSuffix}` and uses stores[0].
+    const build = multichainBrowserBuild();
+    expect(build).toContain('_StoreAdapterWeb.DB_NAME = "mmconnect";');
+    expect(build).toContain(
+      'constructor(dbNameSuffix = "-kv-store", storeName = _StoreAdapterWeb.stores[0])',
+    );
+    expect(build).toContain(`_StoreAdapterWeb.stores = ["${metaMaskConnectSessionStore.store}"`);
+    expect(build).toContain("const adapter = new StoreAdapterWeb2();");
+    expect(metaMaskConnectSessionStore.database).toBe("mmconnect-kv-store");
+    // MWPTransport.connect resumes the first session SessionStore lists there.
+    expect(build).toContain("const session = yield this.getActiveSession();");
+    expect(build).toContain("const sessionStore = yield SessionStore.create(kvstore);");
+    expect(build).toContain("const [activeSession] = yield sessionStore.list();");
+  });
+});

package/src/connectkit/connectors/restoredSession.ts

@@ -0,0 +1,165 @@
+// MetaMask forgets a connection on "Disconnect all" (or a reinstall) and tells
+// the page nothing: no message reaches the session's relay channel. The page
+// resumes the session it stored, sends each request on a channel no wallet
+// reads, and deeplinks a session id MetaMask answers with "Connection Not
+// Found". The request then waits out the relay timer, ten minutes with
+// metaMaskConnectTimeouts. A connect is no way out either: MetaMask Connect
+// resumes any stored session and answers it from its cache (FZ-7655).
+
+export type RestoredSessionTimeout = {
+  /** How long the page may be back in front after a trip to MetaMask with no answer. */
+  afterReturnMs: number;
+  /** How long a request may go unanswered when the page never left for MetaMask. */
+  withoutTripMs: number;
+};
+
+export const defaultRestoredSessionTimeout: RestoredSessionTimeout = {
+  afterReturnMs: 20_000,
+  withoutTripMs: 45_000,
+};
+
+/**
+ * The request a dropped session failed. viem reports it to callers as
+ * ProviderDisconnectedError (4900), with this as its `cause`.
+ */
+export class MetaMaskSessionLostError extends Error {
+  /** EIP-1193 "Disconnected". */
+  readonly code = 4900;
+  constructor() {
+    super(
+      "MetaMask never answered on the stored connection, so it was dropped. Connect your wallet again.",
+    );
+    this.name = "MetaMaskSessionLostError";
+  }
+}
+
+// Where MetaMask Connect keeps its Mobile Wallet Protocol sessions: the IndexedDB
+// store of @metamask/connect-multichain's StoreAdapterWeb, under the keys of
+// @metamask/mobile-wallet-protocol-core's SessionStore. A connect resumes the
+// first session listed there.
+export const metaMaskConnectSessionStore = {
+  database: "mmconnect-kv-store",
+  store: "sdk-kv-store",
+  sessionsKey: "sessions:master-list",
+  sessionKey: (id: string) => `session:${id}`,
+};
+
+/**
+ * Deletes every Mobile Wallet Protocol session MetaMask Connect stored, so no
+ * connect can resume one. MetaMask Connect's own disconnect deletes the session
+ * only once it has closed the relay socket. Never rejects; with no IndexedDB, or
+ * nothing stored, there is nothing to do.
+ */
+export function forgetStoredSessions(
+  idb: IDBFactory | undefined = (globalThis as { indexedDB?: IDBFactory }).indexedDB,
+): Promise<void> {
+  const { database, store, sessionsKey, sessionKey } = metaMaskConnectSessionStore;
+  return new Promise<void>((resolve) => {
+    let open: IDBOpenDBRequest;
+    try {
+      if (!idb) throw new Error("no IndexedDB");
+      open = idb.open(database);
+    } catch {
+      resolve();
+      return;
+    }
+    // A database MetaMask Connect never created stays uncreated: it creates its
+    // object stores only when it makes the database.
+    open.onupgradeneeded = () => open.transaction?.abort();
+    open.onerror = () => resolve();
+    open.onsuccess = () => {
+      const db = open.result;
+      const done = () => {
+        db.close();
+        resolve();
+      };
+      try {
+        if (!db.objectStoreNames.contains(store)) return done();
+        const tx = db.transaction(store, "readwrite");
+        tx.oncomplete = done;
+        tx.onabort = done;
+        const sessions = tx.objectStore(store);
+        const listed = sessions.get(sessionsKey);
+        listed.onsuccess = () => {
+          try {
+            let ids: unknown;
+            try {
+              ids = JSON.parse(String(listed.result ?? "[]"));
+            } catch {
+              ids = [];
+            }
+            for (const id of Array.isArray(ids) ? ids : [])
+              if (typeof id === "string") sessions.delete(sessionKey(id));
+            sessions.delete(sessionsKey);
+          } catch {
+            done();
+          }
+        };
+      } catch {
+        done();
+      }
+    };
+  });
+}
+
+export interface PageLike {
+  visibilityState: string;
+  addEventListener(type: "visibilitychange", listener: () => void): void;
+  removeEventListener(type: "visibilitychange", listener: () => void): void;
+}
+
+/**
+ * Settles as `request` does unless the wallet stays silent: `timeout.afterReturnMs`
+ * once the page is back from MetaMask (leaving again restarts the wait), or
+ * `timeout.withoutTripMs` when it never left. Then `drop` runs and the promise
+ * rejects with MetaMaskSessionLostError. The page cannot ask the wallet whether
+ * it still holds the session, so a live one whose user comes back before
+ * approving, or whose relay takes longer than afterReturnMs to reconnect, is
+ * dropped too and costs a fresh connect.
+ */
+export function untilSilent<T>(
+  request: Promise<T>,
+  timeout: RestoredSessionTimeout,
+  drop: () => Promise<void>,
+  page: PageLike | undefined = (globalThis as { document?: PageLike }).document,
+): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    let leftPage = page?.visibilityState === "hidden";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const settle = () => {
+      settled = true;
+      clearTimeout(timer);
+      page?.removeEventListener("visibilitychange", arm);
+    };
+    const silent = () => {
+      if (settled) return;
+      settle();
+      void drop()
+        .catch(() => undefined)
+        .then(() => reject(new MetaMaskSessionLostError()));
+    };
+    function arm() {
+      clearTimeout(timer);
+      if (page?.visibilityState === "hidden") {
+        leftPage = true;
+        return;
+      }
+      timer = setTimeout(silent, leftPage ? timeout.afterReturnMs : timeout.withoutTripMs);
+    }
+    page?.addEventListener("visibilitychange", arm);
+    arm();
+    request.then(
+      (value) => {
+        if (settled) return;
+        settle();
+        resolve(value);
+      },
+      (error: unknown) => {
+        if (settled) return;
+        settle();
+        reject(error);
+      },
+    );
+  });
+}

package/src/connectkit/defaultConfig.ts

@@ -5,6 +5,7 @@ import { EthereumProviderOptions as AaveAccountOptions } from "@aave/account";
 
 import { setAppMeta } from "@multiplatform.one/connectkit";
 import defaultConnectors from "./defaultConnectors";
+import type { RestoredSessionTimeout } from "./connectors/restoredSession";
 import { discoverWallets, type WalletEcosystem } from "./adapters/discover";
 import { getWalletConnectors } from "./connectors/getWalletConnectors";
 import { ecosystemBySyntheticChainId, syntheticChains } from "./connectors/syntheticChains";
@@ -26,6 +27,11 @@ type DefaultConfigProps = {
   // Aave Account options
   enableAaveAccount?: boolean;
   aaveAccountOptions?: AaveAccountOptions;
+  /**
+   * On a phone, drop a MetaMask session restored from storage that leaves a
+   * wallet request unanswered this long, so the next connect starts fresh.
+   */
+  metaMaskRestoredSessionTimeout?: RestoredSessionTimeout;
   // wallet: append shim-connectors for any detected non-EVM wallet (Solana/Sui/
   // Bitcoin) alongside the EVM connectors. No-op when none are installed. A list
   // limits it to those ecosystems.
@@ -52,6 +58,7 @@ const defaultConfig = ({
   client,
   enableAaveAccount = false,
   aaveAccountOptions,
+  metaMaskRestoredSessionTimeout,
   enableWallet = true,
   ...props
 }: DefaultConfigProps): CreateConfigParameters => {
@@ -87,6 +94,7 @@ const defaultConfig = ({
       coinbaseWalletPreference,
       enableAaveAccount,
       aaveAccountOptions,
+      metaMaskRestoredSessionTimeout,
     });
 
   // Append wallet shim-connectors for detected non-EVM wallets. discoverWallets()

package/src/connectkit/defaultConnectors.ts

@@ -4,6 +4,7 @@ import { CreateConnectorFn } from "wagmi";
 import type { CoinbaseWalletParameters } from "wagmi/connectors/coinbaseWallet";
 import { safe } from "wagmi/connectors/safe";
 import { metaMaskConnect } from "./connectors/metaMaskConnectConnector";
+import type { RestoredSessionTimeout } from "./connectors/restoredSession";
 import {
   isEmbeddedDesktopWebview,
   metaMaskOptionsForEmbeddedDesktop,
@@ -23,6 +24,7 @@ type DefaultConnectorsProps = {
   coinbaseWalletPreference?: CoinbaseWalletParameters<"4">["preference"];
   enableAaveAccount?: boolean;
   aaveAccountOptions?: AaveAccountOptions;
+  metaMaskRestoredSessionTimeout?: RestoredSessionTimeout;
 };
 
 const defaultConnectors = ({
@@ -30,6 +32,7 @@ const defaultConnectors = ({
   coinbaseWalletPreference,
   enableAaveAccount,
   aaveAccountOptions,
+  metaMaskRestoredSessionTimeout,
 }: DefaultConnectorsProps): CreateConnectorFn[] => {
   const shouldUseSafeConnector = !(typeof window === "undefined") && window?.parent !== window;
 
@@ -58,6 +61,9 @@ const defaultConnectors = ({
         url: app.url,
         iconUrl: app.icon,
       },
+      ...(metaMaskRestoredSessionTimeout
+        ? { restoredSessionTimeout: metaMaskRestoredSessionTimeout }
+        : {}),
       ...(isEmbeddedDesktopWebview() ? metaMaskOptionsForEmbeddedDesktop() : {}),
     }),
     coinbaseWalletConnector({

package/src/connectkit/index.ts

@@ -10,6 +10,11 @@ export {
   reopenMetaMask,
   type MetaMaskConnectParameters,
 } from "./connectors/metaMaskConnectConnector";
+export {
+  defaultRestoredSessionTimeout,
+  MetaMaskSessionLostError,
+  type RestoredSessionTimeout,
+} from "./connectors/restoredSession";
 
 // web3's wrapper (generic connectkit useModal + wallet/SIWE openers) keeps the
 // consumer-facing `useModal` API. The agnostic base lives in ./hooks/useModal.

package/src/keycloak/KeycloakWalletLogin.spec.tsx

@@ -3,7 +3,7 @@ import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/re
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { createConfig, createStorage, http } from "wagmi";
 import { mainnet } from "wagmi/chains";
-import { connect } from "wagmi/actions";
+import { connect, disconnect } from "wagmi/actions";
 import { mock } from "wagmi/connectors";
 import { verifyMessage } from "viem";
 import { resetConnectIntentPage, setConnectIntent } from "../connectkit/siwe/connectIntent";
@@ -205,6 +205,56 @@ describe("KeycloakWalletLogin wallet sign-in", () => {
   });
 });
 
+describe("KeycloakWalletLogin when the wallet connection drops during the signature", () => {
+  it("says so, and the next tap connects afresh to a clean sign-in step", async () => {
+    setUserAgent(ANDROID_UA);
+    setUserActivation(true);
+    let failSign!: (error: Error) => void;
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+        if (String(input).endsWith("/nonce")) return new Response("nonce123abc");
+        const body = String(
+          init?.body ?? (input instanceof Request ? await input.clone().text() : ""),
+        );
+        if (/"method":"(eth_sign|personal_sign)"/.test(body))
+          return new Promise<Response>((_, reject) => (failSign = reject));
+        return new Response("not found", { status: 404 });
+      }),
+    );
+    // A session restored from storage, as on a page MetaMask has since forgotten.
+    const { config, connectSpy, walletButton } = renderLogin({
+      mobile: { preferredConnector: "mock" },
+      wagmiConfig: makeConfig(memoryStorage(), true),
+    });
+    await waitFor(() => expect(config.state.status).toBe("connected"));
+    connectSpy.mockClear();
+
+    fireEvent.click(walletButton);
+    await waitFor(() => expect(walletButton.textContent).toBe("Signing…"));
+    await waitFor(() => expect(failSign).toBeTypeOf("function"));
+
+    // What the MetaMask connector does once MetaMask stays silent: wagmi lets go,
+    // then the signature request fails.
+    await disconnect(config);
+    failSign(Object.assign(new Error("MetaMask never answered"), { code: 4900 }));
+
+    const notice = await screen.findByRole("status");
+    expect(notice.id).toBe("mpo-wallet-login-dropped");
+    expect(notice.textContent).toContain("Tap Sign in with Wallet to connect again");
+    await waitFor(() => expect(walletButton.textContent).toBe("Sign in with Wallet"));
+    expect(walletButton.disabled).toBe(false);
+
+    setUserActivation(false);
+    fireEvent.click(walletButton);
+    await waitFor(() => expect(connectSpy).toHaveBeenCalledTimes(1));
+    expect(document.getElementById("mpo-wallet-login-dropped")).toBeNull();
+    await screen.findByText("Sign In With Wallet");
+    expect(screen.queryByText("Unknown Error")).toBeNull();
+    expect(screen.getByText("Sign In")).not.toBeNull();
+  });
+});
+
 describe("KeycloakWalletLogin target", () => {
   it("{ action } posts the credential to a keycloakify page's login action", async () => {
     const submit = vi

package/src/keycloak/KeycloakWalletLogin.tsx

@@ -4,6 +4,7 @@ import { type CSSProperties, useMemo } from "react";
 import type { Chain } from "viem";
 import { type Config, WagmiProvider, createConfig } from "wagmi";
 import { arbitrum, mainnet, optimism, polygon } from "wagmi/chains";
+import { defaultRestoredSessionTimeout } from "../connectkit/connectors/restoredSession";
 import getDefaultConfig from "../connectkit/defaultConfig";
 import { SIWEProvider } from "../connectkit/siwe";
 import { StatusState } from "../connectkit/siwe/SIWEContext";
@@ -69,6 +70,9 @@ export function createKeycloakWalletConfig({
       // Aave Account signs through an app.family.co iframe, which a Keycloak
       // page's default CSP (frame-src 'self') blocks.
       enableAaveAccount: false,
+      // A login MetaMask forgot ("Disconnect all") would otherwise sit on
+      // "Signing…" for the ten-minute relay timer (FZ-7655).
+      metaMaskRestoredSessionTimeout: defaultRestoredSessionTimeout,
     }),
   );
 }
@@ -88,6 +92,8 @@ const buttonStyle: CSSProperties = {
   background: "#fff",
 };
 
+const noticeStyle: CSSProperties = { margin: "8px 0 0", fontSize: 13 };
+
 /**
  * Wallet and GPG sign-in for a Keycloak login page, on the browser flow: the
  * signed credential posts to the page's authenticator. Carries its own wagmi,
@@ -169,7 +175,7 @@ function LoginButtons({
   className,
   buttonClassName,
 }: KeycloakWalletLoginProps) {
-  const { login, status } = useWalletLogin();
+  const { login, status, dropped } = useWalletLogin();
   const { openGpg } = useWeb3Modal();
   const style = buttonClassName ? undefined : buttonStyle;
   const busy = status === StatusState.LOADING || status === StatusState.SUCCESS;
@@ -189,6 +195,11 @@ function LoginButtons({
         <WalletIcon />
         <span>{busy ? "Signing…" : walletLabel}</span>
       </button>
+      {dropped && !busy && (
+        <p id="mpo-wallet-login-dropped" role="status" style={noticeStyle}>
+          The wallet connection was lost. Tap {walletLabel} to connect again.
+        </p>
+      )}
       {gpg && (
         <button
           type="button"

package/src/keycloak/useWalletLogin.ts

@@ -1,5 +1,5 @@
 import { useModal } from "@multiplatform.one/connectkit";
-import { useCallback, useContext, useEffect, useRef } from "react";
+import { useCallback, useContext, useEffect, useRef, useState } from "react";
 import { useAccount } from "wagmi";
 import { useConnectorLauncher } from "../connectkit/openConnector";
 import { SIWEContext, StatusState } from "../connectkit/siwe/SIWEContext";
@@ -23,6 +23,12 @@ export interface UseWalletLoginResult {
   status: StatusState;
   isConnected: boolean;
   address?: string;
+  /**
+   * The wallet connection went away while a signature waited on it, as when
+   * MetaMask never answered a session it no longer holds. The next `login()`
+   * connects afresh and clears it.
+   */
+  dropped: boolean;
 }
 
 function readIntent(key: string, ttl: number): boolean {
@@ -72,6 +78,7 @@ export function useWalletLogin(opts: UseWalletLoginOptions = {}): UseWalletLogin
   const isConnected = onStore ? connection.status === "connected" : wagmiAccount.isConnected;
   const address = onStore ? (connection.address ?? undefined) : wagmiAccount.address;
   const signingRef = useRef(false);
+  const [dropped, setDropped] = useState(false);
 
   const sign = useCallback(async () => {
     const signer = signIn ?? siwe;
@@ -88,6 +95,10 @@ export function useWalletLogin(opts: UseWalletLoginOptions = {}): UseWalletLogin
   }, [signIn, siwe]);
 
   const login = useCallback(async () => {
+    setDropped(false);
+    // A failed signature leaves SIWE on ERROR, which the sign-in step would
+    // show the next attempt as "Unknown Error".
+    if (!signIn && siwe?.status === StatusState.ERROR) siwe.resetStatus();
     if (isConnected) {
       await sign();
       return;
@@ -96,7 +107,7 @@ export function useWalletLogin(opts: UseWalletLoginOptions = {}): UseWalletLogin
     // No await above: a phone's preferred wallet opens from inside the tap.
     if (launcher?.openPreferredConnector()) return;
     setOpen(true);
-  }, [isConnected, sign, intentKey, setOpen, launcher]);
+  }, [isConnected, sign, intentKey, setOpen, launcher, signIn, siwe]);
 
   useEffect(() => {
     if (!isConnected || !readIntent(intentKey, intentTtlMs)) return;
@@ -107,11 +118,16 @@ export function useWalletLogin(opts: UseWalletLoginOptions = {}): UseWalletLogin
 
   useEffect(() => () => writeIntent(intentKey, null), [intentKey]);
 
+  useEffect(() => {
+    if (!isConnected && signingRef.current) setDropped(true);
+  }, [isConnected]);
+
   return {
     login,
     // SignInStatus holds StatusState's values, string for string.
     status: signIn ? (signIn.status as StatusState) : (siwe?.status ?? StatusState.ERROR),
     isConnected,
     address,
+    dropped,
   };
 }

package/types/connectkit/connectors/metaMaskConnectConnector.d.ts

@@ -1,6 +1,7 @@
 import type { EIP1193Provider } from "@metamask/connect-evm";
 import { type CreateConnectorFn } from "wagmi";
 import { type Chain, type Hex } from "viem";
+import { type RestoredSessionTimeout } from "./restoredSession";
 export type MetaMaskConnectParameters = {
     dapp: {
         name: string;
@@ -26,6 +27,14 @@ export type MetaMaskConnectParameters = {
      * rather than to switch to it. Defaults to `metaMaskMayLackChain`.
      */
     addChainFirst?: (chain: Chain) => boolean;
+    /**
+     * On a phone, give up on a session restored from storage once a wallet
+     * request goes unanswered this long (see restoredSession.ts): the request
+     * fails with MetaMaskSessionLostError, wagmi disconnects, the stored session is
+     * deleted and MetaMask Connect disconnects, so the next connect starts a new
+     * one. Off by default.
+     */
+    restoredSessionTimeout?: RestoredSessionTimeout;
 };
 type ConnectorConfig = Parameters<CreateConnectorFn>[0];
 /**

package/types/connectkit/connectors/metaMaskConnectConnector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metaMaskConnectConnector.d.ts","sourceRoot":"","sources":["../../../src/connectkit/connectors/metaMaskConnectConnector.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAsB,MAAM,uBAAuB,CAAC;AAEjF,OAAO,EAA2B,KAAK,iBAAiB,EAAmB,MAAM,OAAO,CAAC;AACzF,OAAO,EAEL,KAAK,KAAK,EAEV,KAAK,GAAG,EAKT,MAAM,MAAM,CAAC;AAKd,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvD,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mFAAmF;IACnF,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAChE,6EAA6E;IAC7E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;CAC3C,CAAC;AAEF,KAAK,eAAe,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;AAGxD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,UAAU,CAAC,EAAE,eAAe,CAAC,YAAY,CAAC,GACzC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAQrB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,EAC7B,UAAU,CAAC,EAAE,eAAe,CAAC,YAAY,CAAC,GACzC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAOrB;AAsGD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAE1D;AAOD,wGAAwG;AACxG,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAK9F;AAqBD;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAIxC;AAgFD,oFAAoF;AACpF,wBAAgB,0BAA0B,IAAI,IAAI,CAIjD;AAWD,wBAAgB,eAAe,CAAC,UAAU,EAAE,yBAAyB,wFAwJpE;yBAxJe,eAAe"}
+{"version":3,"file":"metaMaskConnectConnector.d.ts","sourceRoot":"","sources":["../../../src/connectkit/connectors/metaMaskConnectConnector.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAsB,MAAM,uBAAuB,CAAC;AAEjF,OAAO,EAA2B,KAAK,iBAAiB,EAAmB,MAAM,OAAO,CAAC;AACzF,OAAO,EAEL,KAAK,KAAK,EAEV,KAAK,GAAG,EAKT,MAAM,MAAM,CAAC;AAGd,OAAO,EAAwB,KAAK,sBAAsB,EAAe,MAAM,mBAAmB,CAAC;AAGnG,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvD,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mFAAmF;IACnF,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAChE,6EAA6E;IAC7E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;IAC1C;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACjD,CAAC;AAEF,KAAK,eAAe,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;AAGxD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,UAAU,CAAC,EAAE,eAAe,CAAC,YAAY,CAAC,GACzC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAQrB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,EAC7B,UAAU,CAAC,EAAE,eAAe,CAAC,YAAY,CAAC,GACzC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAOrB;AAsGD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAE1D;AAOD,wGAAwG;AACxG,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAK9F;AAmGD;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAIxC;AAmFD,oFAAoF;AACpF,wBAAgB,0BAA0B,IAAI,IAAI,CAQjD;AAWD,wBAAgB,eAAe,CAAC,UAAU,EAAE,yBAAyB,wFAsMpE;yBAtMe,eAAe"}