Fix MetaMask-mobile voting: ensure mainnet before signing the ballot (#16)

xerxes-openclaw · claude · web-flow · commit bb91c047f965 · 2026-07-23T11:55:30.000-07:00
The ballot is EIP-712 signed with the domain pinned to mainnet (chainId 1).
MetaMask refuses to sign typed data whose domain.chainId doesn't match the
wallet's active chain. On desktop the wallet is already on mainnet so it's
invisible, but MetaMask mobile over WalletConnect keeps whatever chain the
user had open, so signing failed with the generic "Couldn't sign the ballot."

castVote now switches the wallet to mainnet before signing (votingApi
ensureSigningChain), re-reads the chain to catch wallets that ACK the switch
but don't change, and throws WRONG_CHAIN otherwise. safeWalletErr surfaces a
clear "Switch your wallet to Ethereum mainnet" message for both that sentinel
and MetaMask's native chain-mismatch error.

Zero impact on vote integrity: only the active network changes, never the
signed payload or the domain, so every ballot already cast still verifies
identically. Scoped to the vote path; the other signers (submit/delete) have
the same latent bug and can reuse ensureSigningChain next.

4 regression tests: switches when on the wrong chain then signs, no switch on
mainnet, refuses (no signature) when the switch fails, refuses when the switch
silently doesn't change chains. Full suite 152/152.

Co-authored-by: Xerxes &lt;xerxes-openclaw@users.noreply.github.com&gt;
Co-authored-by: Claude Fable 5 &lt;noreply@anthropic.com&gt;
diff --git a/src/app.jsx b/src/app.jsx
@@ -153,6 +153,11 @@ function safeWalletErr(e, verb = "complete that") {
   const isReject = (e && e.name === "UserRejectedRequestError")
     || /user rejected|user denied|rejected the request|request rejected|\b4001\b/i.test(raw);
   if (isReject) return "Signing cancelled.";
+  // Wrong-chain: our own WRONG_CHAIN sentinel (votingApi.ensureSigningChain),
+  // or the wallet's native "must match the active chainId" refusal when the
+  // switch was skipped/unsupported. Common on MetaMask mobile via WalletConnect.
+  const isWrongChain = /WRONG_CHAIN|must match the active chain|chain(?:id)? mismatch|provided chainid .* must match|switch.*(?:chain|network)|unsupported chain/i.test(raw);
+  if (isWrongChain) return "Switch your wallet to Ethereum mainnet, then try again.";
   return `Couldn't ${verb}. Please try again.`;
 }
 
diff --git a/src/votingApi.ts b/src/votingApi.ts
@@ -313,12 +313,49 @@ export async function createProposal(
  * Sign + submit a ballot. Throws on validation failures (over-budget,
  * not a badgeholder, etc.) — caller renders the error.
  */
+// MetaMask (and most wallets) refuse to sign EIP-712 typed data whose
+// domain.chainId doesn't match the wallet's ACTIVE chain — it throws
+// "provided chainId 1 must match the active chainId X". Our DOMAIN is pinned
+// to mainnet (chainId 1). On desktop the wallet is usually already on mainnet
+// so this is invisible, but MetaMask MOBILE over WalletConnect keeps whatever
+// chain the user had open, so signing silently failed there ("Couldn't sign
+// the ballot"). Put the wallet on mainnet before signing. This changes ONLY
+// the active network, never the signed payload or the domain, so every ballot
+// already cast still verifies bit-for-bit identically. Throws WRONG_CHAIN
+// (surfaced as a "switch to mainnet" message) if the wallet won't switch.
+async function ensureSigningChain(walletClient: WalletClient): Promise<void> {
+  let active: number;
+  try {
+    active = await walletClient.getChainId();
+  } catch {
+    return; // can't read the chain; let the sign attempt surface the real error
+  }
+  if (active === mainnet.id) return;
+  try {
+    await walletClient.switchChain({ id: mainnet.id });
+  } catch {
+    throw new Error("WRONG_CHAIN: switch your wallet to Ethereum mainnet to vote.");
+  }
+  // Some mobile wallets ACK the switch but don't actually change chains —
+  // re-read and refuse rather than produce a signature the wallet will reject.
+  let after: number;
+  try {
+    after = await walletClient.getChainId();
+  } catch {
+    after = active;
+  }
+  if (after !== mainnet.id) {
+    throw new Error("WRONG_CHAIN: switch your wallet to Ethereum mainnet to vote.");
+  }
+}
+
 export async function castVote(
   walletClient: WalletClient,
   voter: `0x${string}`,
   proposal: Proposal,
   allocations: Allocation[],
 ): Promise<{ ok: true; voter: `0x${string}` }> {
+  await ensureSigningChain(walletClient);
   const deadlineSec = Math.floor(new Date(proposal.deadline).getTime() / 1000);
   const ballot: Ballot = {
     voter,
diff --git a/tests/client/votingApi.test.ts b/tests/client/votingApi.test.ts
@@ -2,7 +2,13 @@ import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import * as api from "../../src/votingApi";
 
 const ACTOR = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" as `0x${string}`;
-const wallet: any = { signTypedData: vi.fn(async () => "0xsignature" as `0x${string}`) };
+// Wallet already on mainnet (chainId 1) — the common desktop case; the chain
+// guard is a no-op here so these mirror pre-fix behaviour.
+const wallet: any = {
+  signTypedData: vi.fn(async () => "0xsignature" as `0x${string}`),
+  getChainId: vi.fn(async () => 1),
+  switchChain: vi.fn(async () => {}),
+};
 
 let calls: { url: string; init?: any }[] = [];
 function mockFetch(responder: (url: string, init?: any) => any) {
@@ -17,7 +23,11 @@ const errJson = (status: number, body: any = {}) => ({ ok: false, status, json:
 
 const proposal: any = { id: "r-1", title: "T", votingMode: "quadratic", budget: 100, options: [{ id: 1, label: "A" }], deadline: new Date(Date.now() + 86400000).toISOString() };
 
-beforeEach(() => { wallet.signTypedData.mockClear(); });
+beforeEach(() => {
+  wallet.signTypedData.mockClear();
+  wallet.getChainId.mockClear().mockResolvedValue(1);
+  wallet.switchChain.mockClear().mockResolvedValue(undefined);
+});
 afterEach(() => { vi.unstubAllGlobals(); });
 
 describe("read endpoints", () => {
@@ -123,4 +133,40 @@ describe("write endpoints (sign + submit)", () => {
     mockFetch(() => errJson(400, { error: "over_budget" }));
     await expect(api.castVote(wallet, ACTOR, proposal, [{ issueId: 1, points: 99 }])).rejects.toThrow("castVote 400: over_budget");
   });
+
+  // Chain guard (MetaMask-mobile fix): the EIP-712 domain is pinned to mainnet,
+  // so the wallet must be on chainId 1 before signing.
+  it("castVote on the wrong chain switches to mainnet, then signs", async () => {
+    // on Arbitrum first, on mainnet after the switch
+    wallet.getChainId.mockResolvedValueOnce(42161).mockResolvedValueOnce(1);
+    mockFetch(() => okJson({ ok: true, voter: ACTOR }));
+    const r = await api.castVote(wallet, ACTOR, proposal, [{ issueId: 1, points: 5 }]);
+    expect(wallet.switchChain).toHaveBeenCalledWith({ id: 1 });
+    expect(wallet.signTypedData).toHaveBeenCalledOnce();
+    expect(r.ok).toBe(true);
+  });
+
+  it("castVote never switches when already on mainnet", async () => {
+    wallet.getChainId.mockResolvedValue(1);
+    mockFetch(() => okJson({ ok: true, voter: ACTOR }));
+    await api.castVote(wallet, ACTOR, proposal, [{ issueId: 1, points: 5 }]);
+    expect(wallet.switchChain).not.toHaveBeenCalled();
+  });
+
+  it("castVote refuses (no signature) when the wallet won't switch", async () => {
+    wallet.getChainId.mockResolvedValue(42161);
+    wallet.switchChain.mockRejectedValue(new Error("unsupported"));
+    mockFetch(() => okJson({ ok: true, voter: ACTOR }));
+    await expect(api.castVote(wallet, ACTOR, proposal, [{ issueId: 1, points: 5 }])).rejects.toThrow(/mainnet/i);
+    expect(wallet.signTypedData).not.toHaveBeenCalled();
+  });
+
+  it("castVote refuses when the switch silently doesn't change chains", async () => {
+    // wallet ACKs switchChain but stays on Arbitrum (mobile quirk)
+    wallet.getChainId.mockResolvedValue(42161);
+    wallet.switchChain.mockResolvedValue(undefined);
+    mockFetch(() => okJson({ ok: true, voter: ACTOR }));
+    await expect(api.castVote(wallet, ACTOR, proposal, [{ issueId: 1, points: 5 }])).rejects.toThrow(/mainnet/i);
+    expect(wallet.signTypedData).not.toHaveBeenCalled();
+  });
 });
