@snapshot-labs/snapshot.js 0.12.0 → 0.12.2

package/dist/src/verify/index.d.ts

@@ -2,7 +2,7 @@ import type { StarkNetType } from 'starknet';
 import type { TypedDataField } from '@ethersproject/abstract-signer';
 import type { ProviderOptions } from '../utils/provider';
 export type SignaturePayload = {
-    domain: Record<string, string>;
+    domain: Record<string, string | number>;
     types: Record<string, StarkNetType[] | TypedDataField[]>;
     primaryType?: string;
     message: Record<string, any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapshot-labs/snapshot.js",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "repository": "snapshot-labs/snapshot.js",
   "license": "MIT",
   "main": "dist/snapshot.cjs.js",
@@ -11,6 +11,7 @@
     "@ensdomains/eth-ens-namehash": "^2.0.15",
     "@ethersproject/abi": "^5.6.4",
     "@ethersproject/address": "^5.6.1",
+    "@ethersproject/bignumber": "^5.7.0",
     "@ethersproject/bytes": "^5.6.1",
     "@ethersproject/contracts": "^5.6.2",
     "@ethersproject/hash": "^5.7.0",

package/src/constants.json

@@ -1,5 +1,5 @@
 {
-  "livenet": {
+  "mainnet": {
     "hub": "https://hub.snapshot.org",
     "sequencer": "https://seq.snapshot.org"
   },

package/src/sign/index.ts

@@ -57,10 +57,10 @@ export default class Client {
   readonly address: string;
   readonly options: any;
 
-  constructor(address: string = constants.livenet.sequencer, options = {}) {
+  constructor(address: string = constants.mainnet.sequencer, options = {}) {
     address = address.replace(
-      constants.livenet.hub,
-      constants.livenet.sequencer
+      constants.mainnet.hub,
+      constants.mainnet.sequencer
     );
     address = address.replace(
       constants.testnet.hub,

package/src/verify/index.ts

@@ -6,7 +6,7 @@ import type { TypedDataField } from '@ethersproject/abstract-signer';
 import type { ProviderOptions } from '../utils/provider';
 
 export type SignaturePayload = {
-  domain: Record<string, string>;
+  domain: Record<string, string | number>;
   types: Record<string, StarkNetType[] | TypedDataField[]>;
   primaryType?: string;
   message: Record<string, any>;

package/src/verify/starknet.spec.ts

@@ -1,7 +1,9 @@
 import { test, expect, describe } from 'vitest';
 import starknetMessage from '../../test/fixtures/starknet/message-alias.json';
+import starknetMessageRsv from '../../test/fixtures/starknet/message-alias-rsv.json';
 import verify, { getHash } from './starknet';
 import { validateAndParseAddress } from 'starknet';
+import { clone } from '../utils';
 
 describe('verify/starknet', () => {
   describe('getHash()', () => {
@@ -21,47 +23,79 @@ describe('verify/starknet', () => {
   });
 
   describe('verify()', () => {
-    test('should return true if the signature is valid', () => {
-      expect(
-        verify(
-          starknetMessage.address,
-          starknetMessage.sig,
-          starknetMessage.data,
-          'SN_SEPOLIA'
-        )
-      ).resolves.toBe(true);
+    describe.each([
+      ['2', starknetMessage],
+      ['3', starknetMessageRsv]
+    ])('with a %s items signature', (title, message) => {
+      test('should return true if the signature is valid', () => {
+        expect(
+          verify(message.address, message.sig, message.data, 'SN_MAIN')
+        ).resolves.toBe(true);
+      });
+
+      test('should return true if the signature is valid with a padded address', () => {
+        expect(
+          verify(
+            validateAndParseAddress(message.address),
+            message.sig,
+            message.data,
+            'SN_MAIN'
+          )
+        ).resolves.toBe(true);
+      });
+
+      test('should return true when verifying on a different network', () => {
+        expect(
+          verify(message.address, message.sig, message.data, 'SN_SEPOLIA')
+        ).resolves.toBe(true);
+      });
+
+      test('should throw an error if the signature is invalid', () => {
+        expect(
+          verify(
+            '0x7667469b8e93faa642573078b6bf8c790d3a6184b2a1bb39c5c923a732862e1',
+            message.sig,
+            message.data
+          )
+        ).rejects.toThrow();
+      });
     });
 
-    test('should return true if the signature is valid with a padded address', () => {
+    test('should throw an error when the contract is not deployed', () => {
       expect(
         verify(
-          validateAndParseAddress(starknetMessage.address),
+          '0x07f71118e351c02f6EC7099C8CDf93AED66CEd8406E94631cC91637f7D7F203A',
           starknetMessage.sig,
           starknetMessage.data,
-          'SN_SEPOLIA'
+          'SN_MAIN'
         )
-      ).resolves.toBe(true);
+      ).rejects.toThrowError('Contract not deployed');
     });
 
-    test('should throw an error if message is on wrong network', () => {
+    test('should return false when the signature is not valid', () => {
       expect(
         verify(
           starknetMessage.address,
-          starknetMessage.sig,
+          ['1', '2'],
           starknetMessage.data,
           'SN_MAIN'
         )
-      ).rejects.toThrowError();
+      ).resolves.toBe(false);
     });
 
-    test('should throw an error if the signature is invalid', () => {
+    test('should return false when the signature is not valid', () => {
+      const data = clone(starknetMessage.data);
+      data.message.timestamp = 1234;
+
       expect(
-        verify(
-          '0x7667469b8e93faa642573078b6bf8c790d3a6184b2a1bb39c5c923a732862e1',
-          starknetMessage.sig,
-          starknetMessage.data
-        )
-      ).rejects.toThrow();
+        verify(starknetMessage.address, starknetMessage.sig, data, 'SN_MAIN')
+      ).resolves.toBe(false);
+    });
+
+    test('should throw an error on wrong signature length', () => {
+      expect(
+        verify(starknetMessage.address, ['1'], starknetMessage.data, 'SN_MAIN')
+      ).rejects.toThrowError('Invalid signature format');
     });
   });
 });

package/src/verify/starknet.ts

@@ -1,4 +1,5 @@
 import { Contract, RpcProvider, typedData } from 'starknet';
+import { BigNumber } from '@ethersproject/bignumber';
 import type { SignaturePayload } from '.';
 import type { ProviderOptions } from '../utils/provider';
 
@@ -11,11 +12,11 @@ const RPC_URLS: Record<NetworkType, string> = {
 
 const ABI = [
   {
-    name: 'argent::account::interface::IDeprecatedArgentAccount',
+    name: 'argent::common::account::IAccount',
     type: 'interface',
     items: [
       {
-        name: 'isValidSignature',
+        name: 'is_valid_signature',
         type: 'function',
         inputs: [
           {
@@ -23,7 +24,7 @@ const ABI = [
             type: 'core::felt252'
           },
           {
-            name: 'signatures',
+            name: 'signature',
             type: 'core::array::Array::<core::felt252>'
           }
         ],
@@ -67,16 +68,28 @@ export default async function verify(
   network: NetworkType = 'SN_MAIN',
   options: ProviderOptions = {}
 ): Promise<boolean> {
-  const contractAccount = new Contract(
-    ABI,
-    address,
-    getProvider(network, options)
-  );
+  try {
+    const contractAccount = new Contract(
+      ABI,
+      address,
+      getProvider(network, options)
+    );
+
+    if (sig.length < 2) {
+      throw new Error('Invalid signature format');
+    }
 
-  await contractAccount.isValidSignature(getHash(data, address), [
-    sig[0],
-    sig[1]
-  ]);
+    const result = await contractAccount.is_valid_signature(
+      getHash(data, address),
+      sig.slice(-2)
+    );
 
-  return true;
+    return BigNumber.from(result).eq(BigNumber.from('370462705988'));
+  } catch (e: any) {
+    if (e.message.includes('Contract not found')) {
+      throw new Error('Contract not deployed');
+    }
+
+    throw e;
+  }
 }