@walletmesh/aztec-rpc-wallet 0.1.0

package/src/serializers/contract-utils.ts

@@ -0,0 +1,104 @@
+import type { ContractClassWithId, PrivateFunction, PublicFunction } from '@aztec/circuits.js';
+import { type ContractArtifact, type FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/aztec.js';
+
+/**
+ * Serializes a ContractClassWithId instance to a JSON string.
+ * Handles the conversion of complex Aztec types (Fr, Buffer, FunctionSelector) to their string representations.
+ *
+ * The serialization process handles the following contract components:
+ * - version: Contract class version number
+ * - artifactHash: Fr value representing the hash of the contract artifact
+ * - privateFunctions: Array of private function definitions with selectors and VK hashes
+ * - publicFunctions: Array of public function definitions with selectors and bytecode
+ * - packedBytecode: Buffer containing the contract's packed bytecode
+ * - id: Fr value representing the contract class ID
+ *
+ * @param contract - The contract class with ID to serialize
+ * @returns JSON string representation of the contract class
+ * @throws If any contract components cannot be properly serialized
+ */
+export function serializeContractClassWithId(contract: ContractClassWithId): string {
+  return JSON.stringify(contract, (key, value) => {
+    let result = value;
+    switch (key) {
+      case 'version':
+        result = value;
+        break;
+      case 'artifactHash':
+        result = value.toString();
+        break;
+      case 'privateFunctions':
+        result = value.map((fn: PrivateFunction) => ({
+          selector: fn.selector.toString(),
+          vkHash: fn.vkHash.toString(),
+        }));
+        break;
+      case 'publicFunctions':
+        result = value.map((fn: PublicFunction) => ({
+          selector: fn.selector.toString(),
+          bytecode: fn.bytecode.toString('hex'),
+        }));
+        break;
+      case 'packedBytecode':
+        result = value.toString('hex');
+        break;
+      case 'id':
+        result = value.toString();
+        break;
+      default:
+        console.warn(`serializeContractClassWithId: Unknown key: ${key}`);
+        break;
+    }
+    return result;
+  });
+}
+
+/**
+ * Deserializes a JSON string into a ContractClassWithId instance.
+ * Reconstructs complex Aztec types from their string representations.
+ *
+ * The deserialization process handles:
+ * - version: Preserved as-is
+ * - artifactHash: Reconstructed as Fr from hex string
+ * - privateFunctions: Array of functions with:
+ *   * selector: Reconstructed as FunctionSelector
+ *   * vkHash: Reconstructed as Fr
+ * - publicFunctions: Array of functions with:
+ *   * selector: Reconstructed as FunctionSelector
+ *   * bytecode: Reconstructed as Buffer
+ * - packedBytecode: Reconstructed as Buffer from hex string
+ * - id: Reconstructed as Fr from hex string
+ *
+ * @param json - The JSON string to deserialize, previously created by serializeContractClassWithId
+ * @returns Reconstructed ContractClassWithId instance
+ * @throws If the JSON string is malformed or contains invalid data
+ */
+export function deserializeContractClassWithId(json: string): ContractClassWithId {
+  return JSON.parse(json, (key, value) => {
+    switch (key) {
+      case 'version':
+        return value;
+      case 'artifactHash':
+        return Fr.fromHexString(value);
+      case 'privateFunctions':
+        return value.map((fn: { selector: string; vkHash: string }) => ({
+          selector: FunctionSelector.fromString(fn.selector),
+          vkHash: Fr.fromHexString(fn.vkHash),
+        }));
+      case 'publicFunctions':
+        return value.map((fn: { selector: string; bytecode: string }) => ({
+          selector: FunctionSelector.fromString(fn.selector),
+          bytecode: Buffer.from(fn.bytecode, 'hex'),
+        }));
+      case 'packedBytecode':
+        return Buffer.from(value, 'hex');
+      case 'id':
+        return Fr.fromHexString(value);
+      default:
+        console.warn(`deserializeContractClassWithId: Unknown key: ${key}`);
+        break;
+    }
+    return value;
+  });
+}

package/src/serializers/contract.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest';
+import { Fr, AztecAddress } from '@aztec/aztec.js';
+import { Buffer } from 'node:buffer';
+import {
+  aztecGetContractInstanceSerializer,
+  aztecGetContractClassSerializer,
+  aztecGetContractArtifactSerializer,
+  aztecRegisterContractSerializer,
+} from './contract.js';
+import {
+  getContractClassFromArtifact,
+  ContractClassWithIdSchema,
+  ContractInstanceWithAddressSchema,
+  SerializableContractInstance,
+} from '@aztec/circuits.js';
+import {
+  ContractArtifact,
+  ContractArtifactSchema,
+  type FieldLayout,
+  type ContractNote,
+} from '@aztec/foundation/abi';
+import { randomContractArtifact, randomDeployedContract } from '@aztec/circuit-types';
+import { aztecAddressSerializer, frSerializer } from './core.js';
+
+describe('Contract Serializers', () => {
+  describe('aztec_getContractInstance', () => {
+    it('should serialize and deserialize params', () => {
+      const address = AztecAddress.random();
+      const params = { address };
+
+      const serialized = aztecGetContractInstanceSerializer.params.serialize(
+        'aztec_getContractInstance',
+        params,
+      );
+      expect(serialized.method).toBe('aztec_getContractInstance');
+
+      const deserialized = aztecGetContractInstanceSerializer.params.deserialize(
+        'aztec_getContractInstance',
+        serialized,
+      );
+      expect(deserialized.address.toString()).toBe(address.toString());
+    });
+
+    it('should serialize and deserialize result', () => {
+      // Create a contract instance with all required fields
+      const result = SerializableContractInstance.random().withAddress(AztecAddress.random());
+
+      const serialized = aztecGetContractInstanceSerializer.result.serialize(
+        'aztec_getContractInstance',
+        result,
+      );
+      expect(serialized.method).toBe('aztec_getContractInstance');
+
+      const deserialized = aztecGetContractInstanceSerializer.result.deserialize(
+        'aztec_getContractInstance',
+        serialized,
+      );
+      expect(deserialized.address.toString()).toBe(result.address.toString());
+      expect(deserialized.contractClassId.toString()).toBe(result.contractClassId.toString());
+      expect(deserialized.deployer.toString()).toBe(result.deployer.toString());
+      expect(deserialized.salt.toString()).toBe(result.salt.toString());
+      expect(deserialized.version).toBe(result.version);
+    });
+  });
+
+  describe('aztec_getContractClass', () => {
+    it('should serialize and deserialize params', () => {
+      const id = Fr.random();
+      const params = { id };
+
+      const serialized = aztecGetContractClassSerializer.params.serialize('aztec_getContractClass', params);
+      expect(serialized.method).toBe('aztec_getContractClass');
+
+      const deserialized = aztecGetContractClassSerializer.params.deserialize(
+        'aztec_getContractClass',
+        serialized,
+      );
+      expect(deserialized.id.toString()).toBe(id.toString());
+    });
+
+    it('should serialize and deserialize result', () => {
+      const artifact = randomContractArtifact();
+      const result = getContractClassFromArtifact(artifact);
+      const serialized = aztecGetContractClassSerializer.result.serialize('aztec_getContractClass', result);
+      expect(serialized.method).toBe('aztec_getContractClass');
+
+      const deserialized = aztecGetContractClassSerializer.result.deserialize(
+        'aztec_getContractClass',
+        serialized,
+      );
+      expect(deserialized.artifactHash.toString()).toEqual(result.artifactHash.toString());
+      expect(deserialized.id.toString()).toEqual(result.id.toString());
+      expect(deserialized.privateFunctions).toEqual(result.privateFunctions);
+      expect(deserialized.publicFunctions).toEqual(result.publicFunctions);
+      expect(deserialized.packedBytecode).toEqual(result.packedBytecode);
+    });
+  });
+
+  describe('aztec_getContractArtifact', () => {
+    it('should serialize and deserialize params', () => {
+      const id = Fr.random();
+      const serialized = aztecGetContractArtifactSerializer.params.serialize('aztec_getContractArtifact', {
+        id,
+      });
+      expect(serialized.method).toBe('aztec_getContractArtifact');
+
+      const deserialized = aztecGetContractArtifactSerializer.params.deserialize(
+        'aztec_getContractArtifact',
+        serialized,
+      );
+      expect(deserialized.id.toString()).toBe(id.toString());
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = randomContractArtifact();
+      const serialized = aztecGetContractArtifactSerializer.result.serialize(
+        'aztec_getContractArtifact',
+        result,
+      );
+      expect(serialized.method).toBe('aztec_getContractArtifact');
+
+      const deserialized = aztecGetContractArtifactSerializer.result.deserialize(
+        'aztec_getContractArtifact',
+        serialized,
+      );
+      expect(ContractArtifactSchema.parse(deserialized)).toEqual(result);
+    });
+  });
+
+  describe('aztec_registerContract', () => {
+    it('should serialize and deserialize params', () => {
+      const { instance, artifact } = randomDeployedContract();
+      const serialized = aztecRegisterContractSerializer.params.serialize('aztec_registerContract', {
+        instance,
+        artifact,
+      });
+      expect(serialized.method).toBe('aztec_registerContract');
+
+      const deserialized = aztecRegisterContractSerializer.params.deserialize(
+        'aztec_registerContract',
+        serialized,
+      );
+      expect(deserialized.instance.address.toString()).toBe(instance.address.toString());
+      expect(deserialized.instance.contractClassId.toString()).toBe(instance.contractClassId.toString());
+      expect(deserialized.instance.deployer.toString()).toBe(instance.deployer.toString());
+      expect(deserialized.artifact).toEqual(artifact);
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = true;
+
+      const serialized = aztecRegisterContractSerializer.result.serialize('aztec_registerContract', result);
+      expect(serialized.method).toBe('aztec_registerContract');
+
+      const deserialized = aztecRegisterContractSerializer.result.deserialize(
+        'aztec_registerContract',
+        serialized,
+      );
+      expect(deserialized).toBe(result);
+    });
+  });
+});

package/src/serializers/contract.ts

@@ -0,0 +1,350 @@
+import type { AztecWalletMethodMap } from '../types.js';
+import type { JSONRPCSerializedData, JSONRPCSerializer } from './types.js';
+import { encodeBase64, decodeBase64 } from './types.js';
+import { aztecAddressSerializer, frSerializer } from './core.js';
+import { SerializableContractInstance } from '@aztec/circuits.js';
+import { ContractArtifactSchema } from '@aztec/foundation/abi';
+import { serializeContractClassWithId, deserializeContractClassWithId } from './contract-utils.js';
+
+/**
+ * Serializer for the aztec_getContractInstance RPC method.
+ * Handles serialization of contract instance queries and results between JSON-RPC format and native Aztec types.
+ * Used to retrieve deployed contract instances by their address.
+ */
+export class AztecGetContractInstanceSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getContractInstance']['params'],
+      AztecWalletMethodMap['aztec_getContractInstance']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes contract instance query parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing the contract address to look up
+     * @returns Serialized address data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getContractInstance']['params'],
+    ): JSONRPCSerializedData => {
+      const { address } = value;
+      return {
+        method,
+        serialized: encodeBase64(aztecAddressSerializer.serialize(address)),
+      };
+    },
+    /**
+     * Deserializes contract instance query parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized address data
+     * @returns Deserialized query parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getContractInstance']['params'] => {
+      const address = aztecAddressSerializer.deserialize(decodeBase64(data.serialized));
+      return { address };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the contract instance query result.
+     * @param method - The RPC method name
+     * @param value - The contract instance data including address and state
+     * @returns Serialized contract instance data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getContractInstance']['result'],
+    ): JSONRPCSerializedData => {
+      const serializable = new SerializableContractInstance(value);
+      const { address } = value;
+
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify({
+            instance: serializable.toBuffer().toString('hex'),
+            address: aztecAddressSerializer.serialize(address),
+          }),
+        ),
+      };
+    },
+    /**
+     * Deserializes the contract instance query result.
+     * @param method - The RPC method name
+     * @param data - The serialized contract instance data
+     * @returns Deserialized contract instance
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getContractInstance']['result'] => {
+      const { instance, address } = JSON.parse(decodeBase64(data.serialized));
+      const baseInstance = SerializableContractInstance.fromBuffer(Buffer.from(instance, 'hex'));
+      const deserializedAddress = aztecAddressSerializer.deserialize(address);
+      return baseInstance.withAddress(deserializedAddress);
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_getContractClass RPC method.
+ * Handles serialization of contract class queries and results between JSON-RPC format and native Aztec types.
+ * Used to retrieve contract class definitions by their ID.
+ */
+export class AztecGetContractClassSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getContractClass']['params'],
+      AztecWalletMethodMap['aztec_getContractClass']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes contract class query parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing the class ID to look up
+     * @returns Serialized class ID data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getContractClass']['params'],
+    ): JSONRPCSerializedData => {
+      const { id } = value;
+      return {
+        method,
+        serialized: encodeBase64(frSerializer.serialize(id)),
+      };
+    },
+    /**
+     * Deserializes contract class query parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized class ID data
+     * @returns Deserialized query parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getContractClass']['params'] => {
+      const id = frSerializer.deserialize(decodeBase64(data.serialized));
+      return { id };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the contract class query result.
+     * @param method - The RPC method name
+     * @param value - The contract class definition with its ID
+     * @returns Serialized contract class data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getContractClass']['result'],
+    ): JSONRPCSerializedData => {
+      const serialized = serializeContractClassWithId(value);
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(serialized)),
+      };
+    },
+    /**
+     * Deserializes the contract class query result.
+     * @param method - The RPC method name
+     * @param data - The serialized contract class data
+     * @returns Deserialized contract class with ID
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getContractClass']['result'] => {
+      const parsed = JSON.parse(decodeBase64(data.serialized));
+      return deserializeContractClassWithId(parsed);
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_getContractArtifact RPC method.
+ * Handles serialization of contract artifact queries and results between JSON-RPC format and native Aztec types.
+ * Used to retrieve contract artifacts (ABI, bytecode, etc.) by their ID.
+ */
+export class AztecGetContractArtifactSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getContractArtifact']['params'],
+      AztecWalletMethodMap['aztec_getContractArtifact']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes contract artifact query parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing the artifact ID to look up
+     * @returns Serialized artifact ID data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getContractArtifact']['params'],
+    ): JSONRPCSerializedData => {
+      const { id } = value;
+      return {
+        method,
+        serialized: encodeBase64(frSerializer.serialize(id)),
+      };
+    },
+    /**
+     * Deserializes contract artifact query parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized artifact ID data
+     * @returns Deserialized query parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getContractArtifact']['params'] => {
+      const id = frSerializer.deserialize(decodeBase64(data.serialized));
+      return { id };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the contract artifact query result.
+     * @param method - The RPC method name
+     * @param value - The contract artifact data
+     * @returns Serialized contract artifact
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getContractArtifact']['result'],
+    ): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value)),
+      };
+    },
+    /**
+     * Deserializes the contract artifact query result.
+     * @param method - The RPC method name
+     * @param data - The serialized artifact data
+     * @returns Deserialized contract artifact
+     * @throws If the data doesn't match the contract artifact schema
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getContractArtifact']['result'] => {
+      return ContractArtifactSchema.parse(JSON.parse(decodeBase64(data.serialized)));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_registerContract RPC method.
+ * Handles serialization of contract registration requests between JSON-RPC format and native Aztec types.
+ * Used to register new contract instances with optional artifacts.
+ */
+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: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_registerContract']['params'],
+    ): JSONRPCSerializedData => {
+      const { instance, artifact } = value;
+      const serializable = new SerializableContractInstance(instance);
+
+      const serializedInstance = {
+        instance: Buffer.from(serializable.toBuffer()).toString('base64'),
+        address: aztecAddressSerializer.serialize(instance.address),
+      };
+
+      const serializedArtifact = artifact ? JSON.stringify(artifact) : undefined;
+
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify({
+            instance: serializedInstance,
+            artifact: serializedArtifact,
+          }),
+        ),
+      };
+    },
+    /**
+     * Deserializes contract 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_registerContract']['params'] => {
+      const { instance, artifact } = JSON.parse(decodeBase64(data.serialized));
+      const { instance: instanceBuffer, address } = instance;
+      const baseInstance = SerializableContractInstance.fromBuffer(Buffer.from(instanceBuffer, 'base64'));
+      const deserializedAddress = aztecAddressSerializer.deserialize(address);
+      return {
+        instance: baseInstance.withAddress(deserializedAddress),
+        artifact: artifact ? JSON.parse(artifact) : undefined,
+      };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the contract registration result.
+     * @param method - The RPC method name
+     * @param value - Boolean indicating success of registration
+     * @returns Serialized result
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_registerContract']['result'],
+    ): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value)),
+      };
+    },
+    /**
+     * Deserializes the contract registration result.
+     * @param method - The RPC method name
+     * @param data - The serialized result data
+     * @returns Boolean indicating success
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_registerContract']['result'] => {
+      return JSON.parse(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Pre-instantiated serializer instances for Aztec contract-related RPC methods.
+ * These instances can be used directly by the RPC handler implementation.
+ */
+export const aztecGetContractInstanceSerializer = new AztecGetContractInstanceSerializer();
+export const aztecGetContractClassSerializer = new AztecGetContractClassSerializer();
+export const aztecGetContractArtifactSerializer = new AztecGetContractArtifactSerializer();
+export const aztecRegisterContractSerializer = new AztecRegisterContractSerializer();

package/src/serializers/core.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+import { Fr, AztecAddress, CompleteAddress, AuthWitness, TxHash } from '@aztec/aztec.js';
+import {
+  frSerializer,
+  aztecAddressSerializer,
+  completeAddressSerializer,
+  authWitnessSerializer,
+  txHashSerializer,
+} from './core.js';
+
+describe('Core Serializers', () => {
+  describe('FrSerializer', () => {
+    it('should serialize and deserialize Fr values', () => {
+      const original = Fr.random();
+      const serialized = frSerializer.serialize(original);
+      const deserialized = frSerializer.deserialize(serialized);
+      expect(deserialized.toString()).toBe(original.toString());
+    });
+  });
+
+  describe('AztecAddressSerializer', () => {
+    it('should serialize and deserialize AztecAddress values', () => {
+      const original = AztecAddress.random();
+      const serialized = aztecAddressSerializer.serialize(original);
+      const deserialized = aztecAddressSerializer.deserialize(serialized);
+      expect(deserialized.toString()).toBe(original.toString());
+    });
+  });
+
+  describe('CompleteAddressSerializer', () => {
+    it('should serialize and deserialize CompleteAddress values', () => {
+      const original = CompleteAddress.random();
+      const serialized = completeAddressSerializer.serialize(original);
+      const deserialized = completeAddressSerializer.deserialize(serialized);
+      expect(deserialized.toString()).toBe(original.toString());
+    });
+  });
+
+  describe('AuthWitnessSerializer', () => {
+    it('should serialize and deserialize AuthWitness values', () => {
+      const original = AuthWitness.random();
+      const serialized = authWitnessSerializer.serialize(original);
+      const deserialized = authWitnessSerializer.deserialize(serialized);
+      expect(deserialized.toString()).toBe(original.toString());
+    });
+  });
+
+  describe('TxHashSerializer', () => {
+    it('should serialize and deserialize TxHash values', () => {
+      const original = TxHash.random();
+      const serialized = txHashSerializer.serialize(original);
+      const deserialized = txHashSerializer.deserialize(serialized);
+      expect(deserialized.toString()).toBe(original.toString());
+    });
+  });
+});