@walletmesh/aztec-rpc-wallet 0.1.0

package/src/wallet.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import type { AccountWallet, PXE, TxHash } from '@aztec/aztec.js';
+import { JSONRPCWalletClient } from '@walletmesh/router';
+import { AztecChainWallet } from './wallet.js';
+import { ContractArtifactCache } from './contractArtifactCache.js';
+import { AztecWalletError } from './errors.js';
+import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
+import type { AztecWalletContext } from './types.js';
+
+describe('AztecChainWallet', () => {
+  let pxe: PXE;
+  let wallet: AccountWallet;
+  let transport: JSONRPCTransport;
+  let aztecWallet: AztecChainWallet;
+
+  beforeEach(() => {
+    // Mock PXE
+    pxe = {
+      // Add required PXE methods as needed
+    } as unknown as PXE;
+
+    // Mock AccountWallet
+    wallet = {
+      getAddress: vi.fn().mockResolvedValue('mockAddress'),
+    } as unknown as AccountWallet;
+
+    // Mock Transport
+    transport = {
+      send: vi.fn().mockResolvedValue(undefined),
+      on: vi.fn(),
+      off: vi.fn(),
+      emit: vi.fn(),
+    } as unknown as JSONRPCTransport;
+
+    // Create wallet instance
+    aztecWallet = new AztecChainWallet(pxe, wallet, transport);
+
+    // Setup fallback handler and serializer
+    const mockHandler = vi.fn().mockImplementation(async (context, method, params) => {
+      if (!isAztecWalletContext(context)) {
+        throw new AztecWalletError('unknownInternalError', 'Invalid context');
+      }
+      if (method === 'aztec_getAccount') {
+        return await context.wallet.getAddress();
+      }
+      throw new AztecWalletError('invalidRequest', `Method not supported: ${method}`);
+    });
+
+    const mockSerializer = {
+      serialize: vi.fn().mockImplementation((value) => value),
+      deserialize: vi.fn().mockImplementation((value) => value),
+    };
+
+    Object.defineProperties(aztecWallet, {
+      fallbackHandler: {
+        value: mockHandler,
+        writable: true,
+        configurable: true,
+      },
+      fallbackSerializer: {
+        value: mockSerializer,
+        writable: true,
+        configurable: true,
+      },
+    });
+  });
+
+  describe('constructor', () => {
+    it('initializes with valid context', () => {
+      expect(aztecWallet).toBeInstanceOf(AztecChainWallet);
+      const context = (aztecWallet as unknown as { context: AztecWalletContext }).context;
+      expect(context.pxe).toBe(pxe);
+      expect(context.wallet).toBe(wallet);
+      expect(context.contractArtifactCache).toBeInstanceOf(ContractArtifactCache);
+    });
+
+    it('sets up fallback handler and serializer', () => {
+      const instance = aztecWallet as unknown as {
+        fallbackHandler: unknown;
+        fallbackSerializer: unknown;
+      };
+      expect(instance.fallbackHandler).toBeDefined();
+      expect(instance.fallbackSerializer).toBeDefined();
+    });
+
+    it('throws error when handler receives invalid context', async () => {
+      // Create a mock transport that simulates an error response
+      const mockSend = vi
+        .fn()
+        .mockRejectedValue(new AztecWalletError('unknownInternalError', 'Invalid context'));
+
+      const invalidTransport = {
+        send: mockSend,
+        on: vi.fn(),
+        off: vi.fn(),
+        emit: vi.fn(),
+      } as unknown as JSONRPCTransport;
+
+      // Create wallet with invalid context
+      new AztecChainWallet(null as unknown as PXE, null as unknown as AccountWallet, invalidTransport);
+
+      // Attempt to send a request
+      const request = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'test_method',
+        params: [],
+      };
+
+      // Verify the error is thrown
+      await expect(mockSend(request)).rejects.toThrow(AztecWalletError);
+      expect(mockSend).toHaveBeenCalledWith(request);
+    });
+  });
+
+  describe('isAztecWalletContext', () => {
+    it('returns true for valid context', () => {
+      const validContext = {
+        pxe,
+        wallet,
+        contractArtifactCache: new ContractArtifactCache(wallet),
+      };
+      expect(isAztecWalletContext(validContext)).toBe(true);
+    });
+
+    it('returns false for null', () => {
+      expect(isAztecWalletContext(null)).toBe(false);
+    });
+
+    it('returns false for non-object values', () => {
+      expect(isAztecWalletContext(123)).toBe(false);
+      expect(isAztecWalletContext('string')).toBe(false);
+      expect(isAztecWalletContext(undefined)).toBe(false);
+      expect(isAztecWalletContext(true)).toBe(false);
+      expect(isAztecWalletContext([])).toBe(false);
+      expect(isAztecWalletContext(() => {})).toBe(false);
+    });
+
+    it('returns false for missing required properties', () => {
+      expect(isAztecWalletContext({})).toBe(false);
+      expect(isAztecWalletContext({ pxe })).toBe(false);
+      expect(isAztecWalletContext({ pxe, wallet })).toBe(false);
+      expect(isAztecWalletContext({ wallet, contractArtifactCache: new ContractArtifactCache(wallet) })).toBe(
+        false,
+      );
+    });
+
+    it('returns false for objects with null properties', () => {
+      expect(isAztecWalletContext({ pxe: null, wallet: null, contractArtifactCache: null })).toBe(false);
+      expect(
+        isAztecWalletContext({ pxe, wallet: null, contractArtifactCache: new ContractArtifactCache(wallet) }),
+      ).toBe(false);
+      expect(
+        isAztecWalletContext({ pxe: null, wallet, contractArtifactCache: new ContractArtifactCache(wallet) }),
+      ).toBe(false);
+    });
+  });
+
+  describe('asWalletRouterClient', () => {
+    it('returns a JSONRPCWalletClient instance', () => {
+      const client = aztecWallet.asWalletRouterClient();
+      expect(client).toBeInstanceOf(JSONRPCWalletClient);
+    });
+
+    it('returns a valid router client', () => {
+      const client = aztecWallet.asWalletRouterClient();
+      // Verify the client is properly instantiated
+      expect(client).toBeDefined();
+      expect(client).toBeInstanceOf(JSONRPCWalletClient);
+    });
+  });
+
+  describe('request handling', () => {
+    it('handles valid context in fallback handler', async () => {
+      const result = await (
+        aztecWallet as unknown as {
+          fallbackHandler: (
+            context: AztecWalletContext,
+            method: string,
+            params: unknown[],
+          ) => Promise<unknown>;
+        }
+      ).fallbackHandler(
+        {
+          pxe,
+          wallet,
+          contractArtifactCache: new ContractArtifactCache(wallet),
+        },
+        'aztec_getAccount',
+        [],
+      );
+      expect(result).toBe('mockAddress');
+    });
+
+    it('throws error for invalid context in fallback handler', async () => {
+      await expect(
+        (
+          aztecWallet as unknown as {
+            fallbackHandler: (
+              context: AztecWalletContext,
+              method: string,
+              params: unknown[],
+            ) => Promise<unknown>;
+          }
+        ).fallbackHandler({ invalidContext: true } as unknown as AztecWalletContext, 'aztec_getAccount', []),
+      ).rejects.toThrow(AztecWalletError);
+    });
+  });
+
+  describe('message handling', () => {
+    it('processes incoming messages through transport', async () => {
+      const message = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'aztec_getAccount',
+        params: [],
+      };
+
+      // Setup request handler to use fallback handler
+      const handleRequest = async (msg: unknown) => {
+        const typedMessage = msg as { method: string; params: unknown[] };
+        return (
+          aztecWallet as unknown as {
+            fallbackHandler: (
+              context: AztecWalletContext,
+              method: string,
+              params: unknown[],
+            ) => Promise<unknown>;
+          }
+        ).fallbackHandler(
+          { pxe, wallet, contractArtifactCache: new ContractArtifactCache(wallet) },
+          typedMessage.method,
+          typedMessage.params,
+        );
+      };
+
+      (aztecWallet as unknown as { handleRequest: typeof handleRequest }).handleRequest = handleRequest;
+
+      await handleRequest(message);
+      expect(wallet.getAddress).toHaveBeenCalled();
+    });
+
+    it('handles transport errors gracefully', async () => {
+      const message = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'invalidMethod',
+        params: [],
+      };
+
+      // Setup request handler to throw error for invalid method
+      const handleRequest = async (msg: unknown) => {
+        throw new AztecWalletError('invalidRequest', 'Invalid method');
+      };
+
+      (aztecWallet as unknown as { handleRequest: typeof handleRequest }).handleRequest = handleRequest;
+
+      await expect(handleRequest(message)).rejects.toThrow(AztecWalletError);
+    });
+  });
+});
+
+// Helper function to check context type
+function isAztecWalletContext(value: unknown): value is AztecWalletContext {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'pxe' in value &&
+    'wallet' in value &&
+    'contractArtifactCache' in value &&
+    value.pxe !== null &&
+    value.wallet !== null &&
+    value.contractArtifactCache !== null
+  );
+}

package/src/wallet.ts

@@ -0,0 +1,94 @@
+import type { AccountWallet, PXE } from '@aztec/aztec.js';
+
+import { JSONRPCNode, type JSONRPCTransport } from '@walletmesh/jsonrpc';
+import { JSONRPCWalletClient } from '@walletmesh/router';
+
+import type {
+  AztecWalletMethodMap,
+  AztecWalletContext,
+  AztecWalletEventMap,
+  AztecWalletRouterClient,
+} from './types.js';
+import { AztecWalletSerializer } from './serializers/index.js';
+
+import { ContractArtifactCache } from './contractArtifactCache.js';
+import { handler } from './handlers.js';
+
+/**
+ * @module wallet
+ *
+ * This module provides the server-side implementation of the Aztec RPC interface.
+ * It handles incoming RPC requests from dApps and executes them using an Aztec wallet instance.
+ */
+
+/**
+ * JSON-RPC interface implementation for an Aztec Wallet.
+ *
+ * This class provides the core wallet functionality exposed through JSON-RPC:
+ * - Handles incoming RPC requests from dApps
+ * - Manages wallet state and context
+ * - Executes operations through the underlying Aztec wallet
+ * - Serializes responses back to JSON-RPC format
+ *
+ * The wallet supports operations like:
+ * - Account management
+ * - Transaction execution
+ * - Contract interaction
+ * - Note management
+ * - Event logging
+ *
+ * @example
+ * ```typescript
+ * // Create wallet instance
+ * const wallet = new AztecChainWallet(aztecWallet, transport);
+ *
+ * // Handle incoming RPC requests
+ * transport.on('message', async (request) => {
+ *   const response = await wallet.handleRequest(request);
+ *   // Send response back to dApp
+ * });
+ * ```
+ *
+ * @public
+ */
+export class AztecChainWallet extends JSONRPCNode<
+  AztecWalletMethodMap,
+  AztecWalletEventMap,
+  AztecWalletContext
+> {
+  /**
+   * Creates a new AztecWallet instance.
+   *
+   * @param pxe - The PXE instance for the Aztec protocol
+   * @param wallet - The underlying Aztec wallet instance that executes operations
+   * @param transport - Transport layer for sending/receiving JSON-RPC messages
+   *
+   * The wallet instance sets up:
+   * - Contract artifact caching
+   * - Default request handlers
+   * - Custom serialization for Aztec types
+   */
+  constructor(pxe: PXE, wallet: AccountWallet, transport: JSONRPCTransport) {
+    const context: AztecWalletContext = {
+      pxe,
+      wallet,
+      contractArtifactCache: new ContractArtifactCache(wallet),
+    };
+    super(transport, context);
+
+    this.setFallbackHandler(async (handlerContext: AztecWalletContext, method, params) => {
+      return await handler(handlerContext, method, params);
+    });
+    this.setFallbackSerializer(AztecWalletSerializer);
+  }
+
+  /**
+   * Creates a client wrapper for use with WalletMesh router.
+   * This enables the wallet to be used as a client in a routing setup.
+   *
+   * @returns Client interface for the wallet
+   */
+  asWalletRouterClient(): AztecWalletRouterClient {
+    return new JSONRPCWalletClient(this);
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "src/**/*.test.ts",
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/.tsbuildinfo",
+  },
+  "include": [
+    "src/**/*",
+  ]
+}

package/typedoc.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://typedoc-plugin-markdown.org/schema.json",
+  "plugin": [
+    "typedoc-plugin-markdown"
+  ],
+  "entryPoints": [
+    "src/index.ts"
+  ],
+  "out": "docs",
+  "exclude": [
+    "**/*.test.ts"
+  ],
+  "includeVersion": true,
+  "excludePrivate": true
+}

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    testTimeout: 200, // .2 second timeout
+    coverage: {
+      include: ['src/**/*.ts', '!src/**/types.ts', '!src/**/index.ts', '!src/**/*.test.ts'],
+    },
+  },
+});