@walletmesh/aztec-rpc-wallet 0.1.0

package/src/chainProvider.test.ts

@@ -0,0 +1,322 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type { JSONRPCTransport, JSONRPCRequest } from '@walletmesh/jsonrpc';
+import { AztecChainProvider } from './chainProvider.js';
+import { AztecWalletError } from './errors.js';
+import type { ContractInstanceWithAddress, ContractArtifact, AztecAddress } from '@aztec/aztec.js';
+import type { AztecWalletMethodMap } from './types.js';
+
+const createMockTransport = () => ({
+  send: vi.fn().mockImplementation(() => Promise.resolve()),
+});
+
+describe('AztecChainProvider', () => {
+  let provider: AztecChainProvider;
+  let mockTransport: ReturnType<typeof createMockTransport>;
+
+  beforeEach(() => {
+    mockTransport = createMockTransport();
+    provider = new AztecChainProvider(mockTransport);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getAccount', () => {
+    it('returns account address on success', async () => {
+      const expectedAddress = '0x1234567890abcdef';
+      const promise = provider.getAccount();
+
+      // Get the request ID from the sent message
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_getAccount'>],
+      ];
+      expect(sentRequest).toEqual({
+        jsonrpc: '2.0',
+        id: expect.any(String),
+        method: 'aztec_getAccount',
+      });
+
+      // Simulate response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: expectedAddress,
+        id: sentRequest.id,
+      });
+
+      const result = await promise;
+      expect(result).toBe(expectedAddress);
+    });
+
+    it('throws on invalid response', async () => {
+      const promise = provider.getAccount();
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_getAccount'>],
+      ];
+
+      // Simulate error response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: null,
+        id: sentRequest.id,
+      });
+
+      await expect(promise).rejects.toThrow(AztecWalletError);
+    });
+  });
+
+  describe('sendTransaction', () => {
+    const txParams = {
+      functionCalls: [
+        {
+          contractAddress: '0x1234',
+          functionName: 'transfer',
+          args: ['0x5678', 100],
+        },
+      ],
+    };
+
+    it('returns transaction hash on success', async () => {
+      const expectedHash = '0xabcd';
+      const promise = provider.sendTransaction(txParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_sendTransaction'>],
+      ];
+      expect(sentRequest).toEqual({
+        jsonrpc: '2.0',
+        id: expect.any(String),
+        method: 'aztec_sendTransaction',
+        params: txParams,
+      });
+
+      // Simulate response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: expectedHash,
+        id: sentRequest.id,
+      });
+
+      const result = await promise;
+      expect(result).toBe(expectedHash);
+    });
+
+    it('throws on invalid response', async () => {
+      const promise = provider.sendTransaction(txParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_sendTransaction'>],
+      ];
+
+      // Simulate error response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: null,
+        id: sentRequest.id,
+      });
+
+      await expect(promise).rejects.toThrow(AztecWalletError);
+    });
+  });
+
+  describe('simulateTransaction', () => {
+    const txParams = {
+      contractAddress: '0x1234',
+      functionName: 'transfer',
+      args: ['0x5678', 100],
+    };
+
+    it('returns simulation result on success', async () => {
+      const expectedResult = { success: true, data: 'test' };
+      const promise = provider.simulateTransaction(txParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_simulateTransaction'>],
+      ];
+      expect(sentRequest).toEqual({
+        jsonrpc: '2.0',
+        id: expect.any(String),
+        method: 'aztec_simulateTransaction',
+        params: txParams,
+      });
+
+      // Simulate response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: expectedResult,
+        id: sentRequest.id,
+      });
+
+      const result = await promise;
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('throws on invalid response', async () => {
+      const promise = provider.simulateTransaction(txParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_simulateTransaction'>],
+      ];
+
+      // Simulate error response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: null,
+        id: sentRequest.id,
+      });
+
+      await expect(promise).rejects.toThrow(AztecWalletError);
+    });
+  });
+
+  describe('registerContract', () => {
+    const contractParams = {
+      instance: { address: '0x1234' as unknown as AztecAddress } as ContractInstanceWithAddress,
+      artifact: { name: 'TestContract' } as ContractArtifact,
+    };
+
+    it('succeeds on valid response', async () => {
+      const promise = provider.registerContract(contractParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContract'>],
+      ];
+      expect(sentRequest).toEqual({
+        jsonrpc: '2.0',
+        id: expect.any(String),
+        method: 'aztec_registerContract',
+        params: contractParams,
+      });
+
+      // Simulate response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: true,
+        id: sentRequest.id,
+      });
+
+      await expect(promise).resolves.toBeUndefined();
+    });
+
+    it('throws on invalid response', async () => {
+      const promise = provider.registerContract(contractParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContract'>],
+      ];
+
+      // Simulate error response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: false,
+        id: sentRequest.id,
+      });
+
+      await expect(promise).rejects.toThrow(AztecWalletError);
+    });
+  });
+
+  describe('registerContractClass', () => {
+    const classParams = {
+      artifact: { name: 'TestContract' } as ContractArtifact,
+    };
+
+    it('succeeds on valid response', async () => {
+      const promise = provider.registerContractClass(classParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContractClass'>],
+      ];
+      expect(sentRequest).toEqual({
+        jsonrpc: '2.0',
+        id: expect.any(String),
+        method: 'aztec_registerContractClass',
+        params: classParams,
+      });
+
+      // Simulate response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: true,
+        id: sentRequest.id,
+      });
+
+      await expect(promise).resolves.toBeUndefined();
+    });
+
+    it('throws on invalid response', async () => {
+      const promise = provider.registerContractClass(classParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContractClass'>],
+      ];
+
+      // Simulate error response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: false,
+        id: sentRequest.id,
+      });
+
+      await expect(promise).rejects.toThrow(AztecWalletError);
+    });
+  });
+
+  describe('registerSender', () => {
+    const senderParams = {
+      sender: '0x1234' as unknown as AztecAddress,
+    };
+
+    it('succeeds on valid response', async () => {
+      const promise = provider.registerSender(senderParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerSender'>],
+      ];
+      expect(sentRequest).toEqual({
+        jsonrpc: '2.0',
+        id: expect.any(String),
+        method: 'aztec_registerSender',
+        params: senderParams,
+      });
+
+      // Simulate response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: '0x1234',
+        id: sentRequest.id,
+      });
+
+      await expect(promise).resolves.toBeUndefined();
+    });
+
+    it('throws on invalid response', async () => {
+      const promise = provider.registerSender(senderParams);
+
+      // Get the request ID
+      const [[sentRequest]] = mockTransport.send.mock.calls as [
+        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerSender'>],
+      ];
+
+      // Simulate error response
+      await provider.receiveMessage({
+        jsonrpc: '2.0',
+        result: null,
+        id: sentRequest.id,
+      });
+
+      await expect(promise).rejects.toThrow(AztecWalletError);
+    });
+  });
+});

package/src/chainProvider.ts

@@ -0,0 +1,122 @@
+import { JSONRPCNode } from '@walletmesh/jsonrpc';
+import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
+import { AztecWalletError, AztecWalletErrorType } from './errors.js';
+import type {
+  AztecChainId,
+  AztecWalletMethodMap,
+  TransactionParams,
+  TransactionFunctionCall,
+} from './types.js';
+import type { ContractInstanceWithAddress, ContractArtifact } from '@aztec/aztec.js';
+
+/**
+ * Provider for directly interacting with an Aztec chain wallet.
+ * This is a minimal implementation that supports core Aztec operations
+ * without the complexity of multi-chain routing.
+ */
+export class AztecChainProvider extends JSONRPCNode<AztecWalletMethodMap> {
+  protected async makeRequest<M extends keyof AztecWalletMethodMap>(
+    method: M,
+    params?: AztecWalletMethodMap[M]['params'],
+  ): Promise<AztecWalletMethodMap[M]['result']> {
+    try {
+      return await this.callMethod(method, params);
+    } catch (error) {
+      throw new AztecWalletError(
+        AztecWalletErrorType.invalidResponse,
+        error instanceof Error ? error.message : 'Invalid response received',
+      );
+    }
+  }
+
+  public async connect(): Promise<boolean> {
+    try {
+      await this.makeRequest('aztec_connect');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Gets the account address from the wallet.
+   * @returns The account address as a string
+   * @throws {AztecWalletError} If response is invalid
+   */
+  public async getAccount(): Promise<string> {
+    const result = await this.makeRequest('aztec_getAccount');
+    if (typeof result !== 'string' || !result) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid account address returned');
+    }
+    return result;
+  }
+
+  /**
+   * Sends a transaction to the chain.
+   * @param params - Transaction parameters including function calls
+   * @returns Transaction hash
+   * @throws {AztecWalletError} If transaction fails or response invalid
+   */
+  public async sendTransaction(params: TransactionParams): Promise<string> {
+    const result = await this.makeRequest('aztec_sendTransaction', params);
+    if (typeof result !== 'string' || !result) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid transaction hash returned');
+    }
+    return result;
+  }
+
+  /**
+   * Simulates a transaction without submitting it.
+   * @param params - Transaction parameters to simulate
+   * @returns Simulation result
+   * @throws {AztecWalletError} If simulation fails
+   */
+  public async simulateTransaction(params: TransactionFunctionCall): Promise<unknown> {
+    const result = await this.makeRequest('aztec_simulateTransaction', params);
+    if (result === undefined || result === null) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid simulation result returned');
+    }
+    return result;
+  }
+
+  /**
+   * Registers a contract instance with the wallet.
+   * @param params - Contract registration parameters
+   * @throws {AztecWalletError} If registration fails
+   */
+  public async registerContract(params: {
+    instance: ContractInstanceWithAddress;
+    artifact?: ContractArtifact;
+  }): Promise<void> {
+    const result = await this.makeRequest('aztec_registerContract', params);
+    if (result !== true) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Contract registration failed');
+    }
+  }
+
+  /**
+   * Registers a contract class with the wallet.
+   * @param params - Contract class registration parameters
+   * @throws {AztecWalletError} If registration fails
+   */
+  public async registerContractClass(params: {
+    artifact: ContractArtifact;
+  }): Promise<void> {
+    const result = await this.makeRequest('aztec_registerContractClass', params);
+    if (result !== true) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Contract class registration failed');
+    }
+  }
+
+  /**
+   * Registers a sender with the wallet.
+   * @param params - Sender registration parameters
+   * @throws {AztecWalletError} If registration fails
+   */
+  public async registerSender(params: AztecWalletMethodMap['aztec_registerSender']['params']): Promise<void> {
+    const result = await this.makeRequest('aztec_registerSender', params);
+    if (!result) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Sender registration failed');
+    }
+  }
+}

package/src/contractArtifactCache.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it, vi, beforeEach, type Mock } from 'vitest';
+import type { AztecAddress, ContractArtifact, ContractClassWithId, Wallet } from '@aztec/aztec.js';
+import { ContractArtifactCache } from './contractArtifactCache.js';
+import { AztecWalletError } from './errors.js';
+
+describe('ContractArtifactCache', () => {
+  let wallet: Wallet;
+  let cache: ContractArtifactCache;
+  let mockContractAddress: AztecAddress;
+  let mockContractClassId: ContractClassWithId;
+  let mockArtifact: ContractArtifact;
+
+  beforeEach(() => {
+    // Mock contract address and class ID
+    // Create a complete mock of AztecAddress
+    mockContractAddress = {
+      toString: () => '0x123',
+      _branding: 'aztec.Address',
+      xCoord: BigInt(0),
+      size: 32,
+      equals: () => false,
+      toBuffer: () => Buffer.from([]),
+      toFields: () => [],
+      toField: () => BigInt(0),
+      toBigInt: () => BigInt(0),
+      isZero: () => false,
+      isValid: () => true,
+      toAddressPoint: () => ({ x: BigInt(0) }),
+      toJSON: () => ({ x: '0' }),
+      [Symbol.for('nodejs.util.inspect.custom')]: () => 'AztecAddress',
+    } as unknown as AztecAddress;
+
+    // Create a complete mock of ContractClassWithId
+    mockContractClassId = {
+      toString: () => '456',
+      id: BigInt(456),
+      version: 1,
+      artifactHash: BigInt(0),
+      privateFunctions: new Map(),
+      publicFunctions: new Map(),
+      packedBytecode: new Uint8Array(),
+    } as unknown as ContractClassWithId;
+    mockArtifact = { name: 'TestContract' } as ContractArtifact;
+
+    // Create mock wallet
+    wallet = {
+      getContractInstance: vi.fn(),
+      getContractArtifact: vi.fn(),
+    } as unknown as Wallet;
+
+    // Initialize cache with mock wallet
+    cache = new ContractArtifactCache(wallet);
+  });
+
+  it('returns cached artifact if available', async () => {
+    // Setup: Pre-populate cache
+    (cache as unknown as { cache: Map<string, ContractArtifact> }).cache.set(
+      mockContractAddress.toString(),
+      mockArtifact,
+    );
+
+    // Test: Get artifact
+    const result = await cache.getContractArtifact(mockContractAddress);
+
+    // Verify: Result is from cache, wallet methods not called
+    expect(result).toBe(mockArtifact);
+    expect(wallet.getContractInstance).not.toHaveBeenCalled();
+    expect(wallet.getContractArtifact).not.toHaveBeenCalled();
+  });
+
+  it('fetches and caches artifact on cache miss', async () => {
+    // Setup: Configure wallet mocks
+    (wallet.getContractInstance as Mock).mockResolvedValue({ contractClassId: mockContractClassId });
+    (wallet.getContractArtifact as Mock).mockResolvedValue(mockArtifact);
+
+    // Test: Get artifact
+    const result = await cache.getContractArtifact(mockContractAddress);
+
+    // Verify: Correct methods called and result cached
+    expect(wallet.getContractInstance).toHaveBeenCalledWith(mockContractAddress);
+    expect(wallet.getContractArtifact).toHaveBeenCalledWith(mockContractClassId);
+    expect(result).toBe(mockArtifact);
+
+    // Verify: Result was cached
+    expect(
+      (cache as unknown as { cache: Map<string, ContractArtifact> }).cache.get(
+        mockContractAddress.toString(),
+      ),
+    ).toBe(mockArtifact);
+  });
+
+  it('throws error if contract instance not found', async () => {
+    // Setup: Mock contract instance not found
+    (wallet.getContractInstance as Mock).mockResolvedValue(null);
+
+    // Test & Verify: Expect error
+    await expect(cache.getContractArtifact(mockContractAddress)).rejects.toThrow(
+      new AztecWalletError('contractInstanceNotRegistered', mockContractAddress.toString()),
+    );
+
+    // Verify: Nothing cached
+    expect(
+      (cache as unknown as { cache: Map<string, ContractArtifact> }).cache.get(
+        mockContractAddress.toString(),
+      ),
+    ).toBeUndefined();
+  });
+
+  it('throws error if contract artifact not found', async () => {
+    // Setup: Mock contract instance found but artifact missing
+    (wallet.getContractInstance as Mock).mockResolvedValue({ contractClassId: mockContractClassId });
+    (wallet.getContractArtifact as Mock).mockResolvedValue(null);
+
+    // Test & Verify: Expect error
+    await expect(cache.getContractArtifact(mockContractAddress)).rejects.toThrow(
+      new AztecWalletError('contractClassNotRegistered', mockContractClassId.toString()),
+    );
+
+    // Verify: Nothing cached
+    expect(
+      (cache as unknown as { cache: Map<string, ContractArtifact> }).cache.get(
+        mockContractAddress.toString(),
+      ),
+    ).toBeUndefined();
+  });
+});

package/src/contractArtifactCache.ts

@@ -0,0 +1,75 @@
+/**
+ * @module contractArtifactCache
+ *
+ * This module provides caching functionality for Aztec contract artifacts.
+ * It helps improve performance by avoiding repeated fetches of the same contract artifacts.
+ */
+
+import type { AztecAddress, ContractArtifact, Wallet } from '@aztec/aztec.js';
+
+import { AztecWalletError } from './errors.js';
+
+/**
+ * Caches contract artifacts to optimize contract interactions.
+ *
+ * This class maintains an in-memory cache of contract artifacts indexed by contract address.
+ * When a contract artifact is requested:
+ * 1. First checks the cache for an existing artifact
+ * 2. If not found, fetches the contract instance and its artifact from the wallet
+ * 3. Stores the artifact in the cache for future use
+ * 4. Returns the artifact to the caller
+ *
+ * This caching mechanism helps reduce:
+ * - Network requests to fetch contract data
+ * - Processing overhead of parsing contract artifacts
+ * - Memory usage by reusing existing artifacts
+ */
+export class ContractArtifactCache {
+  /** Map of contract addresses to their artifacts */
+  private cache = new Map<string, ContractArtifact>();
+  /** Reference to the wallet instance for fetching contract data */
+  private wallet: Wallet;
+
+  /**
+   * Creates a new ContractArtifactCache instance.
+   * @param wallet - Wallet instance used to fetch contract data when cache misses occur
+   */
+  constructor(wallet: Wallet) {
+    this.wallet = wallet;
+  }
+
+  /**
+   * Retrieves the contract artifact for a given contract address.
+   * First checks the cache, then falls back to fetching from the wallet if needed.
+   *
+   * The process:
+   * 1. Check if artifact exists in cache
+   * 2. If not, get contract instance from wallet
+   * 3. Use instance to get contract class ID
+   * 4. Fetch artifact using class ID
+   * 5. Cache the artifact for future use
+   *
+   * @param contractAddress - The contract address to retrieve the artifact for
+   * @returns Promise resolving to the contract artifact
+   * @throws {AztecWalletError} If contract instance or class not registered
+   */
+  public async getContractArtifact(contractAddress: AztecAddress): Promise<ContractArtifact> {
+    const addressStr = contractAddress.toString();
+    const cached = this.cache.get(addressStr);
+    if (cached) {
+      return cached;
+    }
+
+    const contract = await this.wallet.getContractInstance(contractAddress);
+    if (!contract) {
+      throw new AztecWalletError('contractInstanceNotRegistered', addressStr);
+    }
+    const artifact = await this.wallet.getContractArtifact(contract.contractClassId);
+    if (!artifact) {
+      throw new AztecWalletError('contractClassNotRegistered', contract.contractClassId.toString());
+    }
+
+    this.cache.set(addressStr, artifact);
+    return artifact;
+  }
+}