feat: Implement SNIP29

Author: florian-bellotti

__tests__/accountPaymaster.test.ts

@@ -0,0 +1,116 @@
+import { Account, Signature, Call, PaymasterDetails } from '../src';
+import { PaymasterRpc } from '../src/paymaster/rpc';
+
+jest.mock('../src/paymaster/rpc');
+
+describe('Account - Paymaster integration', () => {
+  const mockBuildTypedData = jest.fn();
+  const mockExecute = jest.fn();
+  const mockSignMessage = jest.fn();
+
+  const fakeTypedData = {
+    types: {},
+    domain: {},
+    primaryType: '',
+    message: {
+      caller: '0xcaller',
+      nonce: '0xnonce',
+      execute_after: '0x1',
+      execute_before: '0x2',
+      calls_len: '0x0',
+      calls: [],
+    },
+  };
+
+  const fakeSignature: Signature = ['0x1', '0x2'];
+  const calls: Call[] = [{ contractAddress: '0x123', entrypoint: 'transfer', calldata: [] }];
+
+  const paymasterResponse = {
+    typedData: fakeTypedData,
+    tokenAmountAndPrice: {
+      estimatedAmount: 1000n,
+      priceInStrk: 200n,
+    },
+  };
+
+  const mockPaymaster = () =>
+    ({
+      buildTypedData: mockBuildTypedData,
+      execute: mockExecute,
+    }) as any;
+
+  const setupAccount = () =>
+    new Account(
+      {},
+      '0xabc',
+      { signMessage: mockSignMessage.mockResolvedValue(fakeSignature) } as any,
+      undefined,
+      undefined,
+      mockPaymaster()
+    );
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (PaymasterRpc as jest.Mock).mockImplementation(mockPaymaster);
+    mockBuildTypedData.mockResolvedValue(paymasterResponse);
+    mockExecute.mockResolvedValue({ transaction_hash: '0x123' });
+  });
+
+  describe('buildPaymasterTypedData', () => {
+    it('should return typed data and token prices from paymaster', async () => {
+      // Given
+      const account = setupAccount();
+
+      // When
+      const result = await account.buildPaymasterTypedData(calls, { gasToken: '0x456' });
+
+      // Then
+      expect(mockBuildTypedData).toHaveBeenCalledWith(
+        '0xabc',
+        calls,
+        '0x456',
+        undefined,
+        undefined
+      );
+      expect(result).toEqual(paymasterResponse);
+    });
+  });
+
+  describe('executePaymaster', () => {
+    it('should sign and execute transaction via paymaster', async () => {
+      // Given
+      const account = setupAccount();
+
+      // When
+      const result = await account.executePaymaster(calls);
+
+      // Then
+      expect(mockBuildTypedData).toHaveBeenCalledTimes(1);
+      expect(mockSignMessage).toHaveBeenCalledWith(fakeTypedData, '0xabc');
+      expect(mockExecute).toHaveBeenCalledWith('0xabc', fakeTypedData, fakeSignature, undefined);
+      expect(result).toEqual({ transaction_hash: '0x123' });
+    });
+
+    it('should throw if estimated fee exceeds maxEstimatedFee', async () => {
+      // Given
+      const account = setupAccount();
+      const details: PaymasterDetails = { maxEstimatedFee: 500n };
+
+      // When / Then
+      await expect(account.executePaymaster(calls, details)).rejects.toThrow(
+        'Estimated max fee too high'
+      );
+    });
+
+    it('should throw if token price exceeds maxPriceInStrk', async () => {
+      // Given
+      const account = setupAccount();
+      const details: PaymasterDetails = { maxPriceInStrk: 100n };
+
+      // When / Then
+      await expect(account.executePaymaster(calls, details)).rejects.toThrow(
+        'Gas token price is too high'
+      );
+    });
+  });
+});

__tests__/config/fixtures.ts

@@ -12,7 +12,6 @@ import { ETransactionVersion } from '../../src/types/api';
 import { toHex } from '../../src/utils/num';
 import { wait } from '../../src/utils/provider';
 import { isString } from '../../src/utils/typed';
-import './customMatchers'; // ensures TS traversal
 
 const readFile = (subpath: string) => fs.readFileSync(path.resolve(__dirname, subpath));
 

__tests__/defaultPaymaster.test.ts

@@ -0,0 +1,175 @@
+import { RpcError } from '../src';
+import { PaymasterRpc } from '../src/paymaster/rpc';
+import fetchMock from '../src/utils/fetchPonyfill';
+import { signatureToHexArray } from '../src/utils/stark';
+import { OutsideExecutionTypedData } from '../src/types/api/paymaster-rpc-spec/nonspec';
+
+jest.mock('../src/utils/fetchPonyfill');
+jest.mock('../src/utils/stark', () => ({
+  signatureToHexArray: jest.fn(() => ['0x1', '0x2']),
+}));
+jest.mock('../src/utils/paymaster', () => ({
+  getDefaultPaymasterNodeUrl: jest.fn(() => 'https://mock-node-url'),
+}));
+
+describe('PaymasterRpc', () => {
+  const mockFetch = fetchMock as jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with default values', () => {
+      // When
+      const client = new PaymasterRpc();
+
+      // Then
+      expect(client.nodeUrl).toBe('https://mock-node-url');
+      expect(client.requestId).toBe(0);
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return true when paymaster is available', async () => {
+      // Given
+      const client = new PaymasterRpc();
+      mockFetch.mockResolvedValueOnce({
+        json: async () => ({ result: true }),
+      });
+
+      // When
+      const result = await client.isAvailable();
+
+      // Then
+      expect(result).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('"method":"paymaster_isAvailable"'),
+        })
+      );
+    });
+
+    it('should return false when paymaster is not available', async () => {
+      // Given
+      const client = new PaymasterRpc();
+      mockFetch.mockResolvedValueOnce({
+        json: async () => ({ result: false }),
+      });
+
+      // When
+      const result = await client.isAvailable();
+
+      // Then
+      expect(result).toBe(false);
+    });
+
+    it('should throw RpcError when RPC returns error', async () => {
+      // Given
+      const client = new PaymasterRpc();
+      mockFetch.mockResolvedValueOnce({
+        json: async () => ({ error: { code: -32000, message: 'RPC failure' } }),
+      });
+
+      // When / Then
+      await expect(client.isAvailable()).rejects.toThrow(RpcError);
+    });
+
+    it('should throw on network error', async () => {
+      // Given
+      const client = new PaymasterRpc();
+      mockFetch.mockRejectedValueOnce(new Error('Network down'));
+
+      // When / Then
+      await expect(client.isAvailable()).rejects.toThrow('Network down');
+    });
+  });
+
+  describe('buildTypedData', () => {
+    it('should return typedData and parsed tokenAmountAndPrice', async () => {
+      // Given
+      const client = new PaymasterRpc();
+      const mockCall = {
+        contractAddress: '0xabc',
+        entrypoint: 'transfer',
+        calldata: ['0x1', '0x2'],
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        json: async () => ({
+          result: {
+            typed_data: { domain: {}, message: {}, types: {} },
+            token_amount_and_price: {
+              estimated_amount: '0x1234',
+              price_in_strk: '0x5678',
+            },
+          },
+        }),
+      });
+
+      // When
+      const result = await client.buildTypedData('0xuser', [mockCall]);
+
+      // Then
+      expect(result.tokenAmountAndPrice.estimatedAmount).toBe(BigInt(0x1234));
+      expect(result.tokenAmountAndPrice.priceInStrk).toBe(BigInt(0x5678));
+      expect(result.typedData).toBeDefined();
+    });
+  });
+
+  describe('execute', () => {
+    it('should send execution request and return transaction hash', async () => {
+      // Given
+      const client = new PaymasterRpc();
+      const mockSignature = ['0x1', '0x2'];
+      const mockTypedData: OutsideExecutionTypedData = {
+        domain: {},
+        types: {},
+        primaryType: '',
+        message: {
+          caller: '0xcaller',
+          nonce: '0xnonce',
+          execute_after: '0x1',
+          execute_before: '0x2',
+          calls_len: '0x0',
+          calls: [],
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        json: async () => ({
+          result: {
+            transaction_hash: '0xaaa',
+            execution_result: 'ok',
+          },
+        }),
+      });
+
+      // When
+      const result = await client.execute('0xuser', mockTypedData, mockSignature);
+
+      // Then
+      expect(signatureToHexArray).toHaveBeenCalledWith(mockSignature);
+      expect(result.transaction_hash).toBe('0xaaa');
+    });
+  });
+
+  describe('getSupportedTokensAndPrices', () => {
+    it('should return supported tokens and prices', async () => {
+      // Given
+      const client = new PaymasterRpc();
+      const expected = { tokens: [], prices: {} };
+
+      mockFetch.mockResolvedValueOnce({
+        json: async () => ({ result: expected }),
+      });
+
+      // When
+      const result = await client.getSupportedTokensAndPrices();
+
+      // Then
+      expect(result).toEqual(expected);
+    });
+  });
+});