@walletmesh/aztec-rpc-wallet 0.3.1 → 0.4.0

package/src/handlers.test.ts

@@ -1,270 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import type { AccountWallet, PXE, TxHash, AztecAddress } from '@aztec/aztec.js';
-import { Fr } from '@aztec/aztec.js';
-import { handler } from './handlers.js';
-import { AztecWalletError } from './errors.js';
-import { ContractArtifactCache } from './contractArtifactCache.js';
-import type {
-  AztecWalletContext,
-  AztecWalletMethodMap,
-  TransactionParams,
-  TransactionFunctionCall,
-} from './types.js';
-
-// Mock Contract.at and NoFeePaymentMethod at the top level
-// Mock Aztec.js dependencies
-vi.mock('@aztec/aztec.js', async () => {
-  const actual = await vi.importActual('@aztec/aztec.js');
-  return {
-    ...actual,
-    Contract: {
-      at: vi.fn(),
-    },
-    NoFeePaymentMethod: class {},
-    AztecAddress: {
-      fromString: vi.fn().mockImplementation((str) => ({
-        toString: () => str,
-        toField: () => new Fr(1),
-        equals: () => false,
-        isZero: () => false,
-      })),
-    },
-    AuthWitness: {
-      fromString: vi.fn().mockImplementation((str) => ({
-        toString: () => str,
-      })),
-    },
-    GasSettings: {
-      default: vi.fn().mockReturnValue({
-        maxFeePerGas: BigInt(1000),
-        maxPriorityFeePerGas: BigInt(100),
-      }),
-    },
-  };
-});
-
-// Mock circuits.js dependencies
-vi.mock('@aztec/circuits.js', () => ({
-  GasSettings: {
-    default: vi.fn().mockReturnValue({
-      maxFeePerGas: BigInt(1000),
-      maxPriorityFeePerGas: BigInt(100),
-    }),
-  },
-}));
-
-describe('RPC Handlers', () => {
-  let context: AztecWalletContext;
-  let pxe: PXE;
-  // Define a type for our mocked wallet that includes the methods we need
-  type MockedWallet = AccountWallet & {
-    sendTransaction: ReturnType<typeof vi.fn>;
-    simulateTransaction: ReturnType<typeof vi.fn>;
-    getContractInstance: ReturnType<typeof vi.fn>;
-    getContractArtifact: ReturnType<typeof vi.fn>;
-    getCurrentBaseFees: ReturnType<typeof vi.fn>;
-    createTxExecutionRequest: ReturnType<typeof vi.fn>;
-    simulateTx: ReturnType<typeof vi.fn>;
-    proveTx: ReturnType<typeof vi.fn>;
-    sendTx: ReturnType<typeof vi.fn>;
-  };
-  let wallet: MockedWallet;
-  let contractArtifactCache: ContractArtifactCache;
-
-  beforeEach(() => {
-    // Mock wallet with common methods
-    wallet = {
-      getAddress: vi.fn().mockResolvedValue('mockAddress'),
-      getContractInstance: vi.fn().mockResolvedValue(undefined),
-      getContractArtifact: vi.fn().mockResolvedValue(undefined),
-      sendTransaction: vi.fn(),
-      simulateTransaction: vi.fn(),
-      getCurrentBaseFees: vi.fn().mockResolvedValue(BigInt(1000)),
-      createTxExecutionRequest: vi.fn().mockResolvedValue({
-        id: 'mockTxId',
-        data: new Uint8Array(),
-      }),
-      simulateTx: vi.fn().mockResolvedValue({
-        privateExecutionResult: {
-          success: true,
-          data: new Uint8Array(),
-        },
-      }),
-      proveTx: vi.fn().mockResolvedValue({
-        toTx: () => ({ id: 'mockTxId' }),
-      }),
-      sendTx: vi.fn().mockResolvedValue({
-        toString: () => 'txHash',
-      } as unknown as TxHash),
-    } as unknown as MockedWallet;
-
-    // Mock PXE
-    pxe = {
-      // Add PXE methods as needed
-    } as unknown as PXE;
-
-    // Create contract artifact cache
-    contractArtifactCache = new ContractArtifactCache(wallet);
-
-    // Setup context
-    context = {
-      pxe,
-      wallet,
-      contractArtifactCache,
-    };
-  });
-
-  describe('Base wallet methods', () => {
-    it('handles wm_getSupportedMethods', async () => {
-      const result = await handler(context, 'wm_getSupportedMethods', []);
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBeGreaterThan(0);
-      expect(result).toContain('aztec_connect');
-      expect(result).toContain('aztec_getAccount');
-    });
-
-    it('handles aztec_connect', async () => {
-      const result = await handler(context, 'aztec_connect', []);
-      expect(result).toBe(true);
-    });
-
-    it('handles aztec_getAccount', async () => {
-      const result = await handler(context, 'aztec_getAccount', []);
-      expect(result).toBe('mockAddress');
-      expect(wallet.getAddress).toHaveBeenCalled();
-    });
-  });
-
-  describe('Transaction methods', () => {
-    // Create a valid AztecAddress for testing
-    // Create a valid hex string for AztecAddress (32 bytes = 64 hex chars)
-    const mockAddressHex = `0x${'1'.repeat(64)}`;
-    const mockAddress = {
-      toString: () => mockAddressHex,
-      toField: () => new Fr(1),
-      equals: () => false,
-      isZero: () => false,
-      _hex: mockAddressHex,
-    } as unknown as AztecAddress;
-
-    const mockFunctionCall: TransactionFunctionCall = {
-      contractAddress: mockAddress.toString(),
-      functionName: 'test',
-      args: ['arg1', 'arg2'],
-    };
-
-    const mockTxParams: TransactionParams = {
-      functionCalls: [mockFunctionCall],
-      authwits: [],
-    };
-
-    beforeEach(async () => {
-      // Mock contract instance with proper request data
-      const mockContract = {
-        methods: {
-          test: vi.fn().mockReturnValue({
-            simulate: vi.fn().mockResolvedValue({
-              success: true,
-              returnValue: '0x123',
-            }),
-            request: vi.fn().mockResolvedValue({
-              contractAddress: mockAddress,
-              functionData: new Uint8Array([1, 2, 3]), // Non-empty function data
-              functionSignature: 'test(uint256,uint256)',
-              args: ['arg1', 'arg2'],
-            }),
-          }),
-        },
-        address: mockAddress,
-      };
-
-      // Configure Contract.at mock
-      const { Contract } = await import('@aztec/aztec.js');
-      (Contract.at as ReturnType<typeof vi.fn>).mockResolvedValue(mockContract);
-
-      // Configure mock return values for contract artifact cache
-      const mockArtifact = {
-        functions: {
-          test: {
-            name: 'test',
-            parameters: [
-              { name: 'arg1', type: 'uint256' },
-              { name: 'arg2', type: 'uint256' },
-            ],
-          },
-        },
-      };
-
-      // Mock contract artifact cache methods
-      contractArtifactCache.getContractArtifact = vi.fn().mockResolvedValue(mockArtifact);
-    });
-
-    it('handles aztec_sendTransaction', async () => {
-      const result = await handler(context, 'aztec_sendTransaction', mockTxParams);
-      expect(result).toBe('txHash');
-      expect(contractArtifactCache.getContractArtifact).toHaveBeenCalled();
-      expect(wallet.createTxExecutionRequest).toHaveBeenCalled();
-      expect(wallet.simulateTx).toHaveBeenCalled();
-      expect(wallet.proveTx).toHaveBeenCalled();
-      expect(wallet.sendTx).toHaveBeenCalled();
-    });
-
-    it('handles aztec_simulateTransaction', async () => {
-      const result = await handler(context, 'aztec_simulateTransaction', mockFunctionCall);
-      expect(result).toEqual({
-        success: true,
-        returnValue: '0x123',
-      });
-      expect(contractArtifactCache.getContractArtifact).toHaveBeenCalled();
-    });
-
-    it('handles transaction errors', async () => {
-      wallet.createTxExecutionRequest.mockRejectedValue(new Error('Transaction failed'));
-      await expect(handler(context, 'aztec_sendTransaction', mockTxParams)).rejects.toThrow(AztecWalletError);
-    });
-  });
-
-  describe('Error handling', () => {
-    it('throws error for unsupported method', async () => {
-      await expect(handler(context, 'unsupported_method' as keyof AztecWalletMethodMap, [])).rejects.toThrow(
-        AztecWalletError,
-      );
-    });
-
-    it('throws error for invalid parameters', async () => {
-      await expect(
-        handler(context, 'aztec_sendTransaction', [] as unknown as TransactionParams),
-      ).rejects.toThrow(AztecWalletError);
-    });
-
-    it('handles null context values', async () => {
-      // Mock the handler to wrap errors
-      const mockHandler = async () => {
-        try {
-          await handler(
-            { pxe, wallet: null, contractArtifactCache } as unknown as AztecWalletContext,
-            'aztec_getAccount',
-            [],
-          );
-        } catch (error) {
-          if (error instanceof Error) {
-            throw new AztecWalletError('unknownInternalError', error.message);
-          }
-          throw error;
-        }
-      };
-
-      await expect(mockHandler()).rejects.toThrow(AztecWalletError);
-    });
-  });
-
-  describe('Account wallet methods', () => {
-    // Add tests for account wallet specific methods
-    // These would test the routing to accountWalletHandler
-    it('routes account wallet methods correctly', async () => {
-      // Mock an account wallet method
-      const accountMethod = 'aztec_getBlock';
-      await expect(handler(context, accountMethod, { number: 1 })).rejects.toThrow(); // Should attempt to route to accountWalletHandler
-    });
-  });
-});

package/src/handlers.ts

@@ -1,70 +0,0 @@
-/**
- * @module handlers
- *
- * This module provides the core RPC method handling logic for the Aztec wallet.
- * It routes incoming RPC requests to appropriate specialized handlers based on the method type.
- *
- * The handlers are organized into categories:
- * - Base wallet methods (connect, getAccount, etc.)
- * - Account wallet methods (chain operations, contract management, etc.)
- * - Transaction methods (send, simulate)
- *
- * Each method handler validates inputs, performs the requested operation through the wallet,
- * and returns properly formatted responses.
- */
-
-import type { AztecWalletMethodMap } from './types.js';
-import { type AztecWalletContext, BASE_WALLET_METHODS } from './types.js';
-import { AztecWalletError } from './errors.js';
-import { sendTransaction, simulateTransaction } from './handlers/transactions.js';
-import { aztecWalletHandler, AZTEC_WALLET_METHODS } from './handlers/aztecAccountWallet.js';
-
-/**
- * Main handler function that routes RPC method calls to appropriate specialized handlers.
- *
- * @param context - The wallet context containing PXE and wallet instances
- * @param method - The RPC method being called
- * @param params - Parameters passed to the method
- * @returns Result from the method handler
- * @throws {AztecWalletError} If method not supported or handler fails
- */
-
-export async function handler<M extends keyof AztecWalletMethodMap>(
-  context: AztecWalletContext,
-  method: M,
-  params: AztecWalletMethodMap[M]['params'],
-): Promise<AztecWalletMethodMap[M]['result']> {
-  if (AZTEC_WALLET_METHODS.includes(method)) {
-    return aztecWalletHandler(context, method, params);
-  }
-  switch (method) {
-    // Base wallet methods
-    case 'wm_getSupportedMethods': {
-      // Return combined list of supported methods from all handlers
-      return [...BASE_WALLET_METHODS, ...AZTEC_WALLET_METHODS] as string[];
-    }
-    case 'aztec_connect': {
-      // Basic connection validation
-      // Note: Main connection logic handled by provider
-      return true;
-    }
-    // Core wallet methods
-    case 'aztec_getAccount':
-      return (await context.wallet.getAddress()).toString();
-
-    // Transaction methods
-    case 'aztec_sendTransaction':
-      return await sendTransaction(
-        context,
-        params as AztecWalletMethodMap['aztec_sendTransaction']['params'],
-      );
-    case 'aztec_simulateTransaction':
-      return await simulateTransaction(
-        context,
-        params as AztecWalletMethodMap['aztec_simulateTransaction']['params'],
-      );
-
-    default:
-      throw new AztecWalletError('invalidRequest', `Method not supported: ${String(method)}`);
-  }
-}

package/src/provider.test.ts

@@ -1,277 +0,0 @@
-import { describe, test, expect, vi, beforeEach } from 'vitest';
-import { AztecProvider } from './provider.js';
-import { AztecWalletError, AztecWalletErrorType } from './errors.js';
-import type { ContractInstanceWithAddress, AztecAddress, ContractArtifact } from '@aztec/aztec.js';
-import { WalletRouterProvider } from '@walletmesh/router';
-import type { OperationBuilder } from '@walletmesh/router';
-import type { Mock } from 'vitest';
-
-const createMockTransport = () => ({
-  send: vi.fn(),
-  on: vi.fn(),
-  off: vi.fn(),
-  close: vi.fn(),
-});
-
-describe('AztecProvider', () => {
-  let provider: AztecProvider;
-  let mockTransport: ReturnType<typeof createMockTransport>;
-  let mockChainBuilder: {
-    chainId: string;
-    provider: WalletRouterProvider;
-    calls: unknown[];
-    call: Mock;
-    execute: Mock;
-  };
-
-  beforeEach(() => {
-    mockTransport = createMockTransport();
-    provider = new AztecProvider(mockTransport);
-
-    // Setup chain builder mock after provider creation
-    mockChainBuilder = {
-      chainId: 'aztec:testnet',
-      provider: provider,
-      calls: [],
-      call: vi.fn(),
-      execute: vi.fn(),
-    };
-
-    // Setup mock chain builder
-    mockChainBuilder.call.mockImplementation(() => mockChainBuilder);
-    mockChainBuilder.execute.mockImplementation(() => Promise.resolve());
-
-    // Setup additional mocks
-    vi.spyOn(provider as WalletRouterProvider, 'sessionId', 'get').mockReturnValue('test-session-id');
-    vi.spyOn(provider, 'chain').mockImplementation((chainId) => {
-      mockChainBuilder.chainId = chainId;
-      mockChainBuilder.call.mockImplementation((method, params) => {
-        mockChainBuilder.calls.push({ method, params });
-        return mockChainBuilder;
-      });
-      mockChainBuilder.execute.mockImplementation(async () => {
-        const result = await Promise.resolve(null);
-        if (result === null) {
-          throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid response');
-        }
-        return result;
-      });
-      return mockChainBuilder as unknown as OperationBuilder;
-    });
-  });
-
-  describe('constructor', () => {
-    test('registers event handlers', () => {
-      // Create a spy on the on method before creating provider
-      const onSpy = vi.spyOn(WalletRouterProvider.prototype, 'on');
-
-      // Create a new provider
-      new AztecProvider(mockTransport);
-
-      expect(onSpy).toHaveBeenCalledWith('wm_walletStateChanged', expect.any(Function));
-      expect(onSpy).toHaveBeenCalledWith('wm_sessionTerminated', expect.any(Function));
-
-      onSpy.mockRestore();
-    });
-
-    test('initializes with empty chain sets', () => {
-      expect(provider.getSupportedChains()).toEqual([]);
-    });
-  });
-
-  describe('handleWalletStateChanged', () => {
-    test('adds chain when accounts become available', () => {
-      const chainId = 'aztec:testnet';
-      provider['requestedChains'].add(chainId);
-
-      provider['handleWalletStateChanged']({
-        chainId,
-        changes: { accounts: ['0x123'] },
-      });
-
-      expect(provider.getSupportedChains()).toContain(chainId);
-    });
-
-    test('removes chain when accounts become unavailable', () => {
-      const chainId = 'aztec:testnet';
-      provider['requestedChains'].add(chainId);
-      provider['connectedChains'].add(chainId);
-
-      provider['handleWalletStateChanged']({
-        chainId,
-        changes: { accounts: [] },
-      });
-
-      expect(provider.getSupportedChains()).not.toContain(chainId);
-    });
-
-    test('ignores events for non-requested chains', () => {
-      const chainId = 'aztec:testnet';
-      // Chain not added to requestedChains
-
-      provider['handleWalletStateChanged']({
-        chainId,
-        changes: { accounts: ['0x123'] },
-      });
-
-      expect(provider.getSupportedChains()).not.toContain(chainId);
-    });
-  });
-
-  describe('handleSessionTerminated', () => {
-    test('clears chains when session matches', () => {
-      const chainId = 'aztec:testnet';
-      provider['requestedChains'].add(chainId);
-      provider['connectedChains'].add(chainId);
-
-      provider['handleSessionTerminated']({
-        sessionId: 'test-session-id',
-        reason: 'test termination',
-      });
-
-      expect(provider.getSupportedChains()).toEqual([]);
-      expect(provider['requestedChains'].size).toBe(0);
-    });
-
-    test('ignores termination for different sessions', () => {
-      const chainId = 'aztec:testnet';
-      provider['requestedChains'].add(chainId);
-      provider['connectedChains'].add(chainId);
-
-      provider['handleSessionTerminated']({
-        sessionId: 'different-session',
-        reason: 'test termination',
-      });
-
-      expect(provider.getSupportedChains()).toContain(chainId);
-      expect(provider['requestedChains'].has(chainId)).toBe(true);
-    });
-  });
-
-  describe('getAccount', () => {
-    test('returns account address on success', async () => {
-      const expectedAddress = '0x123';
-      mockChainBuilder.execute.mockResolvedValueOnce(expectedAddress);
-
-      const result = await provider.getAccount('aztec:testnet');
-      expect(result).toBe(expectedAddress);
-    });
-
-    test('throws on invalid response', async () => {
-      mockChainBuilder.execute.mockResolvedValueOnce(null);
-
-      await expect(provider.getAccount('aztec:testnet')).rejects.toThrowError(
-        new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid account address returned'),
-      );
-    });
-  });
-
-  describe('sendTransaction', () => {
-    const mockTxParams = {
-      functionCalls: [
-        {
-          contractAddress: '0x456',
-          functionName: 'transfer',
-          args: ['0x789', 100],
-        },
-      ],
-    };
-
-    test('returns transaction hash on success', async () => {
-      const expectedHash = '0xabc';
-      mockChainBuilder.execute.mockResolvedValueOnce(expectedHash);
-
-      const result = await provider.sendTransaction('aztec:testnet', mockTxParams);
-      expect(result).toBe(expectedHash);
-    });
-
-    test('throws on invalid response', async () => {
-      mockChainBuilder.execute.mockResolvedValueOnce(null);
-
-      await expect(provider.sendTransaction('aztec:testnet', mockTxParams)).rejects.toThrowError(
-        new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid transaction hash returned'),
-      );
-    });
-  });
-
-  describe('simulateTransaction', () => {
-    const mockSimParams = {
-      contractAddress: '0x456',
-      functionName: 'transfer',
-      args: ['0x789', 100],
-    };
-
-    test('returns simulation result on success', async () => {
-      const expectedResult = { success: true, gas: 1000 };
-      mockChainBuilder.execute.mockResolvedValueOnce(expectedResult);
-
-      const result = await provider.simulateTransaction('aztec:testnet', mockSimParams);
-      expect(result).toEqual(expectedResult);
-    });
-
-    test('throws on invalid response', async () => {
-      mockChainBuilder.execute.mockResolvedValueOnce(null);
-
-      await expect(provider.simulateTransaction('aztec:testnet', mockSimParams)).rejects.toThrowError(
-        new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid simulation result returned'),
-      );
-    });
-  });
-
-  describe('registration methods', () => {
-    test('registerContract executes without error', async () => {
-      mockChainBuilder.execute.mockResolvedValueOnce(undefined);
-
-      await expect(
-        provider.registerContract('aztec:testnet', {
-          instance: {
-            address: '0x123' as unknown as AztecAddress,
-            version: 1,
-            salt: '0x0' as unknown as AztecAddress,
-            deployer: '0x0' as unknown as AztecAddress,
-            contractClassId: '0x0' as unknown as AztecAddress,
-            contractClassVersion: 1,
-            publicKey: '0x0' as unknown as AztecAddress,
-          } as unknown as ContractInstanceWithAddress,
-          artifact: {
-            name: 'TestContract',
-            bytecode: '0x',
-            functionSelectors: {},
-            functions: {},
-            outputs: {},
-            storageLayout: {},
-            events: {},
-          } as unknown as ContractArtifact,
-        }),
-      ).resolves.not.toThrow();
-    });
-
-    test('registerContractClass executes without error', async () => {
-      mockChainBuilder.execute.mockResolvedValueOnce(undefined);
-
-      await expect(
-        provider.registerContractClass('aztec:testnet', {
-          artifact: {
-            name: 'TestContract',
-            bytecode: '0x',
-            functionSelectors: {},
-            functions: {},
-            outputs: {},
-            storageLayout: {},
-            events: {},
-          } as unknown as ContractArtifact,
-        }),
-      ).resolves.not.toThrow();
-    });
-
-    test('registerSender executes without error', async () => {
-      mockChainBuilder.execute.mockResolvedValueOnce(undefined);
-
-      await expect(
-        provider.registerSender('aztec:testnet', {
-          sender: '0x123' as unknown as AztecAddress,
-        }),
-      ).resolves.not.toThrow();
-    });
-  });
-});