refactor: improve readability and robustness

refactor:

Author: wa0x6e

src/helpers/entityValue.ts

@@ -4,14 +4,43 @@ type Proposal = {
 };
 
 /**
- * Calculates the total proposal value based on all votes' total voting power and the proposal's value per strategy.
+ * Calculates the proposal total value based on all votes' total voting power and the proposal's value per strategy.
  * @returns The total value of the given proposal's votes, in the currency unit specified by the proposal's vp_value_by_strategy values
  */
 export function getProposalValue(proposal: Proposal): number {
-  return (
-    proposal.scores_by_strategy[0]
-      ?.map((_, index) => proposal.scores_by_strategy.reduce((sum, array) => sum + array[index], 0))
-      ?.map((value, index) => value * proposal.vp_value_by_strategy[index])
-      ?.reduce((sum, value) => sum + value, 0) || 0
-  );
+  const { scores_by_strategy, vp_value_by_strategy } = proposal;
+
+  if (
+    !scores_by_strategy.length ||
+    !scores_by_strategy[0]?.length ||
+    !vp_value_by_strategy.length
+  ) {
+    return 0;
+  }
+
+  let totalValue = 0;
+  for (let strategyIndex = 0; strategyIndex < vp_value_by_strategy.length; strategyIndex++) {
+    const strategyTotal = scores_by_strategy.reduce((sum, voteScores) => {
+      if (voteScores.length !== vp_value_by_strategy.length) {
+        throw new Error(
+          'Array size mismatch: voteScores length does not match vp_value_by_strategy length'
+        );
+      }
+      const score = voteScores[strategyIndex];
+      if (typeof score !== 'number') {
+        throw new Error(`Invalid score value: expected number, got ${typeof score}`);
+      }
+      return sum + score;
+    }, 0);
+
+    if (typeof vp_value_by_strategy[strategyIndex] !== 'number') {
+      throw new Error(
+        `Invalid vp_value: expected number, got ${typeof vp_value_by_strategy[strategyIndex]}`
+      );
+    }
+
+    totalValue += strategyTotal * vp_value_by_strategy[strategyIndex];
+  }
+
+  return totalValue;
 }

test/unit/helpers/entityValue.test.ts

@@ -49,6 +49,17 @@ describe('getProposalValue', () => {
     expect(result).toBe(0);
   });
 
+  it('should return 0 when vp_value_by_strategy is empty', () => {
+    const proposal = {
+      scores_by_strategy: [[100], [200]],
+      vp_value_by_strategy: []
+    };
+
+    const result = getProposalValue(proposal);
+
+    expect(result).toBe(0);
+  });
+
   it('should handle zero values correctly', () => {
     const proposal = {
       scores_by_strategy: [
@@ -101,4 +112,46 @@ describe('getProposalValue', () => {
 
     expect(result).toBe(200); // 100 * 2.0 = 200
   });
+
+  it('should throw on array size mismatch', () => {
+    const proposal = {
+      scores_by_strategy: [
+        [100, 50], // 2 strategies
+        [200, 75] // 2 strategies
+      ],
+      vp_value_by_strategy: [1.5] // Only 1 strategy value
+    };
+
+    expect(() => getProposalValue(proposal)).toThrow(
+      'Array size mismatch: voteScores length does not match vp_value_by_strategy length'
+    );
+  });
+
+  it('should throw on invalid score value', () => {
+    const proposal = {
+      scores_by_strategy: [
+        [100, 'invalid'], // Invalid string value
+        [200, 75]
+      ],
+      vp_value_by_strategy: [1.5, 2.0]
+    } as any;
+
+    expect(() => getProposalValue(proposal)).toThrow(
+      'Invalid score value: expected number, got string'
+    );
+  });
+
+  it('should throw on invalid vp_value', () => {
+    const proposal = {
+      scores_by_strategy: [
+        [100, 50],
+        [200, 75]
+      ],
+      vp_value_by_strategy: [1.5, 'invalid'] // Invalid string value
+    } as any;
+
+    expect(() => getProposalValue(proposal)).toThrow(
+      'Invalid vp_value: expected number, got string'
+    );
+  });
 });