@multiplatform.one/web3 7.26.0 → 7.28.1

package/src/connectkit/adapters/SuiAdapter.ts

@@ -21,7 +21,15 @@ interface StandardWallet {
 }
 
 interface ConnectFeature {
-  connect: () => Promise<{ accounts?: ReadonlyArray<{ address: string }> }>;
+  connect: (input?: {
+    silent?: boolean;
+  }) => Promise<{ accounts?: ReadonlyArray<{ address: string }> }>;
+}
+interface EventsFeature {
+  on: (
+    event: "change",
+    listener: (properties: { accounts?: ReadonlyArray<{ address: string }> }) => void,
+  ) => () => void;
 }
 interface DisconnectFeature {
   disconnect: () => Promise<void>;
@@ -35,6 +43,7 @@ interface SignPersonalMessageFeature {
 
 /** Minimal Wallet-Standard discovery: returns wallets exposing the Sui sign feature. */
 export function discoverSuiWallets(): StandardWallet[] {
+  if (typeof window === "undefined" || typeof window.addEventListener !== "function") return [];
   const wallets: StandardWallet[] = [];
   const api = {
     register: (...ws: StandardWallet[]) => {
@@ -84,6 +93,43 @@ export class SuiAdapter implements WalletAdapter {
     this.isConnected = true;
   }
 
+  /**
+   * Reconnects without a prompt (`standard:connect` with `silent`). Resolves
+   * false when the wallet answers with no account or refuses (4001); throws
+   * on any other failure, and when no Sui wallet has registered yet.
+   */
+  async restore(): Promise<boolean> {
+    const wallets = discoverSuiWallets();
+    if (!wallets.length) throw new Error("No Sui wallet has registered yet.");
+    const wallet = wallets[0];
+    const connectFeature = wallet.features["standard:connect"] as ConnectFeature;
+    const res = await connectFeature.connect({ silent: true }).catch((error: unknown) => {
+      if ((error as { code?: unknown } | null)?.code === 4001) return undefined;
+      throw error;
+    });
+    const account = res?.accounts?.[0];
+    if (!account) return false;
+    this.wallet = wallet;
+    this.account = account;
+    this.address = account.address;
+    this.isConnected = true;
+    return true;
+  }
+
+  /** The wallet's account changes (`standard:events`); no accounts means it disconnected. */
+  subscribe(listener: () => void): () => void {
+    const events = this.wallet?.features?.["standard:events"] as EventsFeature | undefined;
+    if (!events) return () => {};
+    return events.on("change", ({ accounts }) => {
+      if (!accounts) return;
+      const account = accounts[0] ?? null;
+      this.account = account;
+      this.address = account?.address ?? null;
+      this.isConnected = account !== null;
+      listener();
+    });
+  }
+
   async disconnect(): Promise<void> {
     try {
       const f = this.wallet?.features?.["standard:disconnect"] as DisconnectFeature | undefined;

package/src/connectkit/connectors/ensureWalletConnectors.ts

@@ -1,6 +1,8 @@
 import type { Config, Connector, CreateConnectorFn } from "wagmi";
 
+import { getConnectorEcosystem } from "@multiplatform.one/connectkit";
 import { discoverWallets } from "../adapters/discover";
+import { ecosystemBySyntheticChainId } from "./syntheticChains";
 import { walletAdapterConnector } from "./walletAdapterConnector";
 
 /**
@@ -11,6 +13,9 @@ import { walletAdapterConnector } from "./walletAdapterConnector";
  * `window.unisat` AFTER config creation, so a one-shot discovery misses it and Bitcoin never
  * appears in the modal. This adds the missing connectors to the live config (mirroring how wagmi
  * registers EIP-6963 connectors as wallets announce). Idempotent — skips ids already registered.
+ * Only ecosystems the config already lists, through a synthetic chain or a wallet connector,
+ * are added, so a config built with `enableWallet: false`, or a list of ecosystems, keeps to
+ * what it asked for.
  *
  * @returns the number of connectors added (0 when nothing new was found).
  */
@@ -27,10 +32,14 @@ export function ensureWalletConnectors(config: Config): number {
   )._internal;
   if (!internal) return 0;
 
+  const listed = new Set([
+    ...config.chains.map((chain) => ecosystemBySyntheticChainId[chain.id]),
+    ...config.connectors.map((connector) => getConnectorEcosystem(connector)),
+  ]);
   const existing = new Set(config.connectors.map((c) => c.id));
   let added = 0;
   for (const entry of discoverWallets()) {
-    if (existing.has(entry.id)) continue;
+    if (existing.has(entry.id) || !listed.has(entry.ecosystem)) continue;
     const fn = walletAdapterConnector({
       id: entry.id,
       name: entry.name,

package/src/connectkit/connectors/getWalletConnectors.ts

@@ -6,6 +6,8 @@ import { walletAdapterConnector } from "./walletAdapterConnector";
  * Map wallet `discoverWallets()` output → wagmi `CreateConnectorFn[]`, ready to spread
  * into `createConfig({ connectors: [...evmConnectors, ...getWalletConnectors()] })`.
  * Defaults to probing the page; pass a curated list to override.
+ *
+ * @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`.
  */
 export function getWalletConnectors(
   entries: WalletEntry[] = discoverWallets(),

package/src/connectkit/connectors/syntheticChains.ts

@@ -10,8 +10,11 @@ import type { Ecosystem } from "@multiplatform.one/connectkit";
 
 // 0x534f4c="SOL", 0x535549="SUI", 0x425443="BTC" — reserved, collision-free vs
 // real EVM chainIds.
+/** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const SOLANA_CHAIN_ID = 0x534f4c; // 5_459_788
+/** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const SUI_CHAIN_ID = 0x535549; // 5_461_321
+/** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const BITCOIN_CHAIN_ID = 0x425443; // 4_347_459
 
 export const syntheticChainIdByEcosystem: Record<Exclude<Ecosystem, "evm">, number> = {
@@ -26,6 +29,7 @@ export const ecosystemBySyntheticChainId: Record<number, Ecosystem> = {
   [BITCOIN_CHAIN_ID]: "bitcoin",
 };
 
+/** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const isSyntheticChainId = (chainId?: number): boolean =>
   chainId != null && chainId in ecosystemBySyntheticChainId;
 
@@ -46,8 +50,12 @@ const makeChain = (id: number, name: string, symbol: string, decimals: number):
   rpcUrls: { default: { http: [placeholderRpcUrl] } },
 });
 
+/** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const solanaChain = makeChain(SOLANA_CHAIN_ID, "Solana", "SOL", 9);
+/** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const suiChain = makeChain(SUI_CHAIN_ID, "Sui", "SUI", 9);
+/** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const bitcoinChain = makeChain(BITCOIN_CHAIN_ID, "Bitcoin", "BTC", 8);
 
+/** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const syntheticChains: Chain[] = [solanaChain, suiChain, bitcoinChain];

package/src/connectkit/connectors/walletAdapterConnector.ts

@@ -27,6 +27,8 @@ type ProviderListener = (payload?: unknown) => void;
  * satisfy wagmi's types — it is NEVER used as a real EVM address (only displayed,
  * and handed to Keycloak as the signed message's account). Modeled on
  * createBridgeConnector (see ../../bridge/bridgeConnector.ts).
+ *
+ * @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in 8.0.0 when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`.
  */
 export function walletAdapterConnector(entry: WalletConnectorEntry) {
   const chainId = syntheticChainIdByEcosystem[entry.ecosystem];

package/src/connectkit/defaultConfig.ts

@@ -6,8 +6,9 @@ import { EthereumProviderOptions as AaveAccountOptions } from "@aave/account";
 
 import { setAppMeta } from "@multiplatform.one/connectkit";
 import defaultConnectors from "./defaultConnectors";
+import { discoverWallets, type WalletEcosystem } from "./adapters/discover";
 import { getWalletConnectors } from "./connectors/getWalletConnectors";
-import { syntheticChains } from "./connectors/syntheticChains";
+import { ecosystemBySyntheticChainId, syntheticChains } from "./connectors/syntheticChains";
 
 // App name/icon now live in connectkit's agnostic appMeta module; re-exported here
 // for back-compat.
@@ -27,8 +28,9 @@ type DefaultConfigProps = {
   enableAaveAccount?: boolean;
   aaveAccountOptions?: AaveAccountOptions;
   // wallet: append shim-connectors for any detected non-EVM wallet (Solana/Sui/
-  // Bitcoin) alongside the EVM connectors. No-op when none are installed.
-  enableWallet?: boolean;
+  // Bitcoin) alongside the EVM connectors. No-op when none are installed. A list
+  // limits it to those ecosystems.
+  enableWallet?: boolean | readonly WalletEcosystem[];
 } & Partial<CreateConfigParameters>;
 
 let warnedProjectId = false;
@@ -57,11 +59,18 @@ const defaultConfig = ({
   setAppMeta(appName, appIcon);
   if (walletConnectProjectId) warnIgnoredProjectId();
 
+  const ecosystems: readonly WalletEcosystem[] =
+    enableWallet === true ? ["solana", "sui", "bitcoin"] : enableWallet || [];
+
   // Register the wallet synthetic chains so wagmi can resolve a `chain` object for a
   // connected non-EVM account — ConnectKit's SIWE signIn reads `chain.id`, which is
   // undefined otherwise ("No chainId found"). They carry no real RPC and are never
-  // used for transactions.
-  const allChains = (enableWallet ? [...chains, ...syntheticChains] : chains) as typeof chains;
+  // used for transactions. They also tell ensureWalletConnectors which ecosystems
+  // this config lists.
+  const walletChains = syntheticChains.filter((chain) =>
+    ecosystems.includes(ecosystemBySyntheticChainId[chain.id] as WalletEcosystem),
+  );
+  const allChains = [...chains, ...walletChains] as unknown as typeof chains;
 
   // TODO: nice to have, automate transports based on chains, but for now just provide public if not provided
   const transports: CreateConfigParameters["transports"] =
@@ -83,8 +92,13 @@ const defaultConfig = ({
 
   // Append wallet shim-connectors for detected non-EVM wallets. discoverWallets()
   // returns [] under SSR / when none are installed, so this is a safe no-op there.
-  const connectors: CreateConfigParameters["connectors"] = enableWallet
-    ? [...(baseConnectors ?? []), ...getWalletConnectors()]
+  const connectors: CreateConfigParameters["connectors"] = ecosystems.length
+    ? [
+        ...(baseConnectors ?? []),
+        ...getWalletConnectors(
+          discoverWallets().filter((entry) => ecosystems.includes(entry.ecosystem)),
+        ),
+      ]
     : baseConnectors;
 
   const config: CreateConfigParameters<any, any> = {

package/src/connectkit/siwe/SIWEContext.tsx

@@ -17,6 +17,9 @@ export type SIWESession = {
 
 export type SIWEConfig = {
   // Required
+  // Called at mount and again for every sign-in. A GpgProvider that shows a
+  // challenge built on the same server nonce needs a getNonce that returns the
+  // same nonce until it is spent, as keycloakWallet's does.
   getNonce: () => Promise<string>;
   createMessage: (args: {
     nonce: string;

package/src/connectkit/siwe/SIWEProvider.spec.tsx

@@ -178,3 +178,112 @@ describe("SIWEProvider signing", () => {
     expect(onSign).toHaveBeenCalledWith(expect.objectContaining({ username: "0xevmsig" }));
   });
 });
+
+describe("SIWEProvider nonce", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  // A server that replaces its nonce on every fetch and consumes it on verify,
+  // like Keycloak's /siww/nonce and /siww/register.
+  function nonceServer(fail?: (n: number) => boolean) {
+    let issued = 0;
+    let live: string | undefined;
+    const verified: string[] = [];
+    return {
+      verified,
+      getNonce: async () => {
+        issued += 1;
+        if (fail?.(issued)) throw new Error(`nonce ${issued} failed`);
+        live = `nonce-${issued}`;
+        return live;
+      },
+      verifyMessage: async ({ message }: { message: string }) => {
+        const nonce = message.split(" ").pop();
+        if (!nonce || nonce !== live) return false;
+        live = undefined;
+        verified.push(nonce);
+        return true;
+      },
+    };
+  }
+
+  function mount(server: ReturnType<typeof nonceServer>) {
+    mockUseAccount.mockReturnValue({
+      address: evmAddress,
+      chain: { id: 1 },
+      chainId: 1,
+      connector: { id: "metaMask", type: "injected" },
+    });
+    const createMessage = vi.fn(
+      ({ address, nonce }: { address: string; nonce: string }) =>
+        `example.com login ${address} ${nonce}`,
+    );
+    let ctx: SIWEContextValue | null = null;
+    const Probe = () => {
+      ctx = useContext(SIWEContext);
+      return null;
+    };
+    // staleTime Infinity as an app default must not keep the mount's nonce alive.
+    const client = new QueryClient({
+      defaultOptions: { queries: { staleTime: Infinity, retry: false } },
+    });
+    render(
+      <QueryClientProvider client={client}>
+        <SIWEProvider
+          getNonce={server.getNonce}
+          createMessage={createMessage}
+          verifyMessage={server.verifyMessage}
+          getSession={async () => null}
+          signOut={async () => true}
+        >
+          <Probe />
+        </SIWEProvider>
+      </QueryClientProvider>,
+    );
+    return { createMessage, ctx: () => ctx! };
+  }
+
+  it("signs each sign-in with a nonce fetched for it, so a second one verifies against a server that consumes nonces", async () => {
+    const server = nonceServer();
+    const { ctx } = mount(server);
+    await waitFor(() => expect(ctx().nonce.data).toBe("nonce-1"));
+
+    const results: unknown[] = [];
+    for (let round = 0; round < 2; round += 1) {
+      await act(async () => {
+        results.push(await ctx().signIn());
+      });
+    }
+
+    expect(results).not.toContain(false);
+    expect(server.verified).toEqual(["nonce-2", "nonce-3"]);
+  });
+
+  it("retries a failed nonce fetch once", async () => {
+    const server = nonceServer((n) => n === 2);
+    const { ctx } = mount(server);
+    await waitFor(() => expect(ctx().nonce.data).toBe("nonce-1"));
+
+    let result: unknown;
+    await act(async () => {
+      result = await ctx().signIn();
+    });
+
+    expect(result).not.toBe(false);
+    expect(server.verified).toEqual(["nonce-3"]);
+  });
+
+  it("fails the sign-in when its nonce fetch keeps failing, instead of signing the cached one", async () => {
+    const server = nonceServer((n) => n >= 2);
+    const { createMessage, ctx } = mount(server);
+    await waitFor(() => expect(ctx().nonce.data).toBe("nonce-1"));
+
+    let result: unknown;
+    await act(async () => {
+      result = await ctx().signIn();
+    });
+
+    expect(result).toBe(false);
+    expect(createMessage).not.toHaveBeenCalled();
+    expect(ctx().status).toBe("error");
+  });
+});

package/src/connectkit/siwe/SIWEProvider.tsx

@@ -20,6 +20,12 @@ export const SIWE_SESSION_QUERY_KEY = "ckSiweSession";
 // UTF-8-safe base64 — the keycloak SPI decodes the submitted message as UTF-8.
 const b64 = (s: string) => window.btoa(unescape(encodeURIComponent(s)));
 
+/**
+ * Sign-in over wagmi's account, mounted outside ConnectKitProvider.
+ * @deprecated Goes in 8.0.0. `SignInProvider` signs with whichever family the
+ * connection store holds: `<SignInProvider {...kc.signInConfig(onSign)}>`,
+ * or Web3Provider's `signIn` prop.
+ */
 export const SIWEProvider = ({
   children,
   enabled = true,
@@ -130,13 +136,16 @@ export const SIWEProvider = ({
 
       setStatus(StatusState.LOADING);
 
-      // Read the query live, not this render's `nonce`: right after a reset
-      // its data is the nonce the server just dropped, so wait for the refetch.
-      const nonceState = queryClient.getQueryState<string>([SIWE_NONCE_QUERY_KEY]);
-      const nonceValue =
-        nonceState?.fetchStatus === "fetching"
-          ? (await nonce.refetch({ cancelRefetch: false })).data
-          : nonceState?.data;
+      // Fetch this sign-in's own nonce. A server that consumes its nonce on
+      // verify refuses the one cached at mount the second time, so a cached
+      // value is never reused. A fetch already in flight, such as a reset's
+      // refetch, is joined rather than repeated.
+      const nonceValue = await queryClient.fetchQuery({
+        queryKey: [SIWE_NONCE_QUERY_KEY],
+        queryFn: () => siweConfig.getNonce(),
+        staleTime: 0,
+        retry: 1,
+      });
       if (!nonceValue) {
         throw new Error("Could not fetch nonce");
       }

package/src/connectkit/siwe/connectIntent.spec.ts

@@ -3,7 +3,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   CONNECT_INTENT_TTL_MS,
   clearConnectIntent,
-  consumeConnectIntent,
+  hasConnectIntent,
+  isRestoredPage,
+  resetConnectIntentPage,
   setConnectIntent,
 } from "./connectIntent";
 
@@ -20,71 +22,139 @@ function memoryStorage() {
 
 describe("connectIntent", () => {
   let storage: ReturnType<typeof memoryStorage>;
+  let session: ReturnType<typeof memoryStorage>;
+
+  /** A new document: sessionStorage survives only a same-tab reload, and a browser kill loses it. */
+  const newPage = (keepsSession: boolean) => {
+    resetConnectIntentPage();
+    if (!keepsSession) session.removeItem(KEY);
+  };
 
   beforeEach(() => {
     storage = memoryStorage();
-    vi.stubGlobal("window", { sessionStorage: storage });
+    session = memoryStorage();
+    vi.stubGlobal("window", { localStorage: storage, sessionStorage: session });
   });
   afterEach(() => {
     vi.unstubAllGlobals();
+    resetConnectIntentPage();
   });
 
-  it("defaults the TTL to 90 s", () => {
-    expect(CONNECT_INTENT_TTL_MS).toBe(90_000);
+  it("defaults the TTL to 10 min, the MetaMask Connect request budget", () => {
+    expect(CONNECT_INTENT_TTL_MS).toBe(600_000);
   });
 
-  it("is honoured within the TTL", () => {
+  it("is honoured within the TTL on the page that set it", () => {
     setConnectIntent(undefined, 1_000);
-    expect(consumeConnectIntent(1_000 + 89_999)).toBe(true);
+    expect(hasConnectIntent(1_000 + 599_999, false)).toBe(true);
   });
 
   it("expires after the TTL, so a cold load never fires an unsolicited signature", () => {
     setConnectIntent(undefined, 1_000);
-    expect(consumeConnectIntent(1_000 + 90_000)).toBe(false);
+    expect(hasConnectIntent(1_000 + 600_000, true)).toBe(false);
     expect(storage.getItem(KEY)).toBeNull();
   });
 
-  it("is consumed once", () => {
+  it("is read without being used up, so a page lost after reading it leaves it for the next", () => {
+    setConnectIntent(undefined, 1_000);
+    expect(hasConnectIntent(2_000, false)).toBe(true);
+    expect(hasConnectIntent(3_000, false)).toBe(true);
+    expect(storage.getItem(KEY)).toBe(String(601_000));
+  });
+
+  it("after a browser kill, carries over to a page the browser brought back, not to one opened fresh", () => {
+    setConnectIntent(undefined, 1_000);
+    newPage(false);
+    expect(hasConnectIntent(2_000, false)).toBe(false);
+    expect(hasConnectIntent(2_000, true)).toBe(true);
+    expect(storage.getItem(KEY)).toBe(String(601_000));
+  });
+
+  it("carries over a same-tab reload whatever the browser reports about it", () => {
     setConnectIntent(undefined, 1_000);
-    expect(consumeConnectIntent(2_000)).toBe(true);
-    expect(consumeConnectIntent(2_000)).toBe(false);
+    newPage(true);
+    expect(hasConnectIntent(2_000, false)).toBe(true);
   });
 
   it("takes a custom TTL", () => {
     setConnectIntent(5_000, 1_000);
-    expect(consumeConnectIntent(5_999)).toBe(true);
-    setConnectIntent(5_000, 1_000);
-    expect(consumeConnectIntent(6_000)).toBe(false);
+    expect(hasConnectIntent(5_999, false)).toBe(true);
+    expect(hasConnectIntent(6_000, false)).toBe(false);
   });
 
   it("treats the old '1' flag as expired", () => {
     storage.setItem(KEY, "1");
-    expect(consumeConnectIntent()).toBe(false);
+    expect(hasConnectIntent(Date.now(), true)).toBe(false);
     expect(storage.getItem(KEY)).toBeNull();
   });
 
-  it("is false with nothing stored and after a clear", () => {
-    expect(consumeConnectIntent()).toBe(false);
+  it("is false with nothing stored and after a clear, even on a restored page", () => {
+    expect(hasConnectIntent(Date.now(), true)).toBe(false);
     setConnectIntent();
     clearConnectIntent();
-    expect(consumeConnectIntent()).toBe(false);
+    expect(hasConnectIntent(Date.now(), true)).toBe(false);
+  });
+
+  it("lives in localStorage, which a browser kill keeps, and in sessionStorage", () => {
+    setConnectIntent(undefined, 1_000);
+    expect(storage.getItem(KEY)).toBe(String(601_000));
+    expect(session.getItem(KEY)).toBe(String(601_000));
+    clearConnectIntent();
+    expect(storage.getItem(KEY)).toBeNull();
+    expect(session.getItem(KEY)).toBeNull();
+  });
+
+  it("falls back to sessionStorage where localStorage is missing or has no methods", () => {
+    vi.stubGlobal("window", { localStorage: {}, sessionStorage: session });
+    setConnectIntent(undefined, 1_000);
+    expect(session.getItem(KEY)).toBe(String(601_000));
+    expect(hasConnectIntent(2_000, false)).toBe(true);
   });
 
   it("degrades to false when storage throws", () => {
-    vi.stubGlobal("window", {
-      sessionStorage: {
-        getItem: () => {
-          throw new Error("SecurityError");
-        },
-        setItem: () => {
-          throw new Error("SecurityError");
-        },
-        removeItem: () => {
-          throw new Error("SecurityError");
-        },
+    const throwing = {
+      getItem: () => {
+        throw new Error("SecurityError");
+      },
+      setItem: () => {
+        throw new Error("SecurityError");
       },
-    });
+      removeItem: () => {
+        throw new Error("SecurityError");
+      },
+    };
+    vi.stubGlobal("window", { localStorage: throwing, sessionStorage: throwing });
     expect(() => setConnectIntent()).not.toThrow();
-    expect(consumeConnectIntent()).toBe(false);
+    expect(hasConnectIntent(Date.now(), true)).toBe(false);
+  });
+});
+
+describe("isRestoredPage", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  const page = (type: string, wasDiscarded = false) => {
+    vi.stubGlobal("document", { wasDiscarded });
+    vi.stubGlobal("performance", { getEntriesByType: () => [{ type }] });
+  };
+
+  it("is true for a reload and for the history restore of a killed tab", () => {
+    page("reload");
+    expect(isRestoredPage()).toBe(true);
+    page("back_forward");
+    expect(isRestoredPage()).toBe(true);
+  });
+
+  it("is true for a discarded tab", () => {
+    page("navigate", true);
+    expect(isRestoredPage()).toBe(true);
+  });
+
+  it("is false for a page opened fresh or where the browser says nothing", () => {
+    page("navigate");
+    expect(isRestoredPage()).toBe(false);
+    vi.stubGlobal("performance", undefined);
+    expect(isRestoredPage()).toBe(false);
   });
 });