@multiplatform.one/web3 7.17.0 → 7.19.0

package/src/clients/walletStandard.ts

@@ -0,0 +1,87 @@
+// Minimal Wallet Standard plumbing for Solana: the registry handshake and the
+// feature shapes the client calls. Structural types instead of @wallet-standard/*
+// so the page bundle carries no extra package; Phantom, Solflare and Backpack all
+// register this way.
+
+export interface StandardWalletAccount {
+  readonly address: string;
+  readonly publicKey: Uint8Array;
+  readonly chains: readonly string[];
+  readonly features: readonly string[];
+}
+
+export interface StandardWallet {
+  readonly name: string;
+  readonly icon?: string;
+  readonly chains: readonly string[];
+  readonly accounts: readonly StandardWalletAccount[];
+  readonly features: Readonly<Record<string, unknown>>;
+}
+
+export const SolanaSignMessage = "solana:signMessage";
+export const SolanaSignTransaction = "solana:signTransaction";
+export const SolanaSignAndSendTransaction = "solana:signAndSendTransaction";
+export const StandardConnect = "standard:connect";
+
+export interface SolanaSignMessageFeature {
+  signMessage(
+    ...inputs: { account: StandardWalletAccount; message: Uint8Array }[]
+  ): Promise<{ signedMessage: Uint8Array; signature: Uint8Array }[]>;
+}
+
+export interface SolanaSignTransactionFeature {
+  signTransaction(
+    ...inputs: { account: StandardWalletAccount; transaction: Uint8Array; chain?: string }[]
+  ): Promise<{ signedTransaction: Uint8Array }[]>;
+}
+
+export interface SolanaSignAndSendTransactionFeature {
+  signAndSendTransaction(
+    ...inputs: {
+      account: StandardWalletAccount;
+      transaction: Uint8Array;
+      chain: string;
+      options?: { commitment?: "processed" | "confirmed" | "finalized"; skipPreflight?: boolean };
+    }[]
+  ): Promise<{ signature: Uint8Array }[]>;
+}
+
+export interface StandardConnectFeature {
+  connect(input?: { silent?: boolean }): Promise<{ accounts: readonly StandardWalletAccount[] }>;
+}
+
+/**
+ * Every wallet registered with the Wallet Standard right now. Wallets answer
+ * `app-ready` synchronously, so this can be called again to pick up late ones.
+ */
+export function getStandardWallets(): StandardWallet[] {
+  if (typeof window === "undefined") return [];
+  const wallets: StandardWallet[] = [];
+  const api = {
+    register: (...registered: StandardWallet[]) => {
+      wallets.push(...registered);
+      return () => {};
+    },
+  };
+  const onRegister = (event: Event) => {
+    try {
+      ((event as CustomEvent).detail as (a: typeof api) => void)(api);
+    } catch {
+      // a wallet that throws during registration is simply not offered
+    }
+  };
+  window.addEventListener("wallet-standard:register-wallet", onRegister);
+  try {
+    window.dispatchEvent(new CustomEvent("wallet-standard:app-ready", { detail: api }));
+  } finally {
+    window.removeEventListener("wallet-standard:register-wallet", onRegister);
+  }
+  return [...new Set(wallets)];
+}
+
+/** Wallets that can sign Solana transactions. */
+export function getSolanaWallets(): StandardWallet[] {
+  return getStandardWallets().filter(
+    (wallet) => wallet.features[SolanaSignTransaction] && wallet.features[StandardConnect],
+  );
+}

package/src/connectkit/components/Common/ConnectorList/index.tsx

@@ -10,6 +10,11 @@ import {
   isMetaMaskConnector,
   isPortoConnector,
   isWalletConnectConnector,
+  resolveListEntries,
+  useModalState,
+  useScreenRegistry,
+  type ScreenDef,
+  type ScreenListEntry,
 } from "@multiplatform.one/connectkit";
 
 import {
@@ -51,6 +56,9 @@ const ConnectorList = () => {
   const { lastConnectorId } = useLastConnector();
   const aaveAccountConnector = useAaveAccountConnector();
   const [expanded, setExpanded] = useState<string | null>(null);
+  const { screens } = useScreenRegistry();
+  const modalState = useModalState();
+  const screenEntries = resolveListEntries(screens, modalState);
 
   const filteredWallets = wallets.filter((wallet) => wallet.id !== aaveAccountConnector?.id);
 
@@ -79,7 +87,7 @@ const ConnectorList = () => {
     }
   }
 
-  if (groups.length === 0) {
+  if (groups.length === 0 && screenEntries.length === 0) {
     return (
       <ScrollArea mobileDirection={"horizontal"}>
         <Alert error>No connectors found in ConnectKit config.</Alert>
@@ -111,7 +119,7 @@ const ConnectorList = () => {
 
   return (
     <ScrollArea mobileDirection={"horizontal"}>
-      <ConnectorsContainer $mobile={isMobile} $totalResults={groups.length}>
+      <ConnectorsContainer $mobile={isMobile} $totalResults={groups.length + screenEntries.length}>
         {groups.map((group) =>
           group.members.length === 1 ? (
             <ConnectorItem
@@ -128,6 +136,9 @@ const ConnectorList = () => {
             />
           ),
         )}
+        {screenEntries.map((def) => (
+          <ScreenEntryItem key={def.id} def={def} />
+        ))}
       </ConnectorsContainer>
     </ScrollArea>
   );
@@ -135,6 +146,23 @@ const ConnectorList = () => {
 
 export default ConnectorList;
 
+// A registered screen offered in the list (GPG): tapping it routes to the screen.
+const ScreenEntryItem = ({ def }: { def: ScreenDef & { listEntry: ScreenListEntry } }) => {
+  const context = useContext();
+  const { name, icon } = def.listEntry;
+  return (
+    <ConnectorButton
+      type="button"
+      data-screen-entry={def.id}
+      disabled={context.route !== routes.CONNECTORS}
+      onClick={() => context.setRoute(def.id)}
+    >
+      <ConnectorIcon data-shape="squircle">{icon}</ConnectorIcon>
+      <ConnectorLabel>{name}</ConnectorLabel>
+    </ConnectorButton>
+  );
+};
+
 // A collapsed multi-chain wallet row — clicking expands the chain picker.
 const GroupItem = ({
   group,

package/src/connectkit/components/ConnectButton/index.tsx

@@ -25,6 +25,7 @@ import { useSIWE } from "../../siwe";
 import { Chain } from "viem";
 import { useChainIsSupported } from "../../hooks/useChainIsSupported";
 import { useEnsFallbackConfig } from "../../hooks/useEnsFallbackConfig";
+import { useConnectorLauncher } from "../../openConnector";
 
 const contentVariants: Variants = {
   initial: {
@@ -123,6 +124,7 @@ const ConnectButtonRenderer: React.FC<ConnectButtonRendererProps> = ({ children
   const isMounted = useIsMounted();
   const context = useContext();
   const { open, setOpen } = useModal();
+  const launcher = useConnectorLauncher();
 
   const { address, isConnected, chain } = useAccount();
   const isChainSupported = useChainIsSupported(chain?.id);
@@ -139,6 +141,7 @@ const ConnectButtonRenderer: React.FC<ConnectButtonRendererProps> = ({ children
   }
 
   function show() {
+    if (!isConnected && launcher?.openPreferredConnector()) return;
     setOpen(true);
     context.setRoute(isConnected ? routes.PROFILE : routes.CONNECTORS);
   }
@@ -336,11 +339,13 @@ export function ConnectKitButton({
   const isMounted = useIsMounted();
 
   const context = useContext();
+  const launcher = useConnectorLauncher();
 
   const { isConnected, address, chain } = useAccount();
   const chainIsSupported = useChainIsSupported(chain?.id);
 
   function show() {
+    if (!isConnected && launcher?.openPreferredConnector()) return;
     context.setOpen(true);
     context.setRoute(isConnected ? routes.PROFILE : routes.CONNECTORS);
   }

package/src/connectkit/components/ConnectModal/ConnectWithInjector/index.tsx

@@ -38,6 +38,7 @@ import { useConnect } from "../../../hooks/useConnect";
 import { useWallet } from "../../../wallets/useWallets";
 import { setConnectIntent } from "../../../siwe/connectIntent";
 import { isEmbeddedDesktopWebview } from "../../../connectors/embeddedDesktop";
+import { useConnectorLauncher } from "../../../openConnector";
 import CircleSpinner from "./CircleSpinner";
 
 export const states = {
@@ -166,6 +167,12 @@ const ConnectWithInjector: React.FC<{
     };
   }, [wallet?.connector]);
 
+  // openConnector fires connect() inside the app's own tap, before this screen
+  // mounts, so the connector may have announced its deeplink already.
+  const launcher = useConnectorLauncher();
+  const launchedHere = !!wallet && launcher?.pending?.connector.uid === wallet.connector.uid;
+  const deeplink = sdkDeeplink ?? (launchedHere ? launcher?.pendingDeeplink : null) ?? undefined;
+
   const expiryDefault = 9; // Starting at 10 causes layout shifting, better to start at 9
   const [expiryTimer, setExpiryTimer] = useState<number>(expiryDefault);
 
@@ -176,7 +183,7 @@ const ConnectWithInjector: React.FC<{
   const showEmbeddedDesktopMetaMaskQr =
     !isMobile &&
     isMetaMaskConnector(wallet?.connector.id) &&
-    !!sdkDeeplink &&
+    !!deeplink &&
     isEmbeddedDesktopWebview();
 
   const extensionUrl = wallet?.downloadUrls?.[browser];
@@ -221,6 +228,8 @@ const ConnectWithInjector: React.FC<{
     // (ConnectorList shouldConnectImmediately); firing again here would queue a
     // second SDK request / deeplink into the MetaMask app.
     if (isMobile && isMetaMaskConnector(wallet?.connector.id)) return;
+    // Same when openConnector already fired it inside the app's tap.
+    if (launchedHere) return;
 
     // UX: Give user time to see the UI before opening the extension
     connectTimeout = setTimeout(runConnect, 600);
@@ -468,11 +477,7 @@ const ConnectWithInjector: React.FC<{
                   )}
                 </ModalContent>
                 {showEmbeddedDesktopMetaMaskQr && (
-                  <CustomQRCode
-                    value={sdkDeeplink}
-                    image={walletInfo.icon}
-                    imagePosition="center"
-                  />
+                  <CustomQRCode value={deeplink} image={walletInfo.icon} imagePosition="center" />
                 )}
                 {/* The SDK auto-opens its deeplink, but browsers drop external-
                     protocol navigations whose user activation expired while the
@@ -485,8 +490,8 @@ const ConnectWithInjector: React.FC<{
                     ASWebAuthenticationSession). So once the SDK emits
                     display_uri we render it as a REAL anchor — same-tab,
                     because auth sheets can't open new tabs. */}
-                {isMobile && isMetaMaskConnector(wallet?.connector.id) && sdkDeeplink && (
-                  <Button href={sdkDeeplink} target="_self">
+                {isMobile && isMetaMaskConnector(wallet?.connector.id) && deeplink && (
+                  <Button href={deeplink} target="_self">
                     Open {walletInfo.name}
                   </Button>
                 )}

package/src/connectkit/connectors/walletAdapterConnector.ts

@@ -71,6 +71,8 @@ export function walletAdapterConnector(entry: WalletConnectorEntry) {
       icon: entry.icon,
       // custom tag read by getConnectorEcosystem()/WalletProps.ecosystem
       ecosystem: entry.ecosystem,
+      // read by clientForConnector() to build the per-chain client
+      adapter: entry.adapter,
 
       async getProvider() {
         return provider;

package/src/connectkit/index.ts

@@ -8,6 +8,14 @@ export { wallets } from "./wallets";
 // web3's wrapper (generic connectkit useModal + wallet/SIWE openers) keeps the
 // consumer-facing `useModal` API. The agnostic base lives in ./hooks/useModal.
 export { useWeb3Modal as useModal } from "./useWeb3Modal";
+export {
+  DEFAULT_DESKTOP_OPEN_CONNECTOR_FALLBACK_MS,
+  DEFAULT_OPEN_CONNECTOR_FALLBACK_MS,
+  type MobileConnectOptions,
+  type OpenConnectorOptions,
+  type Web3ConnectKitOptions,
+} from "./openConnector";
+export { CONNECT_INTENT_TTL_MS } from "./siwe/connectIntent";
 export { SIWEProvider, useSIWE, SIWE_NONCE_QUERY_KEY, SIWE_SESSION_QUERY_KEY } from "./siwe";
 export type { SIWESession, SIWEConfig } from "./siwe";
 

package/src/connectkit/openConnector/context.tsx

@@ -0,0 +1,176 @@
+import React, {
+  createContext,
+  useCallback,
+  useContext as useReactContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useSyncExternalStore,
+} from "react";
+import { useAccountEffect, type Connector } from "wagmi";
+import {
+  routes,
+  useContext,
+  isMobile,
+  type ConnectKitOptions,
+} from "@multiplatform.one/connectkit";
+
+import { useConnect } from "../hooks/useConnect";
+import { useConnectors } from "../hooks/useConnectors";
+import { useWallets, type WalletProps } from "../wallets/useWallets";
+import { clearConnectIntent, setConnectIntent } from "../siwe/connectIntent";
+import { defaultOpenConnectorFallbackMs } from "./device";
+import {
+  createConnectorLauncher,
+  type LauncherDeps,
+  type OpenConnectorOptions,
+  type PendingConnect,
+} from "./launcher";
+
+export type MobileConnectOptions = {
+  /**
+   * Connector id a phone connects straight to (e.g. `"metaMaskSDK"`): `openSIWE()`
+   * and the default ConnectKit button skip the wallet list for it. Desktop keeps
+   * the list. A phone here is what connectkit's `isMobile()` reads from the user
+   * agent, so iPadOS Safari and Android's "Desktop site", which both send a desktop
+   * one, keep the list too.
+   */
+  preferredConnector?: string;
+  /** Passed to `openConnector` for the preferred connector. */
+  fallbackMs?: number;
+};
+
+/** ConnectKit options as web3's ConnectKitProvider takes them. */
+export type Web3ConnectKitOptions = ConnectKitOptions & {
+  mobile?: MobileConnectOptions;
+};
+
+export type ConnectorLauncherValue = {
+  openConnector: (id: string, options?: OpenConnectorOptions) => void;
+  /**
+   * On a phone with `mobile.preferredConnector` set, open that connector and
+   * return true. Otherwise do nothing and return false.
+   */
+  openPreferredConnector: () => boolean;
+  /** Wallet id `openConnector` is connecting, or null. */
+  pendingConnector: string | null;
+  /** The pending connect's wallet deeplink, once the connector announced it. */
+  pendingDeeplink: string | null;
+  /** The pending connect, for screens that must not start a second one. */
+  pending: PendingConnect | null;
+};
+
+const ConnectorLauncherContext = createContext<ConnectorLauncherValue | null>(null);
+
+/** The launcher, or null outside web3's ConnectKitProvider. */
+export function useConnectorLauncher(): ConnectorLauncherValue | null {
+  return useReactContext(ConnectorLauncherContext);
+}
+
+export function getMobileOptions(options?: ConnectKitOptions): MobileConnectOptions {
+  return (options as Web3ConnectKitOptions | undefined)?.mobile ?? {};
+}
+
+/**
+ * Find the list wallet for a connector id. The list hides the MetaMask SDK row
+ * behind an injected MetaMask (EIP-6963 `io.metamask`), so an id that is not in
+ * the list resolves through its connector's rdns.
+ */
+export function resolveWallet(
+  wallets: readonly WalletProps[],
+  connectors: readonly Connector[],
+  id: string,
+): WalletProps | undefined {
+  const direct = wallets.find((wallet) => wallet.id === id);
+  if (direct) return direct;
+  const connector = connectors.find((c) => c.id === id);
+  if (!connector) return undefined;
+  const rdns = connector.rdns === undefined ? [] : [connector.rdns].flat();
+  return wallets.find((wallet) => rdns.includes(wallet.id));
+}
+
+export const ConnectorLauncherProvider: React.FC<{ children: React.ReactNode }> = ({
+  children,
+}) => {
+  const context = useContext();
+  const wallets = useWallets();
+  const { connectAsync } = useConnect();
+  const connectors = useConnectors();
+
+  const depsRef = useRef<LauncherDeps>(null as unknown as LauncherDeps);
+  depsRef.current = {
+    connect: (connector) => connectAsync({ connector }),
+    showConnecting: (walletId) => {
+      context.setConnector({ id: walletId });
+      context.setRoute(routes.CONNECT);
+      context.setOpen(true);
+    },
+    showList: () => {
+      context.setRoute(routes.CONNECTORS);
+      context.setOpen(true);
+    },
+    onFailed: () => clearConnectIntent(),
+  };
+  const latest = useRef({ wallets, connectors, options: context.options });
+  latest.current = { wallets, connectors, options: context.options };
+
+  const launcher = useMemo(() => createConnectorLauncher(() => depsRef.current), []);
+  useEffect(() => () => launcher.cancel(), [launcher]);
+  const pending = useSyncExternalStore(launcher.subscribe, launcher.pending, launcher.pending);
+
+  // The session belongs to the connecting screen it opened. Once the user closes the
+  // modal or moves off that screen, a fallback must not pull the list back up.
+  const { open, route } = context;
+  const shownId = context.connector?.id;
+  useEffect(() => {
+    if (!pending) return;
+    if (!open || route !== routes.CONNECT || shownId !== pending.walletId) launcher.cancel();
+  }, [launcher, pending, open, route, shownId]);
+
+  // Any wallet connecting ends the session, including one the user connected some
+  // other way while this connect never answered.
+  useAccountEffect({ onConnect: () => launcher.cancel() });
+
+  const openConnector = useCallback(
+    (id: string, options: OpenConnectorOptions = {}) => {
+      const { wallets, connectors } = latest.current;
+      const wallet = resolveWallet(wallets, connectors, id);
+      if (!wallet) {
+        context.log(`openConnector: no connector ${id}, showing the wallet list.`);
+        depsRef.current.showList();
+        return;
+      }
+      // A phone bounces out to the wallet app and often reloads this page on the
+      // way back; the intent is what carries the flow on into signing.
+      setConnectIntent();
+      launcher.open(wallet.id, wallet.connector, {
+        fallbackMs: options.fallbackMs ?? defaultOpenConnectorFallbackMs(),
+      });
+    },
+    // context.log is stable enough for a debug line; the rest is read through refs.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [launcher],
+  );
+
+  const openPreferredConnector = useCallback(() => {
+    const mobile = getMobileOptions(latest.current.options);
+    if (!mobile.preferredConnector || !isMobile()) return false;
+    openConnector(mobile.preferredConnector, { fallbackMs: mobile.fallbackMs });
+    return true;
+  }, [openConnector]);
+
+  const value = useMemo<ConnectorLauncherValue>(
+    () => ({
+      openConnector,
+      openPreferredConnector,
+      pendingConnector: pending?.walletId ?? null,
+      pendingDeeplink: pending?.deeplink ?? null,
+      pending,
+    }),
+    [openConnector, openPreferredConnector, pending],
+  );
+
+  return (
+    <ConnectorLauncherContext.Provider value={value}>{children}</ConnectorLauncherContext.Provider>
+  );
+};

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";