@snapshot-labs/snapshot.js 0.14.12 → 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.12",
+  "version": "0.14.13",
   "repository": "snapshot-labs/snapshot.js",
   "license": "MIT",
   "main": "dist/snapshot.cjs.js",

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 starknetMessageMultisigner from '../../test/fixtures/starknet/message-alias-multisigner.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';
@@ -25,10 +27,16 @@ describe('verify/starknet', () => {
 
   describe('verify()', () => {
     describe.each([
-      ['2 items', starknetMessage, false],
-      ['3 items', starknetMessageRsv, false],
-      ['multiple signers', starknetMessageMultisigner, true]
-    ])('with a %s signature', (title, message, multisign) => {
+      ['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')
@@ -102,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');
 
@@ -62,38 +32,6 @@ export function getHash(data: SignaturePayload, address: string): string {
   );
 }
 
-/**
- * Processes a StarkNet signature array and returns the appropriate signature format
- * for contract verification.
- * Returns the r ands values for each signature in the array.
- *
- * Handles the following cases:
- * - 2-item array: Standard signature, returns as-is.
- * - 3-item array: Some wallets (e.g., Braavos) may return a 3-item array; returns the last two items.
- * - Multi-signer array: For multisig accounts, the array may contain multiple signatures;
- *   this function extracts the relevant signature pairs.
- *
- * @param {string[]} sig - The signature array to process. Must have at least 2 items.
- * @returns {string[]} The processed signature array suitable for contract verification.
- * @throws {Error} If the signature array has fewer than 2 items.
- */
-function getSignatureArray(sig: string[]): string[] {
-  if (sig.length < 2) {
-    throw new Error('Invalid signature format');
-  }
-
-  if (sig.length <= 3) {
-    return sig.slice(-2);
-  }
-
-  const results: string[] = [];
-  for (let i = 1; i < sig.length; i += 4) {
-    results.push(sig[i + 2], sig[i + 3]);
-  }
-
-  return results;
-}
-
 export default async function verify(
   address: string,
   sig: string[],
@@ -102,18 +40,13 @@ export default async function verify(
   options: ProviderOptions = {}
 ): Promise<boolean> {
   try {
-    const contractAccount = new Contract(
-      ABI,
-      address,
-      getProvider(network, options)
-    );
+    const provider = getProvider(network, options);
 
-    const result = await contractAccount.is_valid_signature(
-      getHash(data, address),
-      getSignatureArray(sig)
-    );
+    // 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');