feat: pull overriding strategies from strategies list

Author: wa0x6e

src/helpers/utils.ts

@@ -7,6 +7,7 @@ import { capture } from '@snapshot-labs/snapshot-sentry';
 import snapshot from '@snapshot-labs/snapshot.js';
 import { Response } from 'express';
 import fetch from 'node-fetch';
+import { getStrategies } from './strategies';
 
 const MAINNET_NETWORK_ID_WHITELIST = ['s', 'eth', 'arb1', 'oeth', 'sn', 'base', 'mnt', 'ape'];
 const TESTNET_NETWORK_ID_WHITELIST = ['s-tn', 'sep', 'curtis', 'linea-testnet', 'sn-sep'];
@@ -62,37 +63,15 @@ export function rpcError(res, code, e, id) {
   });
 }
 
-export function hasStrategyOverride(strategies: any[]) {
-  const keywords = [
-    '"aura-vlaura-vebal-with-overrides"',
-    '"balance-of-with-linear-vesting-power"',
-    '"balancer-delegation"',
-    '"cyberkongz"',
-    '"cyberkongz-v2"',
-    '"delegation"',
-    '"delegation-with-cap"',
-    '"delegation-with-overrides"',
-    '"erc20-balance-of-delegation"',
-    '"erc20-balance-of-fixed-total"',
-    '"erc20-balance-of-quadratic-delegation"',
-    '"erc20-votes-with-override"',
-    '"esd-delegation"',
-    '"ocean-dao-brightid"',
-    '"orbs-network-delegation"',
-    '"api-v2-override"',
-    '"rocketpool-node-operator-delegate-v8"',
-    '"eden-online-override"',
-    '"split-delegation"',
-    '"sonic-staked-balance"'
-  ];
+export function hasStrategyOverride(strategies: any[]): boolean {
+  if (!strategies?.length) return false;
+
   const strategiesStr = JSON.stringify(strategies).toLowerCase();
-  if (keywords.some(keyword => strategiesStr.includes(`"name":${keyword}`))) return true;
-  // Check for split-delegation with delegationOverride
-  const splitDelegation = strategies.filter(strategy => strategy.name === 'split-delegation');
-  return (
-    splitDelegation.length > 0 &&
-    splitDelegation.some(strategy => strategy.params?.delegationOverride)
-  );
+  const overridingStrategies = Object.values(getStrategies())
+    .filter(s => s.override)
+    .map(s => s.id);
+
+  return overridingStrategies.some(strategyId => strategiesStr.includes(`"name":"${strategyId}"`));
 }
 
 export function validateChoices({ type, choices }): boolean {

test/fixtures/strategies.ts

@@ -0,0 +1,31 @@
+// Real strategies from score.snapshot.org/api/strategies
+// Includes only whitelist, ticket, delegation, and multichain strategies for testing
+
+export const STRATEGIES_FIXTURE = {
+  whitelist: {
+    id: 'whitelist',
+    override: false,
+    disabled: false
+  },
+  ticket: {
+    id: 'ticket',
+    override: false,
+    disabled: false
+  },
+  delegation: {
+    id: 'delegation',
+    override: true,
+    disabled: false
+  },
+  multichain: {
+    id: 'multichain',
+    override: false,
+    disabled: true
+  },
+  'delegation-with-cap': {
+    id: 'delegation-with-cap',
+    override: true,
+    disabled: false
+  }
+};
+

test/unit/helpers/utils.test.ts

@@ -0,0 +1,123 @@
+import * as strategies from '../../../src/helpers/strategies';
+import { hasStrategyOverride } from '../../../src/helpers/utils';
+import { STRATEGIES_FIXTURE } from '../../fixtures/strategies';
+
+// Mock the getStrategies function
+jest.mock('../../../src/helpers/strategies');
+const mockGetStrategies = jest.mocked(strategies.getStrategies);
+
+describe('Utils', () => {
+  describe('hasStrategyOverride()', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockGetStrategies.mockReturnValue(STRATEGIES_FIXTURE);
+    });
+
+    it('should return false when strategies array is empty', () => {
+      expect(hasStrategyOverride([])).toBe(false);
+    });
+
+    it('should return false when no overriding strategies exist', () => {
+      const strategies = [
+        { name: 'whitelist', network: '1', params: {} },
+        { name: 'ticket', network: '1', params: {} }
+      ];
+
+      expect(hasStrategyOverride(strategies)).toBe(false);
+    });
+
+    it('should return true when an overriding strategy is used', () => {
+      const strategies = [
+        { name: 'whitelist', network: '1', params: {} },
+        { name: 'delegation', network: '1', params: {} }
+      ];
+
+      expect(hasStrategyOverride(strategies)).toBe(true);
+    });
+
+    it('should return true when multiple overriding strategies are used', () => {
+      const strategies = [
+        { name: 'delegation', network: '1', params: {} },
+        { name: 'delegation-with-cap', network: '1', params: {} }
+      ];
+
+      expect(hasStrategyOverride(strategies)).toBe(true);
+    });
+
+    it('should handle mixed case strategy names correctly', () => {
+      const strategies = [{ name: 'Delegation', network: '1', params: {} }];
+
+      expect(hasStrategyOverride(strategies)).toBe(true);
+    });
+
+    it('should handle case where overriding strategy is disabled', () => {
+      mockGetStrategies.mockReturnValue({
+        delegation: { id: 'delegation', override: true, disabled: true }
+      });
+
+      const strategies = [{ name: 'delegation', network: '1', params: {} }];
+
+      expect(hasStrategyOverride(strategies)).toBe(true);
+    });
+
+    it('should handle inner strategies', () => {
+      const strategies = [
+        {
+          name: 'multichain',
+          network: '1',
+          params: {
+            symbol: 'MULTI',
+            strategies: [
+              {
+                name: 'erc20-balance-of',
+                network: '1',
+                params: {
+                  address: '0x579cea1889991f68acc35ff5c3dd0621ff29b0c9',
+                  decimals: 18
+                }
+              },
+              {
+                name: 'delegation',
+                network: '137',
+                params: {
+                  delegationSpace: 'test.eth',
+                  strategies: [
+                    {
+                      name: 'erc20-balance-of',
+                      params: {
+                        address: '0xB9638272aD6998708de56BBC0A290a1dE534a578',
+                        decimals: 18
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ];
+
+      expect(hasStrategyOverride(strategies)).toBe(true);
+    });
+
+    it('should not match when strategy id appears in other fields', () => {
+      const strategies = [
+        {
+          name: 'whitelist',
+          network: '1',
+          params: { description: 'delegation' }
+        }
+      ];
+
+      expect(hasStrategyOverride(strategies)).toBe(false);
+    });
+
+    it('should handle empty getStrategies result', () => {
+      mockGetStrategies.mockReturnValue({});
+
+      const strategies = [{ name: 'delegation', network: '1', params: {} }];
+
+      expect(hasStrategyOverride(strategies)).toBe(false);
+    });
+  });
+});