@multiplatform.one/web3 7.36.0 → 7.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/web3",
-  "version": "7.36.0",
+  "version": "7.38.0",
   "description": "Web3 wallet integration for multiplatform.one ecosystem with ConnectKit and wagmi",
   "keywords": [
     "connectkit",
@@ -120,10 +120,10 @@
     "@aave/account": "^0.2.1",
     "@coinbase/wallet-sdk": "^4.4.0",
     "@metamask/connect-evm": "^2.1.1",
-    "@multiplatform.one/connectkit": "^7.36.0",
-    "@multiplatform.one/gpg": "^7.36.0",
-    "@multiplatform.one/platform": "^7.36.0",
-    "@multiplatform.one/theme": "^7.36.0",
+    "@multiplatform.one/connectkit": "^7.38.0",
+    "@multiplatform.one/gpg": "^7.38.0",
+    "@multiplatform.one/platform": "^7.38.0",
+    "@multiplatform.one/theme": "^7.38.0",
     "@noble/ciphers": "^1.3.0",
     "@noble/curves": "^1.9.7",
     "@solana/kit": "^8.5.0",
@@ -146,7 +146,7 @@
     "wagmi": "^3.7.1"
   },
   "devDependencies": {
-    "@multiplatform.one/config": "7.36.0",
+    "@multiplatform.one/config": "7.38.0",
     "@tamagui/build": "2.7.6",
     "@tanstack/react-query": "^5.104.3",
     "@testing-library/jest-dom": "^7.0.1",

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

@@ -3,9 +3,16 @@ import type { Chain } from "viem";
 import { getAddress, SwitchChainError, UserRejectedRequestError } from "viem";
 import { base, baseSepolia, bscTestnet, mainnet, polygon, polygonAmoy, sepolia } from "viem/chains";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { IDBFactory } from "fake-indexeddb";
 import { createConfig, http } from "wagmi";
 import { connect, reconnect, sendTransaction, signMessage, signTypedData } from "wagmi/actions";
 
+import {
+  metaMaskConnectKV,
+  SessionStore,
+  storedSession,
+} from "../../../tests/fixtures/metaMaskConnectStore";
+
 import {
   metaMaskConnect,
   metaMaskConnectChainIds,
@@ -666,6 +673,315 @@ describe("metaMaskConnect switchChain on a phone", () => {
   });
 });
 
+describe("metaMaskConnect on a session MetaMask no longer holds", () => {
+  const account = "0x00000000000000000000000000000000000000aa";
+  const timeout = { afterReturnMs: 20_000, withoutTripMs: 45_000 };
+  const listeners = new Set<() => void>();
+  const tab = {
+    visibilityState: "visible",
+    addEventListener: (_: string, listener: () => void) => void listeners.add(listener),
+    removeEventListener: (_: string, listener: () => void) => void listeners.delete(listener),
+  };
+  const show = (state: "hidden" | "visible") => {
+    tab.visibilityState = state;
+    for (const listener of [...listeners]) listener();
+  };
+  // A relay channel no wallet reads: the request is sent and nothing ever comes back.
+  const unanswered = vi.fn(
+    ({ method }: { method: string }) =>
+      new Promise((resolve) => {
+        if (method !== "personal_sign") resolve(null);
+      }),
+  );
+
+  beforeEach(() => {
+    resetMetaMaskConnectClient();
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.stubGlobal("document", tab);
+    tab.visibilityState = "visible";
+    listeners.clear();
+    client.getChainId.mockReturnValue("0x1");
+    client.getProvider.mockReturnValue({ request: unanswered } as never);
+    // createEVMClient resumed the stored session: its cached accounts are there.
+    client.accounts = [account];
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    resetMetaMaskConnectClient();
+    client.disconnect.mockReset();
+    client.disconnect.mockImplementation(async () => undefined);
+    client.accounts = [];
+    client.getChainId.mockImplementation(() => "0x2105");
+    client.getProvider.mockImplementation(() => ({ request: vi.fn() }));
+  });
+
+  function restoredConfig(options: { mobile?: boolean; restoredSessionTimeout?: typeof timeout }) {
+    return createConfig({
+      chains: [mainnet],
+      connectors: [
+        metaMaskConnect({ dapp: { name: "test", url: "https://example.test" }, ...options }),
+      ],
+      transports: { [mainnet.id]: http() },
+      multiInjectedProviderDiscovery: false,
+      storage: null,
+    });
+  }
+
+  async function signOnRestoredSession(config: ReturnType<typeof restoredConfig>) {
+    await reconnect(config);
+    expect(config.state.status).toBe("connected");
+    const signing = signMessage(config, { message: "Sign in" });
+    const outcome: { error?: unknown; settled: boolean } = { settled: false };
+    signing.then(
+      () => (outcome.settled = true),
+      (error: unknown) => Object.assign(outcome, { error, settled: true }),
+    );
+    await vi.advanceTimersByTimeAsync(0);
+    return outcome;
+  }
+
+  it("gives up 20 s after the page is back from MetaMask, drops the session and connects afresh", async () => {
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const outcome = await signOnRestoredSession(config);
+
+    // The deeplink takes the user to MetaMask ("Connection Not Found") and back.
+    show("hidden");
+    await vi.advanceTimersByTimeAsync(30_000);
+    show("visible");
+    await vi.advanceTimersByTimeAsync(timeout.afterReturnMs - 1);
+    expect(outcome.settled).toBe(false);
+    expect(client.disconnect).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    // viem reports EIP-1193's 4900 as ProviderDisconnectedError, ours as its cause.
+    expect(outcome.error).toMatchObject({
+      code: 4900,
+      cause: { name: "MetaMaskSessionLostError" },
+    });
+    expect(client.disconnect).toHaveBeenCalledOnce();
+    expect(config.state.status).toBe("disconnected");
+    expect(config.state.connections.size).toBe(0);
+
+    // MetaMask Connect has forgotten the session, so the next connect is a new one.
+    client.accounts = [];
+    await connect(config, { connector: config.connectors[0]! });
+    expect(client.connect).toHaveBeenCalledOnce();
+  });
+
+  it("gives up after 45 s when the page never got to MetaMask", async () => {
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const outcome = await signOnRestoredSession(config);
+
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs - 1);
+    expect(outcome.settled).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(outcome.error).toMatchObject({ code: 4900 });
+    expect(config.state.status).toBe("disconnected");
+  });
+
+  it("lets go of the page even when MetaMask Connect's disconnect never finishes", async () => {
+    client.disconnect.mockImplementationOnce(() => new Promise(() => undefined));
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const outcome = await signOnRestoredSession(config);
+
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs);
+    expect(config.state.status).toBe("disconnected");
+    expect(outcome.settled).toBe(false);
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(outcome.error).toMatchObject({ code: 4900 });
+  });
+
+  it("connects afresh while a dropped session's disconnect still runs, never on that session", async () => {
+    // fake-indexeddb runs its requests on setImmediate.
+    vi.useRealTimers();
+    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
+    // MetaMask Connect's stored session, which its connect would resume.
+    const idb = new IDBFactory();
+    vi.stubGlobal("indexedDB", idb);
+    const kv = metaMaskConnectKV(idb);
+    await (await SessionStore.create(kv)).set(storedSession("stale"));
+    client.disconnect.mockImplementationOnce(() => new Promise<undefined>(() => undefined));
+    let resumable: string[] | undefined;
+    client.connect.mockImplementationOnce(async () => {
+      resumable = (await (await SessionStore.create(kv)).list()).map((s) => s.id);
+      return { accounts: [account], chainId: "0x1" };
+    });
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const outcome = await signOnRestoredSession(config);
+
+    // The tap lands as the session is dropped, before the request has even failed.
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs);
+    expect(config.state.status).toBe("disconnected");
+    expect(client.disconnect).toHaveBeenCalledOnce();
+    client.accounts = [];
+    let connected = false;
+    connect(config, { connector: config.connectors[0]! }).then(() => (connected = true));
+    for (let i = 0; i < 100 && !connected; i++) {
+      await new Promise((resolve) => setImmediate(resolve));
+      await vi.advanceTimersByTimeAsync(50);
+    }
+
+    // MetaMask Connect's disconnect never finished.
+    expect(client.connect).toHaveBeenCalledOnce();
+    expect(resumable).toEqual([]);
+    expect(config.state.status).toBe("connected");
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(outcome.error).toMatchObject({ code: 4900 });
+    await kv.close();
+  });
+
+  it("makes a connect wait for MetaMask Connect's disconnect still running, then go ahead", async () => {
+    let finishDisconnect!: () => void;
+    client.disconnect.mockImplementationOnce(
+      () => new Promise<undefined>((resolve) => (finishDisconnect = () => resolve(undefined))),
+    );
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const outcome = await signOnRestoredSession(config);
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs + 5_000);
+    expect(outcome.error).toMatchObject({ code: 4900 });
+
+    client.accounts = [];
+    const connecting = connect(config, { connector: config.connectors[0]! });
+    await vi.advanceTimersByTimeAsync(500);
+    expect(client.connect).not.toHaveBeenCalled();
+    finishDisconnect();
+    await connecting;
+    expect(client.connect).toHaveBeenCalledOnce();
+  });
+
+  it("waits at most a second for a disconnect that never finishes", async () => {
+    client.disconnect.mockImplementationOnce(() => new Promise<undefined>(() => undefined));
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const outcome = await signOnRestoredSession(config);
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs + 5_000);
+    expect(outcome.error).toMatchObject({ code: 4900 });
+
+    client.accounts = [];
+    const connecting = connect(config, { connector: config.connectors[0]! });
+    await vi.advanceTimersByTimeAsync(999);
+    expect(client.connect).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1);
+    await connecting;
+    expect(client.connect).toHaveBeenCalledOnce();
+  });
+
+  it("fails the request and lets a connect through when IndexedDB never answers", async () => {
+    // An open request that never fires, as IndexedDB sometimes does on iOS.
+    vi.stubGlobal("indexedDB", { open: () => ({}) });
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const outcome = await signOnRestoredSession(config);
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs);
+    expect(config.state.status).toBe("disconnected");
+
+    client.accounts = [];
+    const connecting = connect(config, { connector: config.connectors[0]! });
+    await vi.advanceTimersByTimeAsync(1_499);
+    expect(outcome.settled).toBe(false);
+    expect(client.connect).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1);
+    await connecting;
+    expect(client.connect).toHaveBeenCalledOnce();
+    expect(outcome.error).toMatchObject({ code: 4900 });
+  });
+
+  it("drops the session once when several requests give up on it together", async () => {
+    let finishDisconnect!: () => void;
+    client.disconnect.mockImplementationOnce(
+      () => new Promise<undefined>((resolve) => (finishDisconnect = () => resolve(undefined))),
+    );
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const first = await signOnRestoredSession(config);
+    const second: { error?: unknown } = {};
+    signMessage(config, { message: "again" }).catch((error: unknown) => (second.error = error));
+
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs);
+    finishDisconnect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(first.error).toMatchObject({ code: 4900 });
+    expect(second.error).toMatchObject({ code: 4900 });
+    expect(client.disconnect).toHaveBeenCalledOnce();
+  });
+
+  it("still watches a restored session whose only answers came from MetaMask Connect's cache", async () => {
+    // eth_requestAccounts on a stored session resolves from cache, never from MetaMask.
+    const request = vi.fn(
+      ({ method }: { method: string }): Promise<unknown> =>
+        method === "personal_sign" ? new Promise(() => undefined) : Promise.resolve([account]),
+    );
+    client.getProvider.mockReturnValue({ request } as never);
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    await reconnect(config);
+    const provider = (await config.connectors[0]!.getProvider()) as {
+      request(args: { method: string }): Promise<unknown>;
+    };
+    await provider.request({ method: "eth_requestAccounts" });
+    await provider.request({ method: "wallet_switchEthereumChain" });
+
+    const outcome = await signOnRestoredSession(config);
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs);
+    expect(outcome.error).toMatchObject({ code: 4900 });
+  });
+
+  it("keeps a restored session MetaMask answers, and stops watching it", async () => {
+    const request = vi.fn(
+      async ({ method }: { method: string }): Promise<unknown> =>
+        method === "personal_sign" ? "0x5167" : null,
+    );
+    client.getProvider.mockReturnValue({ request } as never);
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    await reconnect(config);
+
+    expect(await signMessage(config, { message: "Sign in" })).toBe("0x5167");
+
+    // Answered once: a later request that MetaMask holds a long time is left alone.
+    request.mockImplementation(() => new Promise(() => undefined));
+    signMessage(config, { message: "again" }).catch(() => undefined);
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs * 4);
+    expect(client.disconnect).not.toHaveBeenCalled();
+    expect(config.state.status).toBe("connected");
+  });
+
+  it("leaves a session alone that this page's own connect handshook", async () => {
+    client.accounts = [];
+    const config = restoredConfig({ mobile: true, restoredSessionTimeout: timeout });
+    const events = await (async () => {
+      await vi.waitFor(() => expect(createEVMClient).toHaveBeenCalledTimes(1));
+      return (createEVMClient.mock.calls[0]![0] as { eventHandlers: EventHandlers }).eventHandlers;
+    })();
+    client.connect.mockImplementationOnce(async () => {
+      events.displayUri("metamask://connect/mwp?p=new");
+      return { accounts: [account], chainId: "0x1" };
+    });
+    await connect(config, { connector: config.connectors[0]! });
+
+    signMessage(config, { message: "Sign in" }).catch(() => undefined);
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs * 4);
+    expect(client.disconnect).not.toHaveBeenCalled();
+    expect(config.state.status).toBe("connected");
+  });
+
+  it("waits on the relay as before without restoredSessionTimeout", async () => {
+    const config = restoredConfig({ mobile: true });
+    const outcome = await signOnRestoredSession(config);
+    show("hidden");
+    show("visible");
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs * 4);
+    expect(outcome.settled).toBe(false);
+    expect(client.disconnect).not.toHaveBeenCalled();
+  });
+
+  it("leaves the desktop alone, where MetaMask is the extension", async () => {
+    const config = restoredConfig({ mobile: false, restoredSessionTimeout: timeout });
+    const outcome = await signOnRestoredSession(config);
+    await vi.advanceTimersByTimeAsync(timeout.withoutTripMs * 4);
+    expect(outcome.settled).toBe(false);
+    expect(client.disconnect).not.toHaveBeenCalled();
+  });
+});
+
 describe("metaMaskMayLackChain", () => {
   it("is true for a testnet MetaMask does not ship and false for mainnets and its own testnets", () => {
     expect(metaMaskMayLackChain(baseSepolia)).toBe(true);

package/src/connectkit/connectors/metaMaskConnectConnector.ts

@@ -26,6 +26,7 @@ import {
 } from "viem";
 import { mainnet } from "wagmi/chains";
 
+import { forgetStoredSessions, type RestoredSessionTimeout, untilSilent } from "./restoredSession";
 import { isSyntheticChainId } from "./syntheticChains";
 
 export type MetaMaskConnectParameters = {
@@ -49,6 +50,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];
@@ -227,11 +236,89 @@ let owner: Emitter | undefined;
 const permittedChains = new Set<number>();
 const unrecognizedChains = new Set<number>();
 let lastDeeplink: { url: string; open: (url: string, target?: string) => void } | undefined;
+// Whether MetaMask has answered on this page's session: a connect that ran a
+// handshake (MetaMask Connect raises display_uri only for a new session
+// request) or a wallet request it settled. A session resumed from storage
+// starts unanswered.
+let handshakes = 0;
+let answered = false;
 
 function forgetChains(): void {
   permittedChains.clear();
   unrecognizedChains.clear();
   lastDeeplink = undefined;
+  answered = false;
+}
+
+// What only the wallet answers, so a reply proves MetaMask still holds the
+// session. Not eth_requestAccounts or a switch to a permitted chain: MetaMask
+// Connect answers those from the stored session without asking the wallet.
+const walletMethods = new Set([
+  "personal_sign",
+  "eth_sign",
+  "eth_signTypedData",
+  "eth_signTypedData_v3",
+  "eth_signTypedData_v4",
+  "eth_sendTransaction",
+  "wallet_requestPermissions",
+  "wallet_addEthereumChain",
+  "wallet_watchAsset",
+  "wallet_sendCalls",
+]);
+
+function watchRestoredSession(
+  provider: EIP1193Provider,
+  timeout: RestoredSessionTimeout,
+  drop: () => Promise<void>,
+): EIP1193Provider {
+  const request = ((args: { method: string; params?: unknown }) => {
+    const sent = provider.request(args as never) as Promise<unknown>;
+    if (!walletMethods.has(args.method)) return sent;
+    const heard = sent.then(
+      (value) => {
+        answered = true;
+        return value;
+      },
+      (err: unknown) => {
+        if ((err as { code?: number })?.code === UserRejectedRequestError.code) answered = true;
+        throw err;
+      },
+    );
+    return answered ? heard : untilSilent(heard, timeout, drop);
+  }) as EIP1193Provider["request"];
+  return new Proxy(provider, {
+    get(target, property) {
+      if (property === "request") return request;
+      const value = Reflect.get(target, property);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+  });
+}
+
+// IndexedDB can stop answering (a known iOS failure), so the deletion is capped
+// too; past it, the request still fails and a connect still goes ahead.
+const forgetDeadlineMs = 1_500;
+const dropDeadlineMs = 5_000;
+const disconnectWaitMs = 1_000;
+// The drop under way, shared by every request that gives up meanwhile. It ends
+// once the stored session is deleted and MetaMask Connect's disconnect is done,
+// or at the deadlines.
+let dropping: Promise<void> | undefined;
+// The dropped session's deletion from storage, while it runs.
+let forgetting: Promise<void> | undefined;
+// MetaMask Connect's disconnect, while it runs. One that finishes under a new
+// connect clears the transport that connect handshakes on, so a connect waits
+// for it, briefly: a tap gets this far only once the drop has given up on it.
+let disconnecting: Promise<void> | undefined;
+
+function withDeadline<T>(promise: Promise<T>, ms: number): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  return Promise.race([
+    promise,
+    new Promise<never>((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`timed out after ${ms} ms`)), ms);
+    }),
+  ]).finally(() => clearTimeout(timer));
 }
 
 /**
@@ -315,7 +402,10 @@ function getClient(
           forgetChains();
           owner?.emit("disconnect");
         },
-        displayUri: (uri) => owner?.emit("message", { type: "display_uri", data: uri }),
+        displayUri: (uri) => {
+          handshakes += 1;
+          owner?.emit("message", { type: "display_uri", data: uri });
+        },
       },
     }),
   );
@@ -329,6 +419,10 @@ function getClient(
 export function resetMetaMaskConnectClient(): void {
   client = undefined;
   owner = undefined;
+  handshakes = 0;
+  dropping = undefined;
+  forgetting = undefined;
+  disconnecting = undefined;
   forgetChains();
 }
 
@@ -349,6 +443,7 @@ export function metaMaskConnect(parameters: MetaMaskConnectParameters) {
     const fallbackChainId = Number(Object.keys(networks)[0] ?? 1);
     const mobile = parameters.mobile ?? isMobile();
     const addChainFirst = parameters.addChainFirst ?? metaMaskMayLackChain;
+    const restoredSessionTimeout = mobile ? parameters.restoredSessionTimeout : undefined;
     const instance = () => getClient(parameters, supportedNetworks);
     let guarded: { provider: EIP1193Provider; wrapped: EIP1193Provider } | undefined;
     // Every call wagmi makes on the connector it uses claims the client's events;
@@ -362,6 +457,37 @@ export function metaMaskConnect(parameters: MetaMaskConnectParameters) {
       const hex = mm.getChainId();
       return hex ? Number(hex) : fallbackChainId;
     };
+    // wagmi lets go first, so the page stops waiting even if the relay is gone
+    // too. The stored session goes before the request fails and the page offers
+    // a new connect, so that connect cannot resume it whatever the disconnect
+    // is doing; the deadlines keep a dead relay or IndexedDB from holding the
+    // request open.
+    const dropSession = (): Promise<void> => {
+      if (dropping) return dropping;
+      forgetChains();
+      config.emitter.emit("disconnect");
+      const forgotten: Promise<void> = withDeadline(forgetStoredSessions(), forgetDeadlineMs)
+        .catch(() => undefined)
+        .finally(() => {
+          if (forgetting === forgotten) forgetting = undefined;
+        });
+      forgetting = forgotten;
+      const disconnected: Promise<void> = instance()
+        .then((mm) => mm.disconnect())
+        .catch(() => undefined)
+        .finally(() => {
+          if (disconnecting === disconnected) disconnecting = undefined;
+        });
+      disconnecting = disconnected;
+      const drop: Promise<void> = forgotten
+        .then(() => withDeadline(disconnected, dropDeadlineMs))
+        .catch(() => undefined)
+        .finally(() => {
+          if (dropping === drop) dropping = undefined;
+        });
+      dropping = drop;
+      return drop;
+    };
 
     return {
       id: "metaMaskSDK",
@@ -376,13 +502,23 @@ export function metaMaskConnect(parameters: MetaMaskConnectParameters) {
       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.
+        // Nothing slow comes before mm.connect(): iOS Safari opens the MetaMask
+        // link only within the tap's user activation.
+        if (forgetting) await forgetting;
+        // A tap reaches this wait only when the disconnect outlasted the drop's
+        // deadline. Up to 1 s of the tap's activation can go here; iOS may then
+        // block the link and cost the user one more tap, which beats a hang.
+        if (disconnecting)
+          await withDeadline(disconnecting, disconnectWaitMs).catch(() => undefined);
         const mm = await claim();
         try {
           let accounts = isReconnecting ? accountsOf(mm) : [];
           if (!accounts.length) {
+            const before = handshakes;
             const result = await mm.connect({
               chainIds: metaMaskConnectChainIds(networks, chainId),
             });
+            if (handshakes !== before) answered = true;
             accounts = result.accounts.map((a) => getAddress(a));
           }
           const current = chainIdOf(mm);
@@ -407,11 +543,15 @@ export function metaMaskConnect(parameters: MetaMaskConnectParameters) {
         // connector wraps it for itself.
         const mm = await claim();
         const provider = mm.getProvider();
-        if (guarded?.provider !== provider)
+        if (guarded?.provider !== provider) {
+          const listed = listedChainsOnly(provider, mm, networks, supportedNetworks);
           guarded = {
             provider,
-            wrapped: listedChainsOnly(provider, mm, networks, supportedNetworks),
+            wrapped: restoredSessionTimeout
+              ? watchRestoredSession(listed, restoredSessionTimeout, dropSession)
+              : listed,
           };
+        }
         return guarded.wrapped;
       },
       async isAuthorized() {