feat: compute vote fiat value

feat: add index to vp_value

fix: handle high precision computation

perf:

fix: handle error

fix: increase last vote cb

Author: wa0x6e

src/helpers/actions.ts

@@ -92,6 +92,7 @@ export async function getProposal(space, id) {
     params: {}
   };
   proposal.choices = jsonParse(proposal.choices);
+  proposal.vp_value_by_strategy = jsonParse(proposal.vp_value_by_strategy, []);
 
   return proposal;
 }

src/helpers/utils.ts

@@ -266,3 +266,116 @@ export function getSpaceController(space: string, network = NETWORK) {
 
   return snapshot.utils.getSpaceController(space, networkId, { broviderUrl });
 }
+
+/**
+ * Recursively checks if two arrays have the exact same structure,
+ * including nesting levels at corresponding positions, and contain only valid numbers.
+ *
+ * @param arrayA - First array
+ * @param arrayB - Second array
+ * @returns True if structures match exactly and contain only numbers, false otherwise
+ */
+function arraysHaveSameStructure(arrayA: any, arrayB: any): boolean {
+  // Both must be arrays or both must not be arrays
+  if (Array.isArray(arrayA) !== Array.isArray(arrayB)) {
+    return false;
+  }
+
+  // If neither is an array, check they are valid numeric values
+  if (!Array.isArray(arrayA)) {
+    return (
+      typeof arrayA === 'number' && !isNaN(arrayA) && typeof arrayB === 'number' && !isNaN(arrayB)
+    );
+  }
+
+  // Both are arrays - check they have the same length
+  if (arrayA.length !== arrayB.length) {
+    return false;
+  }
+
+  // Recursively check each element has the same structure and valid content
+  for (let i = 0; i < arrayA.length; i++) {
+    if (!arraysHaveSameStructure(arrayA[i], arrayB[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Validates and prepares arrays for dot product calculation.
+ * Ensures arrays have identical structure and nesting patterns.
+ *
+ * @param arrayA - First array
+ * @param arrayB - Second array
+ * @returns Object with flattened arrays, or null if invalid or structure mismatch
+ */
+function validateAndFlattenArrays(
+  arrayA: any,
+  arrayB: any
+): { flatArrayA: any[]; flatArrayB: any[] } | null {
+  if (!Array.isArray(arrayA) || !Array.isArray(arrayB)) {
+    return null;
+  }
+
+  // Check for exact structural match
+  if (!arraysHaveSameStructure(arrayA, arrayB)) {
+    return null;
+  }
+
+  // Structure matches, safe to flatten
+  const flatArrayA = arrayA.flat(Infinity);
+  const flatArrayB = arrayB.flat(Infinity);
+
+  return { flatArrayA, flatArrayB };
+}
+
+/**
+ * Computes the dot product of two arrays by multiplying corresponding elements and summing the results.
+ *
+ * This function performs a dot product calculation between two arrays of numbers using
+ * JavaScript's native arithmetic. Both arrays are flattened to handle nested structures
+ * of unlimited depth before calculation. Arrays must have identical structure and contain only numbers.
+ *
+ * @param arrayA - First array of numbers. Can contain deeply nested arrays of any depth
+ * @param arrayB - Second array of numbers. Must have the same structure as arrayA after flattening
+ * @returns The computed dot product as a number. Returns 0 if arrays are invalid or mismatched.
+ *
+ * @example
+ * // Simple arrays
+ * dotProduct([1, 2, 3], [10, 20, 30]) // Returns 140 (1*10 + 2*20 + 3*30)
+ *
+ * @example
+ * // Nested arrays (2 levels)
+ * dotProduct([1, [2, 3]], [10, [20, 30]]) // Returns 140 (1*10 + 2*20 + 3*30)
+ *
+ * @example
+ * // Financial calculations
+ * dotProduct([1.833444691890596], [1000.123456789]) // Uses JavaScript precision
+ */
+export function dotProduct(arrayA: any[], arrayB: any[]): number {
+  const validation = validateAndFlattenArrays(arrayA, arrayB);
+  if (!validation) {
+    throw new Error('Invalid arrays structure mismatch');
+  }
+
+  const { flatArrayA, flatArrayB } = validation;
+
+  // Use pure JavaScript arithmetic for all calculations
+  let sum = 0;
+
+  for (let i = 0; i < flatArrayA.length; i++) {
+    const numA = flatArrayA[i];
+    const numB = flatArrayB[i];
+
+    const product = numA * numB;
+
+    // Only add finite numbers to avoid NaN propagation
+    if (isFinite(product)) {
+      sum += product;
+    }
+  }
+
+  return sum;
+}

src/writer/vote.ts

@@ -1,10 +1,12 @@
+import { capture } from '@snapshot-labs/snapshot-sentry';
 import snapshot from '@snapshot-labs/snapshot.js';
 import { getProposal } from '../helpers/actions';
 import log from '../helpers/log';
 import db from '../helpers/mysql';
-import { captureError, hasStrategyOverride, jsonParse } from '../helpers/utils';
+import { captureError, dotProduct, hasStrategyOverride, jsonParse } from '../helpers/utils';
 import { updateProposalAndVotes } from '../scores';
 
+const LAST_VOTE_CB = 1;
 const scoreAPIUrl = process.env.SCORE_API_URL || 'https://score.snapshot.org';
 
 // async function isLimitReached(space) {
@@ -116,6 +118,17 @@ export async function action(body, ipfs, receipt, id, context): Promise<void> {
   const withOverride = hasStrategyOverride(context.proposal.strategies);
   if (vpState === 'final' && withOverride) vpState = 'pending';
 
+  // Compute vote value
+  let vp_value = 0;
+  let cb = 0;
+
+  try {
+    vp_value = dotProduct(context.proposal.vp_value_by_strategy, context.vp.vp_by_strategy);
+    cb = LAST_VOTE_CB;
+  } catch (e: any) {
+    capture(e, { msg, proposalId });
+  }
+
   const params = {
     id,
     ipfs,
@@ -130,7 +143,8 @@ export async function action(body, ipfs, receipt, id, context): Promise<void> {
     vp: context.vp.vp,
     vp_by_strategy: JSON.stringify(context.vp.vp_by_strategy),
     vp_state: vpState,
-    cb: 0
+    vp_value,
+    cb
   };
 
   // Check if voter already voted

test/schema.sql

@@ -100,6 +100,7 @@ CREATE TABLE votes (
   vp DECIMAL(64,30) NOT NULL,
   vp_by_strategy JSON NOT NULL,
   vp_state VARCHAR(24) NOT NULL,
+  vp_value DECIMAL(13,3) NOT NULL DEFAULT 0.000,
   cb INT(11) NOT NULL,
   PRIMARY KEY (voter, space, proposal),
   UNIQUE KEY id (id),
@@ -111,6 +112,7 @@ CREATE TABLE votes (
   INDEX app (app),
   INDEX vp (vp),
   INDEX vp_state (vp_state),
+  INDEX vp_value (vp_value),
   INDEX cb (cb)
 );
 

test/unit/helpers/utils.test.ts

@@ -0,0 +1,118 @@
+import { dotProduct } from '../../../src/helpers/utils';
+
+describe('utils', () => {
+  describe('dotProduct()', () => {
+    describe('Input Validation', () => {
+      it('should return 0 for invalid array inputs', () => {
+        expect(dotProduct(null as any, [1, 2])).toBe(0);
+        expect(dotProduct([1, 2], null as any)).toBe(0);
+        expect(dotProduct(undefined as any, [1, 2])).toBe(0);
+        expect(dotProduct([1, 2], undefined as any)).toBe(0);
+        expect(dotProduct('string' as any, [1, 2])).toBe(0);
+        expect(dotProduct([1, 2], 'string' as any)).toBe(0);
+      });
+
+      it('should return 0 for arrays of different lengths', () => {
+        expect(dotProduct([1, 2], [3])).toBe(0);
+        expect(dotProduct([1], [2, 3, 4])).toBe(0);
+        expect(dotProduct([], [1, 2])).toBe(0); // Empty vs non-empty
+        expect(dotProduct([], [])).toBe(0); // Both empty
+      });
+
+      it('should reject arrays with non-numeric values', () => {
+        expect(dotProduct([1, null, 3], [4, 5, 6])).toBe(0); // Should reject null values
+        expect(dotProduct([1, undefined, 3], [4, 5, 6])).toBe(0); // Should reject undefined values
+        expect(dotProduct([1, 2, 3], [4, null, 6])).toBe(0); // Should reject null values
+        expect(dotProduct(['1', '2'], ['3', '4'])).toBe(0); // Should reject string numbers
+        expect(dotProduct([1, '2'], [3, '4'])).toBe(0); // Should reject mixed types
+        expect(dotProduct([1, 'invalid', 3], [4, 5, 6])).toBe(0); // Should reject invalid strings
+        expect(dotProduct([1, {}, 3], [4, 5, 6])).toBe(0); // Should reject objects
+        expect(dotProduct([1, [], 3], [4, 5, 6])).toBe(0); // Should reject arrays as values
+      });
+
+      it('should reject mixed flat and nested arrays with different structures', () => {
+        expect(dotProduct([1, 2], [[3], 4])).toBe(0); // Different structures - should reject
+        expect(dotProduct([[1], 2], [3, 4])).toBe(0); // Different structures - should reject
+      });
+    });
+
+    describe('Basic Calculations', () => {
+      it('should calculate dot product for simple arrays', () => {
+        expect(dotProduct([1, 2, 3], [4, 5, 6])).toBe(32); // 1*4 + 2*5 + 3*6 = 32
+        expect(dotProduct([2, 3], [4, 5])).toBe(23); // 2*4 + 3*5 = 23
+        expect(dotProduct([1], [5])).toBe(5); // 1*5 = 5
+      });
+
+      it('should handle arrays with zeros', () => {
+        expect(dotProduct([1, 0, 3], [4, 5, 6])).toBe(22); // 1*4 + 0*5 + 3*6 = 22
+        expect(dotProduct([0, 0, 0], [1, 2, 3])).toBe(0); // All zeros in first array
+      });
+
+      it('should handle negative numbers', () => {
+        expect(dotProduct([-1, 2], [3, -4])).toBe(-11); // -1*3 + 2*(-4) = -11
+        expect(dotProduct([-2, -3], [-4, -5])).toBe(23); // -2*(-4) + -3*(-5) = 23
+      });
+    });
+
+    describe('Nested Array Support', () => {
+      it('should handle nested arrays (single level)', () => {
+        expect(dotProduct([1, [2, 3]], [4, [5, 6]])).toBe(32); // Flattened: [1,2,3] • [4,5,6] = 32
+      });
+
+      it('should handle deeply nested arrays', () => {
+        expect(dotProduct([1, [2, [3, 4]]], [5, [6, [7, 8]]])).toBe(70); // [1,2,3,4] • [5,6,7,8] = 70
+        expect(dotProduct([[[1]], [2]], [[[3]], [4]])).toBe(11); // [1,2] • [3,4] = 11
+      });
+    });
+
+    describe('JavaScript Native Precision', () => {
+      it('should handle large × large number multiplication', () => {
+        // Test realistic large financial numbers
+        // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+        const votingPower = [123456789012.456789];
+        // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+        const tokenValue = [987654321.123456789];
+
+        const result = dotProduct(votingPower, tokenValue);
+        // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+        const expected = 123456789012.456789 * 987654321.123456789;
+
+        expect(result).toBe(expected);
+      });
+
+      it('should handle small × large number multiplication (DeFi scenario)', () => {
+        // Test small token values with large voting power
+        const smallTokenValues = [1e-18, 1e-12, 1e-6]; // Wei, micro, milli units
+        const largeVotingPower = [1e18, 1e15, 1e12]; // Large voting power values
+
+        const result = dotProduct(smallTokenValues, largeVotingPower);
+
+        // Should equal: 1 + 1000 + 1000000 = 1001001
+        expect(result).toBe(1001001);
+      });
+
+      it('should handle maximum precision decimal numbers', () => {
+        // Test JavaScript's precision limits (~15-16 significant digits)
+        // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+        const maxDecimalA = [1.1234567890123456];
+        const maxDecimalB = [2.9876543210987654];
+
+        const result = dotProduct(maxDecimalA, maxDecimalB);
+        // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+        const expected = 1.1234567890123456 * 2.9876543210987654;
+
+        expect(result).toBe(expected);
+      });
+
+      it('should handle underflow edge cases', () => {
+        // Test numbers that underflow to 0
+        const verySmallA = [1e-200];
+        const verySmallB = [1e-200];
+
+        const result = dotProduct(verySmallA, verySmallB);
+
+        expect(result).toBe(0); // JavaScript underflow behavior
+      });
+    });
+  });
+});