@walletmesh/aztec-rpc-wallet 0.3.0 → 0.4.0

package/src/client/aztec-router-provider.test.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AztecRouterProvider } from './aztec-router-provider.js';
+import { AztecAddress, CompleteAddress } from '@aztec/aztec.js';
+// import { jsonStringify } from '@aztec/foundation/json-rpc'; // Unused
+import type {
+  JSONRPCRequest,
+  JSONRPCResponse,
+  JSONRPCTransport,
+  // JSONRPCMethodMap, // Unused
+} from '@walletmesh/jsonrpc';
+
+// Define a minimal method map for testing purposes
+// import type { JSONRPCParams } from '@walletmesh/jsonrpc'; // Unused
+
+// This map is for conceptual organization in tests; actual type safety comes from provider.call
+// interface TestAztecMethodMap { // Unused
+//   aztec_getAddress: { result: AztecAddress; params?: undefined };
+//   aztec_getCompleteAddress: { result: CompleteAddress; params?: undefined };
+//   aztec_getBlockNumber: { result: number; params?: undefined };
+//   some_unknown_method: { result: unknown; params?: Record<string, unknown> };
+//   wm_call: { params: WmCallParams; result: unknown }; // This is the outer request
+//   wm_connect: {
+//     params?: { chainId?: string; options?: unknown };
+//     result: { sessionId: string; permissions: unknown };
+//   };
+// }
+
+// Define an interface for the structure of params for 'wm_call'
+// Type aliases for simplified mock typing
+// biome-ignore lint/suspicious/noExplicitAny: Test mock simplification
+type JSONRPCRequestAny = JSONRPCRequest<any, any, any>;
+// biome-ignore lint/suspicious/noExplicitAny: Test mock simplification
+type JSONRPCResponseAny = JSONRPCResponse<any>;
+interface WmCallParams {
+  chainId: string;
+  call: {
+    method: string;
+    params?: unknown;
+  };
+}
+describe('AztecRouterProvider', () => {
+  let mockTransport: JSONRPCTransport;
+  let provider: AztecRouterProvider;
+  let sendMock: ReturnType<typeof vi.fn>;
+  // biome-ignore lint/suspicious/noExplicitAny: Test mock simplification
+  let messageHandler: (msg: JSONRPCResponse<any, any>) => void;
+  // let requestIdCounter = 0; // Unused
+
+  beforeEach(() => {
+    // requestIdCounter = 0; // Unused
+    sendMock = vi.fn();
+    mockTransport = {
+      send: sendMock,
+      // biome-ignore lint/suspicious/noExplicitAny: Test mock simplification
+      onMessage: (handler: (msg: JSONRPCResponse<any, any>) => void) => {
+        messageHandler = handler;
+        // Return a dummy cleanup function as expected by onMessage
+        return () => {};
+      },
+    };
+    provider = new AztecRouterProvider(mockTransport);
+  });
+
+  describe('serialization', () => {
+    it('should serialize AztecAddress results correctly', async () => {
+      // Use a fixed test address string (AztecAddress format is 0x + 64 hex chars)
+      const testAddressStr = `0x${'1'.repeat(64)}`;
+
+      sendMock.mockImplementation(async (request: JSONRPCRequestAny) => {
+        if (request.method === 'wm_call') {
+          const resultPayload = {
+            serialized: JSON.stringify(testAddressStr),
+            method: 'aztec_getAddress',
+          };
+          const response: JSONRPCResponseAny = {
+            jsonrpc: '2.0',
+            id: request.id,
+            result: resultPayload,
+          };
+          process.nextTick(() => {
+            messageHandler(response);
+          });
+        }
+      });
+
+      provider['_sessionId'] = 'test-session';
+
+      const result = await provider.call('aztec:mainnet', {
+        method: 'aztec_getAddress',
+      });
+
+      expect(result).toBeDefined();
+      expect(result).toBeInstanceOf(AztecAddress);
+      expect((result as AztecAddress).toString()).toBe(testAddressStr);
+    });
+
+    it('should serialize CompleteAddress results correctly', async () => {
+      const testAddressStr =
+        '0x' +
+        '0637a51d0657242e85d8389b701d0b997a1e725beef42950eeb7b47ba900ceb2' +
+        '12b2a7eb642de67d21bace929313fb39ee45ffe7f5c413fb605c4e1cc71ede46' +
+        '270c635ac4debe508923847587d63f2004fdce3a0aadd4eb2fa32e756b3b7ceb' +
+        '100faf645e19c147761f6f18ef79be235c9b57a0005b3ecdda388f26fc20682b' +
+        '03f65a881a51f556be8f6d731d7d6f464c0a6cd04b6ce96ad03f968d9b254605' +
+        '040de5aed50467bbb4cd92d22b9d9fb84563606620b4c98be389a558345eadd3' +
+        '23db82d556864738e123fa48da67c8946bbea413b5d3b970c38ba908079812b3' +
+        '2880ba2fb9aa6d14696cba7dc3d8d39d1502e1ca459b0639793364fe97286432' +
+        '283df6e9a33d818fec833209ee18686cd306c49a7a479baefb725410bbaab16c' +
+        '303c5120ccdd027bfc35a7e666e6940d49c0dfcf25e56e3420558e42b6a3dd91';
+
+      sendMock.mockImplementation(async (request: JSONRPCRequestAny) => {
+        if (request.method === 'wm_call') {
+          const resultPayload = {
+            serialized: JSON.stringify(testAddressStr),
+            method: 'aztec_getCompleteAddress',
+          };
+          const response: JSONRPCResponseAny = {
+            jsonrpc: '2.0',
+            id: request.id,
+            result: resultPayload,
+          };
+          process.nextTick(() => {
+            messageHandler(response);
+          });
+        }
+      });
+
+      provider['_sessionId'] = 'test-session';
+
+      const result = await provider.call('aztec:mainnet', {
+        method: 'aztec_getCompleteAddress',
+      });
+
+      expect(result).toBeInstanceOf(CompleteAddress);
+      expect(result).toHaveProperty('address');
+      expect(result).toHaveProperty('publicKeys');
+      expect(result).toHaveProperty('partialAddress');
+    });
+
+    it('should pass through method calls without parameters', async () => {
+      let capturedRequest: JSONRPCRequestAny | undefined;
+      sendMock.mockImplementation(async (request: JSONRPCRequestAny) => {
+        if (request.method === 'wm_call') {
+          capturedRequest = request;
+          const response: JSONRPCResponseAny = {
+            jsonrpc: '2.0',
+            id: request.id,
+            result: 123,
+          };
+          process.nextTick(() => {
+            messageHandler(response);
+          });
+        }
+      });
+
+      provider['_sessionId'] = 'test-session';
+
+      await provider.call('aztec:mainnet', {
+        method: 'aztec_getBlockNumber',
+      });
+
+      expect(capturedRequest).toBeDefined();
+      if (capturedRequest) {
+        expect(capturedRequest.method).toBe('wm_call');
+        const params = capturedRequest.params as WmCallParams | undefined;
+        expect(params).toBeDefined();
+
+        if (params?.call) {
+          expect(params.call.method).toBe('aztec_getBlockNumber');
+          expect(params.call.params).toBeUndefined();
+        } else if (params) {
+          expect(params).toHaveProperty('call');
+        }
+      }
+    });
+
+    it('should handle methods without serializers', async () => {
+      sendMock.mockImplementation(async (request: JSONRPCRequestAny) => {
+        if (request.method === 'wm_call') {
+          const resultPayload = { someData: 'test' };
+          const response: JSONRPCResponseAny = {
+            jsonrpc: '2.0',
+            id: request.id,
+            result: resultPayload,
+          };
+          process.nextTick(() => {
+            messageHandler(response);
+          });
+        }
+      });
+
+      provider['_sessionId'] = 'test-session';
+
+      const result = await provider.call('aztec:mainnet', {
+        method: 'some_unknown_method' as string,
+        params: { test: 'data' },
+      });
+
+      expect(result).toEqual({ someData: 'test' });
+    });
+  });
+
+  describe('connection management', () => {
+    it('should maintain session after connection', async () => {
+      sendMock.mockImplementation(async (request: JSONRPCRequestAny) => {
+        if (request.method === 'wm_connect') {
+          const resultPayload = {
+            sessionId: 'test-session-123',
+            permissions: {
+              'aztec:mainnet': {
+                methods: ['aztec_getAddress'],
+                metadata: {},
+              },
+            },
+          };
+          const response: JSONRPCResponseAny = {
+            jsonrpc: '2.0',
+            id: request.id,
+            result: resultPayload,
+          };
+          process.nextTick(() => {
+            messageHandler(response);
+          });
+        }
+      });
+
+      const result = await provider.connect({
+        'aztec:mainnet': ['aztec_getAddress'],
+      });
+
+      expect(result.sessionId).toBe('test-session-123');
+      expect(provider.sessionId).toBe('test-session-123');
+    });
+  });
+});

package/src/client/aztec-router-provider.ts

@@ -0,0 +1,64 @@
+import { WalletRouterProvider } from '@walletmesh/router';
+import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
+import { registerAztecSerializers } from './register-serializers.js';
+
+/**
+ * An extended {@link WalletRouterProvider} specifically for Aztec network interactions.
+ *
+ * This class automatically registers all necessary Aztec-specific type serializers
+ * (e.g., for `AztecAddress`, `Fr`, `TxExecutionRequest`) upon instantiation.
+ * This ensures that when dApps communicate with an Aztec wallet via this provider,
+ * all Aztec types are correctly serialized for JSON-RPC transport and deserialized
+ * back into their proper object instances on receipt.
+ *
+ * It simplifies the setup for dApp developers, as they do not need to manually
+ * register serializers for Aztec types.
+ *
+ * @example
+ * ```typescript
+ * import { AztecRouterProvider, createAztecWallet } from '@walletmesh/aztec-rpc-wallet';
+ * import { MyCustomTransport } from './my-custom-transport'; // Assuming a custom transport
+ *
+ * // 1. Create a JSON-RPC transport
+ * const transport = new MyCustomTransport();
+ *
+ * // 2. Create the AztecRouterProvider instance
+ * const provider = new AztecRouterProvider(transport);
+ *
+ * // 3. Connect to the Aztec chain (e.g., testnet) and request permissions
+ * await provider.connect({
+ *   'aztec:testnet': ['aztec_getAddress', 'aztec_sendTx']
+ * });
+ *
+ * // 4. Create an AztecDappWallet instance using the provider
+ * const wallet = await createAztecWallet(provider, 'aztec:testnet');
+ *
+ * // Now, calls made through 'wallet' will automatically handle Aztec type serialization:
+ * const address = await wallet.getAddress(); // AztecAddress instance
+ * // const txRequest = ...;
+ * // const txHash = await wallet.sendTx(await wallet.proveTx(txRequest)); // Tx, TxHash instances
+ * ```
+ *
+ * @see {@link WalletRouterProvider} for the base class functionality.
+ * @see {@link registerAztecSerializers} for the underlying serializer registration.
+ * @see {@link AztecDappWallet} which is typically used with this provider.
+ */
+export class AztecRouterProvider extends WalletRouterProvider {
+  /**
+   * Constructs an instance of `AztecRouterProvider`.
+   *
+   * Upon construction, it immediately registers all Aztec-specific serializers
+   * with the underlying JSON-RPC node managed by the `WalletRouterProvider`.
+   *
+   * @param transport - The {@link JSONRPCTransport} instance to be used for
+   *                    communication between the dApp and the WalletRouter.
+   * @param context - Optional context object that can be passed to the
+   *                  `WalletRouterProvider` constructor.
+   */
+  constructor(transport: JSONRPCTransport, context?: Record<string, unknown>) {
+    super(transport, context);
+
+    // Register all Aztec serializers on this provider instance
+    registerAztecSerializers(this);
+  }
+}

package/src/client/helpers.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ALL_AZTEC_METHODS, connectAztec } from './helpers.js';
+import { createAztecWallet, type AztecDappWallet } from './aztec-dapp-wallet.js';
+import type { WalletRouterProvider } from '@walletmesh/router'; // Removed SessionData
+
+// Mock the aztec-dapp-wallet module
+vi.mock('./aztec-dapp-wallet.js', () => ({
+  createAztecWallet: vi.fn(),
+}));
+
+// Mock provider
+const createMockProvider = () => {
+  const connect = vi.fn();
+  const on = vi.fn();
+  const off = vi.fn();
+  const call = vi.fn();
+  return {
+    connect,
+    on,
+    off,
+    call,
+  } as unknown as WalletRouterProvider;
+};
+
+describe('helpers', () => {
+  let provider: ReturnType<typeof createMockProvider>;
+
+  beforeEach(() => {
+    provider = createMockProvider();
+    vi.clearAllMocks();
+  });
+
+  describe('constants', () => {
+    it('should export ALL_AZTEC_METHODS with all available methods', () => {
+      // Should include essential methods
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getAddress');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getCompleteAddress');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getChainId');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getVersion');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_sendTx');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getTxReceipt');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_simulateTx');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getNodeInfo');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getBlockNumber');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getCurrentBaseFees');
+
+      // Should include additional methods
+      expect(ALL_AZTEC_METHODS).toContain('aztec_registerSender');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getSenders');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_removeSender');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_registerContract');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_registerContractClass');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getContractMetadata');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getContractClassMetadata');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_proveTx');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_profileTx');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_simulateUtility');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getPrivateEvents');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getPublicEvents');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getPXEInfo');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_getBlock');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_createAuthWit');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_wmDeployContract');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_wmExecuteTx');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_wmSimulateTx');
+      expect(ALL_AZTEC_METHODS).toContain('aztec_wmDeployContract');
+
+      // Check total length
+      expect(ALL_AZTEC_METHODS).toHaveLength(28);
+    });
+  });
+
+  describe('connectAztec', () => {
+    it('should connect and create wallet with default chainId and methods', async () => {
+      const mockConnectResult = {
+        sessionId: 'test-session',
+        permissions: { 'aztec:mainnet': {} }, // Mock HumanReadableChainPermissions
+      };
+      const mockWallet = { address: '0x123' } as unknown as AztecDappWallet;
+
+      vi.mocked(provider.connect).mockResolvedValue(mockConnectResult);
+      vi.mocked(createAztecWallet).mockResolvedValue(mockWallet);
+
+      const result = await connectAztec(provider);
+
+      expect(provider.connect).toHaveBeenCalledWith({
+        'aztec:mainnet': ALL_AZTEC_METHODS,
+      });
+      expect(createAztecWallet).toHaveBeenCalledWith(provider, 'aztec:mainnet');
+      expect(result).toEqual({
+        sessionId: mockConnectResult.sessionId,
+        wallet: mockWallet,
+      });
+    });
+
+    it('should connect and create wallet with custom chainId', async () => {
+      const mockConnectResult = {
+        sessionId: 'test-session',
+        permissions: { 'aztec:custom': {} },
+      };
+      const mockWallet = { address: '0x123' } as unknown as AztecDappWallet;
+      const customChainId = 'aztec:custom';
+
+      vi.mocked(provider.connect).mockResolvedValue(mockConnectResult);
+      vi.mocked(createAztecWallet).mockResolvedValue(mockWallet);
+
+      const result = await connectAztec(provider, customChainId);
+
+      expect(provider.connect).toHaveBeenCalledWith({
+        [customChainId]: ALL_AZTEC_METHODS,
+      });
+      expect(createAztecWallet).toHaveBeenCalledWith(provider, customChainId);
+      expect(result).toEqual({
+        sessionId: mockConnectResult.sessionId,
+        wallet: mockWallet,
+      });
+    });
+
+    it('should connect and create wallet with custom methods', async () => {
+      const mockConnectResult = {
+        sessionId: 'test-session',
+        permissions: { 'aztec:mainnet': {} },
+      };
+      const mockWallet = { address: '0x123' } as unknown as AztecDappWallet;
+      const customMethods = ['aztec_getAddress', 'aztec_sendTx'];
+
+      vi.mocked(provider.connect).mockResolvedValue(mockConnectResult);
+      vi.mocked(createAztecWallet).mockResolvedValue(mockWallet);
+
+      const result = await connectAztec(provider, undefined, customMethods);
+
+      expect(provider.connect).toHaveBeenCalledWith({
+        'aztec:mainnet': customMethods,
+      });
+      expect(createAztecWallet).toHaveBeenCalledWith(provider, 'aztec:mainnet');
+      expect(result).toEqual({
+        sessionId: mockConnectResult.sessionId,
+        wallet: mockWallet,
+      });
+    });
+
+    it('should connect and create wallet with custom chainId and methods', async () => {
+      const mockConnectResult = {
+        sessionId: 'test-session',
+        permissions: { 'aztec:testnet': {} },
+      };
+      const mockWallet = { address: '0x123' } as unknown as AztecDappWallet;
+      const customChainId = 'aztec:testnet';
+      const customMethods = ['aztec_getAddress'];
+
+      vi.mocked(provider.connect).mockResolvedValue(mockConnectResult);
+      vi.mocked(createAztecWallet).mockResolvedValue(mockWallet);
+
+      const result = await connectAztec(provider, customChainId, customMethods);
+
+      expect(provider.connect).toHaveBeenCalledWith({
+        [customChainId]: customMethods,
+      });
+      expect(createAztecWallet).toHaveBeenCalledWith(provider, customChainId);
+      expect(result).toEqual({
+        sessionId: mockConnectResult.sessionId,
+        wallet: mockWallet,
+      });
+    });
+
+    it('should handle connection failure', async () => {
+      const error = new Error('Connection failed');
+      vi.mocked(provider.connect).mockRejectedValue(error);
+
+      await expect(connectAztec(provider)).rejects.toThrow('Connection failed');
+      expect(createAztecWallet).not.toHaveBeenCalled();
+    });
+
+    it('should handle wallet creation failure', async () => {
+      const mockConnectResult = {
+        sessionId: 'test-session',
+        permissions: { 'aztec:mainnet': {} },
+      };
+      const error = new Error('Wallet creation failed');
+
+      vi.mocked(provider.connect).mockResolvedValue(mockConnectResult);
+      vi.mocked(createAztecWallet).mockRejectedValue(error);
+
+      await expect(connectAztec(provider)).rejects.toThrow('Wallet creation failed');
+    });
+  });
+});

package/src/client/helpers.ts

@@ -0,0 +1,91 @@
+import type { AztecChainId } from '../types.js';
+import type { AztecDappWallet } from './aztec-dapp-wallet.js';
+import { createAztecWallet } from './aztec-dapp-wallet.js';
+import type { AztecRouterProvider } from './aztec-router-provider.js';
+import { createLogger } from '@aztec/foundation/log';
+
+const logger = createLogger('aztec-rpc-wallet:helpers');
+
+/**
+ * A comprehensive list of all JSON-RPC methods supported by the Aztec RPC wallet.
+ * This array includes standard Aztec wallet methods as well as WalletMesh-specific extensions (prefixed with `wm_`).
+ * It can be used when establishing a connection to request permissions for all available functionalities.
+ *
+ * @see {@link AztecWalletMethodMap} for detailed type information on each method.
+ * @see {@link connectAztec} and {@link connectAztecWithWallet} which use this list by default.
+ */
+export const ALL_AZTEC_METHODS = [
+  'aztec_getAddress',
+  'aztec_getCompleteAddress',
+  'aztec_getChainId',
+  'aztec_getVersion',
+  'aztec_sendTx',
+  'aztec_getTxReceipt',
+  'aztec_simulateTx',
+  'aztec_getNodeInfo',
+  'aztec_getBlockNumber',
+  'aztec_getCurrentBaseFees',
+  'aztec_registerSender',
+  'aztec_getSenders',
+  'aztec_removeSender',
+  'aztec_registerContract',
+  'aztec_registerContractClass',
+  'aztec_getContractMetadata',
+  'aztec_getContractClassMetadata',
+  'aztec_proveTx',
+  'aztec_profileTx',
+  'aztec_simulateUtility',
+  'aztec_getPrivateEvents',
+  'aztec_getPublicEvents',
+  'aztec_getPXEInfo',
+  'aztec_getBlock',
+  'aztec_createAuthWit',
+  'aztec_wmDeployContract',
+  'aztec_wmExecuteTx',
+  'aztec_wmSimulateTx',
+] as const;
+
+/**
+ * Establishes a connection to an Aztec wallet service and creates an initialized {@link AztecDappWallet} instance.
+ * This function requests permissions for the specified methods on the given Aztec chain,
+ * then instantiates and initializes the wallet.
+ * Initialization includes fetching and caching essential data like the wallet address and chain ID.
+ *
+ * By default, it requests permissions for all methods defined in {@link ALL_AZTEC_METHODS}
+ * on the 'aztec:mainnet' chain.
+ *
+ * @param provider - The {@link AztecRouterProvider} instance to use for the connection.
+ *                   This provider must be configured with appropriate transport and Aztec serializers.
+ * @param chainId - The {@link AztecChainId} to connect to (e.g., 'aztec:mainnet', 'aztec:31337').
+ *                  Defaults to 'aztec:mainnet'.
+ * @param methods - An array of method names for which permissions are requested.
+ *                  Defaults to {@link ALL_AZTEC_METHODS}.
+ * @returns A promise that resolves to an object containing the `sessionId` for the connection
+ *          and a fully initialized {@link AztecDappWallet} instance.
+ * @throws If the connection or wallet initialization fails.
+ *
+ * @example
+ * ```typescript
+ * const provider = new AztecRouterProvider(myTransport);
+ * const { sessionId, wallet } = await connectAztec(provider, 'aztec:testnet');
+ * const address = wallet.getAddress(); // Wallet is ready to use
+ * console.log('Connected with session ID:', sessionId, 'Wallet address:', address.toString());
+ * ```
+ */
+export async function connectAztec(
+  provider: AztecRouterProvider,
+  chainId: AztecChainId = 'aztec:mainnet',
+  methods: readonly (keyof import('../types.js').AztecWalletMethodMap | string)[] = ALL_AZTEC_METHODS,
+): Promise<{ sessionId: string; wallet: AztecDappWallet }> {
+  // Establish connection
+  const { sessionId } = await provider.connect({
+    [chainId]: [...methods] as string[],
+  });
+
+  // Create and initialize wallet (this pre-caches all synchronous values)
+  const wallet = await createAztecWallet(provider, chainId);
+  logger.debug(`Connected to Aztec wallet: ${sessionId}`);
+
+  return { sessionId, wallet };
+}
+

package/src/client/register-serializers.ts

@@ -0,0 +1,108 @@
+import type { WalletRouterProvider } from '@walletmesh/router';
+import { AztecWalletSerializer } from '../wallet/serializers.js';
+import type { AztecWalletMethodMap } from '../types.js';
+
+/**
+ * Registers the {@link AztecWalletSerializer} for all relevant Aztec JSON-RPC methods
+ * on a given {@link WalletRouterProvider} instance.
+ *
+ * This utility function ensures that any `WalletRouterProvider` (not just the specialized
+ * {@link AztecRouterProvider}) can be configured to correctly handle serialization and
+ * deserialization of Aztec-specific data types (e.g., `AztecAddress`, `Fr`, `TxExecutionRequest`)
+ * when interacting with an Aztec wallet.
+ *
+ * It iterates through a predefined list of Aztec methods and associates them with
+ * the comprehensive {@link AztecWalletSerializer}.
+ *
+ * @param provider - The {@link WalletRouterProvider} instance on which to register the serializers.
+ *                   After this function call, the provider will be equipped to handle Aztec methods.
+ *
+ * @example
+ * ```typescript
+ * import { WalletRouterProvider } from '@walletmesh/router';
+ * import { registerAztecSerializers, ALL_AZTEC_METHODS } from '@walletmesh/aztec-rpc-wallet';
+ * import { MyCustomTransport } from './my-custom-transport';
+ *
+ * // 1. Create a generic WalletRouterProvider
+ * const transport = new MyCustomTransport();
+ * const provider = new WalletRouterProvider(transport);
+ *
+ * // 2. Register Aztec serializers on it
+ * registerAztecSerializers(provider);
+ *
+ * // 3. Now the provider can correctly handle Aztec methods and types
+ * await provider.connect({ 'aztec:testnet': ALL_AZTEC_METHODS });
+ * const address = await provider.call('aztec:testnet', { method: 'aztec_getAddress' });
+ * // 'address' will be correctly deserialized into an AztecAddress instance (or equivalent based on serializer)
+ * ```
+ *
+ * @see {@link AztecWalletSerializer} for the actual serialization logic.
+ * @see {@link AztecRouterProvider} for a provider that calls this automatically.
+ * @see {@link AztecWalletMethodMap} for the list of methods and their types.
+ */
+export function registerAztecSerializers(provider: WalletRouterProvider): void {
+  // List of all Aztec wallet methods that need the AztecWalletSerializer.
+  // This list should ideally be kept in sync with ALL_AZTEC_METHODS or derived from AztecWalletMethodMap.
+  // Note: 'aztec_createTxExecutionRequest' is a client-side method, not a direct RPC method name.
+  // The actual RPC methods involved in tx creation are typically aztec_proveTx, aztec_sendTx, etc.
+  // However, if it were an RPC method, it would be listed here.
+  // For now, using a manually curated list that matches most of AztecWalletMethodMap.
+  const aztecMethods: (keyof AztecWalletMethodMap)[] = [
+    // Chain/Node Methods
+    'aztec_getBlock',
+    'aztec_getBlockNumber',
+    'aztec_getChainId',
+    'aztec_getVersion',
+    'aztec_getNodeInfo',
+    'aztec_getProvenBlockNumber',
+    'aztec_getPXEInfo',
+    'aztec_getCurrentBaseFees',
+
+    // Account Methods
+    'aztec_getAddress',
+    'aztec_getCompleteAddress',
+
+    // AuthWitness Methods
+    'aztec_createAuthWit',
+
+    // Sender Methods
+    'aztec_registerSender',
+    'aztec_getSenders',
+    'aztec_removeSender',
+
+    // Contract Methods
+    'aztec_getContracts',
+    'aztec_getContractMetadata',
+    'aztec_getContractClassMetadata',
+    'aztec_registerContract',
+    'aztec_registerContractClass',
+
+    // Transaction Methods
+    // 'aztec_createTxExecutionRequest', // This is a client-side method, not an RPC method.
+    'aztec_proveTx',
+    'aztec_sendTx',
+    'aztec_getTxReceipt',
+    'aztec_simulateTx',
+    'aztec_profileTx',
+    'aztec_simulateUtility',
+
+    // Event Methods
+    'aztec_getPrivateEvents',
+    'aztec_getPublicEvents',
+
+    // Contract Interaction Methods (WalletMesh specific)
+    'aztec_wmExecuteTx',
+    'aztec_wmSimulateTx',
+    'aztec_wmDeployContract',
+
+    // Base WalletMesh method often included
+    'wm_getSupportedMethods',
+  ];
+
+  // Register the unified Aztec serializer for all methods
+  for (const method of aztecMethods) {
+    // The AztecWalletSerializer is already set up with all the proper
+    // serialization logic for each method
+    provider.registerMethodSerializer(method as string, AztecWalletSerializer);
+  }
+}