@snapshot-labs/snapshot.js 0.8.3 → 0.9.1

package/dist/utils.d.ts

@@ -31,7 +31,9 @@ export declare function sendTransaction(web3: any, contractAddress: string, abi:
 export declare function getScores(space: string, strategies: Strategy[], network: string, addresses: string[], snapshot?: number | string, scoreApiUrl?: string, options?: any): Promise<any>;
 export declare function getVp(address: string, network: string, strategies: Strategy[], snapshot: number | 'latest', space: string, delegation: boolean, options?: Options): Promise<any>;
 export declare function validate(validation: string, author: string, space: string, network: string, snapshot: number | 'latest', params: any, options: any): Promise<any>;
-export declare function validateSchema(schema: any, data: any): true | import("ajv").ErrorObject<string, Record<string, any>, unknown>[] | null | undefined;
+export declare function validateSchema(schema: any, data: any, options?: {
+    snapshotEnv: string;
+}): true | import("ajv").ErrorObject<string, Record<string, any>, unknown>[] | null | undefined;
 export declare function getEnsTextRecord(ens: string, record: string, network?: string, options?: any): Promise<any>;
 export declare function getSpaceUri(id: string, network?: string, options?: any): Promise<string | null>;
 export declare function getEnsOwner(ens: string, network?: string, options?: any): Promise<string | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapshot-labs/snapshot.js",
-  "version": "0.8.3",
+  "version": "0.9.1",
   "repository": "snapshot-labs/snapshot.js",
   "license": "MIT",
   "main": "dist/snapshot.cjs.js",

package/src/schemas/space.json

@@ -79,6 +79,7 @@
         },
         "network": {
           "type": "string",
+          "snapshotNetwork": true,
           "title": "network",
           "minLength": 1,
           "maxLength": 32
@@ -114,7 +115,8 @@
               "network": {
                 "type": "string",
                 "maxLength": 12,
-                "title": "network"
+                "title": "network",
+                "snapshotNetwork": true
               },
               "params": {
                 "type": "object",
@@ -346,6 +348,7 @@
               },
               "network": {
                 "type": "string",
+                "snapshotNetwork": true,
                 "title": "Network",
                 "maxLength": 12
               }

package/src/schemas/zodiac.json

@@ -15,7 +15,8 @@
             "properties": {
               "network": {
                 "title": "Network",
-                "type": "string"
+                "type": "string",
+                "snapshotNetwork": true
               },
               "multisend": {
                 "title": "Multisend contract address",

package/src/utils.spec.js

@@ -0,0 +1,475 @@
+import { describe, test, expect, vi, afterEach } from 'vitest';
+import * as crossFetch from 'cross-fetch';
+import { validate, getScores, getVp } from './utils';
+
+vi.mock('cross-fetch', async () => {
+  const actual = await vi.importActual('cross-fetch');
+
+  return {
+    ...actual,
+    default: vi.fn()
+  };
+});
+const fetch = vi.mocked(crossFetch.default);
+
+describe('utils', () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('validate', () => {
+    const payload = {
+      validation: 'basic',
+      author: '0xeF8305E140ac520225DAf050e2f71d5fBcC543e7',
+      space: 'fabien.eth',
+      network: '1',
+      snapshot: 7929876,
+      params: {
+        minScore: 0.9,
+        strategies: [
+          {
+            name: 'eth-balance',
+            params: {}
+          }
+        ]
+      }
+    };
+
+    function _validate({
+      validation,
+      author,
+      space,
+      network,
+      snapshot,
+      params,
+      options
+    }) {
+      return validate(
+        validation ?? payload.validation,
+        author ?? payload.author,
+        space ?? payload.space,
+        network ?? payload.network,
+        snapshot ?? payload.snapshot,
+        params ?? payload.params,
+        options ?? {}
+      );
+    }
+
+    describe('when passing invalid args', () => {
+      const cases = [
+        [
+          'author is an invalid address',
+          { author: 'test-address' },
+          /invalid author/i
+        ],
+        ['network is not valid', { network: 'mainnet' }, /invalid network/i],
+        ['network is empty', { network: '' }, /invalid network/i],
+        [
+          'snapshot is smaller than start block',
+          { snapshot: 1234 },
+          /snapshot \([0-9]+\) must be 'latest' or greater than network start block/i
+        ]
+      ];
+
+      test.each(cases)('throw an error when %s', async (title, args, err) => {
+        await expect(_validate(args)).rejects.toMatch(err);
+      });
+    });
+
+    describe('when passing valid args', () => {
+      test('send a JSON-RPC payload to score-api', async () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(_validate({})).resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://score.snapshot.org',
+          expect.objectContaining({
+            body: JSON.stringify({
+              jsonrpc: '2.0',
+              method: 'validate',
+              params: payload
+            })
+          })
+        );
+      });
+
+      test('send a POST request with JSON content-type', async () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(_validate({})).resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://score.snapshot.org',
+          expect.objectContaining({
+            method: 'POST',
+            headers: {
+              Accept: 'application/json',
+              'Content-Type': 'application/json'
+            }
+          })
+        );
+      });
+
+      test('can customize the score-api url', () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(
+          _validate({ options: { url: 'https://snapshot.org/?apiKey=xxx' } })
+        ).resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://snapshot.org/?apiKey=xxx',
+          expect.anything()
+        );
+      });
+
+      test('returns the JSON-RPC result property', () => {
+        const result = { result: 'OK' };
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve(result))
+        });
+
+        expect(_validate({})).resolves.toEqual('OK');
+      });
+    });
+
+    describe('when score-api is sending a JSON-RPC error', () => {
+      test('rejects with the JSON-RPC error object', () => {
+        const result = { error: { message: 'Oh no' } };
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve(result))
+        });
+
+        expect(_validate({})).rejects.toEqual(result.error);
+      });
+    });
+
+    describe('when the fetch request is failing with not network error', () => {
+      test('rejects with the error', () => {
+        const result = new Error('Oh no');
+        fetch.mockReturnValue({
+          json: () => {
+            throw result;
+          }
+        });
+
+        expect(_validate({})).rejects.toEqual(result);
+      });
+    });
+  });
+  describe('getScores', () => {
+    const payload = {
+      space: 'test.eth',
+      network: '1',
+      snapshot: 7929876,
+      strategies: [
+        {
+          name: 'erc20-balance-of',
+          params: {
+            symbol: 'TEST',
+            address: '0xc23F41519D7DFaDf9eed53c00f08C06CD5cDde54',
+            network: '1',
+            decimals: 18
+          },
+          network: '1'
+        }
+      ],
+      addresses: ['0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11']
+    };
+
+    function _getScores({
+      space,
+      strategies,
+      network,
+      addresses,
+      snapshot,
+      scoreApiUrl,
+      options
+    }) {
+      return getScores(
+        space ?? payload.space,
+        strategies ?? payload.strategies,
+        network ?? payload.network,
+        addresses ?? payload.addresses,
+        snapshot ?? payload.snapshot,
+        scoreApiUrl ?? 'https://score.snapshot.org',
+        options ?? {}
+      );
+    }
+
+    describe('when passing invalid args', () => {
+      const cases = [
+        [
+          'addresses contains invalid address',
+          { addresses: ['test-address'] },
+          /invalid address/i
+        ],
+        [
+          'addresses is not an array',
+          { addresses: 'test-address' },
+          /addresses should be an array/i
+        ],
+        [
+          'addresses is an empty array',
+          { addresses: [] },
+          /addresses can not be empty/i
+        ],
+        ['network is not valid', { network: 'mainnet' }, /invalid network/i],
+        ['network is empty', { network: '' }, /invalid network/i],
+        [
+          'snapshot is smaller than start block',
+          { snapshot: 1234 },
+          /snapshot \([0-9]+\) must be 'latest' or greater than network start block/i
+        ],
+        [
+          'strategy contains invalid network',
+          { strategies: [{ name: '', network: 'test' }] },
+          /invalid network \(.*\) in strategy/i
+        ]
+      ];
+
+      test.each(cases)('throw an error when %s', async (title, args, err) => {
+        await expect(_getScores(args)).rejects.toMatch(err);
+      });
+    });
+
+    describe('when passing valid args', () => {
+      test('send a JSON-RPC payload to score-api', async () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(_getScores({})).resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://score.snapshot.org/api/scores',
+          expect.objectContaining({
+            body: JSON.stringify({ params: payload })
+          })
+        );
+      });
+
+      test('send a POST request with JSON content-type', async () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(_getScores({})).resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://score.snapshot.org/api/scores',
+          expect.objectContaining({
+            method: 'POST',
+            headers: {
+              Accept: 'application/json',
+              'Content-Type': 'application/json'
+            }
+          })
+        );
+      });
+
+      test('can customize the score-api url', () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(_getScores({ scoreApiUrl: 'https://snapshot.org/?apiKey=xxx' }))
+          .resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://snapshot.org/api/scores?apiKey=xxx',
+          expect.anything()
+        );
+      });
+
+      test('returns the JSON-RPC result scores property', () => {
+        const result = { scores: 'SCORES', other: 'Other' };
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result }))
+        });
+
+        expect(_getScores({})).resolves.toEqual('SCORES');
+      });
+
+      test('returns the JSON-RPC all properties', () => {
+        const result = { scores: 'SCORES', other: 'Other' };
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result }))
+        });
+
+        expect(
+          _getScores({ options: { returnValue: 'all' } })
+        ).resolves.toEqual(result);
+      });
+    });
+
+    describe('when score-api is sending a JSON-RPC error', () => {
+      test('rejects with the JSON-RPC error object', () => {
+        const result = { error: { message: 'Oh no' } };
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve(result))
+        });
+
+        expect(_getScores({})).rejects.toEqual(result.error);
+      });
+    });
+
+    describe('when the fetch request is failing with not network error', () => {
+      test('rejects with the error', () => {
+        const result = new Error('Oh no');
+        fetch.mockReturnValue({
+          json: () => {
+            throw result;
+          }
+        });
+
+        expect(_getScores({})).rejects.toEqual(result);
+      });
+    });
+  });
+  describe('getVp', () => {
+    const payload = {
+      address: '0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11',
+      network: '1',
+      strategies: [
+        {
+          name: 'erc20-balance-of',
+          params: {
+            symbol: 'TEST',
+            address: '0xc23F41519D7DFaDf9eed53c00f08C06CD5cDde54',
+            network: '1',
+            decimals: 18
+          },
+          network: '1'
+        }
+      ],
+      snapshot: 7929876,
+      space: 'test.eth',
+      delegation: false,
+      options: undefined
+    };
+
+    function _getVp({ voter, network, strategies, snapshot, options }) {
+      return getVp(
+        voter ?? payload.address,
+        network ?? payload.network,
+        strategies ?? payload.strategies,
+        snapshot ?? payload.snapshot,
+        'test.eth' ?? payload.space,
+        false ?? payload.delegation,
+        options ?? payload.options
+      );
+    }
+
+    describe('when passing invalid args', () => {
+      const cases = [
+        [
+          'voter is not a valid address',
+          { voter: 'test-address' },
+          /invalid voter address/i
+        ],
+        ['voter is empty', { voter: '' }, /invalid voter address/i],
+        ['network is not valid', { network: 'mainnet' }, /invalid network/i],
+        ['network is empty', { network: '' }, /invalid network/i],
+        [
+          'snapshot is smaller than start block',
+          { snapshot: 1234 },
+          /snapshot \([0-9]+\) must be 'latest' or greater than network start block/i
+        ],
+        [
+          'strategy contains invalid network',
+          { strategies: [{ name: '', network: 'test' }] },
+          /invalid network \(.*\) in strategy/i
+        ]
+      ];
+
+      test.each(cases)('throw an error when %s', async (title, args, err) => {
+        await expect(_getVp(args)).rejects.toMatch(err);
+      });
+    });
+
+    describe('when passing valid args', () => {
+      test('send a JSON-RPC payload to score-api', async () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(_getVp({})).resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://score.snapshot.org',
+          expect.objectContaining({
+            body: JSON.stringify({
+              jsonrpc: '2.0',
+              method: 'get_vp',
+              params: payload
+            })
+          })
+        );
+      });
+
+      test('send a POST request with JSON content-type', async () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(_getVp({})).resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://score.snapshot.org',
+          expect.objectContaining({
+            method: 'POST',
+            headers: {
+              Accept: 'application/json',
+              'Content-Type': 'application/json'
+            }
+          })
+        );
+      });
+
+      test('can customize the score-api url', () => {
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result: 'OK' }))
+        });
+
+        expect(_getVp({ options: { url: 'https://snapshot.org' } })).resolves;
+        expect(fetch).toHaveBeenCalledWith(
+          'https://snapshot.org',
+          expect.anything()
+        );
+      });
+
+      test('returns the JSON-RPC result property', () => {
+        const result = { data: 'OK' };
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve({ result }))
+        });
+
+        expect(_getVp({})).resolves.toEqual(result);
+      });
+    });
+
+    describe('when score-api is sending a JSON-RPC error', () => {
+      test('rejects with the JSON-RPC error object', () => {
+        const result = { error: { message: 'Oh no' } };
+        fetch.mockReturnValue({
+          json: () => new Promise((resolve) => resolve(result))
+        });
+
+        expect(_getVp({})).rejects.toEqual(result.error);
+      });
+    });
+
+    describe('when the fetch request is failing with not network error', () => {
+      test('rejects with the error', () => {
+        const result = new Error('Oh no');
+        fetch.mockReturnValue({
+          json: () => {
+            throw result;
+          }
+        });
+
+        expect(_getVp({})).rejects.toEqual(result);
+      });
+    });
+  });
+});

package/src/utils.ts

@@ -31,13 +31,19 @@ export const SNAPSHOT_SUBGRAPH_URL = delegationSubgraphs;
 const ENS_RESOLVER_ABI = [
   'function text(bytes32 node, string calldata key) external view returns (string memory)'
 ];
+const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000';
 
 const scoreApiHeaders = {
   Accept: 'application/json',
   'Content-Type': 'application/json'
 };
 
-const ajv = new Ajv({ allErrors: true, allowUnionTypes: true, $data: true });
+const ajv = new Ajv({
+  allErrors: true,
+  allowUnionTypes: true,
+  $data: true,
+  passContext: true
+});
 // @ts-ignore
 addFormats(ajv);
 
@@ -68,6 +74,28 @@ ajv.addFormat('ethValue', {
   }
 });
 
+const networksIds = Object.keys(networks);
+const mainnetNetworkIds = Object.keys(networks).filter(
+  (id) => !networks[id].testnet
+);
+const testnetNetworkIds = Object.keys(networks).filter(
+  (id) => networks[id].testnet
+);
+
+ajv.addKeyword({
+  keyword: 'snapshotNetwork',
+  validate: function (schema, data) {
+    // @ts-ignore
+    const snapshotEnv = this.snapshotEnv || 'default';
+    if (snapshotEnv === 'mainnet') return mainnetNetworkIds.includes(data);
+    if (snapshotEnv === 'testnet') return testnetNetworkIds.includes(data);
+    return networksIds.includes(data);
+  },
+  error: {
+    message: 'must be a valid network used by snapshot'
+  }
+});
+
 // Custom URL format to allow empty string values
 // https://github.com/snapshot-labs/snapshot.js/pull/541/files
 ajv.addFormat('customUrl', {
@@ -222,6 +250,33 @@ export async function getScores(
   scoreApiUrl = 'https://score.snapshot.org',
   options: any = {}
 ) {
+  if (!Array.isArray(addresses)) {
+    return inputError('addresses should be an array of addresses');
+  }
+  if (addresses.length === 0) {
+    return inputError('addresses can not be empty');
+  }
+  const invalidAddress = addresses.find((address) => !isValidAddress(address));
+  if (invalidAddress) {
+    return inputError(`Invalid address: ${invalidAddress}`);
+  }
+  if (!isValidNetwork(network)) {
+    return inputError(`Invalid network: ${network}`);
+  }
+  const invalidStrategy = strategies.find(
+    (strategy) => strategy.network && !isValidNetwork(strategy.network)
+  );
+  if (invalidStrategy) {
+    return inputError(
+      `Invalid network (${invalidStrategy.network}) in strategy ${invalidStrategy.name}`
+    );
+  }
+  if (!isValidSnapshot(snapshot, network)) {
+    return inputError(
+      `Snapshot (${snapshot}) must be 'latest' or greater than network start block (${networks[network].start})`
+    );
+  }
+
   const url = new URL(scoreApiUrl);
   url.pathname = '/api/scores';
   scoreApiUrl = url.toString();
@@ -267,6 +322,27 @@ export async function getVp(
 ) {
   if (!options) options = {};
   if (!options.url) options.url = 'https://score.snapshot.org';
+  if (!isValidAddress(address)) {
+    return inputError(`Invalid voter address: ${address}`);
+  }
+  if (!isValidNetwork(network)) {
+    return inputError(`Invalid network: ${network}`);
+  }
+  const invalidStrategy = strategies.find(
+    (strategy) => strategy.network && !isValidNetwork(strategy.network)
+  );
+
+  if (invalidStrategy) {
+    return inputError(
+      `Invalid network (${invalidStrategy.network}) in strategy ${invalidStrategy.name}`
+    );
+  }
+  if (!isValidSnapshot(snapshot, network)) {
+    return inputError(
+      `Snapshot (${snapshot}) must be 'latest' or greater than network start block (${networks[network].start})`
+    );
+  }
+
   const init = {
     method: 'POST',
     headers: scoreApiHeaders,
@@ -306,6 +382,19 @@ export async function validate(
   params: any,
   options: any
 ) {
+  if (!isValidAddress(author)) {
+    return inputError(`Invalid author: ${author}`);
+  }
+
+  if (!isValidNetwork(network)) {
+    return inputError(`Invalid network: ${network}`);
+  }
+  if (!isValidSnapshot(snapshot, network)) {
+    return inputError(
+      `Snapshot (${snapshot}) must be 'latest' or greater than network start block (${networks[network].start})`
+    );
+  }
+
   if (!options) options = {};
   if (!options.url) options.url = 'https://score.snapshot.org';
   const init = {
@@ -338,9 +427,15 @@ export async function validate(
   }
 }
 
-export function validateSchema(schema, data) {
+export function validateSchema(
+  schema,
+  data,
+  options = {
+    snapshotEnv: 'default'
+  }
+) {
   const ajvValidate = ajv.compile(schema);
-  const valid = ajvValidate(data);
+  const valid = ajvValidate.call(options, data);
   return valid ? valid : ajvValidate.errors;
 }
 
@@ -497,6 +592,25 @@ export function getNumberWithOrdinal(n) {
   return n + (s[(v - 20) % 10] || s[v] || s[0]);
 }
 
+function isValidNetwork(network: string) {
+  return !!networks[network];
+}
+
+function isValidAddress(address: string) {
+  return isAddress(address) && address !== EMPTY_ADDRESS;
+}
+
+function isValidSnapshot(snapshot: number | string, network: string) {
+  return (
+    snapshot === 'latest' ||
+    (typeof snapshot === 'number' && snapshot >= networks[network].start)
+  );
+}
+
+function inputError(message: string) {
+  return Promise.reject(new Error(message));
+}
+
 export default {
   call,
   multicall,