@multiplatform.one/web3 7.19.0 → 7.21.0

package/src/bundler/metaMaskConnectTimeouts.spec.ts

@@ -0,0 +1,390 @@
+import { mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runInThisContext } from "node:vm";
+
+import type { Plugin as EsbuildPlugin } from "esbuild";
+import {
+  build,
+  type InlineConfig,
+  optimizeDeps,
+  type Plugin,
+  type Rolldown,
+  resolveConfig,
+} from "vite";
+import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
+
+import { metaMaskConnectTimeoutsEsbuild } from "../esbuild";
+import { metaMaskConnectTimeouts } from "../vite";
+import {
+  createMetaMaskConnectTimeoutTracker,
+  patchMetaMaskConnectTimeouts,
+} from "./metaMaskConnectTimeouts";
+
+const web3Root = fileURLToPath(new URL("../..", import.meta.url));
+const requireHere = createRequire(import.meta.url);
+
+const multichainPkg = "@metamask/connect-multichain";
+const dappClientPkg = "@metamask/mobile-wallet-protocol-dapp-client";
+
+/** Every JS file a package's root export can resolve to, whatever the bundler's conditions. */
+function exportedFiles(pkgDir: string): string[] {
+  const { exports } = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
+  const files = new Set<string>();
+  const walk = (node: unknown) => {
+    if (typeof node === "string") {
+      if (/\.[cm]?js$/.test(node)) files.add(join(pkgDir, node));
+    } else if (node && typeof node === "object") Object.values(node).forEach(walk);
+  };
+  walk(exports["."]);
+  return [...files];
+}
+
+const multichainDir = dirname(requireHere.resolve(`${multichainPkg}/package.json`));
+const dappClientDir = join(dirname(requireHere.resolve(dappClientPkg)), "..");
+const connectEvmEntry = requireHere.resolve("@metamask/connect-evm");
+const multichainFiles = exportedFiles(multichainDir);
+const dappClientFiles = exportedFiles(dappClientDir);
+const read = (file: string) => readFileSync(file, "utf8");
+
+const pageLoadResume =
+  /resumeSession_fn = function\(session, options\)[\s\S]*?isContinuingPriorAttempt \? this\.options\.resumeTimeout : options \? this\.options\.connectionTimeout : 120 \* 1e3/;
+const stockConnectionTimer =
+  /isContinuingPriorAttempt \? this\.options\.resumeTimeout : this\.options\.connectionTimeout/g;
+
+describe("the timer patches on the installed MetaMask Connect", () => {
+  it("finds every entry file the bundlers can pick", () => {
+    expect(multichainFiles.length).toBeGreaterThanOrEqual(4);
+    expect(dappClientFiles.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("raises the request timer to 600 s and the handshake timer to 540 s", () => {
+    for (const file of multichainFiles) {
+      const tracker = createMetaMaskConnectTimeoutTracker();
+      tracker.see(connectEvmEntry);
+      const code = read(file);
+      expect(code).toMatch(/DEFAULT_REQUEST_TIMEOUT\d* = 60 \* 1e3;\s+CONNECTION_GRACE_PERIOD =/);
+      const patched = tracker.patch(file, code)!.code;
+      expect(patched).toMatch(
+        /DEFAULT_REQUEST_TIMEOUT\d* = 600 \* 1e3;\s+CONNECTION_GRACE_PERIOD = 60 \* 1e3;/,
+      );
+      for (const dapp of dappClientFiles) tracker.patch(dapp, read(dapp));
+      expect(tracker.problem()).toBeUndefined();
+    }
+    for (const file of dappClientFiles) {
+      const code = read(file);
+      expect(code).toContain("HANDSHAKE_TIMEOUT = 60 * 1e3;");
+      const patched = patchMetaMaskConnectTimeouts(file, code)!.code;
+      expect(patched).toContain("HANDSHAKE_TIMEOUT = 540 * 1e3;");
+      expect(patched).not.toContain("HANDSHAKE_TIMEOUT = 60 * 1e3;");
+    }
+  });
+
+  it("gives only the option-less page-load resume the stock 120 s", () => {
+    for (const file of multichainFiles) {
+      const code = read(file);
+      expect(code.match(stockConnectionTimer)).toHaveLength(2);
+      const patched = patchMetaMaskConnectTimeouts(file, code)!.code;
+      expect(patched).toMatch(pageLoadResume);
+      // startSession (a new connect) keeps the long connection timer.
+      expect(patched.match(stockConnectionTimer)).toHaveLength(1);
+      expect(patched.indexOf("startSession_fn = function")).toBeLessThan(
+        patched.search(stockConnectionTimer),
+      );
+    }
+  });
+
+  it("fails the build when a package renames the marker it looks for", () => {
+    const [multichain] = multichainFiles;
+    const [dappClient] = dappClientFiles;
+
+    const renamedGrace = createMetaMaskConnectTimeoutTracker();
+    renamedGrace.see(connectEvmEntry);
+    expect(
+      renamedGrace.patch(
+        multichain!,
+        read(multichain!).replaceAll("CONNECTION_GRACE_PERIOD", "CONNECTION_GRACE_MS"),
+      ),
+    ).toBeUndefined();
+    renamedGrace.patch(dappClient!, read(dappClient!));
+    expect(renamedGrace.problem()).toMatch(
+      /left the timers in @metamask\/connect-multichain unpatched/,
+    );
+
+    const renamedHandshake = createMetaMaskConnectTimeoutTracker();
+    renamedHandshake.see(connectEvmEntry);
+    renamedHandshake.patch(multichain!, read(multichain!));
+    renamedHandshake.patch(
+      dappClient!,
+      read(dappClient!).replaceAll("HANDSHAKE_TIMEOUT", "HANDSHAKE_GRACE"),
+    );
+    expect(renamedHandshake.problem()).toMatch(
+      /left the timers in @metamask\/mobile-wallet-protocol-dapp-client unpatched/,
+    );
+  });
+
+  it("throws when a timer changed its value", () => {
+    const [multichain] = multichainFiles;
+    const [dappClient] = dappClientFiles;
+    const code = read(multichain!);
+
+    expect(() =>
+      patchMetaMaskConnectTimeouts(
+        multichain!,
+        code.replace(/(DEFAULT_REQUEST_TIMEOUT\d*) = 60 \* 1e3;/, "$1 = 90 * 1e3;"),
+      ),
+    ).toThrow(/timer DEFAULT_REQUEST_TIMEOUT not found/);
+    expect(() =>
+      patchMetaMaskConnectTimeouts(
+        dappClient!,
+        read(dappClient!).replace("HANDSHAKE_TIMEOUT = 60 * 1e3;", "HANDSHAKE_TIMEOUT = 45 * 1e3;"),
+      ),
+    ).toThrow(/timer HANDSHAKE_TIMEOUT not found/);
+    // A resume that no longer reads the connection timer must not send the
+    // rewrite on to startSession's copy of the expression.
+    expect(() =>
+      patchMetaMaskConnectTimeouts(
+        multichain!,
+        code.replace(stockConnectionTimer, (match, offset: number) =>
+          offset < code.indexOf("startSession_fn = function")
+            ? "isContinuingPriorAttempt ? this.options.resumeTimeout : this.options.handshakeTimeout"
+            : match,
+        ),
+      ),
+    ).toThrow(/timer the page-load session resume not found/);
+  });
+});
+
+type MWPTransportClass = new (
+  dappClient: unknown,
+  kvstore: unknown,
+) => {
+  options: { requestTimeout: number; connectionTimeout: number; resumeTimeout: number };
+  getActiveSession(): Promise<unknown>;
+  connect(options?: { scopes: string[]; caipAccountIds: string[] }): Promise<void>;
+};
+
+/** connect-multichain's MWPTransport from its node build, with the timer patch applied. */
+function loadPatchedMWPTransport() {
+  const file = requireHere.resolve(multichainPkg);
+  const code = patchMetaMaskConnectTimeouts(file, read(file))!.code;
+  const requireThere = createRequire(file);
+  const wrapper = runInThisContext(
+    `(function (module, exports, require, __filename, __dirname) {${code}\nreturn (init_mwp(), MWPTransport);\n})`,
+    { filename: file },
+  );
+  const module = { exports: {} };
+  const MWPTransport: MWPTransportClass = wrapper(
+    module,
+    module.exports,
+    requireThere,
+    file,
+    dirname(file),
+  );
+  const { TransportTimeoutError } = requireThere("@metamask/multichain-api-client");
+  return { MWPTransport, TransportTimeoutError: TransportTimeoutError as new () => Error };
+}
+
+describe("the patched MetaMask Connect transport", () => {
+  const { MWPTransport, TransportTimeoutError } = loadPatchedMWPTransport();
+
+  function transport(storedSession: boolean) {
+    // A relay that never answers: nothing resumes, nothing connects.
+    const dappClient = {
+      state: "DISCONNECTED",
+      on: vi.fn(),
+      off: vi.fn(),
+      once: vi.fn(),
+      resume: () => new Promise(() => undefined),
+      connect: () => new Promise(() => undefined),
+      disconnect: vi.fn(async () => undefined),
+      sendRequest: vi.fn(async () => undefined),
+    };
+    const store = new Map<string, string>();
+    const kvstore = {
+      get: async (key: string) => store.get(key) ?? null,
+      set: async (key: string, value: string) => void store.set(key, value),
+      delete: async (key: string) => void store.delete(key),
+    };
+    const mwp = new MWPTransport(dappClient, kvstore);
+    mwp.getActiveSession = async () => (storedSession ? { id: "stored" } : undefined);
+    return mwp;
+  }
+
+  function settle(promise: Promise<unknown>) {
+    const state: { error?: unknown; settled: boolean } = { settled: false };
+    promise.then(
+      () => Object.assign(state, { settled: true }),
+      (error) => Object.assign(state, { settled: true, error }),
+    );
+    return state;
+  }
+
+  afterEach(() => vi.useRealTimers());
+
+  it("waits 600 s for a reply and 660 s for a connection", () => {
+    expect(transport(false).options).toMatchObject({
+      requestTimeout: 600_000,
+      connectionTimeout: 660_000,
+    });
+  });
+
+  it("gives up on resuming a stored session on page load after 120 s", async () => {
+    vi.useFakeTimers();
+    const pageLoad = settle(transport(true).connect());
+    await vi.advanceTimersByTimeAsync(119_999);
+    expect(pageLoad.settled).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(pageLoad.error).toBeInstanceOf(TransportTimeoutError);
+  });
+
+  it("keeps a connect on a stored session open for 660 s", async () => {
+    vi.useFakeTimers();
+    const connect = settle(transport(true).connect({ scopes: ["eip155:1"], caipAccountIds: [] }));
+    await vi.advanceTimersByTimeAsync(659_999);
+    expect(connect.settled).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connect.error).toBeInstanceOf(TransportTimeoutError);
+  });
+
+  it("keeps a new connect open for 660 s", async () => {
+    vi.useFakeTimers();
+    const connect = settle(transport(false).connect({ scopes: ["eip155:1"], caipAccountIds: [] }));
+    await vi.advanceTimersByTimeAsync(659_999);
+    expect(connect.settled).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connect.error).toBeInstanceOf(TransportTimeoutError);
+  });
+});
+
+const entryId = "mpo-web3-timer-entry";
+const entrySource = 'export { createEVMClient } from "@metamask/connect-evm";';
+
+const entry: Plugin = {
+  name: "entry",
+  enforce: "pre",
+  resolveId: (id) => (id === entryId ? `\0${entryId}` : null),
+  load: (id) => (id === `\0${entryId}` ? entrySource : null),
+};
+
+/** Stands in for a MetaMask Connect release that renamed the marker the patch looks for. */
+const renameGracePeriod: Plugin = {
+  name: "rename-grace-period",
+  enforce: "pre",
+  transform: (code, id) =>
+    id.replace(/\\/g, "/").includes(`/${multichainPkg}/`)
+      ? code.replaceAll("CONNECTION_GRACE_PERIOD", "CONNECTION_GRACE_MS")
+      : null,
+};
+
+function expectLongTimers(code: string) {
+  expect(code).toMatch(/DEFAULT_REQUEST_TIMEOUT[\w$]* = 600 \* 1e3;\s+CONNECTION_GRACE_PERIOD/);
+  expect(code).toMatch(/HANDSHAKE_TIMEOUT[\w$]* = 540 \* 1e3;/);
+  expect(code).toMatch(/resumeTimeout : [\w$]+ \? this\.options\.connectionTimeout : 120 \* 1e3/);
+  expect(code).not.toMatch(/DEFAULT_REQUEST_TIMEOUT[\w$]* = 60 \* 1e3;\s+CONNECTION_GRACE_PERIOD/);
+  expect(code).not.toMatch(/HANDSHAKE_TIMEOUT[\w$]* = 60 \* 1e3;/);
+}
+
+function viteBuild(plugins: Plugin[]) {
+  return build({
+    configFile: false,
+    logLevel: "silent",
+    root: web3Root,
+    publicDir: false,
+    plugins,
+    build: {
+      write: false,
+      minify: false,
+      rolldownOptions: { input: entryId, preserveEntrySignatures: "exports-only" },
+    },
+  }) as Promise<Rolldown.RolldownOutput>;
+}
+
+describe("the bundler plugins", () => {
+  const cacheDirs: string[] = [];
+  afterAll(() => {
+    for (const dir of cacheDirs) rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("ships the long timers in a vite build", async () => {
+    const output = await viteBuild([entry, metaMaskConnectTimeouts()]);
+    expectLongTimers(output.output.map((chunk) => ("code" in chunk ? chunk.code : "")).join("\n"));
+  }, 120_000);
+
+  it("fails a vite build that bundles MetaMask Connect with a marker gone", async () => {
+    await expect(viteBuild([entry, renameGracePeriod, metaMaskConnectTimeouts()])).rejects.toThrow(
+      /left the timers in @metamask\/connect-multichain unpatched/,
+    );
+  }, 120_000);
+
+  async function preBundle(extra: Plugin[]) {
+    const cacheDir = mkdtempSync(join(tmpdir(), "mpo-web3-timers-"));
+    cacheDirs.push(cacheDir);
+    const inline: InlineConfig = {
+      configFile: false,
+      logLevel: "silent",
+      root: web3Root,
+      cacheDir,
+      optimizeDeps: {
+        include: ["@metamask/connect-evm"],
+        noDiscovery: true,
+        rolldownOptions: { plugins: extra },
+      },
+      plugins: [metaMaskConnectTimeouts()],
+    };
+    await optimizeDeps(await resolveConfig(inline, "serve"), true);
+    const deps = join(cacheDir, "deps");
+    return readdirSync(deps)
+      .filter((file) => file.endsWith(".js"))
+      .map((file) => readFileSync(join(deps, file), "utf8"))
+      .join("\n");
+  }
+
+  it("ships the long timers in the dev server's dependency pre-bundle", async () => {
+    expectLongTimers(await preBundle([]));
+  }, 120_000);
+
+  it("fails the dev server's pre-bundle when a marker is gone", async () => {
+    await expect(preBundle([renameGracePeriod])).rejects.toThrow(
+      /left the timers in @metamask\/connect-multichain unpatched/,
+    );
+  }, 120_000);
+
+  async function esbuildBundle(before: EsbuildPlugin[] = []) {
+    const esbuild = await import("esbuild");
+    const result = await esbuild.build({
+      stdin: { contents: entrySource, resolveDir: web3Root },
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "browser",
+      logLevel: "silent",
+      plugins: [...before, metaMaskConnectTimeoutsEsbuild()],
+    });
+    return result.outputFiles.map((file) => file.text).join("\n");
+  }
+
+  it("ships the long timers in an esbuild bundle", async () => {
+    expectLongTimers(await esbuildBundle());
+  }, 120_000);
+
+  it("fails an esbuild bundle when a marker is gone", async () => {
+    const renamed: EsbuildPlugin = {
+      name: "rename-grace-period",
+      setup(build) {
+        build.onLoad(
+          { filter: /[\\/]@metamask[\\/]connect-multichain[\\/].*\.[cm]?js$/ },
+          (args) => ({
+            contents: read(args.path).replaceAll("CONNECTION_GRACE_PERIOD", "CONNECTION_GRACE_MS"),
+            loader: "js",
+          }),
+        );
+      },
+    };
+    await expect(esbuildBundle([renamed])).rejects.toThrow(
+      /left the timers in @metamask\/connect-multichain unpatched/,
+    );
+  }, 120_000);
+});

package/src/bundler/metaMaskConnectTimeouts.ts

@@ -0,0 +1,126 @@
+// MetaMask Connect gives up on the wallet after fixed timers it has no option
+// for: a request's reply after 60 s, and the connect handshake 60 s after its
+// 60 s session request expires. Both are module constants (connect-multichain
+// builds its MWPTransport without options), so the only way to move them is to
+// rewrite the constant in the bundled source. On Android 16 the browser has no
+// network while MetaMask is in front, so the wallet's answer waits in the relay
+// until the user switches back; a user who lingered in MetaMask lost the request
+// to those timers. Both become ten minutes (540 s + the 60 s session expiry).
+//
+// The connection timer is the request timer plus 60 s, so it grows to 660 s with
+// it. That is right for a connect the user is approving in MetaMask, but the same
+// timer bounds resuming a stored session on page load, where nobody is in
+// MetaMask and connector calls wait on the resume. The resume made without
+// connect options (the page-load one) keeps the stock 120 s.
+//
+// A pattern that stops matching fails the build instead of quietly shipping the
+// short timers again.
+
+export type MetaMaskConnectTimerRewrite = {
+  /** The timer, as a build error names it. */
+  timer: string;
+  pattern: RegExp;
+  replacement: string;
+};
+
+export type MetaMaskConnectTimeoutPatch = {
+  pkg: string;
+  marker: string;
+  rewrites: readonly MetaMaskConnectTimerRewrite[];
+};
+
+export const metaMaskConnectTimeoutPatches: readonly MetaMaskConnectTimeoutPatch[] = [
+  {
+    pkg: "@metamask/connect-multichain",
+    marker: "CONNECTION_GRACE_PERIOD",
+    rewrites: [
+      {
+        timer: "DEFAULT_REQUEST_TIMEOUT",
+        pattern: /(DEFAULT_REQUEST_TIMEOUT\d*) = 60 \* 1e3;(\s+CONNECTION_GRACE_PERIOD =)/,
+        replacement: "$1 = 600 * 1e3;$2",
+      },
+      {
+        timer: "the page-load session resume",
+        pattern:
+          /(resumeSession_fn = function\((\w+), (\w+)\)(?:(?!startSession_fn)[\s\S])*?isContinuingPriorAttempt \? this\.options\.resumeTimeout : )this\.options\.connectionTimeout/,
+        replacement: "$1$3 ? this.options.connectionTimeout : 120 * 1e3",
+      },
+    ],
+  },
+  {
+    pkg: "@metamask/mobile-wallet-protocol-dapp-client",
+    marker: "HANDSHAKE_TIMEOUT",
+    rewrites: [
+      {
+        timer: "HANDSHAKE_TIMEOUT",
+        pattern: /(HANDSHAKE_TIMEOUT) = 60 \* 1e3;/,
+        replacement: "$1 = 540 * 1e3;",
+      },
+    ],
+  },
+];
+
+const metaMaskConnectPkg = "@metamask/connect-evm";
+
+const normalize = (id: string) => id.replace(/\\/g, "/");
+
+/** Which timer patch a module needs, or undefined when it carries none. */
+export function metaMaskConnectTimeoutPatchFor(
+  id: string,
+  code: string,
+): MetaMaskConnectTimeoutPatch | undefined {
+  const path = normalize(id);
+  return metaMaskConnectTimeoutPatches.find(
+    (patch) => path.includes(`/${patch.pkg}/`) && code.includes(patch.marker),
+  );
+}
+
+/**
+ * Raise the timers in one module's source. Returns undefined for a module that
+ * holds no timer, and throws when a module holds one the patterns no longer match.
+ */
+export function patchMetaMaskConnectTimeouts(
+  id: string,
+  code: string,
+): { pkg: string; code: string } | undefined {
+  const patch = metaMaskConnectTimeoutPatchFor(id, code);
+  if (!patch) return undefined;
+  let patched = code;
+  for (const rewrite of patch.rewrites) {
+    if (!rewrite.pattern.test(patched))
+      throw new Error(
+        `MetaMask Connect timer ${rewrite.timer} not found in ${id}: ${patch.pkg} changed its source, so the long Android timers cannot be applied`,
+      );
+    patched = patched.replace(rewrite.pattern, rewrite.replacement);
+  }
+  return { pkg: patch.pkg, code: patched };
+}
+
+/**
+ * Counts what one build patched, so the build can refuse to ship MetaMask Connect
+ * with a timer left short (a package renamed the marker the patch looks for).
+ */
+export function createMetaMaskConnectTimeoutTracker() {
+  const patched = new Map<string, number>();
+  let bundlesMetaMaskConnect = false;
+  return {
+    see(id: string) {
+      if (normalize(id).includes(`/${metaMaskConnectPkg}/`)) bundlesMetaMaskConnect = true;
+    },
+    patch(id: string, code: string) {
+      this.see(id);
+      const result = patchMetaMaskConnectTimeouts(id, code);
+      if (result) patched.set(result.pkg, (patched.get(result.pkg) ?? 0) + 1);
+      return result;
+    },
+    /** Error text when the build bundles MetaMask Connect with a timer left unpatched. */
+    problem(): string | undefined {
+      if (!bundlesMetaMaskConnect) return undefined;
+      const missing = metaMaskConnectTimeoutPatches
+        .map((patch) => patch.pkg)
+        .filter((pkg) => !patched.get(pkg));
+      if (!missing.length) return undefined;
+      return `the build bundles ${metaMaskConnectPkg} but left the timers in ${missing.join(", ")} unpatched`;
+    },
+  };
+}

package/src/connectkit/adapters/SolanaAdapter.ts

@@ -9,7 +9,7 @@
 // base64(message); message is the SIWS text; address == base58 ed25519 pubkey.
 //
 // (A future system-browser / Mobile-Wallet-Adapter path — the Solana analogue
-// of WalletConnect — would be a separate adapter, same as the Ethereum gap.)
+// of a relay — would be a separate adapter, same as the Ethereum gap.)
 
 import type { SignInMessageOptions, WalletAdapter, WalletAddress } from "./types";
 

package/src/connectkit/adapters/discover.ts

@@ -19,7 +19,7 @@ export interface WalletEntry {
 /**
  * Detect the non-EVM wallets present in the page (Solana / Sui / Bitcoin). EVM
  * wallets are intentionally NOT returned here — they are handled natively by
- * wagmi's EIP-6963 / Coinbase / WalletConnect connectors. One entry per
+ * wagmi's EIP-6963 / Coinbase / MetaMask connectors. One entry per
  * (ecosystem, primary wallet); each carries a ready wallet adapter.
  */
 export function discoverWallets(): WalletEntry[] {

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

@@ -9,7 +9,6 @@ import {
   isCoinbaseWalletConnector,
   isMetaMaskConnector,
   isPortoConnector,
-  isWalletConnectConnector,
   resolveListEntries,
   useModalState,
   useScreenRegistry,
@@ -25,7 +24,6 @@ import {
   RecentlyUsedTag,
 } from "./styles";
 
-import { useWeb3 } from "../../contexts/web3";
 import { WalletProps, useWallets } from "../../../wallets/useWallets";
 import { useLastConnector } from "../../../hooks/useLastConnector";
 import { setConnectIntent } from "../../../siwe/connectIntent";
@@ -62,13 +60,12 @@ const ConnectorList = () => {
 
   const filteredWallets = wallets.filter((wallet) => wallet.id !== aaveAccountConnector?.id);
 
-  const walletsToDisplay =
-    context.options?.hideRecentBadge || lastConnectorId === "walletConnect" // do not hoist walletconnect to top of list
-      ? filteredWallets
-      : [
-          ...filteredWallets.filter((wallet) => lastConnectorId === wallet.connector.id),
-          ...filteredWallets.filter((wallet) => lastConnectorId !== wallet.connector.id),
-        ];
+  const walletsToDisplay = context.options?.hideRecentBadge
+    ? filteredWallets
+    : [
+        ...filteredWallets.filter((wallet) => lastConnectorId === wallet.connector.id),
+        ...filteredWallets.filter((wallet) => lastConnectorId !== wallet.connector.id),
+      ];
 
   // Group by brand name (first-seen order preserved).
   const groups: WalletGroup[] = [];
@@ -205,63 +202,36 @@ const ConnectorItem = ({
   isRecent?: boolean;
   labelOverride?: string;
 }) => {
-  const {
-    connect: { getUri },
-  } = useWeb3();
-  const uri = getUri();
   const isMobile = useIsMobile();
   const context = useContext();
 
   const { connect } = useConnect();
 
-  let deeplink =
-    !isMetaMaskConnector(wallet.connector.id) && // metaMaskSDK deep-links via the SDK's connect(), never via WalletConnect
-    ((!wallet.isInstalled && isMobile) || (wallet.shouldDeeplinkDesktop && !isMobile))
-      ? wallet.getWalletConnectDeeplink?.(uri ?? "")
-      : undefined;
-
-  const redirectToMoreWallets = isMobile && isWalletConnectConnector(wallet.id);
   // Safari requires opening popup on user gesture, so we connect immediately here.
-  // metaMaskSDK on mobile must also connect inside the tap gesture so the SDK's
-  // app deeplink isn't blocked by the browser's user-activation rules.
+  // MetaMask on mobile must also connect inside the tap gesture so its app
+  // deeplink isn't blocked by the browser's user-activation rules.
   const shouldConnectImmediately =
     ((detectBrowser() === "safari" || detectBrowser() === "ios") &&
       (isCoinbaseWalletConnector(wallet.connector.id) || isPortoConnector(wallet.connector.id))) ||
     (isMobile && isMetaMaskConnector(wallet.connector.id));
 
-  if (redirectToMoreWallets || shouldConnectImmediately) deeplink = undefined; // mobile redirects to more wallets page
-
   return (
     <ConnectorButton
       type="button"
-      as={deeplink ? "a" : undefined}
-      href={deeplink ? deeplink : undefined}
       disabled={context.route !== routes.CONNECTORS}
-      onClick={
-        deeplink
-          ? undefined
-          : () => {
-              if (redirectToMoreWallets) {
-                context.setRoute(routes.MOBILECONNECTORS);
-              } else {
-                if (shouldConnectImmediately) {
-                  // Mobile deeplinks out to the wallet app and comes back through a
-                  // page remount, so record the intent to continue into signing before
-                  // we lose all in-memory state (see connectIntent).
-                  setConnectIntent();
-                  connect({ connector: wallet?.connector });
-                }
-                context.setRoute(routes.CONNECT);
-                context.setConnector({ id: wallet.id });
-              }
-            }
-      }
+      onClick={() => {
+        if (shouldConnectImmediately) {
+          // Mobile deeplinks out to the wallet app and comes back through a
+          // page remount, so record the intent to continue into signing before
+          // we lose all in-memory state (see connectIntent).
+          setConnectIntent();
+          connect({ connector: wallet?.connector });
+        }
+        context.setRoute(routes.CONNECT);
+        context.setConnector({ id: wallet.id });
+      }}
     >
-      <ConnectorIcon
-        data-small={wallet.iconShouldShrink}
-        data-shape={wallet.iconShape}
-        data-background={redirectToMoreWallets}
-      >
+      <ConnectorIcon data-small={wallet.iconShouldShrink} data-shape={wallet.iconShape}>
         {wallet.iconConnector ?? wallet.icon}
       </ConnectorIcon>
       <ConnectorLabel>