@walletmesh/aztec-rpc-wallet 0.1.0

package/src/handlers.test.ts

@@ -0,0 +1,270 @@
+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

@@ -0,0 +1,70 @@
+/**
+ * @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/index.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import * as exports from './index.js';
+
+describe('index exports', () => {
+  it('should export AztecProvider', () => {
+    expect(exports.AztecProvider).toBeDefined();
+  });
+
+  it('should export AztecChainWallet', () => {
+    expect(exports.AztecChainWallet).toBeDefined();
+  });
+
+  it('should export error utilities', () => {
+    expect(exports.AztecWalletError).toBeDefined();
+    expect(exports.AztecWalletErrorMap).toBeDefined();
+  });
+
+  // Type exports can't be tested at runtime, but we can verify the file compiles
+  it('should compile with type exports', () => {
+    // This test passes by virtue of the file compiling
+    expect(true).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,64 @@
+/**
+ * @module @walletmesh/aztec-rpc-wallet
+ *
+ * This module provides a JSON-RPC implementation for interacting with Aztec Network.
+ * It enables communication between dApps and wallets through a standardized interface.
+ */
+
+/**
+ * Provider class for dApps to interact with Aztec wallets
+ * @see AztecProvider
+ */
+export { AztecProvider } from './provider.js';
+
+/**
+ * Minimal provider for direct interaction with an Aztec chain wallet
+ * @see AztecChainProvider
+ */
+export { AztecChainProvider } from './chainProvider.js';
+
+/**
+ * Wallet implementation that handles RPC requests from dApps
+ * @see AztecChainWallet
+ */
+export { AztecChainWallet } from './wallet.js';
+export { AztecChainWalletMiddleware } from './types.js';
+
+/**
+ * Cache for contract artifacts
+ * @see ContractArtifactCache
+ */
+export { ContractArtifactCache } from './contractArtifactCache.js';
+
+/**
+ * Error handling utilities for RPC communication
+ * @see AztecWalletError
+ * @see AztecWalletErrorMap
+ */
+export { AztecWalletError, AztecWalletErrorMap } from './errors.js';
+
+/**
+ * Type definitions for RPC interfaces
+ */
+export type {
+  /** Chain identifier type */
+  AztecChainId,
+  /** Context passed through RPC middleware */
+  AztecWalletContext,
+  /** Event map for wallet events */
+  AztecWalletEventMap,
+  /** Base method map for core wallet functionality */
+  AztecWalletBaseMethodMap,
+  /** Complete method map including all Aztec methods */
+  AztecWalletMethodMap,
+  /** Middleware type for processing RPC requests */
+  AztecWalletMiddleware,
+  /** Router client type for wallet mesh integration */
+  AztecWalletRouterClient,
+  /** Handler type for wallet methods */
+  AztecWalletMethodHandler,
+  /** Type for contract function calls */
+  TransactionFunctionCall,
+  /** Parameters for transaction requests */
+  TransactionParams,
+} from './types.js';

package/src/provider.test.ts

@@ -0,0 +1,276 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { AztecProvider } from './provider.js';
+import { AztecWalletError, AztecWalletErrorType } from './errors.js';
+import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
+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');
+      const 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();
+    });
+  });
+});