@walletmesh/aztec-rpc-wallet 0.3.1 → 0.4.0

package/src/serializers/contract.ts

@@ -1,183 +0,0 @@
-import type { AztecWalletMethodMap } from '../types.js';
-import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
-import { ContractClassWithIdSchema, ContractInstanceWithAddressSchema } from '@aztec/circuits.js';
-import { ContractArtifactSchema } from '@aztec/foundation/abi';
-import { AztecAddress, Fr } from '@aztec/aztec.js';
-import { jsonStringify, jsonParseWithSchema } from '@aztec/foundation/json-rpc';
-import type { ZodFor } from '@aztec/foundation/schemas';
-import type { ContractMetadata, ContractClassMetadata } from '@aztec/circuit-types';
-import { z } from 'zod';
-
-// Zod schemas for contract metadata serialization.
-// These are copied from @aztec/circuit-types because they are not exported.
-const ContractMetadataSchema = z.object({
-  contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
-  isContractInitialized: z.boolean(),
-  isContractPubliclyDeployed: z.boolean(),
-}) satisfies ZodFor<ContractMetadata>;
-
-const ContractClassMetadataSchema = z.object({
-  contractClass: z.union([ContractClassWithIdSchema, z.undefined()]),
-  isContractClassPubliclyRegistered: z.boolean(),
-  artifact: z.union([ContractArtifactSchema, z.undefined()]),
-}) satisfies ZodFor<ContractClassMetadata>;
-
-/**
- * Serializer for the aztec_getContractClassMetadata RPC method.
- * Handles serialization of contract class metadata queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetContractClassMetadataSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getContractClassMetadata']['params'],
-      AztecWalletMethodMap['aztec_getContractClassMetadata']['result']
-    >
-{
-  params = {
-    /**
-     * Serializes contract class metadata query parameters for RPC transport.
-     * @param method - The RPC method name
-     * @param value - The parameters containing the class ID and artifact inclusion flag
-     * @returns Serialized query parameters
-     */
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getContractClassMetadata']['params'],
-    ): Promise<JSONRPCSerializedData> =>
-      Promise.resolve({
-        method,
-        serialized: JSON.stringify({
-          id: value.id.toString(),
-          includeArtifact: value.includeArtifact,
-        }),
-      }),
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getContractClassMetadata']['params']> => {
-      const { id, includeArtifact } = JSON.parse(data.serialized);
-      return {
-        id: Fr.fromString(id),
-        includeArtifact,
-      };
-    },
-  };
-  result = {
-    /**
-     * Serializes the contract class metadata query result.
-     * @param method - The RPC method name
-     * @param value - The contract class metadata including class definition and registration status
-     * @returns Serialized contract class metadata
-     */
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getContractClassMetadata']['result'],
-    ): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(value),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getContractClassMetadata']['result']> => {
-      return await jsonParseWithSchema(data.serialized, ContractClassMetadataSchema);
-    },
-  };
-}
-
-export class AztecGetContractMetadataSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getContractMetadata']['params'],
-      AztecWalletMethodMap['aztec_getContractMetadata']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getContractMetadata']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(value.address),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getContractMetadata']['params']> => {
-      return {
-        address: await jsonParseWithSchema(data.serialized, AztecAddress.schema),
-      };
-    },
-  };
-
-  result = {
-    serialize: async (
-      method: string,
-      contractMetadata: AztecWalletMethodMap['aztec_getContractMetadata']['result'],
-    ): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(contractMetadata),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getContractMetadata']['result']> => {
-      return await jsonParseWithSchema(data.serialized, ContractMetadataSchema);
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_registerContract RPC method.
- * Handles serialization of contract registration requests between JSON-RPC format and native Aztec types.
- */
-export class AztecRegisterContractSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_registerContract']['params'],
-      AztecWalletMethodMap['aztec_registerContract']['result']
-    >
-{
-  params = {
-    /**
-     * Serializes contract registration parameters for RPC transport.
-     * @param method - The RPC method name
-     * @param value - The parameters containing contract instance and optional artifact
-     * @returns Serialized registration data
-     */
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_registerContract']['params'],
-    ): Promise<JSONRPCSerializedData> => ({
-      method,
-      serialized: JSON.stringify({
-        instance: jsonStringify(value.instance),
-        artifact: value.artifact ? jsonStringify(value.artifact) : undefined,
-      }),
-    }),
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_registerContract']['params']> => {
-      const { instance, artifact } = JSON.parse(data.serialized);
-      return {
-        instance: await jsonParseWithSchema(instance, ContractInstanceWithAddressSchema),
-        artifact: artifact ? await jsonParseWithSchema(artifact, ContractArtifactSchema) : undefined,
-      };
-    },
-  };
-}
-
-/**
- * Pre-instantiated serializer instances for Aztec contract-related RPC methods.
- * These instances can be used directly by the RPC handler implementation.
- */
-export const aztecRegisterContractSerializer = new AztecRegisterContractSerializer();
-export const aztecGetContractClassMetadataSerializer = new AztecGetContractClassMetadataSerializer();
-export const aztecGetContractMetadataSerializer = new AztecGetContractMetadataSerializer();

package/src/serializers/index.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it, beforeEach } from 'vitest';
-import { AztecWalletSerializer } from './index.js';
-import { AztecAddress, Tx } from '@aztec/aztec.js';
-import type { JSONRPCSerializer } from '@walletmesh/jsonrpc';
-import type { AztecWalletMethodMap } from '../types.js';
-
-describe('AztecWalletSerializer', () => {
-  // Test known method (using aztec_setScopes as an example)
-  const knownMethod = 'aztec_setScopes';
-
-  // Test unknown method
-  const unknownMethod = 'unknown_method';
-
-  // Type assertion since we verify result exists in beforeEach
-  const resultSerializer = (AztecWalletSerializer as Required<JSONRPCSerializer<unknown, unknown>>).result;
-
-  describe('params', () => {
-    it('should serialize params for known methods', async () => {
-      const params = { scopes: [await AztecAddress.random()] };
-      const result = await AztecWalletSerializer.params.serialize(knownMethod, params);
-      expect(result).toBeDefined();
-      expect(result.method).toBe(knownMethod);
-      expect(typeof result.serialized).toBe('string');
-    });
-
-    it('should wrap unknown method params in JSONRPCSerializedData format', async () => {
-      const params = { someParam: 'value' };
-      const result = await AztecWalletSerializer.params.serialize(unknownMethod, params);
-      expect(result).toBeDefined();
-      expect(result.method).toBe(unknownMethod);
-      expect(typeof result.serialized).toBe('string');
-    });
-
-    it('should pass through serialized data for unknown methods', async () => {
-      const serializedData = { serialized: 'base64data', method: unknownMethod };
-      const result = await AztecWalletSerializer.params.deserialize(unknownMethod, serializedData);
-      expect(result).toEqual(serializedData);
-    });
-
-    it('should throw error when params serializer fails', async () => {
-      const params = { scopes: undefined }; // Invalid - scopes must be an array
-      await expect(AztecWalletSerializer.params.serialize(knownMethod, params)).rejects.toThrow(
-        /Failed to serialize params/,
-      );
-    });
-
-    it('should throw error when params deserializer fails', async () => {
-      const serializedData = { serialized: 'invalid-data', method: knownMethod };
-      await expect(AztecWalletSerializer.params.deserialize(knownMethod, serializedData)).rejects.toThrow(
-        /Failed to deserialize params/,
-      );
-    });
-  });
-
-  describe('result', () => {
-    beforeEach(() => {
-      // Ensure result serializer exists
-      expect(resultSerializer).toBeDefined();
-    });
-
-    it('should serialize result for known methods', async () => {
-      const value = true;
-      const result = await resultSerializer.serialize(knownMethod, value);
-      expect(result).toBeDefined();
-      expect(result.method).toBe(knownMethod);
-      expect(typeof result.serialized).toBe('string');
-    });
-
-    it('should wrap unknown method result in JSONRPCSerializedData format', async () => {
-      const testResult = { someResult: 'value' };
-      const result = await resultSerializer.serialize(unknownMethod, testResult);
-      expect(result).toBeDefined();
-      expect(result.method).toBe(unknownMethod);
-      expect(typeof result.serialized).toBe('string');
-    });
-
-    it('should pass through serialized data for unknown methods', async () => {
-      const serializedData = { serialized: 'base64data', method: unknownMethod };
-      const result = await resultSerializer.deserialize(unknownMethod, serializedData);
-      expect(result).toEqual(serializedData);
-    });
-
-    it('should throw error when result serializer fails', async () => {
-      interface CircularRef {
-        ref: CircularRef | null;
-      }
-      const circular: CircularRef = { ref: null };
-      circular.ref = circular; // Create circular reference which can't be JSON stringified
-      await expect(resultSerializer.serialize(knownMethod, circular)).rejects.toThrow(
-        /Failed to serialize result/,
-      );
-    });
-
-    it('should throw error when result deserializer fails', async () => {
-      const serializedData = { serialized: 'invalid-data', method: knownMethod };
-      await expect(resultSerializer.deserialize(knownMethod, serializedData)).rejects.toThrow(
-        /Failed to deserialize result/,
-      );
-    });
-  });
-
-  describe('integration', () => {
-    it('should handle contract methods', async () => {
-      const method = 'aztec_getContractMetadata';
-      const params = { address: await AztecAddress.random() };
-
-      const serializedParams = await AztecWalletSerializer.params.serialize(method, params);
-      expect(serializedParams).toBeDefined();
-      expect(serializedParams.method).toBe(method);
-      expect(typeof serializedParams.serialized).toBe('string');
-
-      const deserializedParams = (await AztecWalletSerializer.params.deserialize(
-        method,
-        serializedParams,
-      )) as AztecWalletMethodMap['aztec_getContractMetadata']['params'];
-      expect(deserializedParams.address.toString()).toBe(params.address.toString());
-    });
-
-    it('should handle transaction methods', async () => {
-      const method = 'aztec_sendTx';
-      const tx = await Tx.random();
-      const params = { tx };
-
-      const serializedParams = await AztecWalletSerializer.params.serialize(method, params);
-      expect(serializedParams).toBeDefined();
-      expect(serializedParams.method).toBe(method);
-      expect(typeof serializedParams.serialized).toBe('string');
-
-      const deserializedParams = (await AztecWalletSerializer.params.deserialize(
-        method,
-        serializedParams,
-      )) as AztecWalletMethodMap['aztec_sendTx']['params'];
-      expect(deserializedParams.tx.toBuffer().toString('hex')).toBe(tx.toBuffer().toString('hex'));
-    });
-  });
-});

package/src/serializers/index.ts

@@ -1,191 +0,0 @@
-import type { AztecWalletMethodMap } from '../types.js';
-import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
-
-/**
- * Re-export all serializer types and implementations.
- * This provides a single entry point for importing any serializer functionality.
- */
-export * from './account.js';
-export * from './contract.js';
-export * from './transaction.js';
-export * from './note.js';
-export * from './log.js';
-
-// Import all serializer instances
-import {
-  aztecSetScopesSerializer,
-  aztecRegisterAccountSerializer,
-  aztecAddAuthWitnessSerializer,
-  aztecGetAuthWitnessSerializer,
-} from './account.js';
-import {
-  aztecGetContractMetadataSerializer,
-  aztecGetContractClassMetadataSerializer,
-  aztecRegisterContractSerializer,
-} from './contract.js';
-import {
-  aztecCreateTxExecutionRequestSerializer,
-  aztecProveTxSerializer,
-  aztecSendTxSerializer,
-  aztecGetTxReceiptSerializer,
-  aztecGetTxEffectSerializer,
-  aztecSimulateTxSerializer,
-} from './transaction.js';
-import { aztecGetNotesSerializer, aztecAddNoteSerializer, aztecAddNullifiedNoteSerializer } from './note.js';
-import {
-  aztecGetPublicLogsSerializer,
-  aztecGetContractClassLogsSerializer,
-  aztecGetPrivateEventsSerializer,
-  aztecGetPublicEventsSerializer,
-} from './log.js';
-
-/**
- * Type alias for Aztec RPC method names.
- * Represents all available methods in the Aztec wallet RPC interface.
- */
-type AztecMethodName = keyof AztecWalletMethodMap;
-
-/**
- * Registry of all available method serializers.
- * Maps each RPC method name to its corresponding serializer implementation.
- * This mapping is used by the main AztecWalletSerializer to route method calls
- * to the appropriate specialized serializer.
- */
-const methodSerializers: Record<AztecMethodName, JSONRPCSerializer<unknown, unknown>> = {
-  // Account methods
-  aztec_setScopes: aztecSetScopesSerializer,
-  aztec_registerAccount: aztecRegisterAccountSerializer,
-  aztec_addAuthWitness: aztecAddAuthWitnessSerializer,
-  aztec_getAuthWitness: aztecGetAuthWitnessSerializer,
-
-  // Contract methods
-  aztec_getContractMetadata: aztecGetContractMetadataSerializer,
-  aztec_getContractClassMetadata: aztecGetContractClassMetadataSerializer,
-  aztec_registerContract: aztecRegisterContractSerializer,
-
-  // Transaction methods
-  aztec_createTxExecutionRequest: aztecCreateTxExecutionRequestSerializer,
-  aztec_proveTx: aztecProveTxSerializer,
-  aztec_sendTx: aztecSendTxSerializer,
-  aztec_getTxReceipt: aztecGetTxReceiptSerializer,
-  aztec_getTxEffect: aztecGetTxEffectSerializer,
-  aztec_simulateTx: aztecSimulateTxSerializer,
-
-  // Note methods
-  aztec_getNotes: aztecGetNotesSerializer,
-  aztec_addNote: aztecAddNoteSerializer,
-  aztec_addNullifiedNote: aztecAddNullifiedNoteSerializer,
-
-  // Log methods
-  aztec_getPublicLogs: aztecGetPublicLogsSerializer,
-  aztec_getContractClassLogs: aztecGetContractClassLogsSerializer,
-  aztec_getPrivateEvents: aztecGetPrivateEventsSerializer,
-  aztec_getPublicEvents: aztecGetPublicEventsSerializer,
-};
-
-/**
- * Helper function to wrap unknown values in a standard JSON-RPC format.
- * Used as a fallback when no specific serializer is available for a method.
- *
- * @param method - The RPC method name
- * @param value - The value to wrap
- * @returns Standardized JSON-RPC data structure
- */
-async function wrapUnknownValue(method: string, value: unknown): Promise<JSONRPCSerializedData> {
-  return Promise.resolve({
-    method,
-    serialized: JSON.stringify(value),
-  });
-}
-
-/**
- * Main serializer for the Aztec wallet RPC interface.
- * Provides a unified interface for serializing all supported RPC methods.
- *
- * This serializer:
- * 1. Routes each method call to its specialized serializer from methodSerializers
- * 2. Provides fallback handling for unknown methods
- * 3. Wraps all serialization operations in proper error handling
- */
-export const AztecWalletSerializer: JSONRPCSerializer<unknown, unknown> = {
-  params: {
-    /**
-     * Serializes RPC method parameters using the appropriate method serializer.
-     * @param method - The RPC method name
-     * @param value - The parameters to serialize
-     * @returns Serialized parameter data
-     * @throws If serialization fails or encounters an error
-     */
-    serialize: async (method: string, value: unknown): Promise<JSONRPCSerializedData> => {
-      const serializer = methodSerializers[method as AztecMethodName];
-      if (!serializer?.params) {
-        return wrapUnknownValue(method, value);
-      }
-
-      try {
-        return await serializer.params.serialize(method, value);
-      } catch (error) {
-        throw new Error(`Failed to serialize params for method ${method}: ${error}`);
-      }
-    },
-    /**
-     * Deserializes RPC method parameters using the appropriate method serializer.
-     * @param method - The RPC method name
-     * @param data - The serialized parameter data
-     * @returns Deserialized parameters
-     * @throws If deserialization fails or encounters an error
-     */
-    deserialize: async (method: string, data: JSONRPCSerializedData): Promise<unknown> => {
-      const serializer = methodSerializers[method as AztecMethodName];
-      if (!serializer?.params) {
-        return data;
-      }
-
-      try {
-        return await serializer.params.deserialize(method, data);
-      } catch (error) {
-        throw new Error(`Failed to deserialize params for method ${method}: ${error}`);
-      }
-    },
-  },
-  result: {
-    /**
-     * Serializes RPC method results using the appropriate method serializer.
-     * @param method - The RPC method name
-     * @param value - The result to serialize
-     * @returns Serialized result data
-     * @throws If serialization fails or encounters an error
-     */
-    serialize: async (method: string, value: unknown): Promise<JSONRPCSerializedData> => {
-      const serializer = methodSerializers[method as AztecMethodName];
-      if (!serializer?.result) {
-        return wrapUnknownValue(method, value);
-      }
-
-      try {
-        return await serializer.result.serialize(method, value);
-      } catch (error) {
-        throw new Error(`Failed to serialize result for method ${method}: ${error}`);
-      }
-    },
-    /**
-     * Deserializes RPC method results using the appropriate method serializer.
-     * @param method - The RPC method name
-     * @param data - The serialized result data
-     * @returns Deserialized result
-     * @throws If deserialization fails or encounters an error
-     */
-    deserialize: async (method: string, data: JSONRPCSerializedData): Promise<unknown> => {
-      const serializer = methodSerializers[method as AztecMethodName];
-      if (!serializer?.result) {
-        return data;
-      }
-
-      try {
-        return await serializer.result.deserialize(method, data);
-      } catch (error) {
-        throw new Error(`Failed to deserialize result for method ${method}: ${error}`);
-      }
-    },
-  },
-};