@walletmesh/aztec-rpc-wallet 0.1.0

package/src/aztecRemoteWallet.test.ts

@@ -0,0 +1,542 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { Fr, getContractClassFromArtifact } from '@aztec/aztec.js';
+import type {
+  AztecAddress,
+  TxExecutionRequest,
+  ContractInstanceWithAddress,
+  ContractClassWithId,
+  ContractArtifact,
+  ExtendedNote,
+  TxHash,
+  L2Block,
+  NodeInfo,
+  Point,
+  LogFilter,
+  TxReceipt,
+  Tx,
+  CompleteAddress,
+  PartialAddress,
+  AuthWitness,
+} from '@aztec/aztec.js';
+import type {
+  GetUnencryptedLogsResponse,
+  PrivateExecutionResult,
+  TxProvingResult,
+  TxSimulationResult,
+  InBlock,
+  TxEffect,
+  EventMetadataDefinition,
+  PXEInfo,
+  IncomingNotesFilter,
+  UniqueNote,
+} from '@aztec/circuit-types';
+import { randomDeployedContract } from '@aztec/circuit-types';
+
+import type { ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
+import type { GasFees } from '@aztec/circuits.js';
+import { AztecRemoteWallet, createAztecRPCWallet } from './aztecRemoteWallet.js';
+import type { AztecProvider } from './provider.js';
+import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
+
+describe('AztecRemoteWallet', () => {
+  let provider: AztecProvider;
+  let wallet: AztecRemoteWallet;
+  let mockChainBuilder: { call: ReturnType<typeof vi.fn>; execute: ReturnType<typeof vi.fn> };
+  const chainId = 'aztec:testnet';
+  const mockAddress = { toString: () => '0x1234' } as unknown as AztecAddress;
+  const mockChainIdFr = Fr.fromString('1');
+  const mockVersionFr = Fr.fromString('1');
+
+  beforeEach(() => {
+    // Mock provider and chain builder
+    mockChainBuilder = {
+      call: vi.fn().mockReturnThis(),
+      execute: vi.fn().mockResolvedValue(undefined),
+    };
+    provider = {
+      chain: vi.fn().mockReturnValue(mockChainBuilder),
+    } as unknown as AztecProvider;
+
+    wallet = new AztecRemoteWallet(provider, chainId);
+  });
+
+  describe('core operations', () => {
+    it('gets address', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockAddress);
+
+      // First call should throw and trigger async load
+      expect(() => wallet.getAddress()).toThrow('Address not yet available');
+
+      // Wait for promise to resolve
+      await new Promise(process.nextTick);
+
+      // Second call should return cached value
+      expect(wallet.getAddress()).toBe(mockAddress);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getAddress');
+    });
+
+    it('gets complete address', async () => {
+      const mockCompleteAddress = { toString: () => '0x1234' } as unknown as CompleteAddress;
+      mockChainBuilder.execute.mockResolvedValueOnce(mockCompleteAddress);
+
+      expect(() => wallet.getCompleteAddress()).toThrow('Complete address not yet available');
+      await new Promise(process.nextTick);
+      expect(wallet.getCompleteAddress()).toBe(mockCompleteAddress);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getCompleteAddress');
+    });
+
+    it('gets chain ID', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockChainIdFr);
+
+      expect(() => wallet.getChainId()).toThrow('Chain ID not yet available');
+      await new Promise(process.nextTick);
+      expect(wallet.getChainId()).toStrictEqual(mockChainIdFr);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getChainId');
+    });
+
+    it('gets version', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockVersionFr);
+
+      expect(() => wallet.getVersion()).toThrow('Version not yet available');
+      await new Promise(process.nextTick);
+      expect(wallet.getVersion()).toStrictEqual(mockVersionFr);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getVersion');
+    });
+
+    it('gets scopes', async () => {
+      const mockScopes = [mockAddress];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockScopes);
+
+      expect(() => wallet.getScopes()).toThrow('Scopes not yet available');
+      await new Promise(process.nextTick);
+      expect(wallet.getScopes()).toBe(mockScopes);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getScopes');
+    });
+
+    it('gets scopes async', async () => {
+      const mockScopes = [mockAddress];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockScopes);
+
+      const result = await wallet.getScopesAsync();
+      expect(result).toBe(mockScopes);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getScopes');
+    });
+
+    it('checks if L1 to L2 message is synced', async () => {
+      const mockL1ToL2Message = Fr.fromString('1');
+      const mockResult = true;
+      mockChainBuilder.execute.mockResolvedValueOnce(mockResult);
+
+      const result = await wallet.isL1ToL2MessageSynced(mockL1ToL2Message);
+      expect(result).toBe(mockResult);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_isL1ToL2MessageSynced', {
+        l1ToL2Message: mockL1ToL2Message,
+      });
+    });
+
+    it('creates tx execution request', async () => {
+      const mockExec = { someParam: 'value' } as unknown as ExecutionRequestInit;
+      const mockRequest = { id: '123' } as unknown as TxExecutionRequest;
+      mockChainBuilder.execute.mockResolvedValueOnce(mockRequest);
+
+      const result = await wallet.createTxExecutionRequest(mockExec);
+      expect(result).toBe(mockRequest);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_createTxExecutionRequest', {
+        exec: mockExec,
+      });
+    });
+
+    it('creates auth wit', async () => {
+      const mockIntent = Fr.fromString('1');
+      const mockAuthWitness = { witness: '0x1234' } as unknown as AuthWitness;
+      mockChainBuilder.execute.mockResolvedValueOnce(mockAuthWitness);
+
+      const result = await wallet.createAuthWit(mockIntent);
+      expect(result).toBe(mockAuthWitness);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_createAuthWit', { intent: mockIntent });
+    });
+
+    it('sets scopes', async () => {
+      const mockScopes = [mockAddress];
+      const mockResult = true;
+      mockChainBuilder.execute.mockResolvedValueOnce(mockResult);
+
+      wallet.setScopes(mockScopes);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_setScopes', { scopes: mockScopes });
+    });
+
+    it('adds capsule', async () => {
+      const mockCapsule = [Fr.fromString('1')];
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+      await wallet.addCapsule(mockCapsule);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_addCapsule', { capsule: mockCapsule });
+    });
+
+    it('registers account', async () => {
+      const mockSecretKey = Fr.fromString('1');
+      const mockPartialAddress = {} as PartialAddress;
+      const mockCompleteAddress = {} as CompleteAddress;
+      mockChainBuilder.execute.mockResolvedValueOnce(mockCompleteAddress);
+
+      const result = await wallet.registerAccount(mockSecretKey, mockPartialAddress);
+      expect(result).toBe(mockCompleteAddress);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_registerAccount', {
+        secretKey: mockSecretKey,
+        partialAddress: mockPartialAddress,
+      });
+    });
+
+    it('gets registered accounts', async () => {
+      const mockAccounts = [{} as CompleteAddress];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockAccounts);
+
+      const result = await wallet.getRegisteredAccounts();
+      expect(result).toBe(mockAccounts);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getRegisteredAccounts');
+    });
+  });
+
+  describe('contract operations', () => {
+    const { instance, artifact } = randomDeployedContract();
+    const contractClass = getContractClassFromArtifact(artifact);
+
+    it('gets contract instance', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(instance);
+
+      const result = await wallet.getContractInstance(instance.address);
+      expect(result).toBe(instance);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getContractInstance', {
+        address: instance.address,
+      });
+    });
+
+    it('gets contract class', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(contractClass);
+
+      const result = await wallet.getContractClass(contractClass.id);
+      expect(result).toBe(contractClass);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getContractClass', { id: contractClass.id });
+    });
+
+    it('gets contract artifact', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(artifact);
+
+      const result = await wallet.getContractArtifact(contractClass.id);
+      expect(result).toBe(artifact);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getContractArtifact', {
+        id: contractClass.id,
+      });
+    });
+
+    it('registers contract', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+      await wallet.registerContract({ instance: instance, artifact: artifact });
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_registerContract', {
+        instance,
+        artifact,
+      });
+    });
+
+    it('registers contract class', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+      await wallet.registerContractClass(artifact);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_registerContractClass', {
+        artifact: artifact,
+      });
+    });
+
+    it('gets contracts', async () => {
+      const mockContracts = [instance.address];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockContracts);
+
+      const result = await wallet.getContracts();
+      expect(result).toBe(mockContracts);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getContracts');
+    });
+  });
+
+  describe('auth witness operations', () => {
+    const mockAuthWitness = { witness: '0x1234' } as unknown as AuthWitness;
+    const mockMessageHash = Fr.fromString('1');
+
+    it('adds auth witness', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+      await wallet.addAuthWitness(mockAuthWitness);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_addAuthWitness', {
+        authWitness: mockAuthWitness,
+      });
+    });
+
+    it('gets auth witness', async () => {
+      const mockWitness = [Fr.fromString('1')];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockWitness);
+      const result = await wallet.getAuthWitness(mockMessageHash);
+      expect(result).toBe(mockWitness);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getAuthWitness', {
+        messageHash: mockMessageHash,
+      });
+    });
+  });
+
+  describe('transaction operations', () => {
+    const mockTxRequest = {} as TxExecutionRequest;
+    const mockPrivateExecutionResult = {} as PrivateExecutionResult;
+    const mockTxHash = {} as TxHash;
+    const mockTx = {} as Tx;
+    const mockTxEffect = {} as InBlock<TxEffect>;
+    const mockTxReceipt = {} as TxReceipt;
+    const mockSimulationResult = {} as TxSimulationResult;
+    const mockProvingResult = {} as TxProvingResult;
+
+    it('simulates tx', async () => {
+      const mockScopes = [mockAddress];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockScopes).mockResolvedValueOnce(mockSimulationResult);
+
+      const result = await wallet.simulateTx(mockTxRequest, true);
+      expect(result).toBe(mockSimulationResult);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_simulateTx', {
+        txRequest: mockTxRequest,
+        simulatePublic: true,
+        msgSender: undefined,
+        skipTxValidation: undefined,
+        enforceFeePayment: undefined,
+        profile: undefined,
+      });
+    });
+
+    it('proves tx', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockProvingResult);
+
+      const result = await wallet.proveTx(mockTxRequest, mockPrivateExecutionResult);
+      expect(result).toBe(mockProvingResult);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_proveTx', {
+        txRequest: mockTxRequest,
+        privateExecutionResult: mockPrivateExecutionResult,
+      });
+    });
+
+    it('sends tx', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockTxHash);
+
+      const result = await wallet.sendTx(mockTx);
+      expect(result).toBe(mockTxHash);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_sendTx', { tx: mockTx });
+    });
+
+    it('gets tx effect', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockTxEffect);
+
+      const result = await wallet.getTxEffect(mockTxHash);
+      expect(result).toBe(mockTxEffect);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getTxEffect', { txHash: mockTxHash });
+    });
+
+    it('gets tx receipt', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockTxReceipt);
+
+      const result = await wallet.getTxReceipt(mockTxHash);
+      expect(result).toBe(mockTxReceipt);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getTxReceipt', { txHash: mockTxHash });
+    });
+  });
+
+  describe('storage and block operations', () => {
+    const mockStorageSlot = Fr.fromString('1');
+    const mockStorageValue = Fr.fromString('2');
+    const mockBlock = {} as L2Block;
+    const mockGasFees = {} as GasFees;
+    const mockBlockNumber = 123;
+
+    it('gets public storage at', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockStorageValue);
+
+      const result = await wallet.getPublicStorageAt(mockAddress, mockStorageSlot);
+      expect(result).toBe(mockStorageValue);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getPublicStorageAt', {
+        contract: mockAddress,
+        storageSlot: mockStorageSlot,
+      });
+    });
+
+    it('gets block', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockBlock);
+
+      const result = await wallet.getBlock(mockBlockNumber);
+      expect(result).toBe(mockBlock);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getBlock', { number: mockBlockNumber });
+    });
+
+    it('gets current base fees', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockGasFees);
+
+      const result = await wallet.getCurrentBaseFees();
+      expect(result).toBe(mockGasFees);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getCurrentBaseFees');
+    });
+
+    it('gets block number', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockBlockNumber);
+
+      const result = await wallet.getBlockNumber();
+      expect(result).toBe(mockBlockNumber);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getBlockNumber');
+    });
+
+    it('gets proven block number', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(mockBlockNumber);
+
+      const result = await wallet.getProvenBlockNumber();
+      expect(result).toBe(mockBlockNumber);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getProvenBlockNumber');
+    });
+  });
+
+  describe('contract verification operations', () => {
+    it('checks if contract class is publicly registered', async () => {
+      const mockId = Fr.fromString('1');
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+
+      const result = await wallet.isContractClassPubliclyRegistered(mockId);
+      expect(result).toBe(true);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_isContractClassPubliclyRegistered', {
+        id: mockId,
+      });
+    });
+
+    it('checks if contract is publicly deployed', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+
+      const result = await wallet.isContractPubliclyDeployed(mockAddress);
+      expect(result).toBe(true);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_isContractPubliclyDeployed', {
+        address: mockAddress,
+      });
+    });
+
+    it('checks if contract is initialized', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+
+      const result = await wallet.isContractInitialized(mockAddress);
+      expect(result).toBe(true);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_isContractInitialized', {
+        address: mockAddress,
+      });
+    });
+  });
+
+  describe('PXE operations', () => {
+    it('gets PXE info', async () => {
+      const mockInfo = { version: '1.0.0' } as unknown as PXEInfo;
+      mockChainBuilder.execute.mockResolvedValueOnce(mockInfo);
+      const result = await wallet.getPXEInfo();
+      expect(result).toBe(mockInfo);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getPXEInfo');
+    });
+  });
+
+  describe('note operations', () => {
+    const mockNote = {} as ExtendedNote;
+    const mockFilter = {} as IncomingNotesFilter;
+
+    it('adds note', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+      await wallet.addNote(mockNote);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_addNote', { note: mockNote });
+    });
+
+    it('adds nullified note', async () => {
+      mockChainBuilder.execute.mockResolvedValueOnce(true);
+      await wallet.addNullifiedNote(mockNote);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_addNullifiedNote', { note: mockNote });
+    });
+
+    it('gets incoming notes', async () => {
+      const mockNotes = [{}] as UniqueNote[];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockNotes);
+      const result = await wallet.getIncomingNotes(mockFilter);
+      expect(result).toBe(mockNotes);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getIncomingNotes', { filter: mockFilter });
+    });
+  });
+
+  describe('event operations', () => {
+    const mockEvent = {
+      eventSelector: Fr.fromString('1') as unknown as Fr & { _branding: 'EventSelector' },
+      abiType: 'array',
+      fieldNames: ['field1', 'field2'],
+    } as unknown as EventMetadataDefinition;
+    const mockVpks = [{}] as Point[];
+    const mockCompleteAddress = { publicKeys: { masterIncomingViewingPublicKey: {} } } as CompleteAddress;
+
+    it('gets encrypted events with default vpks', async () => {
+      const mockEvents = [{ data: '0x1234' }];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockCompleteAddress).mockResolvedValueOnce(mockEvents);
+
+      // Initialize complete address
+      try {
+        wallet.getCompleteAddress();
+      } catch (e) {
+        // Expected error
+      }
+
+      // Wait for promise to resolve
+      await new Promise(process.nextTick);
+
+      const result = await wallet.getEncryptedEvents(mockEvent, 0, 10);
+      expect(result).toBe(mockEvents);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getEncryptedEvents', {
+        event: mockEvent,
+        from: 0,
+        limit: 10,
+        vpks: [mockCompleteAddress.publicKeys.masterIncomingViewingPublicKey],
+      });
+    });
+
+    it('gets encrypted events with custom vpks', async () => {
+      const mockEvents = [{ data: '0x1234' }];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockCompleteAddress).mockResolvedValueOnce(mockEvents);
+
+      // Initialize complete address
+      try {
+        wallet.getCompleteAddress();
+      } catch (e) {
+        // Expected error
+      }
+
+      // Wait for promise to resolve
+      await new Promise(process.nextTick);
+
+      const result = await wallet.getEncryptedEvents(mockEvent, 0, 10, mockVpks);
+      expect(result).toBe(mockEvents);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getEncryptedEvents', {
+        event: mockEvent,
+        from: 0,
+        limit: 10,
+        vpks: mockVpks,
+      });
+    });
+
+    it('gets unencrypted events', async () => {
+      const mockEvents = [{ data: '0x1234' }];
+      mockChainBuilder.execute.mockResolvedValueOnce(mockEvents);
+      const result = await wallet.getUnencryptedEvents(mockEvent, 0, 10);
+      expect(result).toBe(mockEvents);
+      expect(mockChainBuilder.call).toHaveBeenCalledWith('aztec_getUnencryptedEvents', {
+        event: mockEvent,
+        from: 0,
+        limit: 10,
+      });
+    });
+  });
+});
+
+describe('createAztecRPCWallet', () => {
+  it('creates wallet instance with transport and chain ID', () => {
+    const transport = {} as JSONRPCTransport;
+    const chainId = 'aztec:testnet';
+
+    const wallet = createAztecRPCWallet(transport, chainId);
+
+    expect(wallet).toBeInstanceOf(AztecRemoteWallet);
+  });
+});