feat: add vp_value to leaderboard and defer vote deletion to async script

- Add vp_value column to leaderboard table, updated asynchronously
  by votesVpValue when votes are finalized
- Add PENDING_DELETE cb status for deferred vote deletion
- Add deleteProposalVotes async script to process flagged votes in
  batches (update leaderboard/spaces counters, then delete)
- Simplify delete-proposal writer: flags votes instead of deleting inline
- Initialize vp_value to 0 on leaderboard row creation

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: wa0x6e

src/constants.ts

@@ -3,6 +3,7 @@ export const CB = {
   PENDING_SYNC: 0, // Default db value, waiting from value from overlord
   PENDING_COMPUTE: -1,
   PENDING_FINAL: -2,
+  PENDING_DELETE: -3,
   INELIGIBLE: -10, // Payload format, can not compute
   ERROR_SYNC: -11 // Sync error from overlord, waiting for retry
 };

src/helpers/deleteProposalVotes.ts

@@ -0,0 +1,74 @@
+import snapshot from '@snapshot-labs/snapshot.js';
+import log from './log';
+import db from './mysql';
+import { CB } from '../constants';
+
+type Vote = {
+  id: string;
+  voter: string;
+  space: string;
+  vp_value: number;
+  vp_state: string;
+};
+
+const REFRESH_INTERVAL = 60 * 1000;
+const BATCH_SIZE = 100;
+
+async function getVotesPendingDeletion(): Promise<Vote[]> {
+  return db.queryAsync(
+    `SELECT id, voter, space, vp_value, vp_state FROM votes WHERE cb = ? LIMIT ?`,
+    [CB.PENDING_DELETE, BATCH_SIZE]
+  );
+}
+
+async function processVotes(votes: Vote[]) {
+  const query: string[] = [];
+  const params: (string | number | string[])[] = [];
+
+  // Update spaces vote_count
+  const grouped = new Map<string, Vote[]>();
+  for (const vote of votes) {
+    if (!grouped.has(vote.space)) {
+      grouped.set(vote.space, []);
+    }
+    grouped.get(vote.space)!.push(vote);
+  }
+
+  for (const [space, spaceVotes] of grouped) {
+    query.push('UPDATE spaces SET vote_count = GREATEST(vote_count - ?, 0) WHERE id = ?');
+    params.push(spaceVotes.length, space);
+  }
+
+  // Update leaderboard vote_count and vp_value
+  for (const vote of votes) {
+    query.push(
+      `UPDATE leaderboard
+        SET vote_count = GREATEST(vote_count - 1, 0),
+            vp_value = GREATEST(vp_value - ?, 0)
+        WHERE user = ? AND space = ?`
+    );
+    params.push(vote.vp_state === 'final' ? vote.vp_value : 0, vote.voter, vote.space);
+  }
+
+  // Delete votes
+  query.push('DELETE FROM votes WHERE id IN (?)');
+  params.push(votes.map(v => v.id));
+
+  await db.queryAsync(query.join(';'), params);
+}
+
+export default async function run() {
+  while (true) {
+    const votes = await getVotesPendingDeletion();
+
+    if (votes.length) {
+      log.info(`[deleteProposalVotes] ${votes.length} votes to delete`);
+      await processVotes(votes);
+    }
+
+    if (votes.length < BATCH_SIZE) {
+      log.info('[deleteProposalVotes] sleeping');
+      await snapshot.utils.sleep(REFRESH_INTERVAL);
+    }
+  }
+}

src/helpers/votesVpValue.ts

@@ -9,6 +9,8 @@ type ProposalVpValues = Map<string, { cb: number; vpValueByStrategy: number[] }>
 
 type Datum = {
   id: string;
+  voter: string;
+  space: string;
   vpState: string;
   vpByStrategy: number[];
   vpValueByStrategy: number[];
@@ -22,6 +24,8 @@ const PROPOSALS_BATCH_SIZE = 50000;
 const datumSchema = z
   .object({
     id: z.string(),
+    voter: z.string(),
+    space: z.string(),
     vpState: z.string(),
     vpValueByStrategy: z.array(z.number().finite()),
     vpByStrategy: z.array(z.number().finite())
@@ -31,17 +35,26 @@ const datumSchema = z
   });
 
 async function getPendingVotes(): Promise<
-  { id: string; proposal: string; vpState: string; vpByStrategy: number[] }[]
+  {
+    id: string;
+    voter: string;
+    space: string;
+    proposal: string;
+    vpState: string;
+    vpByStrategy: number[];
+  }[]
 > {
   const query = `
-    SELECT id, proposal, vp_state, vp_by_strategy
+    SELECT id, voter, space, proposal, vp_state, vp_by_strategy
     FROM votes
     WHERE cb = ?
     LIMIT ?`;
   const results = await db.queryAsync(query, [CB.PENDING_COMPUTE, DEFAULT_BATCH_SIZE]);
 
   return results.map((r: any) => ({
     id: r.id,
+    voter: r.voter,
+    space: r.space,
     proposal: r.proposal,
     vpState: r.vp_state,
     vpByStrategy: JSON.parse(r.vp_by_strategy)
@@ -88,6 +101,7 @@ async function refreshVotesVpValues(data: Datum[]) {
   const ids: string[] = [];
   const vpValues: Map<string, number> = new Map();
   const cbValues: Map<string, number> = new Map();
+  const leaderboardUpdates: { value: number; voter: string; space: string }[] = [];
 
   for (const datum of data) {
     if (datum.proposalCb === CB.INELIGIBLE) {
@@ -110,6 +124,16 @@ async function refreshVotesVpValues(data: Datum[]) {
         validatedDatum.id,
         validatedDatum.vpState === 'final' ? CB.FINAL : CB.PENDING_FINAL
       );
+
+      // Leaderboard update only for final votes
+      // to avoid vp fluctuations with overriding strategies
+      if (validatedDatum.vpState === 'final') {
+        leaderboardUpdates.push({
+          value,
+          voter: validatedDatum.voter,
+          space: validatedDatum.space
+        });
+      }
     } catch (e) {
       capture(e);
       ids.push(datum.id);
@@ -132,8 +156,21 @@ async function refreshVotesVpValues(data: Datum[]) {
     cbParams.push(id, cbValues.get(id)!);
   }
 
-  const query = `UPDATE votes SET vp_value = CASE ${vpCases} END, cb = CASE ${cbCases} END WHERE id IN (${placeholders})`;
-  await db.queryAsync(query, [...vpParams, ...cbParams, ...ids]);
+  const queries: string[] = [
+    `UPDATE votes SET vp_value = CASE ${vpCases} END, cb = CASE ${cbCases} END WHERE id IN (${placeholders})`
+  ];
+  const params: (number | string)[] = [...vpParams, ...cbParams, ...ids];
+
+  for (const update of leaderboardUpdates) {
+    queries.push(
+      `UPDATE leaderboard
+        SET vp_value = vp_value + ?
+        WHERE user = ? AND space = ?`
+    );
+    params.push(update.value, update.voter, update.space);
+  }
+
+  await db.queryAsync(queries.join(';'), params);
 }
 
 async function processBatch(proposalVpValues: ProposalVpValues): Promise<number> {
@@ -146,6 +183,8 @@ async function processBatch(proposalVpValues: ProposalVpValues): Promise<number>
       const proposal = proposalVpValues.get(v.proposal)!;
       return {
         id: v.id,
+        voter: v.voter,
+        space: v.space,
         vpState: v.vpState,
         vpByStrategy: v.vpByStrategy,
         vpValueByStrategy: proposal.vpValueByStrategy,

src/index.ts

@@ -3,6 +3,7 @@ import { fallbackLogger, initLogger } from '@snapshot-labs/snapshot-sentry';
 import cors from 'cors';
 import express from 'express';
 import api from './api';
+import deleteProposalVotes from './helpers/deleteProposalVotes';
 import log from './helpers/log';
 import initMetrics from './helpers/metrics';
 import refreshModeration from './helpers/moderation';
@@ -26,6 +27,7 @@ async function startServer() {
   refreshProposalsVpValue();
   refreshProposalsScoresValue();
   refreshVotesVpValue();
+  deleteProposalVotes();
 
   await initializeStrategies();
   refreshStrategies();

src/writer/delete-proposal.ts

@@ -1,3 +1,4 @@
+import { CB } from '../constants';
 import { getProposal, getSpace } from '../helpers/actions';
 import db from '../helpers/mysql';
 import { jsonParse } from '../helpers/utils';
@@ -21,36 +22,19 @@ export async function verify(body): Promise<any> {
 export async function action(body): Promise<void> {
   const msg = jsonParse(body.msg);
   const proposal = await getProposal(msg.space, msg.payload.proposal);
-
-  const voters = await db.queryAsync(`SELECT voter FROM votes WHERE proposal = ?`, [
-    msg.payload.proposal
-  ]);
   const id = msg.payload.proposal;
 
-  let queries = `
+  const queries = `
     DELETE FROM proposals WHERE id = ? LIMIT 1;
-    DELETE FROM votes WHERE proposal = ?;
+    UPDATE votes SET cb = ? WHERE proposal = ?;
     UPDATE leaderboard
       SET proposal_count = GREATEST(proposal_count - 1, 0)
       WHERE user = ? AND space = ?
       LIMIT 1;
     UPDATE spaces
-      SET proposal_count = GREATEST(proposal_count - 1, 0), vote_count = GREATEST(vote_count - ?, 0)
+      SET proposal_count = GREATEST(proposal_count - 1, 0)
       WHERE id = ?;
   `;
 
-  const parameters = [id, id, proposal.author, msg.space, voters.length, msg.space];
-
-  if (voters.length > 0) {
-    queries += `
-    UPDATE leaderboard SET vote_count = GREATEST(vote_count - 1, 0)
-      WHERE user IN (?) AND space = ?;
-  `;
-    parameters.push(
-      voters.map(voter => voter.voter),
-      msg.space
-    );
-  }
-
-  await db.queryAsync(queries, parameters);
+  await db.queryAsync(queries, [id, CB.PENDING_DELETE, id, proposal.author, msg.space, msg.space]);
 }

src/writer/vote.ts

@@ -182,8 +182,8 @@ export async function action(body, ipfs, receipt, id, context): Promise<void> {
     await db.queryAsync(
       `
         INSERT INTO votes SET ?;
-        INSERT INTO leaderboard (space, user, vote_count, last_vote)
-          VALUES(?, ?, 1, ?)
+        INSERT INTO leaderboard (space, user, vote_count, last_vote, vp_value)
+          VALUES(?, ?, 1, ?, 0)
           ON DUPLICATE KEY UPDATE vote_count = vote_count + 1, last_vote = ?;
         UPDATE spaces SET vote_count = vote_count + 1 WHERE id = ?;
       `,

test/schema.sql

@@ -192,11 +192,13 @@ CREATE TABLE leaderboard (
   vote_count SMALLINT UNSIGNED NOT NULL DEFAULT '0',
   proposal_count SMALLINT UNSIGNED NOT NULL DEFAULT '0',
   last_vote BIGINT,
+  vp_value DECIMAL(13,3) NOT NULL DEFAULT 0.000,
   PRIMARY KEY user_space (user,space),
   INDEX space (space),
   INDEX vote_count (vote_count),
   INDEX proposal_count (proposal_count),
-  INDEX last_vote (last_vote)
+  INDEX last_vote (last_vote),
+  INDEX vp_value (vp_value)
 );
 
 CREATE TABLE skins (