[staging] Tornado Cash integration — validate before dev (reindex required)

.changeset/tornado-cash-integration.md

@@ -0,0 +1,7 @@
+---
+"@anticapture/indexer": minor
+"@anticapture/api": minor
+"@anticapture/dashboard": minor
+---
+
+Integrate Tornado Cash DAO (TORN): custom stake-to-vote indexer (lock-based delegated supply, timestamp governance), timestamp-based proposal-status API client, and dashboard config/icon.

apps/api/cmd/index.ts

@@ -181,7 +181,7 @@ if (!daoClient) {
 }
 
 const pgClient = drizzle(env.DATABASE_URL, {
-  schema,
+  schema: { ...schema, ...offchainSchema },
   casing: "snake_case",
 });
 
@@ -396,32 +396,28 @@ if (env.DAO_ID === DaoIdEnum.ENS) {
   revenue(app, revenueDuneClient);
 }
 
-if (daoClient.supportOffchainData()) {
-  const pgUnifiedClient = drizzle(env.DATABASE_URL, {
-    schema: { ...schema, ...offchainSchema },
-    casing: "snake_case",
-  });
-
-  const offchainProposalsRepo = wrapWithTracing(
-    new OffchainProposalRepository(pgUnifiedClient),
-  );
-  const offchainVotesRepo = wrapWithTracing(
-    new OffchainVoteRepository(pgUnifiedClient),
-  );
-  offchainProposals(
-    app,
-    wrapWithTracing(new OffchainProposalsService(offchainProposalsRepo)),
-  );
-  offchainVotes(
-    app,
-    wrapWithTracing(new OffchainVotesService(offchainVotesRepo)),
-  );
+const supportOffchain = daoClient.supportOffchainData();
+const offchainProposalsRepo = wrapWithTracing(
+  new OffchainProposalRepository(pgClient),
+);
+const offchainVotesRepo = wrapWithTracing(new OffchainVoteRepository(pgClient));
+offchainProposals(
+  app,
+  wrapWithTracing(new OffchainProposalsService(offchainProposalsRepo)),
+  supportOffchain,
+);
+offchainVotes(
+  app,
+  wrapWithTracing(new OffchainVotesService(offchainVotesRepo)),
+  supportOffchain,
+);
 
-  const offchainNonVotersRepo = new OffchainNonVotersRepositoryImpl(
-    pgUnifiedClient,
-  );
-  offchainNonVoters(app, new OffchainNonVotersService(offchainNonVotersRepo));
-}
+const offchainNonVotersRepo = new OffchainNonVotersRepositoryImpl(pgClient);
+offchainNonVoters(
+  app,
+  wrapWithTracing(new OffchainNonVotersService(offchainNonVotersRepo)),
+  supportOffchain,
+);
 
 serve(
   {

apps/api/src/clients/index.ts

@@ -10,6 +10,7 @@ export * from "./uni";
 export * from "./shu";
 export * from "./aave";
 export * from "./fluid";
+export * from "./torn";
 
 export interface DAOClient {
   getDaoId: () => string;

apps/api/src/clients/torn/abi.ts

@@ -0,0 +1,44 @@
+export const TORNGovernorAbi = [
+  {
+    type: "function",
+    name: "QUORUM_VOTES",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "VOTING_DELAY",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "VOTING_PERIOD",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "PROPOSAL_THRESHOLD",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "EXECUTION_DELAY",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "EXECUTION_EXPIRATION",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+  },
+] as const;

apps/api/src/clients/torn/index.ts

@@ -0,0 +1,203 @@
+import { Account, Address, Chain, Client, Transport } from "viem";
+
+import { DAOClient } from "@/clients";
+import { ProposalStatus } from "@/lib/constants";
+
+import { GovernorBase } from "../governor.base";
+
+import { TORNGovernorAbi } from "./abi";
+
+const BLOCK_TIME = 12;
+
+export class TORNClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+  TAccount extends Account | undefined = Account | undefined,
+>
+  extends GovernorBase
+  implements DAOClient
+{
+  protected address: Address;
+  protected abi: typeof TORNGovernorAbi;
+
+  constructor(client: Client<TTransport, TChain, TAccount>, address: Address) {
+    super(client);
+    this.address = address;
+    this.abi = TORNGovernorAbi;
+  }
+
+  getDaoId(): string {
+    return "TORN";
+  }
+
+  async getQuorum(_proposalId: string | null): Promise<bigint> {
+    return this.getCachedQuorum(async () => {
+      return this.readContract({
+        abi: this.abi,
+        address: this.address,
+        functionName: "QUORUM_VOTES",
+      });
+    });
+  }
+
+  // TORN governance times everything in seconds, but the platform contract
+  // for getVotingDelay/getVotingPeriod expects BLOCK units (consumers multiply
+  // by blockTime to recover seconds). Convert seconds → blocks on read.
+  async getVotingDelay(): Promise<bigint> {
+    if (!this.cache.votingDelay) {
+      const seconds = (await this.readContract({
+        abi: this.abi,
+        address: this.address,
+        functionName: "VOTING_DELAY",
+      })) as bigint;
+      this.cache.votingDelay = seconds / BigInt(BLOCK_TIME);
+    }
+    return this.cache.votingDelay!;
+  }
+
+  async getVotingPeriod(): Promise<bigint> {
+    if (!this.cache.votingPeriod) {
+      const seconds = (await this.readContract({
+        abi: this.abi,
+        address: this.address,
+        functionName: "VOTING_PERIOD",
+      })) as bigint;
+      this.cache.votingPeriod = seconds / BigInt(BLOCK_TIME);
+    }
+    return this.cache.votingPeriod!;
+  }
+
+  async getProposalThreshold(): Promise<bigint> {
+    if (!this.cache.proposalThreshold) {
+      this.cache.proposalThreshold = (await this.readContract({
+        abi: this.abi,
+        address: this.address,
+        functionName: "PROPOSAL_THRESHOLD",
+      })) as bigint;
+    }
+    return this.cache.proposalThreshold!;
+  }
+
+  async getTimelockDelay(): Promise<bigint> {
+    if (!this.cache.timelockDelay) {
+      this.cache.timelockDelay = (await this.readContract({
+        abi: this.abi,
+        address: this.address,
+        functionName: "EXECUTION_DELAY",
+      })) as bigint;
+    }
+    return this.cache.timelockDelay!;
+  }
+
+  private async getExecutionExpiration(): Promise<bigint> {
+    if (!this.cache.executionPeriod) {
+      this.cache.executionPeriod = (await this.readContract({
+        abi: this.abi,
+        address: this.address,
+        functionName: "EXECUTION_EXPIRATION",
+      })) as bigint;
+    }
+    return this.cache.executionPeriod!;
+  }
+
+  calculateQuorum(votes: {
+    forVotes: bigint;
+    againstVotes: bigint;
+    abstainVotes: bigint;
+  }): bigint {
+    // Tornado's Governance.state() reaches quorum on forVotes + againstVotes
+    // (both sides count toward QUORUM_VOTES), not forVotes alone.
+    return votes.forVotes + votes.againstVotes;
+  }
+
+  alreadySupportCalldataReview(): boolean {
+    return false;
+  }
+
+  /**
+   * Tornado Cash proposal status — timestamp-based, not block-based.
+   *
+   * The governor uses seconds for all timing parameters (VOTING_DELAY,
+   * VOTING_PERIOD, EXECUTION_DELAY, EXECUTION_EXPIRATION). We derive
+   * startTime synthetically from endTimestamp and the block range.
+   *
+   * State machine:
+   *   EXECUTED → finalized (persisted by indexer)
+   *   now < startTime → PENDING
+   *   now < endTimestamp → ACTIVE
+   *   forVotes + againstVotes < quorum → NO_QUORUM
+   *   forVotes <= againstVotes → DEFEATED
+   *   now < endTimestamp + EXECUTION_DELAY → QUEUED
+   *   now < endTimestamp + EXECUTION_DELAY + EXECUTION_EXPIRATION → PENDING_EXECUTION
+   *   else → EXPIRED
+   */
+  async getProposalStatus(
+    proposal: {
+      id: string;
+      status: string;
+      startBlock: number;
+      endBlock: number;
+      forVotes: bigint;
+      againstVotes: bigint;
+      abstainVotes: bigint;
+      endTimestamp: bigint;
+    },
+    _currentBlock: number,
+    currentTimestamp: number,
+  ): Promise<string> {
+    // Already finalized via event
+    if (proposal.status === ProposalStatus.EXECUTED) {
+      return ProposalStatus.EXECUTED;
+    }
+
+    if (proposal.status === ProposalStatus.CANCELED) {
+      return ProposalStatus.CANCELED;
+    }
+
+    const now = BigInt(currentTimestamp);
+    const endTimestamp = proposal.endTimestamp;
+
+    // Estimate startTime from endTimestamp and block range
+    const votingDurationSeconds =
+      BigInt(proposal.endBlock - proposal.startBlock) * BigInt(BLOCK_TIME);
+    const startTime = endTimestamp - votingDurationSeconds;
+
+    if (now < startTime) {
+      return ProposalStatus.PENDING;
+    }
+
+    if (now < endTimestamp) {
+      return ProposalStatus.ACTIVE;
+    }
+
+    // After voting period ends — check quorum and majority
+    const quorum = await this.getQuorum(proposal.id);
+    const proposalQuorum = this.calculateQuorum({
+      forVotes: proposal.forVotes,
+      againstVotes: proposal.againstVotes,
+      abstainVotes: proposal.abstainVotes,
+    });
+
+    if (proposalQuorum < quorum) {
+      return ProposalStatus.NO_QUORUM;
+    }
+
+    if (proposal.forVotes <= proposal.againstVotes) {
+      return ProposalStatus.DEFEATED;
+    }
+
+    // Passed — check timelock windows
+    const executionDelay = await this.getTimelockDelay();
+    const executionExpiration = await this.getExecutionExpiration();
+
+    if (now < endTimestamp + executionDelay) {
+      return ProposalStatus.QUEUED;
+    }
+
+    if (now < endTimestamp + executionDelay + executionExpiration) {
+      return ProposalStatus.PENDING_EXECUTION;
+    }
+
+    return ProposalStatus.EXPIRED;
+  }
+}

apps/api/src/controllers/proposals/offchainProposals.ts

@@ -16,6 +16,7 @@ import { OffchainProposalsService } from "@/services";
 export function offchainProposals(
   app: Hono,
   service: OffchainProposalsService,
+  supportOffchain: boolean,
 ) {
   app.openapi(
     createRoute({
@@ -39,9 +40,24 @@ export function offchainProposals(
             },
           },
         },
+        400: {
+          description: "Offchain data not supported",
+          content: {
+            "application/json": {
+              schema: ErrorResponseSchema,
+            },
+          },
+        },
       },
     }),
     async (context) => {
+      if (!supportOffchain) {
+        return context.json(
+          ErrorResponseSchema.parse({ error: "Offchain data not supported" }),
+          400,
+        );
+      }
+
       const { skip, limit, orderDirection, status, fromDate, endDate, lean } =
         context.req.valid("query");
 

apps/api/src/controllers/votes/offchainNonVoters.ts

@@ -10,6 +10,7 @@ import { OffchainNonVotersService } from "@/services";
 export function offchainNonVoters(
   app: Hono,
   service: OffchainNonVotersService,
+  supportOffchain: boolean,
 ) {
   app.openapi(
     createRoute({
@@ -35,6 +36,14 @@ export function offchainNonVoters(
             },
           },
         },
+        400: {
+          description: "Offchain data not supported",
+          content: {
+            "application/json": {
+              schema: ErrorResponseSchema,
+            },
+          },
+        },
         404: {
           description: "Proposal not found",
           content: {
@@ -46,6 +55,13 @@ export function offchainNonVoters(
       },
     }),
     async (context) => {
+      if (!supportOffchain) {
+        return context.json(
+          ErrorResponseSchema.parse({ error: "Offchain data not supported" }),
+          400,
+        );
+      }
+
       const { id } = context.req.valid("param");
       const { skip, limit, orderDirection, addresses } =
         context.req.valid("query");