@snapshot-labs/snapshot.js 0.14.11 → 0.14.13

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

@@ -1,5 +1,5 @@
-import type { SignaturePayload } from '.';
 import type { ProviderOptions } from '../utils/provider';
+import type { SignaturePayload } from '.';
 export type NetworkType = 'SN_MAIN' | 'SN_SEPOLIA';
 export declare function isStarknetMessage(data: SignaturePayload): boolean;
 export declare function getHash(data: SignaturePayload, address: string): string;

package/package.json

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

package/src/sign/hashedTypes.json

@@ -57,6 +57,7 @@
   "6f6cdd15a1e9e6c4ee544231c4fa7b6c7e5183bc2b37fa4bd1a695f458348ab7": "delete-space",
   "1aad7825b991457fca04aae48a2a49d815ada524e10316af0da5522ea48b3df6": "alias",
   "8ea9074bff3a30cb61f4f0f0f142c9335c6be828feba0571a45de3f1fd0319c0": "alias",
+  "23310e197cbdcd80e506c0dbdd41831c9cf91d103a3ab663b278a1944a210920": "alias",
   "42f8858a21d4aa232721cb97074851e729829ea362b88bb21f3879899663b586": "follow",
   "2bb75450e28b06f259ea764cd669de6bde0ba70ce729b0ff05ab9df56e0ff21d": "unfollow",
   "2ffbebcbd22ef48fd2f4a1182ff1feda7795b57689bd6f0dd73c89e925e7fefb": "profile",

package/src/verify/starknet.spec.ts

@@ -1,6 +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 starknetMessageBraavos from '../../test/fixtures/starknet/message-alias-braavos.json';
+import starknetMessageArgentXGuardian from '../../test/fixtures/starknet/message-alias-argent-x-guardian.json';
+import starknetMessageArgentXStandard from '../../test/fixtures/starknet/message-alias-argent-x-standard.json';
+import starknetMessageArgentXMultisig from '../../test/fixtures/starknet/message-alias-argent-x-multisig.json';
 import verify, { getHash } from './starknet';
 import { validateAndParseAddress } from 'starknet';
 import { clone } from '../utils';
@@ -24,9 +27,16 @@ describe('verify/starknet', () => {
 
   describe('verify()', () => {
     describe.each([
-      ['2', starknetMessage],
-      ['3', starknetMessageRsv]
-    ])('with a %s items signature', (title, message) => {
+      ['2 items (legacy)', starknetMessage, false],
+      ['Braavos', starknetMessageBraavos, false],
+      ['Argent X standard account', starknetMessageArgentXStandard],
+      [
+        'Argent X account with guardian/Argent X Mobile/Argent Web',
+        starknetMessageArgentXGuardian,
+        true
+      ],
+      ['Argent X multisig account', starknetMessageArgentXMultisig, true]
+    ])('with a %s signature', (_, message, multisign = false) => {
       test('should return true if the signature is valid', () => {
         expect(
           verify(message.address, message.sig, message.data, 'SN_MAIN')
@@ -44,11 +54,19 @@ describe('verify/starknet', () => {
         ).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);
-      });
+      if (multisign) {
+        test('should throw an error when verifying on a different network', () => {
+          expect(
+            verify(message.address, message.sig, message.data, 'SN_SEPOLIA')
+          ).rejects.toThrowError();
+        });
+      } else {
+        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(
@@ -92,10 +110,10 @@ describe('verify/starknet', () => {
       ).resolves.toBe(false);
     });
 
-    test('should throw an error on wrong signature length', () => {
+    test('should return false when the signature is not valid', () => {
       expect(
         verify(starknetMessage.address, ['1'], starknetMessage.data, 'SN_MAIN')
-      ).rejects.toThrowError('Invalid signature format');
+      ).resolves.toBe(false);
     });
   });
 });

package/src/verify/starknet.ts

@@ -1,8 +1,7 @@
-import { Contract, RpcProvider, typedData, constants } from 'starknet';
-import { BigNumber } from '@ethersproject/bignumber';
+import { RpcProvider, typedData, constants, TypedData } from 'starknet';
 import networks from '../networks.json';
-import type { SignaturePayload } from '.';
 import type { ProviderOptions } from '../utils/provider';
+import type { SignaturePayload } from '.';
 
 export type NetworkType = 'SN_MAIN' | 'SN_SEPOLIA';
 
@@ -11,35 +10,6 @@ const RPC_URLS: Record<NetworkType, string> = {
   SN_SEPOLIA: networks[constants.StarknetChainId.SN_SEPOLIA]?.rpc?.[0]
 };
 
-const ABI = [
-  {
-    name: 'argent::common::account::IAccount',
-    type: 'interface',
-    items: [
-      {
-        name: 'is_valid_signature',
-        type: 'function',
-        inputs: [
-          {
-            name: 'hash',
-            type: 'core::felt252'
-          },
-          {
-            name: 'signature',
-            type: 'core::array::Array::<core::felt252>'
-          }
-        ],
-        outputs: [
-          {
-            type: 'core::felt252'
-          }
-        ],
-        state_mutability: 'view'
-      }
-    ]
-  }
-];
-
 function getProvider(network: NetworkType, options: ProviderOptions) {
   if (!RPC_URLS[network]) throw new Error('Invalid network');
 
@@ -70,22 +40,13 @@ export default async function verify(
   options: ProviderOptions = {}
 ): Promise<boolean> {
   try {
-    const contractAccount = new Contract(
-      ABI,
-      address,
-      getProvider(network, options)
-    );
-
-    if (sig.length < 2) {
-      throw new Error('Invalid signature format');
-    }
+    const provider = getProvider(network, options);
 
-    const result = await contractAccount.is_valid_signature(
-      getHash(data, address),
-      sig.slice(-2)
-    );
+    // Check if the contract is deployed
+    // Will throw on non-deployed contract
+    await provider.getClassAt(address);
 
-    return BigNumber.from(result).eq(BigNumber.from('370462705988'));
+    return provider.verifyMessageInStarknet(data as TypedData, sig, address);
   } catch (e: any) {
     if (e.message.includes('Contract not found')) {
       throw new Error('Contract not deployed');