feat(rounds): gate voting by delegated Gnars votes at a fixed snapshot

Builds on xSatori's #115 (all UI/route/service structure is theirs):
rounds voting requires delegated Gnars voting power, enforced server-
side at vote submission.

One change on top: the power is read with getPastVotes at the round's
voting-open instant instead of live getVotes. Live votes let the same
Gnars vote once per re-delegation hop (A delegates to B, B votes, A
re-delegates to C, C votes — usage is tracked per wallet, so every hop
arrives fresh; on fixed_per_wallet each hop gets the FULL per-wallet
allotment). The checkpoint at votingStartsAt is immutable, so those
Gnars sat in exactly one wallet at that instant — the same snapshot
model the onchain governor uses, and the policy that comes with it:
delegating transfers the vote.

The Gnars token runs timestamp clock mode (ERC-6372), so the timepoint
is the round's votingStartsAt directly — no block derivation. A future
timepoint returns 0 without touching the chain (ERC-5805 would revert,
and an unopened round has no snapshot).

Co-authored-by: xSatori <99294685+xSatori@users.noreply.github.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: 3 people

src/services/round-voting-power.test.ts

@@ -1,5 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { Round } from "@/features/rounds/types";
+import { serverPublicClient } from "@/lib/rpc";
+import { getRoundVotingPower } from "./rounds";
 
 vi.mock("server-only", () => ({}));
 
@@ -9,9 +11,6 @@ vi.mock("@/lib/rpc", () => ({
   },
 }));
 
-import { serverPublicClient } from "@/lib/rpc";
-import { getRoundVotingPower } from "./rounds";
-
 const readContract = vi.mocked(serverPublicClient.readContract);
 
 const walletAddress = "0x39a7b6fa1597bb6657fe84e64e3b836c37d6f75d";
@@ -63,14 +62,43 @@ describe("getRoundVotingPower", () => {
   it("returns votesPerWallet for fixed_per_wallet when delegated Gnars voting power is greater than 0", async () => {
     readContract.mockResolvedValueOnce(7n);
 
-    await expect(getRoundVotingPower(baseRound("fixed_per_wallet", 5), walletAddress)).resolves.toBe(
-      5,
-    );
+    await expect(
+      getRoundVotingPower(baseRound("fixed_per_wallet", 5), walletAddress),
+    ).resolves.toBe(5);
   });
 
   it("returns delegated Gnars voting power for one_per_nft", async () => {
     readContract.mockResolvedValueOnce(7n);
 
     await expect(getRoundVotingPower(baseRound("one_per_nft"), walletAddress)).resolves.toBe(7);
   });
+
+  it("reads votes at the round's voting-open SNAPSHOT, not live", async () => {
+    // Live getVotes would let the same Gnars vote once per re-delegation hop
+    // (A→B votes, A re-delegates→C votes). The checkpoint at votingStartsAt is
+    // immutable, so the power must be read there.
+    readContract.mockResolvedValueOnce(7n);
+
+    await getRoundVotingPower(baseRound("one_per_nft"), walletAddress);
+
+    expect(readContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        functionName: "getPastVotes",
+        args: [
+          expect.any(String),
+          BigInt(Math.floor(Date.parse("2026-06-03T00:00:00.000Z") / 1000)),
+        ],
+      }),
+    );
+  });
+
+  it("returns 0 without touching the chain when voting has not opened yet", async () => {
+    // ERC-5805 reverts on a future timepoint; a round that has not opened has
+    // no snapshot and nobody can vote in it — 0 is the true answer.
+    const future = baseRound("one_per_nft");
+    future.votingStartsAt = new Date(Date.now() + 86_400_000).toISOString();
+
+    await expect(getRoundVotingPower(future, walletAddress)).resolves.toBe(0);
+    expect(readContract).not.toHaveBeenCalled();
+  });
 });

src/services/round-voting-power.ts

@@ -6,31 +6,60 @@ import { serverPublicClient } from "@/lib/rpc";
 const gnarsVotesAbi = [
   {
     type: "function",
-    name: "getVotes",
+    name: "getPastVotes",
     stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
+    inputs: [
+      { name: "account", type: "address" },
+      // Named "timepoint" per ERC-5805; the Gnars token runs timestamp clock
+      // mode (ERC-6372), so this is a UNIX TIMESTAMP, not a block number —
+      // the same fact useCastVote.ts documents for onchain proposal voting.
+      { name: "timepoint", type: "uint256" },
+    ],
     outputs: [{ name: "", type: "uint256" }],
   },
 ] as const;
 
-export async function getDelegatedGnarsVotingPower(walletAddress?: string | null) {
+/**
+ * Delegated Gnars voting power AT A FIXED SNAPSHOT, not live.
+ *
+ * Live `getVotes` would let the same Gnars vote in one round N times:
+ * A delegates to B, B votes, A re-delegates to C, C votes — vote usage is
+ * tracked per wallet, so every hop arrives with fresh usage and full power.
+ * Delegation is free, so 10 Gnars plus N empty wallets would be N ballots.
+ *
+ * Reading `getPastVotes` at the round's voting-open instant closes that: the
+ * checkpoint is immutable, and those 10 Gnars sat in exactly ONE wallet's
+ * checkpoint at that timestamp. Re-delegating afterwards moves nothing. This
+ * is the same snapshot model the DAO's onchain governor uses for proposals,
+ * and the policy that comes with it — delegating transfers the vote; a holder
+ * who delegated does not vote, their delegate does.
+ */
+export async function getDelegatedGnarsVotingPower(
+  walletAddress: string | null | undefined,
+  snapshotTimestamp: number,
+) {
   if (!walletAddress || !isAddress(walletAddress)) return 0;
+  // A future timepoint makes ERC-5805 revert (FutureLookup); a round whose
+  // voting has not opened has no snapshot yet, and nobody can vote in it
+  // anyway — 0 is the true answer, not a degraded one.
+  if (!Number.isFinite(snapshotTimestamp) || snapshotTimestamp * 1000 > Date.now()) return 0;
 
   const normalizedWallet = getAddress(walletAddress);
 
   try {
     const votes = await serverPublicClient.readContract({
       address: DAO_ADDRESSES.token,
       abi: gnarsVotesAbi,
-      functionName: "getVotes",
-      args: [normalizedWallet],
+      functionName: "getPastVotes",
+      args: [normalizedWallet, BigInt(snapshotTimestamp)],
     });
 
     return toSafeInteger(votes);
   } catch (error) {
     console.error("[rounds] failed to read delegated Gnars voting power", {
       walletAddress: normalizedWallet,
       tokenAddress: DAO_ADDRESSES.token,
+      snapshotTimestamp,
       error,
     });
     return 0;

src/services/rounds.ts

@@ -463,7 +463,10 @@ export async function getPublicRoundBySlug(slug: string): Promise<RoundWithSubmi
 
 export async function getRoundVotingPower(round: Round, walletAddress?: string | null) {
   if (!walletAddress || !isAddress(walletAddress)) return 0;
-  const delegatedVotingPower = await getDelegatedGnarsVotingPower(walletAddress);
+  // Snapshot at the instant voting opened — see getDelegatedGnarsVotingPower
+  // for why live votes would let the same Gnars vote once per re-delegation.
+  const snapshotTimestamp = Math.floor(Date.parse(round.votingStartsAt) / 1000);
+  const delegatedVotingPower = await getDelegatedGnarsVotingPower(walletAddress, snapshotTimestamp);
   if (delegatedVotingPower <= 0) return 0;
 
   if (round.votingStrategy === "fixed_per_wallet") return round.votesPerWallet;