@walletmesh/aztec-rpc-wallet 0.2.0 → 0.3.0

package/src/serializers/contract.test.ts

@@ -1,140 +1,17 @@
 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 { aztecRegisterContractSerializer } from './contract.js';
+import { randomDeployedContract } from '@aztec/circuit-types';
 describe('Contract Serializers', () => {
-  describe('aztec_getContractInstance', () => {
-    it('should serialize and deserialize params', async () => {
-      const address = await 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', async () => {
-      // Create a contract instance with all required fields
-      const result = (await SerializableContractInstance.random()).withAddress(await 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', async () => {
-      const id = await 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', async () => {
-      const artifact = await 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', async () => {
-      const id = await 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', async () => {
-      const result = await 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', async () => {
       const { instance, artifact } = await randomDeployedContract();
-      const serialized = aztecRegisterContractSerializer.params.serialize('aztec_registerContract', {
+      const serialized = await aztecRegisterContractSerializer.params.serialize('aztec_registerContract', {
         instance,
         artifact,
       });
       expect(serialized.method).toBe('aztec_registerContract');
 
-      const deserialized = aztecRegisterContractSerializer.params.deserialize(
+      const deserialized = await aztecRegisterContractSerializer.params.deserialize(
         'aztec_registerContract',
         serialized,
       );
@@ -143,18 +20,5 @@ describe('Contract Serializers', () => {
       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

@@ -1,184 +1,135 @@
 import type { AztecWalletMethodMap } from '../types.js';
 import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
-import { SerializableContractInstance, ContractClassWithIdSchema } from '@aztec/circuits.js';
+import { ContractClassWithIdSchema, ContractInstanceWithAddressSchema } from '@aztec/circuits.js';
 import { ContractArtifactSchema } from '@aztec/foundation/abi';
 import { AztecAddress, Fr } from '@aztec/aztec.js';
-import type { ContractInstanceWithAddress } 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';
 
-/**
- * Serializer for the aztec_getContractInstance RPC method.
- * Handles serialization of contract instance queries and results between JSON-RPC format and native Aztec types.
- */
-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 => ({
-      method,
-      serialized: jsonStringify(value.address),
-    }),
-    deserialize: (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getContractInstance']['params'] => {
-      return {
-        address: jsonParseWithSchema(data.serialized, AztecAddress.schema),
-      };
-    },
-  };
+// 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>;
 
-  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: ContractInstanceWithAddress): JSONRPCSerializedData => ({
-      method,
-      serialized: JSON.stringify({
-        serializableContractInstance: new SerializableContractInstance(value).toBuffer(),
-        address: jsonStringify(value.address),
-      }),
-    }),
-    deserialize: (_method: string, data: JSONRPCSerializedData): ContractInstanceWithAddress => {
-      const parsed = JSON.parse(data.serialized);
-      return SerializableContractInstance.fromBuffer(
-        Buffer.from(parsed.serializableContractInstance),
-      ).withAddress(jsonParseWithSchema(parsed.address, AztecAddress.schema));
-    },
-  };
-}
+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_getContractClass RPC method.
- * Handles serialization of contract class queries and results between JSON-RPC format and native Aztec types.
+ * 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 AztecGetContractClassSerializer
+export class AztecGetContractClassMetadataSerializer
   implements
     JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getContractClass']['params'],
-      AztecWalletMethodMap['aztec_getContractClass']['result']
+      AztecWalletMethodMap['aztec_getContractClassMetadata']['params'],
+      AztecWalletMethodMap['aztec_getContractClassMetadata']['result']
     >
 {
   params = {
     /**
-     * Serializes contract class query parameters for RPC transport.
+     * Serializes contract class metadata 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
+     * @param value - The parameters containing the class ID and artifact inclusion flag
+     * @returns Serialized query parameters
      */
-    serialize: (
+    serialize: async (
       method: string,
-      value: AztecWalletMethodMap['aztec_getContractClass']['params'],
-    ): JSONRPCSerializedData => ({
-      method,
-      serialized: JSON.stringify({
-        id: value.id.toString(),
+      value: AztecWalletMethodMap['aztec_getContractClassMetadata']['params'],
+    ): Promise<JSONRPCSerializedData> =>
+      Promise.resolve({
+        method,
+        serialized: JSON.stringify({
+          id: value.id.toString(),
+          includeArtifact: value.includeArtifact,
+        }),
       }),
-    }),
-    deserialize: (
+    deserialize: async (
       _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getContractClass']['params'] => {
-      const { id } = JSON.parse(data.serialized);
-      return { id: Fr.fromString(id) };
+    ): Promise<AztecWalletMethodMap['aztec_getContractClassMetadata']['params']> => {
+      const { id, includeArtifact } = JSON.parse(data.serialized);
+      return {
+        id: Fr.fromString(id),
+        includeArtifact,
+      };
     },
   };
-
   result = {
     /**
-     * Serializes the contract class query result.
+     * Serializes the contract class metadata query result.
      * @param method - The RPC method name
-     * @param value - The contract class definition with its ID
-     * @returns Serialized contract class data
+     * @param value - The contract class metadata including class definition and registration status
+     * @returns Serialized contract class metadata
      */
-    serialize: (
+    serialize: async (
       method: string,
-      value: AztecWalletMethodMap['aztec_getContractClass']['result'],
-    ): JSONRPCSerializedData => ({
-      method,
-      serialized: JSON.stringify(value),
-    }),
-    deserialize: (
+      value: AztecWalletMethodMap['aztec_getContractClassMetadata']['result'],
+    ): Promise<JSONRPCSerializedData> => {
+      return {
+        method,
+        serialized: jsonStringify(value),
+      };
+    },
+    deserialize: async (
       _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getContractClass']['result'] => {
-      const parsed = JSON.parse(data.serialized);
-      return ContractClassWithIdSchema.parse(parsed);
+    ): Promise<AztecWalletMethodMap['aztec_getContractClassMetadata']['result']> => {
+      return await jsonParseWithSchema(data.serialized, ContractClassMetadataSchema);
     },
   };
 }
 
-/**
- * Serializer for the aztec_getContractArtifact RPC method.
- * Handles serialization of contract artifact queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetContractArtifactSerializer
+export class AztecGetContractMetadataSerializer
   implements
     JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getContractArtifact']['params'],
-      AztecWalletMethodMap['aztec_getContractArtifact']['result']
+      AztecWalletMethodMap['aztec_getContractMetadata']['params'],
+      AztecWalletMethodMap['aztec_getContractMetadata']['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: (
+    serialize: async (
       method: string,
-      value: AztecWalletMethodMap['aztec_getContractArtifact']['params'],
-    ): JSONRPCSerializedData => ({
-      method,
-      serialized: JSON.stringify({
-        id: value.id.toString(),
-      }),
-    }),
-    deserialize: (
+      value: AztecWalletMethodMap['aztec_getContractMetadata']['params'],
+    ): Promise<JSONRPCSerializedData> => {
+      return {
+        method,
+        serialized: jsonStringify(value.address),
+      };
+    },
+    deserialize: async (
       _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getContractArtifact']['params'] => {
-      const { id } = JSON.parse(data.serialized);
-      return { id: Fr.fromString(id) };
+    ): Promise<AztecWalletMethodMap['aztec_getContractMetadata']['params']> => {
+      return {
+        address: await jsonParseWithSchema(data.serialized, AztecAddress.schema),
+      };
     },
   };
 
   result = {
-    /**
-     * Serializes the contract artifact query result.
-     * @param method - The RPC method name
-     * @param value - The contract artifact data
-     * @returns Serialized contract artifact
-     */
-    serialize: (
+    serialize: async (
       method: string,
-      value: AztecWalletMethodMap['aztec_getContractArtifact']['result'],
-    ): JSONRPCSerializedData => ({
-      method,
-      serialized: JSON.stringify(ContractArtifactSchema.parse(value)),
-    }),
-    deserialize: (
+      contractMetadata: AztecWalletMethodMap['aztec_getContractMetadata']['result'],
+    ): Promise<JSONRPCSerializedData> => {
+      return {
+        method,
+        serialized: jsonStringify(contractMetadata),
+      };
+    },
+    deserialize: async (
       _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getContractArtifact']['result'] =>
-      ContractArtifactSchema.parse(JSON.parse(data.serialized)),
+    ): Promise<AztecWalletMethodMap['aztec_getContractMetadata']['result']> => {
+      return await jsonParseWithSchema(data.serialized, ContractMetadataSchema);
+    },
   };
 }
 
@@ -200,57 +151,33 @@ export class AztecRegisterContractSerializer
      * @param value - The parameters containing contract instance and optional artifact
      * @returns Serialized registration data
      */
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_registerContract']['params'],
-    ): JSONRPCSerializedData => ({
+    ): Promise<JSONRPCSerializedData> => ({
       method,
       serialized: JSON.stringify({
-        serializableContractInstance: new SerializableContractInstance(value.instance).toBuffer(),
-        address: value.instance.address.toString(),
-        artifact: value.artifact ? ContractArtifactSchema.parse(value.artifact) : undefined,
+        instance: jsonStringify(value.instance),
+        artifact: value.artifact ? jsonStringify(value.artifact) : undefined,
       }),
     }),
-    deserialize: (
+    deserialize: async (
       _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_registerContract']['params'] => {
-      const { serializableContractInstance, address, artifact } = JSON.parse(data.serialized);
+    ): Promise<AztecWalletMethodMap['aztec_registerContract']['params']> => {
+      const { instance, artifact } = JSON.parse(data.serialized);
       return {
-        instance: SerializableContractInstance.fromBuffer(
-          Buffer.from(serializableContractInstance),
-        ).withAddress(AztecAddress.fromString(address)),
-        artifact: artifact ? ContractArtifactSchema.parse(artifact) : undefined,
+        instance: await jsonParseWithSchema(instance, ContractInstanceWithAddressSchema),
+        artifact: artifact ? await jsonParseWithSchema(artifact, ContractArtifactSchema) : 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 => ({
-      method,
-      serialized: JSON.stringify(value),
-    }),
-    deserialize: (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_registerContract']['result'] => JSON.parse(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();
+export const aztecGetContractClassMetadataSerializer = new AztecGetContractClassMetadataSerializer();
+export const aztecGetContractMetadataSerializer = new AztecGetContractMetadataSerializer();

package/src/serializers/index.test.ts

@@ -1,7 +1,7 @@
-import { describe, expect, it, beforeEach, vi } from 'vitest';
+import { describe, expect, it, beforeEach } from 'vitest';
 import { AztecWalletSerializer } from './index.js';
 import { AztecAddress, Tx } from '@aztec/aztec.js';
-import type { JSONRPCSerializer } from './types.js';
+import type { JSONRPCSerializer } from '@walletmesh/jsonrpc';
 import type { AztecWalletMethodMap } from '../types.js';
 
 describe('AztecWalletSerializer', () => {
@@ -17,36 +17,36 @@ describe('AztecWalletSerializer', () => {
   describe('params', () => {
     it('should serialize params for known methods', async () => {
       const params = { scopes: [await AztecAddress.random()] };
-      const result = AztecWalletSerializer.params.serialize(knownMethod, params);
+      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', () => {
+    it('should wrap unknown method params in JSONRPCSerializedData format', async () => {
       const params = { someParam: 'value' };
-      const result = AztecWalletSerializer.params.serialize(unknownMethod, params);
+      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', () => {
+    it('should pass through serialized data for unknown methods', async () => {
       const serializedData = { serialized: 'base64data', method: unknownMethod };
-      const result = AztecWalletSerializer.params.deserialize(unknownMethod, serializedData);
+      const result = await AztecWalletSerializer.params.deserialize(unknownMethod, serializedData);
       expect(result).toEqual(serializedData);
     });
 
-    it('should throw error when params serializer fails', () => {
+    it('should throw error when params serializer fails', async () => {
       const params = { scopes: undefined }; // Invalid - scopes must be an array
-      expect(() => AztecWalletSerializer.params.serialize(knownMethod, params)).toThrow(
+      await expect(AztecWalletSerializer.params.serialize(knownMethod, params)).rejects.toThrow(
         /Failed to serialize params/,
       );
     });
 
-    it('should throw error when params deserializer fails', () => {
+    it('should throw error when params deserializer fails', async () => {
       const serializedData = { serialized: 'invalid-data', method: knownMethod };
-      expect(() => AztecWalletSerializer.params.deserialize(knownMethod, serializedData)).toThrow(
+      await expect(AztecWalletSerializer.params.deserialize(knownMethod, serializedData)).rejects.toThrow(
         /Failed to deserialize params/,
       );
     });
@@ -58,40 +58,42 @@ describe('AztecWalletSerializer', () => {
       expect(resultSerializer).toBeDefined();
     });
 
-    it('should serialize result for known methods', () => {
+    it('should serialize result for known methods', async () => {
       const value = true;
-      const result = resultSerializer.serialize(knownMethod, value);
+      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', () => {
+    it('should wrap unknown method result in JSONRPCSerializedData format', async () => {
       const testResult = { someResult: 'value' };
-      const result = resultSerializer.serialize(unknownMethod, testResult);
+      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', () => {
+    it('should pass through serialized data for unknown methods', async () => {
       const serializedData = { serialized: 'base64data', method: unknownMethod };
-      const result = resultSerializer.deserialize(unknownMethod, serializedData);
+      const result = await resultSerializer.deserialize(unknownMethod, serializedData);
       expect(result).toEqual(serializedData);
     });
 
-    it('should throw error when result serializer fails', () => {
+    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
-      expect(() => resultSerializer.serialize(knownMethod, circular)).toThrow(/Failed to serialize result/);
+      await expect(resultSerializer.serialize(knownMethod, circular)).rejects.toThrow(
+        /Failed to serialize result/,
+      );
     });
 
-    it('should throw error when result deserializer fails', () => {
+    it('should throw error when result deserializer fails', async () => {
       const serializedData = { serialized: 'invalid-data', method: knownMethod };
-      expect(() => resultSerializer.deserialize(knownMethod, serializedData)).toThrow(
+      await expect(resultSerializer.deserialize(knownMethod, serializedData)).rejects.toThrow(
         /Failed to deserialize result/,
       );
     });
@@ -99,18 +101,18 @@ describe('AztecWalletSerializer', () => {
 
   describe('integration', () => {
     it('should handle contract methods', async () => {
-      const method = 'aztec_getContractInstance';
+      const method = 'aztec_getContractMetadata';
       const params = { address: await AztecAddress.random() };
 
-      const serializedParams = AztecWalletSerializer.params.serialize(method, params);
+      const serializedParams = await AztecWalletSerializer.params.serialize(method, params);
       expect(serializedParams).toBeDefined();
       expect(serializedParams.method).toBe(method);
       expect(typeof serializedParams.serialized).toBe('string');
 
-      const deserializedParams = AztecWalletSerializer.params.deserialize(
+      const deserializedParams = (await AztecWalletSerializer.params.deserialize(
         method,
         serializedParams,
-      ) as AztecWalletMethodMap['aztec_getContractInstance']['params'];
+      )) as AztecWalletMethodMap['aztec_getContractMetadata']['params'];
       expect(deserializedParams.address.toString()).toBe(params.address.toString());
     });
 
@@ -119,15 +121,15 @@ describe('AztecWalletSerializer', () => {
       const tx = await Tx.random();
       const params = { tx };
 
-      const serializedParams = AztecWalletSerializer.params.serialize(method, params);
+      const serializedParams = await AztecWalletSerializer.params.serialize(method, params);
       expect(serializedParams).toBeDefined();
       expect(serializedParams.method).toBe(method);
       expect(typeof serializedParams.serialized).toBe('string');
 
-      const deserializedParams = AztecWalletSerializer.params.deserialize(
+      const deserializedParams = (await AztecWalletSerializer.params.deserialize(
         method,
         serializedParams,
-      ) as AztecWalletMethodMap['aztec_sendTx']['params'];
+      )) as AztecWalletMethodMap['aztec_sendTx']['params'];
       expect(deserializedParams.tx.toBuffer().toString('hex')).toBe(tx.toBuffer().toString('hex'));
     });
   });