@walletmesh/aztec-rpc-wallet 0.2.0 → 0.3.0

package/src/chainProvider.test.ts

@@ -1,12 +1,19 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import type { JSONRPCTransport, JSONRPCRequest } from '@walletmesh/jsonrpc';
+import type { 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()),
+  send: vi
+    .fn()
+    .mockImplementation(
+      async (_request: JSONRPCRequest<AztecWalletMethodMap, keyof AztecWalletMethodMap>) => {
+        // Default mock implementation that records the call but returns undefined
+        return undefined;
+      },
+    ),
 });
 
 describe('AztecChainProvider', () => {
@@ -27,10 +34,16 @@ describe('AztecChainProvider', () => {
       const expectedAddress = '0x1234567890abcdef';
       const promise = provider.getAccount();
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID from the sent message
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_getAccount'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_getAccount'>;
       expect(sentRequest).toEqual({
         jsonrpc: '2.0',
         id: expect.any(String),
@@ -51,10 +64,16 @@ describe('AztecChainProvider', () => {
     it('throws on invalid response', async () => {
       const promise = provider.getAccount();
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_getAccount'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_getAccount'>;
 
       // Simulate error response
       await provider.receiveMessage({
@@ -82,10 +101,16 @@ describe('AztecChainProvider', () => {
       const expectedHash = '0xabcd';
       const promise = provider.sendTransaction(txParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_sendTransaction'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_sendTransaction'>;
       expect(sentRequest).toEqual({
         jsonrpc: '2.0',
         id: expect.any(String),
@@ -107,10 +132,16 @@ describe('AztecChainProvider', () => {
     it('throws on invalid response', async () => {
       const promise = provider.sendTransaction(txParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_sendTransaction'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_sendTransaction'>;
 
       // Simulate error response
       await provider.receiveMessage({
@@ -134,10 +165,16 @@ describe('AztecChainProvider', () => {
       const expectedResult = { success: true, data: 'test' };
       const promise = provider.simulateTransaction(txParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_simulateTransaction'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_simulateTransaction'>;
       expect(sentRequest).toEqual({
         jsonrpc: '2.0',
         id: expect.any(String),
@@ -159,10 +196,16 @@ describe('AztecChainProvider', () => {
     it('throws on invalid response', async () => {
       const promise = provider.simulateTransaction(txParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_simulateTransaction'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_simulateTransaction'>;
 
       // Simulate error response
       await provider.receiveMessage({
@@ -184,10 +227,16 @@ describe('AztecChainProvider', () => {
     it('succeeds on valid response', async () => {
       const promise = provider.registerContract(contractParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContract'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContract'>;
       expect(sentRequest).toEqual({
         jsonrpc: '2.0',
         id: expect.any(String),
@@ -208,10 +257,16 @@ describe('AztecChainProvider', () => {
     it('throws on invalid response', async () => {
       const promise = provider.registerContract(contractParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContract'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContract'>;
 
       // Simulate error response
       await provider.receiveMessage({
@@ -232,10 +287,16 @@ describe('AztecChainProvider', () => {
     it('succeeds on valid response', async () => {
       const promise = provider.registerContractClass(classParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContractClass'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContractClass'>;
       expect(sentRequest).toEqual({
         jsonrpc: '2.0',
         id: expect.any(String),
@@ -256,10 +317,16 @@ describe('AztecChainProvider', () => {
     it('throws on invalid response', async () => {
       const promise = provider.registerContractClass(classParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContractClass'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerContractClass'>;
 
       // Simulate error response
       await provider.receiveMessage({
@@ -280,10 +347,16 @@ describe('AztecChainProvider', () => {
     it('succeeds on valid response', async () => {
       const promise = provider.registerSender(senderParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerSender'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerSender'>;
       expect(sentRequest).toEqual({
         jsonrpc: '2.0',
         id: expect.any(String),
@@ -304,10 +377,16 @@ describe('AztecChainProvider', () => {
     it('throws on invalid response', async () => {
       const promise = provider.registerSender(senderParams);
 
+      // Wait for the async operation to complete
+      await Promise.resolve();
+
       // Get the request ID
-      const [[sentRequest]] = mockTransport.send.mock.calls as [
-        [JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerSender'>],
-      ];
+      expect(mockTransport.send).toHaveBeenCalledTimes(1);
+      const firstCall = mockTransport.send.mock.calls[0];
+      if (!firstCall) throw new Error('Expected mock to be called');
+      const request = firstCall[0];
+      if (!request) throw new Error('Expected request to be defined');
+      const sentRequest = request as JSONRPCRequest<AztecWalletMethodMap, 'aztec_registerSender'>;
 
       // Simulate error response
       await provider.receiveMessage({

package/src/contractArtifactCache.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi, beforeEach, type Mock } from 'vitest';
-import type { AztecAddress, ContractArtifact, ContractClassWithId, Wallet } from '@aztec/aztec.js';
+import type { AztecAddress, ContractArtifact, Fr, Wallet } from '@aztec/aztec.js';
+import { randomDeployedContract } from '@aztec/circuit-types';
 import { ContractArtifactCache } from './contractArtifactCache.js';
 import { AztecWalletError } from './errors.js';
 
@@ -7,45 +8,23 @@ describe('ContractArtifactCache', () => {
   let wallet: Wallet;
   let cache: ContractArtifactCache;
   let mockContractAddress: AztecAddress;
-  let mockContractClassId: ContractClassWithId;
+  let mockContractClassId: Fr;
   let mockArtifact: ContractArtifact;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     // 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;
+
+    const { instance, artifact } = await randomDeployedContract();
+
+    mockContractAddress = instance.address;
+    mockContractClassId = instance.contractClassId;
+    mockArtifact = artifact;
 
     // Create mock wallet
     wallet = {
-      getContractInstance: vi.fn(),
-      getContractArtifact: vi.fn(),
+      getContractMetadata: vi.fn(),
+      getContractClassMetadata: vi.fn(),
     } as unknown as Wallet;
 
     // Initialize cache with mock wallet
@@ -64,21 +43,23 @@ describe('ContractArtifactCache', () => {
 
     // Verify: Result is from cache, wallet methods not called
     expect(result).toBe(mockArtifact);
-    expect(wallet.getContractInstance).not.toHaveBeenCalled();
-    expect(wallet.getContractArtifact).not.toHaveBeenCalled();
+    expect(wallet.getContractMetadata).not.toHaveBeenCalled();
+    expect(wallet.getContractClassMetadata).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);
+    (wallet.getContractMetadata as Mock).mockResolvedValue({
+      contractInstance: { contractClassId: mockContractClassId },
+    });
+    (wallet.getContractClassMetadata as Mock).mockResolvedValue({ artifact: 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(wallet.getContractMetadata).toHaveBeenCalledWith(mockContractAddress);
+    expect(wallet.getContractClassMetadata).toHaveBeenCalledWith(mockContractClassId);
     expect(result).toBe(mockArtifact);
 
     // Verify: Result was cached
@@ -89,9 +70,9 @@ describe('ContractArtifactCache', () => {
     ).toBe(mockArtifact);
   });
 
-  it('throws error if contract instance not found', async () => {
+  it('throws error if contract metadata not found', async () => {
     // Setup: Mock contract instance not found
-    (wallet.getContractInstance as Mock).mockResolvedValue(null);
+    (wallet.getContractMetadata as Mock).mockResolvedValue({ contractInstance: undefined });
 
     // Test & Verify: Expect error
     await expect(cache.getContractArtifact(mockContractAddress)).rejects.toThrow(
@@ -106,10 +87,12 @@ describe('ContractArtifactCache', () => {
     ).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);
+  it('throws error if contract class metadata not found', async () => {
+    // Setup: Mock contract metadata found but class metadata missing
+    (wallet.getContractMetadata as Mock).mockResolvedValue({
+      contractInstance: { contractClassId: mockContractClassId },
+    });
+    (wallet.getContractClassMetadata as Mock).mockResolvedValue({ artifact: undefined });
 
     // Test & Verify: Expect error
     await expect(cache.getContractArtifact(mockContractAddress)).rejects.toThrow(

package/src/contractArtifactCache.ts

@@ -60,16 +60,26 @@ export class ContractArtifactCache {
       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());
-    }
+    try {
+      const contractMetadata = await this.wallet.getContractMetadata(contractAddress);
+      const contract = contractMetadata.contractInstance;
+      if (!contract) {
+        throw new AztecWalletError('contractInstanceNotRegistered', addressStr);
+      }
 
-    this.cache.set(addressStr, artifact);
-    return artifact;
+      const contractClassMetadata = await this.wallet.getContractClassMetadata(contract.contractClassId);
+      const artifact = contractClassMetadata.artifact;
+      if (!artifact) {
+        throw new AztecWalletError('contractClassNotRegistered', contract.contractClassId.toString());
+      }
+      this.cache.set(addressStr, artifact);
+      return artifact;
+    } catch (error) {
+      if (error instanceof AztecWalletError) {
+        throw error;
+      }
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      throw new AztecWalletError('contractInstanceNotRegistered', `${addressStr}: ${errorMessage}`);
+    }
   }
 }

package/src/handlers/aztecAccountWallet.test.ts

@@ -6,7 +6,6 @@ import type {
   ContractInstanceWithAddress,
   ContractArtifact,
   PublicKeys,
-  Note,
   AuthWitness,
   Tx,
 } from '@aztec/aztec.js';
@@ -46,12 +45,8 @@ describe('Aztec Account Wallet Handler', () => {
       createAuthWit: vi.fn(),
       isL1ToL2MessageSynced: vi.fn(),
       getContracts: vi.fn(),
-      getContractInstance: vi.fn(),
-      getContractClass: vi.fn(),
-      getContractArtifact: vi.fn(),
-      isContractClassPubliclyRegistered: vi.fn(),
-      isContractPubliclyDeployed: vi.fn(),
-      isContractInitialized: vi.fn(),
+      getContractMetadata: vi.fn(),
+      getContractClassMetadata: vi.fn(),
       registerContract: vi.fn(),
       registerContractClass: vi.fn(),
       getPublicStorageAt: vi.fn(),
@@ -255,91 +250,22 @@ describe('Aztec Account Wallet Handler', () => {
   });
 
   describe('Contract Methods', () => {
-    it('handles aztec_getContractInstance', async () => {
+    it('handles aztec_getContractMetadata', async () => {
       const mockAddress = await AztecAddress.random();
-      const mockInstance = {
-        address: mockAddress,
-        toString: () => mockAddress.toString(),
-      } as unknown as ContractInstanceWithAddress;
-      wallet.getContractInstance = vi.fn().mockResolvedValue(mockInstance);
-
-      const result = await aztecWalletHandler(context, 'aztec_getContractInstance', { address: mockAddress });
-      expect(result).toBe(mockInstance);
-    });
-
-    it('throws error when contract instance not found', async () => {
-      wallet.getContractInstance = vi.fn().mockResolvedValue(null);
-
-      const testAddress = await AztecAddress.random();
-      await expect(
-        aztecWalletHandler(context, 'aztec_getContractInstance', { address: testAddress }),
-      ).rejects.toThrow(AztecWalletError);
-    });
-
-    it('handles aztec_getContractClass', async () => {
-      const mockId = await Fr.random();
-      const mockContractClass = { id: mockId };
-      wallet.getContractClass = vi.fn().mockResolvedValue(mockContractClass);
-
-      const result = await aztecWalletHandler(context, 'aztec_getContractClass', { id: mockId });
-      expect(result).toBe(mockContractClass);
-    });
-
-    it('throws error when contract class not found', async () => {
-      wallet.getContractClass = vi.fn().mockResolvedValue(null);
-      const mockId = await Fr.random();
-
-      await expect(aztecWalletHandler(context, 'aztec_getContractClass', { id: mockId })).rejects.toThrow(
-        AztecWalletError,
-      );
-    });
-
-    it('handles aztec_getContractArtifact', async () => {
-      const mockId = await Fr.random();
-      const mockArtifact = { id: mockId, name: 'TestContract' };
-      wallet.getContractArtifact = vi.fn().mockResolvedValue(mockArtifact);
+      const mockMetadata = { address: mockAddress };
+      wallet.getContractMetadata = vi.fn().mockResolvedValue(mockMetadata);
 
-      const result = await aztecWalletHandler(context, 'aztec_getContractArtifact', { id: mockId });
-      expect(result).toBe(mockArtifact);
+      const result = await aztecWalletHandler(context, 'aztec_getContractMetadata', { address: mockAddress });
+      expect(result).toBe(mockMetadata);
     });
 
-    it('throws error when contract artifact not found', async () => {
-      wallet.getContractArtifact = vi.fn().mockResolvedValue(null);
+    it('handles aztec_getContractClassMetadata', async () => {
       const mockId = await Fr.random();
+      const mockMetadata = { id: mockId };
+      wallet.getContractClassMetadata = vi.fn().mockResolvedValue(mockMetadata);
 
-      await expect(aztecWalletHandler(context, 'aztec_getContractArtifact', { id: mockId })).rejects.toThrow(
-        AztecWalletError,
-      );
-    });
-
-    it('handles aztec_isContractClassPubliclyRegistered', async () => {
-      const mockId = await Fr.random();
-      wallet.isContractClassPubliclyRegistered = vi.fn().mockResolvedValue(true);
-
-      const result = await aztecWalletHandler(context, 'aztec_isContractClassPubliclyRegistered', {
-        id: mockId,
-      });
-      expect(result).toBe(true);
-    });
-
-    it('handles aztec_isContractPubliclyDeployed', async () => {
-      const mockAddress = await AztecAddress.random();
-      wallet.isContractPubliclyDeployed = vi.fn().mockResolvedValue(true);
-
-      const result = await aztecWalletHandler(context, 'aztec_isContractPubliclyDeployed', {
-        address: mockAddress,
-      });
-      expect(result).toBe(true);
-    });
-
-    it('handles aztec_isContractInitialized', async () => {
-      const mockAddress = await AztecAddress.random();
-      wallet.isContractInitialized = vi.fn().mockResolvedValue(true);
-
-      const result = await aztecWalletHandler(context, 'aztec_isContractInitialized', {
-        address: mockAddress,
-      });
-      expect(result).toBe(true);
+      const result = await aztecWalletHandler(context, 'aztec_getContractClassMetadata', { id: mockId });
+      expect(result).toBe(mockMetadata);
     });
 
     it('handles aztec_registerContract', async () => {