@walletmesh/aztec-rpc-wallet 0.1.0

package/src/provider.ts

@@ -0,0 +1,189 @@
+import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
+import type { RouterEventMap } from '@walletmesh/router';
+import { WalletRouterProvider } from '@walletmesh/router';
+import { AztecWalletError, AztecWalletErrorType } from './errors.js';
+import type { AztecChainId, AztecWalletMethodMap, TransactionParams } from './types.js';
+
+/**
+ * Provider for interacting with multiple Aztec chains through WalletMesh router.
+ *
+ * This class implements the client-side interface for dApps to communicate with Aztec wallets.
+ * It handles:
+ * - Connection management for multiple chains
+ * - Session tracking
+ * - Method calls with proper context
+ * - Event handling for wallet state changes
+ *
+ * @example
+ * ```typescript
+ * // Create provider with transport
+ * const provider = new AztecProvider(transport);
+ *
+ * // Connect to chains
+ * await provider.connect(['aztec:testnet', 'aztec:devnet']);
+ *
+ * // Single operation using convenience method
+ * const address = await provider.getAccount('aztec:testnet');
+ *
+ * // Single operation using chain builder
+ * const txHash = await provider.chain('aztec:testnet')
+ *   .call('aztec_sendTransaction', {
+ *     functionCalls: [{
+ *       contractAddress: "0x...",
+ *       functionName: "transfer",
+ *       args: [recipient, amount]
+ *     }]
+ *   })
+ *   .execute();
+ *
+ * // Multiple operations in one call
+ * const [account, contracts, blockNumber] = await provider
+ *   .chain('aztec:testnet')
+ *   .call('aztec_getAccount')
+ *   .call('aztec_getContracts')
+ *   .call('aztec_getBlockNumber')
+ *   .execute();
+ * ```
+ */
+export class AztecProvider extends WalletRouterProvider {
+  private connectedChains: Set<AztecChainId>;
+  private requestedChains: Set<AztecChainId>;
+
+  constructor(transport: JSONRPCTransport) {
+    super(transport);
+    this.connectedChains = new Set();
+    this.requestedChains = new Set();
+
+    // Bind event handlers
+    this.handleWalletStateChanged = this.handleWalletStateChanged.bind(this);
+    this.handleSessionTerminated = this.handleSessionTerminated.bind(this);
+
+    // Register event handlers
+    this.on('wm_walletStateChanged', this.handleWalletStateChanged);
+    this.on('wm_sessionTerminated', this.handleSessionTerminated);
+  }
+
+  /**
+   * Handles wallet state change events from the router.
+   * Updates the set of connected chains based on account availability.
+   * @param params - Event parameters containing chain ID and changes
+   */
+  private handleWalletStateChanged(params: RouterEventMap['wm_walletStateChanged']): void {
+    const { chainId, changes } = params;
+    const aztecChainId = chainId as AztecChainId;
+
+    // Only handle events for requested chains
+    if (this.requestedChains.has(aztecChainId)) {
+      if (changes.accounts && changes.accounts.length > 0) {
+        this.connectedChains.add(aztecChainId);
+        console.log('Chain connected:', aztecChainId);
+      } else {
+        this.connectedChains.delete(aztecChainId);
+        console.log('Chain disconnected:', aztecChainId);
+      }
+      console.log('Connected chains:', Array.from(this.connectedChains));
+    }
+  }
+
+  /**
+   * Handles session termination events from the router.
+   * Cleans up session state and connected chains.
+   * @param params - Event parameters containing session ID
+   */
+  private handleSessionTerminated(params: RouterEventMap['wm_sessionTerminated']): void {
+    const { sessionId } = params;
+    if (sessionId === this.sessionId) {
+      this.connectedChains.clear();
+      this.requestedChains.clear();
+      console.log('Session terminated, all chains cleared');
+    }
+  }
+
+  /**
+   * Gets the list of currently connected chain IDs.
+   * @returns Array of connected chain IDs
+   */
+  public getSupportedChains(): AztecChainId[] {
+    return Array.from(this.connectedChains);
+  }
+
+  public async getAccount(chainId: AztecChainId): Promise<string> {
+    const result = await this.chain(chainId).call('aztec_getAccount').execute();
+    if (typeof result !== 'string' || !result) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid account address returned');
+    }
+    return result;
+  }
+
+  /**
+   * Sends a transaction to the specified chain.
+   * @param chainId - ID of the chain to send transaction to
+   * @param params - Transaction parameters including function calls and optional auth witnesses
+   * @returns Transaction hash
+   * @throws {AztecWalletError} If transaction fails or response invalid
+   */
+  public async sendTransaction(chainId: AztecChainId, params: TransactionParams): Promise<string> {
+    const result = await this.chain(chainId).call('aztec_sendTransaction', params).execute();
+    if (typeof result !== 'string' || !result) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid transaction hash returned');
+    }
+    return result;
+  }
+
+  /**
+   * Simulates a transaction without submitting it.
+   * @param chainId - ID of the chain to simulate on
+   * @param params - Transaction parameters to simulate
+   * @returns Simulation result
+   * @throws {AztecWalletError} If simulation fails
+   */
+  public async simulateTransaction(
+    chainId: AztecChainId,
+    params: TransactionParams['functionCalls'][0],
+  ): Promise<unknown> {
+    const result = await this.chain(chainId).call('aztec_simulateTransaction', params).execute();
+    if (result === undefined || result === null) {
+      throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid simulation result returned');
+    }
+    return result;
+  }
+
+  /**
+   * Registers a contract instance with the wallet.
+   * @param chainId - ID of the chain where contract is deployed
+   * @param params - Contract registration parameters
+   * @throws {AztecWalletError} If registration fails
+   */
+  public async registerContract(
+    chainId: AztecChainId,
+    params: AztecWalletMethodMap['aztec_registerContract']['params'],
+  ): Promise<void> {
+    await this.chain(chainId).call('aztec_registerContract', params).execute();
+  }
+
+  /**
+   * Registers a contract class with the wallet.
+   * @param chainId - ID of the chain to register on
+   * @param params - Contract class registration parameters
+   * @throws {AztecWalletError} If registration fails
+   */
+  public async registerContractClass(
+    chainId: AztecChainId,
+    params: AztecWalletMethodMap['aztec_registerContractClass']['params'],
+  ): Promise<void> {
+    await this.chain(chainId).call('aztec_registerContractClass', params).execute();
+  }
+
+  /**
+   * Registers a transaction sender with the wallet.
+   * @param chainId - ID of the chain to register on
+   * @param params - Sender registration parameters
+   * @throws {AztecWalletError} If registration fails
+   */
+  public async registerSender(
+    chainId: AztecChainId,
+    params: AztecWalletMethodMap['aztec_registerSender']['params'],
+  ): Promise<void> {
+    await this.chain(chainId).call('aztec_registerSender', params).execute();
+  }
+}

package/src/serializers/account.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest';
+import { Fr, AztecAddress, CompleteAddress, AuthWitness } from '@aztec/aztec.js';
+import {
+  aztecSetScopesSerializer,
+  aztecRegisterAccountSerializer,
+  aztecAddAuthWitnessSerializer,
+  aztecGetAuthWitnessSerializer,
+} from './account.js';
+import { decodeBase64 } from './types.js';
+import { frSerializer } from './core.js';
+
+describe('Account Serializers', () => {
+  describe('aztec_setScopes', () => {
+    const METHOD = 'aztec_setScopes';
+
+    it('should serialize and deserialize params', () => {
+      const scopes = [AztecAddress.random(), AztecAddress.random()];
+      const params = { scopes };
+
+      const serialized = aztecSetScopesSerializer.params.serialize(METHOD, params);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecSetScopesSerializer.params.deserialize(METHOD, serialized);
+      expect(deserialized.scopes.map((s) => s.toString())).toEqual(scopes.map((s) => s.toString()));
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = true;
+
+      const serialized = aztecSetScopesSerializer.result.serialize(METHOD, result);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecSetScopesSerializer.result.deserialize(METHOD, serialized);
+      expect(deserialized).toBe(result);
+    });
+  });
+
+  describe('aztec_registerAccount', () => {
+    const METHOD = 'aztec_registerAccount';
+
+    it('should serialize and deserialize params', () => {
+      const secretKey = Fr.random();
+      const partialAddress = Fr.random();
+      const params = { secretKey, partialAddress };
+
+      const serialized = aztecRegisterAccountSerializer.params.serialize(METHOD, params);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecRegisterAccountSerializer.params.deserialize(METHOD, serialized);
+      expect(deserialized.secretKey.toString()).toBe(secretKey.toString());
+      expect(deserialized.partialAddress.toString()).toBe(partialAddress.toString());
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = CompleteAddress.random();
+
+      const serialized = aztecRegisterAccountSerializer.result.serialize(METHOD, result);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecRegisterAccountSerializer.result.deserialize(METHOD, serialized);
+      expect(deserialized.toString()).toBe(result.toString());
+    });
+  });
+
+  describe('aztec_addAuthWitness', () => {
+    const METHOD = 'aztec_addAuthWitness';
+
+    it('should serialize and deserialize params', () => {
+      const authWitness = AuthWitness.random();
+      const params = { authWitness };
+
+      const serialized = aztecAddAuthWitnessSerializer.params.serialize(METHOD, params);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecAddAuthWitnessSerializer.params.deserialize(METHOD, serialized);
+      expect(deserialized.authWitness.toString()).toBe(authWitness.toString());
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = true;
+
+      const serialized = aztecAddAuthWitnessSerializer.result.serialize(METHOD, result);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecAddAuthWitnessSerializer.result.deserialize(METHOD, serialized);
+      expect(deserialized).toBe(result);
+    });
+  });
+
+  describe('aztec_getAuthWitness', () => {
+    const METHOD = 'aztec_getAuthWitness';
+
+    it('should serialize and deserialize params', () => {
+      const messageHash = Fr.random();
+      const params = { messageHash };
+
+      const serialized = aztecGetAuthWitnessSerializer.params.serialize(METHOD, params);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecGetAuthWitnessSerializer.params.deserialize(METHOD, serialized);
+      expect(deserialized.messageHash.toString()).toBe(messageHash.toString());
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = [Fr.random(), Fr.random()];
+
+      const serialized = aztecGetAuthWitnessSerializer.result.serialize(METHOD, result);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecGetAuthWitnessSerializer.result.deserialize(METHOD, serialized);
+      expect(deserialized.map((w) => w.toString())).toEqual(result.map((w) => w.toString()));
+    });
+  });
+
+  describe('Base64 encoding/decoding', () => {
+    it('should properly encode and decode data', () => {
+      const messageHash = Fr.random();
+      const serialized = aztecGetAuthWitnessSerializer.params.serialize('aztec_getAuthWitness', {
+        messageHash,
+      });
+      const decoded = frSerializer.deserialize(decodeBase64(serialized.serialized));
+      expect(decoded.toString()).toBe(messageHash.toString());
+    });
+  });
+});

package/src/serializers/account.ts

@@ -0,0 +1,319 @@
+import type { AztecWalletMethodMap } from '../types.js';
+import type { JSONRPCSerializedData, JSONRPCSerializer } from './types.js';
+import { encodeBase64, decodeBase64 } from './types.js';
+import {
+  aztecAddressSerializer,
+  completeAddressSerializer,
+  frSerializer,
+  authWitnessSerializer,
+} from './core.js';
+import type { PartialAddress, AztecAddress } from '@aztec/aztec.js';
+
+/**
+ * Serializer for the aztec_setScopes RPC method.
+ * Handles serialization of account scope settings between JSON-RPC format and native Aztec types.
+ * Scopes define which contracts can interact with an account.
+ */
+export class AztecSetScopesSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_setScopes']['params'],
+      AztecWalletMethodMap['aztec_setScopes']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes scope setting parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing an array of Aztec addresses representing scopes
+     * @returns Serialized scope data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_setScopes']['params'],
+    ): JSONRPCSerializedData => {
+      const { scopes } = value;
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify(scopes.map((s: AztecAddress) => aztecAddressSerializer.serialize(s))),
+        ),
+      };
+    },
+    /**
+     * Deserializes scope setting parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized scope data
+     * @returns Deserialized scope parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_setScopes']['params'] => {
+      const scopes = JSON.parse(decodeBase64(data.serialized)).map((s: string) =>
+        aztecAddressSerializer.deserialize(s),
+      );
+      return { scopes };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the scope setting result.
+     * @param method - The RPC method name
+     * @param value - Boolean indicating success of the scope setting operation
+     * @returns Serialized result
+     */
+    serialize: (method: string, value: boolean): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value)),
+      };
+    },
+    /**
+     * Deserializes the scope setting result.
+     * @param method - The RPC method name
+     * @param data - The serialized result data
+     * @returns Boolean indicating success
+     */
+    deserialize: (method: string, data: JSONRPCSerializedData): boolean => {
+      return JSON.parse(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_registerAccount RPC method.
+ * Handles serialization of account registration data between JSON-RPC format and native Aztec types.
+ * Account registration involves creating a new account with a secret key and partial address.
+ */
+export class AztecRegisterAccountSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_registerAccount']['params'],
+      AztecWalletMethodMap['aztec_registerAccount']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes account registration parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing secret key and partial address
+     * @returns Serialized registration data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_registerAccount']['params'],
+    ): JSONRPCSerializedData => {
+      const { secretKey, partialAddress } = value;
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify([
+            frSerializer.serialize(secretKey),
+            frSerializer.serialize(partialAddress as unknown as PartialAddress),
+          ]),
+        ),
+      };
+    },
+    /**
+     * Deserializes account registration parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized registration data
+     * @returns Deserialized registration parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_registerAccount']['params'] => {
+      const [secretKey, partialAddress] = JSON.parse(decodeBase64(data.serialized));
+      return {
+        secretKey: frSerializer.deserialize(secretKey),
+        partialAddress: frSerializer.deserialize(partialAddress) as PartialAddress,
+      };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the account registration result.
+     * @param method - The RPC method name
+     * @param value - The complete address of the registered account
+     * @returns Serialized complete address
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_registerAccount']['result'],
+    ): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(completeAddressSerializer.serialize(value)),
+      };
+    },
+    /**
+     * Deserializes the account registration result.
+     * @param method - The RPC method name
+     * @param data - The serialized complete address
+     * @returns Deserialized complete address
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_registerAccount']['result'] => {
+      return completeAddressSerializer.deserialize(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_addAuthWitness RPC method.
+ * Handles serialization of authentication witness data between JSON-RPC format and native Aztec types.
+ * Auth witnesses are used to prove transaction authorization.
+ */
+export class AztecAddAuthWitnessSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_addAuthWitness']['params'],
+      AztecWalletMethodMap['aztec_addAuthWitness']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes auth witness addition parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing the auth witness to add
+     * @returns Serialized auth witness data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_addAuthWitness']['params'],
+    ): JSONRPCSerializedData => {
+      const { authWitness } = value;
+      return {
+        method,
+        serialized: encodeBase64(authWitnessSerializer.serialize(authWitness)),
+      };
+    },
+    /**
+     * Deserializes auth witness addition parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized auth witness data
+     * @returns Deserialized auth witness parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_addAuthWitness']['params'] => {
+      const authWitness = authWitnessSerializer.deserialize(decodeBase64(data.serialized));
+      return { authWitness };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the auth witness addition result.
+     * @param method - The RPC method name
+     * @param value - Boolean indicating success of the witness addition
+     * @returns Serialized result
+     */
+    serialize: (method: string, value: boolean): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value)),
+      };
+    },
+    /**
+     * Deserializes the auth witness addition result.
+     * @param method - The RPC method name
+     * @param data - The serialized result data
+     * @returns Boolean indicating success
+     */
+    deserialize: (method: string, data: JSONRPCSerializedData): boolean => {
+      return JSON.parse(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_getAuthWitness RPC method.
+ * Handles serialization of authentication witness retrieval between JSON-RPC format and native Aztec types.
+ * Retrieves auth witnesses associated with a specific message hash.
+ */
+export class AztecGetAuthWitnessSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getAuthWitness']['params'],
+      AztecWalletMethodMap['aztec_getAuthWitness']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes auth witness retrieval parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing the message hash to look up
+     * @returns Serialized message hash data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getAuthWitness']['params'],
+    ): JSONRPCSerializedData => {
+      const { messageHash } = value;
+      return {
+        method,
+        serialized: encodeBase64(frSerializer.serialize(messageHash)),
+      };
+    },
+    /**
+     * Deserializes auth witness retrieval parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized message hash data
+     * @returns Deserialized message hash parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getAuthWitness']['params'] => {
+      const messageHash = frSerializer.deserialize(decodeBase64(data.serialized));
+      return { messageHash };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the auth witness retrieval result.
+     * @param method - The RPC method name
+     * @param value - Array of field elements representing auth witnesses
+     * @returns Serialized witness array
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getAuthWitness']['result'],
+    ): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value.map((w) => frSerializer.serialize(w)))),
+      };
+    },
+    /**
+     * Deserializes the auth witness retrieval result.
+     * @param method - The RPC method name
+     * @param data - The serialized witness array data
+     * @returns Array of deserialized field elements
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getAuthWitness']['result'] => {
+      return JSON.parse(decodeBase64(data.serialized)).map((w: string) => frSerializer.deserialize(w));
+    },
+  };
+}
+
+/**
+ * Pre-instantiated serializer instances for Aztec account-related RPC methods.
+ * These instances can be used directly by the RPC handler implementation.
+ */
+export const aztecSetScopesSerializer = new AztecSetScopesSerializer();
+export const aztecRegisterAccountSerializer = new AztecRegisterAccountSerializer();
+export const aztecAddAuthWitnessSerializer = new AztecAddAuthWitnessSerializer();
+export const aztecGetAuthWitnessSerializer = new AztecGetAuthWitnessSerializer();