feat: validate space strategies

src/helpers/spaceValidation.ts

@@ -0,0 +1,84 @@
+import snapshot from '@snapshot-labs/snapshot.js';
+import log from './log';
+import { strategies } from './strategies';
+
+const DEFAULT_SNAPSHOT_ENV: string = 'testnet';
+
+export async function validateSpaceSettings(
+  originalSpace: any,
+  snapshotEnv = DEFAULT_SNAPSHOT_ENV
+): Promise<void> {
+  const spaceType = originalSpace.turbo ? 'turbo' : 'default';
+  const space = snapshot.utils.clone(originalSpace);
+
+  if (space?.deleted) return Promise.reject('space deleted, contact admin');
+
+  delete space.deleted;
+  delete space.flagged;
+  delete space.verified;
+  delete space.turbo;
+  delete space.hibernated;
+  delete space.id;
+
+  if (space.parent && space.parent === originalSpace.id) {
+    return Promise.reject('space cannot be its own parent');
+  }
+
+  if (
+    space.children &&
+    Array.isArray(space.children) &&
+    space.children.includes(originalSpace.id)
+  ) {
+    return Promise.reject('space cannot be its own child');
+  }
+
+  const schemaIsValid: any = snapshot.utils.validateSchema(snapshot.schemas.space, space, {
+    spaceType,
+    snapshotEnv
+  });
+
+  if (schemaIsValid !== true) {
+    log.warn('[writer] Wrong space format', schemaIsValid);
+    const firstErrorObject: any = Object.values(schemaIsValid)[0];
+    if (firstErrorObject.message === 'network not allowed') {
+      return Promise.reject(firstErrorObject.message);
+    }
+    return Promise.reject('wrong space format');
+  }
+
+  const strategiesIds: string[] = space.strategies.map((strategy: any) => strategy.name);
+  if (snapshotEnv !== 'testnet') {
+    const hasTicket = strategiesIds.includes('ticket');
+    const hasVotingValidation =
+      space.voteValidation?.name && !['any'].includes(space.voteValidation.name);
+
+    if (hasTicket && !hasVotingValidation) {
+      return Promise.reject('space with ticket requires voting validation');
+    }
+
+    const hasProposalValidation =
+      (space.validation?.name && space.validation.name !== 'any') ||
+      space.filters?.minScore ||
+      space.filters?.onlyMembers;
+
+    if (!hasProposalValidation) {
+      return Promise.reject('space missing proposal validation');
+    }
+  }
+
+  for (const id of strategiesIds) {
+    const strategy = strategies[id];
+
+    if (!strategy) {
+      return Promise.reject(`strategy "${id}" is not a valid strategy`);
+    }
+
+    if (strategy.disabled) {
+      return Promise.reject(`strategy "${id}" is not available anymore`);
+    }
+
+    if (strategy.override && spaceType !== 'turbo') {
+      return Promise.reject(`strategy "${id}" is only available for pro spaces`);
+    }
+  }
+}

src/helpers/strategies.ts

@@ -0,0 +1,73 @@
+import { URL } from 'url';
+import { capture } from '@snapshot-labs/snapshot-sentry';
+import snapshot from '@snapshot-labs/snapshot.js';
+import log from './log';
+
+type Strategy = {
+  id: string;
+  override: boolean;
+  disabled: boolean;
+};
+
+const RUN_INTERVAL = 60e3 * 5; // 5 minutes
+const MAX_CONSECUTIVE_FAILS = 3;
+const URI = new URL(
+  '/api/strategies',
+  process.env.SCORE_API_URL ?? 'https://score.snapshot.org'
+).toString();
+
+let consecutiveFailsCount = 0;
+let shouldStop = false;
+export let strategies: Record<Strategy['id'], Strategy> = {};
+
+async function loadStrategies() {
+  const res = await snapshot.utils.getJSON(URI);
+
+  if ('error' in res) {
+    capture(new Error('Failed to load strategies'), {
+      contexts: { input: { uri: URI }, res }
+    });
+    return true;
+  }
+
+  const strat = Object.values(res).map((strategy: any) => ({
+    id: strategy.key,
+    override: strategy.dependOnOtherAddress || false,
+    disabled: strategy.disabled || false
+  }));
+
+  strategies = Object.fromEntries(strat.map(strategy => [strategy.id, strategy]));
+}
+
+export async function initialize() {
+  log.info('[strategies] Initial strategies load');
+  await loadStrategies();
+  log.info('[strategies] Initial strategies load complete');
+}
+
+export async function run() {
+  while (!shouldStop) {
+    try {
+      log.info('[strategies] Start strategies refresh');
+      await loadStrategies();
+      consecutiveFailsCount = 0;
+      log.info('[strategies] End strategies refresh');
+    } catch (e: any) {
+      consecutiveFailsCount++;
+
+      if (consecutiveFailsCount >= MAX_CONSECUTIVE_FAILS) {
+        capture(e);
+      }
+      log.error(`[strategies] failed to load ${JSON.stringify(e)}`);
+    }
+
+    // if stop() has been called after sleep started,
+    // the loop will exit only after the sleep has completed
+    await snapshot.utils.sleep(RUN_INTERVAL);
+  }
+}
+
+export function stop() {
+  log.info('[strategies] Stopping strategies refresh');
+  shouldStop = true;
+}

src/index.ts

@@ -8,25 +8,62 @@ import initMetrics from './helpers/metrics';
 import refreshModeration from './helpers/moderation';
 import rateLimit from './helpers/rateLimit';
 import shutter from './helpers/shutter';
+import {
+  initialize as initializeStrategies,
+  run as refreshStrategies,
+  stop as stopStrategies
+} from './helpers/strategies';
 import { trackTurboStatuses } from './helpers/turbo';
 
 const app = express();
 
-initLogger(app);
-refreshModeration();
-initMetrics(app);
-trackTurboStatuses();
+async function startServer() {
+  initLogger(app);
+  refreshModeration();
 
-app.disable('x-powered-by');
-app.use(express.json({ limit: '20mb' }));
-app.use(express.urlencoded({ limit: '20mb', extended: false }));
-app.use(cors({ maxAge: 86400 }));
-app.use(rateLimit);
-app.set('trust proxy', 1);
-app.use('/', api);
-app.use('/shutter', shutter);
+  await initializeStrategies();
+  refreshStrategies();
 
-fallbackLogger(app);
+  initMetrics(app);
+  trackTurboStatuses();
 
-const PORT = process.env.PORT || 3001;
-app.listen(PORT, () => log.info(`Started on: http://localhost:${PORT}`));
+  app.disable('x-powered-by');
+  app.use(express.json({ limit: '20mb' }));
+  app.use(express.urlencoded({ limit: '20mb', extended: false }));
+  app.use(cors({ maxAge: 86400 }));
+  app.use(rateLimit);
+  app.set('trust proxy', 1);
+  app.use('/', api);
+  app.use('/shutter', shutter);
+
+  fallbackLogger(app);
+
+  const PORT = process.env.PORT || 3001;
+  return app.listen(PORT, () => log.info(`Started on: http://localhost:${PORT}`));
+}
+
+startServer()
+  .then(server => {
+    const gracefulShutdown = (signal: string) => {
+      log.info(`Received ${signal}, shutting down gracefully...`);
+
+      stopStrategies();
+
+      server.close(() => {
+        log.info('Server closed');
+        process.exit(0);
+      });
+
+      setTimeout(() => {
+        log.error('Could not close connections in time, forcefully shutting down');
+        process.exit(1);
+      }, 10000);
+    };
+
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+  })
+  .catch(error => {
+    log.error('Failed to start server:', error);
+    process.exit(1);
+  });

src/writer/proposal.ts

@@ -2,13 +2,13 @@ import { capture } from '@snapshot-labs/snapshot-sentry';
 import snapshot from '@snapshot-labs/snapshot.js';
 import networks from '@snapshot-labs/snapshot.js/src/networks.json';
 import { uniq } from 'lodash';
-import { validateSpaceSettings } from './settings';
 import { getPremiumNetworkIds, getSpace } from '../helpers/actions';
 import log from '../helpers/log';
 import { containsFlaggedLinks, flaggedAddresses } from '../helpers/moderation';
 import { isMalicious } from '../helpers/monitoring';
 import db from '../helpers/mysql';
 import { getLimits, getSpaceType } from '../helpers/options';
+import { validateSpaceSettings } from '../helpers/spaceValidation';
 import { captureError, getQuorum, jsonParse, validateChoices } from '../helpers/utils';
 
 const scoreAPIUrl = process.env.SCORE_API_URL || 'https://score.snapshot.org';
@@ -65,11 +65,7 @@ async function validateSpace(space: any) {
     return Promise.reject('space hibernated');
   }
 
-  try {
-    await validateSpaceSettings(space);
-  } catch (e) {
-    return Promise.reject(e);
-  }
+  await validateSpaceSettings(space, process.env.NETWORK);
 }
 
 export async function verify(body): Promise<any> {

src/writer/settings.ts

@@ -1,10 +1,10 @@
 import { capture } from '@snapshot-labs/snapshot-sentry';
-import snapshot from '@snapshot-labs/snapshot.js';
 import isEqual from 'lodash/isEqual';
 import { addOrUpdateSpace, getSpace } from '../helpers/actions';
 import log from '../helpers/log';
 import db from '../helpers/mysql';
 import { getLimit, getSpaceType } from '../helpers/options';
+import { validateSpaceSettings } from '../helpers/spaceValidation';
 import {
   addToWalletConnectWhitelist,
   clearStampCache,
@@ -15,65 +15,6 @@ import {
 
 const SNAPSHOT_ENV = process.env.NETWORK || 'testnet';
 
-export async function validateSpaceSettings(originalSpace: any) {
-  const spaceType = originalSpace.turbo ? 'turbo' : 'default';
-  const space = snapshot.utils.clone(originalSpace);
-
-  if (space?.deleted) return Promise.reject('space deleted, contact admin');
-
-  delete space.deleted;
-  delete space.flagged;
-  delete space.verified;
-  delete space.turbo;
-  delete space.hibernated;
-  delete space.id;
-
-  if (space.parent && space.parent === originalSpace.id) {
-    return Promise.reject('space cannot be its own parent');
-  }
-
-  if (
-    space.children &&
-    Array.isArray(space.children) &&
-    space.children.includes(originalSpace.id)
-  ) {
-    return Promise.reject('space cannot be its own child');
-  }
-
-  const schemaIsValid: any = snapshot.utils.validateSchema(snapshot.schemas.space, space, {
-    spaceType,
-    snapshotEnv: SNAPSHOT_ENV
-  });
-
-  if (schemaIsValid !== true) {
-    log.warn('[writer] Wrong space format', schemaIsValid);
-    const firstErrorObject: any = Object.values(schemaIsValid)[0];
-    if (firstErrorObject.message === 'network not allowed') {
-      return Promise.reject(firstErrorObject.message);
-    }
-    return Promise.reject('wrong space format');
-  }
-
-  if (SNAPSHOT_ENV !== 'testnet') {
-    const hasTicket = space.strategies.some(strategy => strategy.name === 'ticket');
-    const hasVotingValidation =
-      space.voteValidation?.name && !['any'].includes(space.voteValidation.name);
-
-    if (hasTicket && !hasVotingValidation) {
-      return Promise.reject('space with ticket requires voting validation');
-    }
-
-    const hasProposalValidation =
-      (space.validation?.name && space.validation.name !== 'any') ||
-      space.filters?.minScore ||
-      space.filters?.onlyMembers;
-
-    if (!hasProposalValidation) {
-      return Promise.reject('space missing proposal validation');
-    }
-  }
-}
-
 export async function verify(body): Promise<any> {
   const msg = jsonParse(body.msg);
   if (msg.space.length > 64) {
@@ -82,12 +23,15 @@ export async function verify(body): Promise<any> {
   const space = await getSpace(msg.space, true);
 
   try {
-    await validateSpaceSettings({
-      ...msg.payload,
-      id: msg.space,
-      deleted: space?.deleted,
-      turbo: space?.turbo
-    });
+    await validateSpaceSettings(
+      {
+        ...msg.payload,
+        id: msg.space,
+        deleted: space?.deleted,
+        turbo: space?.turbo
+      },
+      process.env.NETWORK
+    );
   } catch (e) {
     return Promise.reject(e);
   }

test/e2e/api.test.ts

@@ -58,7 +58,7 @@ describe('POST /flag', () => {
           settings: JSON.stringify(space.settings)
         }))
         .map(async space => {
-          db.queryAsync('INSERT INTO snapshot_sequencer_test.spaces SET ?', space);
+          return db.queryAsync('INSERT INTO snapshot_sequencer_test.spaces SET ?', space);
         })
     );
 
@@ -75,7 +75,7 @@ describe('POST /flag', () => {
           vp_value_by_strategy: JSON.stringify(proposal.vp_value_by_strategy || [])
         }))
         .map(async proposal => {
-          db.queryAsync('INSERT INTO snapshot_sequencer_test.proposals SET ?', proposal);
+          return db.queryAsync('INSERT INTO snapshot_sequencer_test.proposals SET ?', proposal);
         })
     );
   });