@multiplatform.one/web3 7.17.0 → 7.18.0

package/src/connectkit/openConnector/device.spec.ts

@@ -0,0 +1,86 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it } from "vitest";
+
+import { defaultOpenConnectorFallbackMs, isTouchDevice } from "./device";
+import {
+  DEFAULT_DESKTOP_OPEN_CONNECTOR_FALLBACK_MS,
+  DEFAULT_OPEN_CONNECTOR_FALLBACK_MS,
+} from "./launcher";
+
+const IPADOS_SAFARI_UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15";
+const ANDROID_DESKTOP_SITE_UA =
+  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36";
+const ANDROID_UA =
+  "Mozilla/5.0 (Linux; Android 16; Pixel 9) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Mobile Safari/537.36";
+const WINDOWS_UA =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36";
+
+const coarse = () => ({ matches: true });
+const fine = () => ({ matches: false });
+
+function setNavigator(userAgent: string, maxTouchPoints: number) {
+  Object.defineProperty(window.navigator, "userAgent", { value: userAgent, configurable: true });
+  Object.defineProperty(window.navigator, "maxTouchPoints", {
+    value: maxTouchPoints,
+    configurable: true,
+  });
+}
+
+afterEach(() => {
+  setNavigator(WINDOWS_UA, 0);
+});
+
+describe("isTouchDevice", () => {
+  it("counts iPadOS Safari, which sends a Mac user agent", () => {
+    expect(isTouchDevice({ userAgent: IPADOS_SAFARI_UA, maxTouchPoints: 5 }, fine)).toBe(true);
+  });
+
+  it("does not count a Mac", () => {
+    expect(isTouchDevice({ userAgent: IPADOS_SAFARI_UA, maxTouchPoints: 0 }, coarse)).toBe(false);
+  });
+
+  it("counts Android's Desktop site: touch points and a coarse primary pointer", () => {
+    expect(isTouchDevice({ userAgent: ANDROID_DESKTOP_SITE_UA, maxTouchPoints: 5 }, coarse)).toBe(
+      true,
+    );
+  });
+
+  it("does not count a touch-screen laptop, whose primary pointer is fine", () => {
+    expect(isTouchDevice({ userAgent: WINDOWS_UA, maxTouchPoints: 10 }, fine)).toBe(false);
+  });
+
+  it("is false without a navigator (SSR) or a matchMedia", () => {
+    expect(isTouchDevice(null, coarse)).toBe(false);
+    expect(isTouchDevice({ userAgent: ANDROID_DESKTOP_SITE_UA, maxTouchPoints: 5 }, null)).toBe(
+      false,
+    );
+  });
+
+  it("is false when matchMedia throws", () => {
+    const throws = () => {
+      throw new Error("no media queries");
+    };
+    expect(isTouchDevice({ userAgent: ANDROID_DESKTOP_SITE_UA, maxTouchPoints: 5 }, throws)).toBe(
+      false,
+    );
+  });
+});
+
+describe("defaultOpenConnectorFallbackMs", () => {
+  it("is the phone default on a phone", () => {
+    setNavigator(ANDROID_UA, 5);
+    expect(defaultOpenConnectorFallbackMs()).toBe(DEFAULT_OPEN_CONNECTOR_FALLBACK_MS);
+  });
+
+  it("is the phone default on an iPad that asks for the desktop site", () => {
+    setNavigator(IPADOS_SAFARI_UA, 5);
+    expect(defaultOpenConnectorFallbackMs()).toBe(DEFAULT_OPEN_CONNECTOR_FALLBACK_MS);
+  });
+
+  it("is still a fallback on desktop, so an explicit call never spins forever", () => {
+    setNavigator(WINDOWS_UA, 0);
+    expect(defaultOpenConnectorFallbackMs()).toBe(DEFAULT_DESKTOP_OPEN_CONNECTOR_FALLBACK_MS);
+    expect(DEFAULT_DESKTOP_OPEN_CONNECTOR_FALLBACK_MS).toBeGreaterThan(0);
+  });
+});

package/src/connectkit/openConnector/device.ts

@@ -0,0 +1,37 @@
+import { isMobile } from "@multiplatform.one/connectkit";
+
+import {
+  DEFAULT_DESKTOP_OPEN_CONNECTOR_FALLBACK_MS,
+  DEFAULT_OPEN_CONNECTOR_FALLBACK_MS,
+} from "./launcher";
+
+type DeviceNavigator = { userAgent?: string; maxTouchPoints?: number };
+type MatchMedia = (query: string) => { matches: boolean };
+
+/**
+ * A touch device whose browser sends a desktop user agent, which connectkit's
+ * `isMobile()` reads as desktop: iPadOS Safari sends a Mac one, and Android's
+ * "Desktop site" a Linux one. A Mac reports no touch points, and a laptop's touch
+ * screen is not its primary pointer, so neither counts.
+ */
+export function isTouchDevice(
+  nav: DeviceNavigator | null = typeof navigator === "undefined" ? null : navigator,
+  matchMedia: MatchMedia | null = typeof window === "undefined" || !window.matchMedia
+    ? null
+    : (query) => window.matchMedia(query),
+): boolean {
+  if (!nav || (nav.maxTouchPoints ?? 0) < 2) return false;
+  if (/Macintosh/.test(nav.userAgent ?? "")) return true;
+  try {
+    return matchMedia?.("(pointer: coarse)").matches ?? false;
+  } catch {
+    return false;
+  }
+}
+
+/** The `fallbackMs` an `openConnector` call without one gets on this device. */
+export function defaultOpenConnectorFallbackMs(): number {
+  return isMobile() || isTouchDevice()
+    ? DEFAULT_OPEN_CONNECTOR_FALLBACK_MS
+    : DEFAULT_DESKTOP_OPEN_CONNECTOR_FALLBACK_MS;
+}

package/src/connectkit/openConnector/index.ts

@@ -0,0 +1,18 @@
+export {
+  createConnectorLauncher,
+  DEFAULT_DESKTOP_OPEN_CONNECTOR_FALLBACK_MS,
+  DEFAULT_OPEN_CONNECTOR_FALLBACK_MS,
+  type ConnectorLauncher,
+  type LauncherDeps,
+  type OpenConnectorOptions,
+  type PendingConnect,
+} from "./launcher";
+export {
+  ConnectorLauncherProvider,
+  getMobileOptions,
+  resolveWallet,
+  useConnectorLauncher,
+  type ConnectorLauncherValue,
+  type MobileConnectOptions,
+  type Web3ConnectKitOptions,
+} from "./context";

package/src/connectkit/openConnector/launcher.spec.ts

@@ -0,0 +1,325 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Connector } from "wagmi";
+
+import { createConnectorLauncher, type LauncherDeps } from "./launcher";
+
+type Message = { type: string; data?: unknown };
+
+function fakeConnector(uid: string) {
+  const handlers = new Set<(message: Message) => void>();
+  const emitter = {
+    on: (_event: string, fn: (message: Message) => void) => handlers.add(fn),
+    off: (_event: string, fn: (message: Message) => void) => handlers.delete(fn),
+    emit: (message: Message) => handlers.forEach((fn) => fn(message)),
+    listeners: () => handlers.size,
+  };
+  return { uid, id: uid, name: uid, emitter } as unknown as Connector & {
+    emitter: typeof emitter;
+  };
+}
+
+function deferred() {
+  let resolve!: (value?: unknown) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+function setup() {
+  const calls: string[] = [];
+  const win = new EventTarget();
+  const doc = Object.assign(new EventTarget(), { visibilityState: "visible" });
+  const connects: ReturnType<typeof deferred>[] = [];
+  const deps: LauncherDeps = {
+    connect: vi.fn((connector: Connector) => {
+      calls.push(`connect:${connector.uid}`);
+      const d = deferred();
+      connects.push(d);
+      return d.promise;
+    }),
+    showConnecting: vi.fn((walletId: string) => calls.push(`connecting:${walletId}`)),
+    showList: vi.fn(() => calls.push("list")),
+    onFailed: vi.fn(),
+    win,
+    doc,
+  };
+  const launcher = createConnectorLauncher(() => deps);
+  return { launcher, deps, calls, win, doc, connects };
+}
+
+// Let promise callbacks run under fake timers.
+const flush = () => Promise.resolve().then(() => undefined);
+
+describe("createConnectorLauncher", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("calls connect() synchronously, before open() returns and before any UI change", () => {
+    const { launcher, deps, calls } = setup();
+    const mm = fakeConnector("metaMaskSDK");
+
+    launcher.open("metaMaskSDK", mm, { fallbackMs: 6000 });
+
+    expect(deps.connect).toHaveBeenCalledTimes(1);
+    expect(deps.connect).toHaveBeenCalledWith(mm);
+    expect(calls).toEqual(["connect:metaMaskSDK", "connecting:metaMaskSDK"]);
+    expect(launcher.pending()?.walletId).toBe("metaMaskSDK");
+  });
+
+  it("falls back to the list when the page never loses focus within fallbackMs", () => {
+    const { launcher, deps } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    vi.advanceTimersByTime(5999);
+    expect(deps.showList).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(1);
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+    expect(deps.onFailed).not.toHaveBeenCalled();
+    expect(launcher.pending()).toBeNull();
+  });
+
+  it("keeps waiting when the wallet app took focus (blur)", () => {
+    const { launcher, deps, win } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    win.dispatchEvent(new Event("blur"));
+    vi.advanceTimersByTime(10_000);
+
+    expect(deps.showList).not.toHaveBeenCalled();
+    expect(launcher.pending()?.walletId).toBe("metaMaskSDK");
+  });
+
+  it("keeps waiting when the page went hidden", () => {
+    const { launcher, deps, doc } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    doc.visibilityState = "hidden";
+    doc.dispatchEvent(new Event("visibilitychange"));
+    vi.advanceTimersByTime(10_000);
+
+    expect(deps.showList).not.toHaveBeenCalled();
+  });
+
+  it("falls back to the list when connect fails", async () => {
+    const { launcher, deps, connects } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    const error = new Error("User rejected request");
+    connects[0].reject(error);
+    await flush();
+
+    expect(deps.onFailed).toHaveBeenCalledWith(error);
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+    expect(launcher.pending()).toBeNull();
+    vi.advanceTimersByTime(10_000);
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+  });
+
+  it("ends quietly when connect lands", async () => {
+    const { launcher, deps, connects } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    connects[0].resolve();
+    await flush();
+    vi.advanceTimersByTime(10_000);
+
+    expect(deps.showList).not.toHaveBeenCalled();
+    expect(launcher.pending()).toBeNull();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("re-tap re-issues the pending request on the same connector and keeps one session", async () => {
+    const { launcher, deps, connects } = setup();
+    const mm = fakeConnector("metaMaskSDK");
+    launcher.open("metaMaskSDK", mm, { fallbackMs: 6000 });
+    const first = launcher.pending();
+    vi.advanceTimersByTime(3000);
+
+    launcher.open("metaMaskSDK", mm, { fallbackMs: 6000 });
+
+    expect(deps.connect).toHaveBeenCalledTimes(2);
+    expect(deps.connect).toHaveBeenLastCalledWith(mm);
+    expect(launcher.pending()).toBe(first);
+    expect(vi.getTimerCount()).toBe(1);
+
+    // The ORIGINAL timer still decides: 3000 ms more, not 6000.
+    vi.advanceTimersByTime(3000);
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+
+    // The re-issued request failing on its own does not fall back a second time.
+    connects[1].reject(new Error("already pending"));
+    await flush();
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-tap after the fallback starts a fresh connect", () => {
+    const { launcher, deps } = setup();
+    const mm = fakeConnector("metaMaskSDK");
+    launcher.open("metaMaskSDK", mm, { fallbackMs: 6000 });
+    vi.advanceTimersByTime(6000);
+
+    launcher.open("metaMaskSDK", mm, { fallbackMs: 6000 });
+
+    expect(deps.connect).toHaveBeenCalledTimes(2);
+    expect(launcher.pending()?.walletId).toBe("metaMaskSDK");
+    expect(vi.getTimerCount()).toBe(1);
+  });
+
+  it("opening another connector ends the pending one without falling back", () => {
+    const { launcher, deps } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+    launcher.open("coinbaseWalletSDK", fakeConnector("coinbaseWalletSDK"), { fallbackMs: 6000 });
+
+    expect(launcher.pending()?.walletId).toBe("coinbaseWalletSDK");
+    expect(vi.getTimerCount()).toBe(1);
+    expect(deps.showList).not.toHaveBeenCalled();
+  });
+
+  it("captures the wallet deeplink the connector announces", () => {
+    const { launcher } = setup();
+    const mm = fakeConnector("metaMaskSDK");
+    const seen: Array<string | undefined> = [];
+    launcher.subscribe(() => seen.push(launcher.pending()?.deeplink));
+
+    launcher.open("metaMaskSDK", mm, { fallbackMs: 6000 });
+    mm.emitter.emit({ type: "display_uri", data: "metamask://connect/mwp?p=abc" });
+
+    expect(launcher.pending()?.deeplink).toBe("metamask://connect/mwp?p=abc");
+    expect(seen).toContain("metamask://connect/mwp?p=abc");
+
+    launcher.cancel();
+    expect(mm.emitter.listeners()).toBe(0);
+  });
+
+  it("runs no timer without fallbackMs", () => {
+    const { launcher, deps, win } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"));
+
+    expect(vi.getTimerCount()).toBe(0);
+    win.dispatchEvent(new Event("blur"));
+    win.dispatchEvent(new Event("focus"));
+    expect(vi.getTimerCount()).toBe(0);
+    vi.advanceTimersByTime(60_000);
+    expect(deps.showList).not.toHaveBeenCalled();
+  });
+
+  it("re-arms the fallback when the page comes back with the connect still pending", () => {
+    const { launcher, deps, win } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    win.dispatchEvent(new Event("blur"));
+    vi.advanceTimersByTime(20_000);
+    expect(deps.showList).not.toHaveBeenCalled();
+
+    // A dismissed chooser, or a relay answer lost in the background.
+    win.dispatchEvent(new Event("focus"));
+    vi.advanceTimersByTime(5999);
+    expect(deps.showList).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(1);
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+    expect(launcher.pending()).toBeNull();
+  });
+
+  it("restarts the wait from the return, not from the tap", () => {
+    const { launcher, deps, win } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    vi.advanceTimersByTime(1000);
+    win.dispatchEvent(new Event("blur"));
+    vi.advanceTimersByTime(4500);
+    win.dispatchEvent(new Event("focus"));
+
+    vi.advanceTimersByTime(5999);
+    expect(deps.showList).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(1);
+    vi.advanceTimersByTime(1);
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-arms when the page turns visible again", () => {
+    const { launcher, deps, doc } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    doc.visibilityState = "hidden";
+    doc.dispatchEvent(new Event("visibilitychange"));
+    vi.advanceTimersByTime(20_000);
+    expect(deps.showList).not.toHaveBeenCalled();
+
+    doc.visibilityState = "visible";
+    doc.dispatchEvent(new Event("visibilitychange"));
+    vi.advanceTimersByTime(6000);
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+  });
+
+  it("a page that leaves again after coming back keeps waiting", () => {
+    const { launcher, deps, win } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    win.dispatchEvent(new Event("blur"));
+    win.dispatchEvent(new Event("focus"));
+    vi.advanceTimersByTime(2000);
+    win.dispatchEvent(new Event("blur"));
+    vi.advanceTimersByTime(20_000);
+
+    expect(deps.showList).not.toHaveBeenCalled();
+    expect(launcher.pending()?.walletId).toBe("metaMaskSDK");
+  });
+
+  it("a focus with no blur before it leaves the original timer alone", () => {
+    const { launcher, deps, win } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+
+    vi.advanceTimersByTime(3000);
+    win.dispatchEvent(new Event("focus"));
+    vi.advanceTimersByTime(3000);
+
+    expect(deps.showList).toHaveBeenCalledTimes(1);
+  });
+
+  it("cancel() ends the session and stops watching; the wagmi connect is left alone", async () => {
+    const { launcher, deps, win, connects } = setup();
+    const mm = fakeConnector("metaMaskSDK");
+    const seen: Array<string | null> = [];
+    launcher.subscribe(() => seen.push(launcher.pending()?.walletId ?? null));
+    launcher.open("metaMaskSDK", mm, { fallbackMs: 6000 });
+    win.dispatchEvent(new Event("blur"));
+
+    launcher.cancel();
+
+    expect(launcher.pending()).toBeNull();
+    expect(seen[seen.length - 1]).toBeNull();
+    expect(vi.getTimerCount()).toBe(0);
+    expect(mm.emitter.listeners()).toBe(0);
+    win.dispatchEvent(new Event("focus"));
+    expect(vi.getTimerCount()).toBe(0);
+
+    connects[0].reject(new Error("User rejected request"));
+    await flush();
+    vi.advanceTimersByTime(60_000);
+    expect(deps.showList).not.toHaveBeenCalled();
+    expect(deps.onFailed).not.toHaveBeenCalled();
+  });
+
+  it("a return after the connect landed arms nothing", async () => {
+    const { launcher, deps, win, connects } = setup();
+    launcher.open("metaMaskSDK", fakeConnector("metaMaskSDK"), { fallbackMs: 6000 });
+    win.dispatchEvent(new Event("blur"));
+
+    connects[0].resolve();
+    await flush();
+    win.dispatchEvent(new Event("focus"));
+
+    expect(vi.getTimerCount()).toBe(0);
+    expect(launcher.pending()).toBeNull();
+    vi.advanceTimersByTime(60_000);
+    expect(deps.showList).not.toHaveBeenCalled();
+  });
+});

package/src/connectkit/openConnector/launcher.ts

@@ -0,0 +1,203 @@
+import type { Connector } from "wagmi";
+
+// Opening ONE connector straight from an app's button, without showing the wallet
+// list first. A phone that goes straight to MetaMask saves the user a tap, but only
+// if the connect fires inside that tap: a browser opens the wallet's deeplink only
+// while the tap's user activation is live, so anything that defers connect() (a
+// route change, an effect, a timer) loses it. The launcher therefore calls connect()
+// before it touches any UI, and hands the UI updates to its caller.
+//
+// When the wallet never comes up (no MetaMask app: the deeplink goes nowhere and the
+// page never loses focus) or the connect fails, the user lands on the wallet list,
+// so a straight-to-wallet button is never a dead end. The same holds when the user
+// comes back from the wallet app and its answer never arrives (a dismissed chooser,
+// a relay reply lost while the page was in the background): the page being in front
+// again restarts the wait.
+
+/** A page still in front this long after the tap never reached the wallet app. */
+export const DEFAULT_OPEN_CONNECTOR_FALLBACK_MS = 6_000;
+
+/**
+ * The desktop default. An extension's popup window blurs the page, but a wallet that
+ * answers in the page (a QR code to scan) does not, so desktop waits longer.
+ */
+export const DEFAULT_DESKTOP_OPEN_CONNECTOR_FALLBACK_MS = 30_000;
+
+export type OpenConnectorOptions = {
+  /**
+   * How long the page may stay in front with the connect unanswered before the
+   * wallet list shows: after the tap, and again each time the page comes back from
+   * the wallet app. Defaults to 6000 ms on a phone or tablet and to 30000 ms on
+   * desktop. `0` turns it off, and the connecting screen then waits for the connect
+   * to settle however long that takes.
+   */
+  fallbackMs?: number;
+};
+
+export type PendingConnect = {
+  /** The wallet-list id the connect was opened for. */
+  walletId: string;
+  connector: Connector;
+  /** The wallet deeplink, once the connector announces one (`display_uri`). */
+  deeplink?: string;
+};
+
+type Listener = (event: Event) => void;
+
+export type LauncherDeps = {
+  connect: (connector: Connector) => Promise<unknown>;
+  /** Show the connecting state for this wallet. */
+  showConnecting: (walletId: string) => void;
+  /** Show the wallet list. */
+  showList: () => void;
+  /** A connect settled with an error; runs before the list shows. */
+  onFailed?: (error: unknown) => void;
+  win?: {
+    addEventListener: (type: string, listener: Listener) => void;
+    removeEventListener: (type: string, listener: Listener) => void;
+  };
+  doc?: {
+    addEventListener: (type: string, listener: Listener) => void;
+    removeEventListener: (type: string, listener: Listener) => void;
+    visibilityState?: string;
+  };
+};
+
+type Session = {
+  pending: PendingConnect;
+  stop: () => void;
+};
+
+export type ConnectorLauncher = {
+  /**
+   * Connect `connector` now, inside the caller's gesture. A second call for the
+   * connector already connecting re-issues the request inside the new tap (MetaMask
+   * Connect answers it by re-opening the pending request) and keeps the one
+   * session: no second timer, no reset of the connecting state.
+   */
+  open: (walletId: string, connector: Connector, options?: OpenConnectorOptions) => void;
+  pending: () => PendingConnect | null;
+  subscribe: (listener: () => void) => () => void;
+  /**
+   * End the pending session without falling back: the user left the connecting
+   * screen, a wallet connected, or the provider unmounted. The wagmi connect itself
+   * carries on.
+   */
+  cancel: () => void;
+};
+
+export function createConnectorLauncher(getDeps: () => LauncherDeps): ConnectorLauncher {
+  let session: Session | null = null;
+  const listeners = new Set<() => void>();
+  const emit = () => listeners.forEach((listener) => listener());
+
+  const end = (s: Session) => {
+    if (session !== s) return;
+    s.stop();
+    session = null;
+    emit();
+  };
+
+  const open: ConnectorLauncher["open"] = (walletId, connector, options = {}) => {
+    const deps = getDeps();
+
+    const current = session;
+    if (current && current.pending.connector.uid === connector.uid) {
+      deps.connect(connector).then(
+        () => end(current),
+        () => undefined,
+      );
+      deps.showConnecting(current.pending.walletId);
+      return;
+    }
+    if (current) end(current);
+
+    const win = deps.win ?? (typeof window !== "undefined" ? window : undefined);
+    const doc = deps.doc ?? (typeof document !== "undefined" ? document : undefined);
+
+    const fallbackMs = options.fallbackMs ?? 0;
+    let left = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const disarm = () => {
+      if (timer !== undefined) clearTimeout(timer);
+      timer = undefined;
+    };
+    const arm = () => {
+      disarm();
+      if (fallbackMs <= 0) return;
+      timer = setTimeout(() => {
+        timer = undefined;
+        // While the wallet app has the page, wait for the page to come back.
+        if (!left) fallBack();
+      }, fallbackMs);
+    };
+    const onLeave = () => {
+      left = true;
+    };
+    const onReturn = () => {
+      if (!left) return;
+      left = false;
+      arm();
+    };
+    const onVisibility = () => {
+      if (doc?.visibilityState === "hidden") onLeave();
+      else onReturn();
+    };
+    const onMessage = (message: { type: string; data?: unknown }) => {
+      if (session !== s || message.type !== "display_uri" || typeof message.data !== "string") {
+        return;
+      }
+      s.pending = { ...s.pending, deeplink: message.data };
+      emit();
+    };
+
+    const s: Session = {
+      pending: { walletId, connector },
+      stop: () => {
+        disarm();
+        win?.removeEventListener("blur", onLeave);
+        win?.removeEventListener("pagehide", onLeave);
+        win?.removeEventListener("focus", onReturn);
+        win?.removeEventListener("pageshow", onReturn);
+        doc?.removeEventListener("visibilitychange", onVisibility);
+        connector.emitter?.off?.("message", onMessage);
+      },
+    };
+    session = s;
+
+    const fallBack = (error?: unknown) => {
+      if (session !== s) return;
+      end(s);
+      if (error !== undefined) getDeps().onFailed?.(error);
+      getDeps().showList();
+    };
+
+    connector.emitter?.on?.("message", onMessage);
+    deps.connect(connector).then(
+      () => end(s),
+      (error: unknown) => fallBack(error ?? new Error("connect failed")),
+    );
+
+    win?.addEventListener("blur", onLeave);
+    win?.addEventListener("pagehide", onLeave);
+    win?.addEventListener("focus", onReturn);
+    win?.addEventListener("pageshow", onReturn);
+    doc?.addEventListener("visibilitychange", onVisibility);
+    arm();
+
+    deps.showConnecting(walletId);
+    emit();
+  };
+
+  return {
+    open,
+    pending: () => session?.pending ?? null,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    cancel: () => {
+      if (session) end(session);
+    },
+  };
+}