@walletmesh/aztec-rpc-wallet 0.1.1 → 0.3.0

package/src/serializers/transaction.test.ts

@@ -40,11 +40,16 @@ describe('Transaction Serializers', () => {
       };
       const params = { exec };
 
-      const serialized = aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecCreateTxExecutionRequestSerializer.params.deserialize(METHOD, serialized);
-      expect(JSON.stringify(deserialized.exec)).toBe(JSON.stringify(params.exec));
+      const deserialized = await aztecCreateTxExecutionRequestSerializer.params.deserialize(
+        METHOD,
+        serialized,
+      );
+      expect(deserialized.exec.calls).toEqual([]);
+      expect(deserialized.exec.fee.gasSettings.equals(randomTx.txContext.gasSettings)).toBe(true);
+      expect(deserialized.exec.fee.paymentMethod).toBeDefined();
     });
 
     it('should handle complex function calls in params', async () => {
@@ -69,30 +74,32 @@ describe('Transaction Serializers', () => {
       };
       const params = { exec };
 
-      const serialized = aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
-      const deserialized = aztecCreateTxExecutionRequestSerializer.params.deserialize(METHOD, serialized);
+      const serialized = await aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
+      const deserialized = await aztecCreateTxExecutionRequestSerializer.params.deserialize(
+        METHOD,
+        serialized,
+      );
 
-      expect(deserialized.exec.calls[0].name).toBe(exec.calls[0].name);
-      expect(deserialized.exec.calls[0].to.toString()).toBe(exec.calls[0].to.toString());
-      expect(deserialized.exec.calls[0].type).toBe(exec.calls[0].type);
+      // biome-ignore lint/style/noNonNullAssertion: test
+      expect(deserialized.exec.calls[0]!.name).toBe(exec.calls[0]!.name);
+      // biome-ignore lint/style/noNonNullAssertion: test
+      expect(deserialized.exec.calls[0]!.to.toString()).toBe(exec.calls[0]!.to.toString());
+      // biome-ignore lint/style/noNonNullAssertion: test
+      expect(deserialized.exec.calls[0]!.type).toBe(exec.calls[0]!.type);
     });
 
     it('should serialize and deserialize result', async () => {
       const result = await TxExecutionRequest.random();
 
-      const serialized = aztecCreateTxExecutionRequestSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecCreateTxExecutionRequestSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecCreateTxExecutionRequestSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecCreateTxExecutionRequestSerializer.result.deserialize(
+        METHOD,
+        serialized,
+      );
       expect(deserialized.toString()).toBe(result.toString());
     });
-
-    it('should handle invalid params', () => {
-      expect(() => {
-        // @ts-ignore - Testing invalid input
-        aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, { exec: null });
-      }).toThrow();
-    });
   });
 
   describe('aztec_getTxEffect', () => {
@@ -102,10 +109,10 @@ describe('Transaction Serializers', () => {
       const txHash = await TxHash.random();
       const params = { txHash };
 
-      const serialized = aztecGetTxEffectSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetTxEffectSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetTxEffectSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetTxEffectSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txHash.toString()).toBe(txHash.toString());
     });
 
@@ -120,8 +127,8 @@ describe('Transaction Serializers', () => {
         data: effect,
       };
 
-      const serialized = aztecGetTxEffectSerializer.result.serialize(METHOD, result);
-      const deserialized = aztecGetTxEffectSerializer.result.deserialize(METHOD, serialized);
+      const serialized = await aztecGetTxEffectSerializer.result.serialize(METHOD, result);
+      const deserialized = await aztecGetTxEffectSerializer.result.deserialize(METHOD, serialized);
 
       expect(deserialized.l2BlockNumber).toBe(result.l2BlockNumber);
       expect(deserialized.data).toBeDefined();
@@ -135,10 +142,10 @@ describe('Transaction Serializers', () => {
       const txHash = await TxHash.random();
       const params = { txHash };
 
-      const serialized = aztecGetTxReceiptSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetTxReceiptSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetTxReceiptSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetTxReceiptSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txHash.toString()).toBe(txHash.toString());
     });
 
@@ -152,8 +159,8 @@ describe('Transaction Serializers', () => {
         undefined,
       );
 
-      const serialized = aztecGetTxReceiptSerializer.result.serialize(METHOD, receipt);
-      const deserialized = aztecGetTxReceiptSerializer.result.deserialize(METHOD, serialized);
+      const serialized = await aztecGetTxReceiptSerializer.result.serialize(METHOD, receipt);
+      const deserialized = await aztecGetTxReceiptSerializer.result.deserialize(METHOD, serialized);
 
       expect(deserialized.txHash.toString()).toBe(receipt.txHash.toString());
       expect(deserialized.error).toBe(receipt.error);
@@ -167,20 +174,20 @@ describe('Transaction Serializers', () => {
       const tx = await Tx.random();
       const params = { tx };
 
-      const serialized = aztecSendTxSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecSendTxSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecSendTxSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecSendTxSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.tx.toBuffer().toString('hex')).toBe(tx.toBuffer().toString('hex'));
     });
 
     it('should serialize and deserialize result', async () => {
       const result = await TxHash.random();
 
-      const serialized = aztecSendTxSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecSendTxSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecSendTxSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecSendTxSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized.toString()).toBe(result.toString());
     });
   });
@@ -198,10 +205,10 @@ describe('Transaction Serializers', () => {
         profile: false,
       };
 
-      const serialized = aztecSimulateTxSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecSimulateTxSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecSimulateTxSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecSimulateTxSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txRequest.toString()).toBe((params.txRequest as TxExecutionRequest).toString());
       expect(deserialized.simulatePublic).toBe(params.simulatePublic);
       expect(deserialized.msgSender?.toString()).toBe(params.msgSender.toString());
@@ -213,8 +220,8 @@ describe('Transaction Serializers', () => {
     it('should serialize and deserialize result', async () => {
       const result = await TxSimulationResult.random();
 
-      const serialized = aztecSimulateTxSerializer.result.serialize(METHOD, result);
-      const deserialized = aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
+      const serialized = await aztecSimulateTxSerializer.result.serialize(METHOD, result);
+      const deserialized = await aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
 
       expect(deserialized.privateExecutionResult).toBeDefined();
       expect(deserialized.publicInputs).toBeDefined();
@@ -253,8 +260,8 @@ describe('Transaction Serializers', () => {
       publicOutput.revertReason = await SimulationError.random();
       const result = new TxSimulationResult(privateExecutionResult, publicInputs, publicOutput, undefined);
 
-      const serialized = aztecSimulateTxSerializer.result.serialize(METHOD, result);
-      const deserialized = aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
+      const serialized = await aztecSimulateTxSerializer.result.serialize(METHOD, result);
+      const deserialized = await aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
 
       const output = deserialized.publicOutput;
       expect(output).toBeDefined();
@@ -273,10 +280,10 @@ describe('Transaction Serializers', () => {
       const privateExecutionResult = await PrivateExecutionResult.random();
       const params = { txRequest, privateExecutionResult };
 
-      const serialized = aztecProveTxSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecProveTxSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecProveTxSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecProveTxSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txRequest.toString()).toBe(txRequest.toString());
       expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
         jsonStringify(privateExecutionResult),
@@ -286,10 +293,10 @@ describe('Transaction Serializers', () => {
     it('should serialize and deserialize result', async () => {
       const result = await TxProvingResult.random();
 
-      const serialized = aztecProveTxSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecProveTxSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecProveTxSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecProveTxSerializer.result.deserialize(METHOD, serialized);
       expect(jsonStringify(deserialized)).toEqual(jsonStringify(result));
     });
 
@@ -302,8 +309,8 @@ describe('Transaction Serializers', () => {
       privateExecutionResult.entrypoint.nestedExecutions.push(nestedExecution.entrypoint);
 
       const params = { txRequest, privateExecutionResult };
-      const serialized = aztecProveTxSerializer.params.serialize(METHOD, params);
-      const deserialized = aztecProveTxSerializer.params.deserialize(METHOD, serialized);
+      const serialized = await aztecProveTxSerializer.params.serialize(METHOD, params);
+      const deserialized = await aztecProveTxSerializer.params.deserialize(METHOD, serialized);
 
       expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
         jsonStringify(privateExecutionResult),

package/src/serializers/transaction.ts

@@ -1,17 +1,40 @@
 import type { AztecWalletMethodMap } from '../types.js';
 import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
-import { TxProvingResult } from '@aztec/circuit-types';
 import {
+  FunctionCall,
   PrivateExecutionResult,
   TxEffect,
   TxSimulationResult,
   inBlockSchemaFor,
   TxHash,
+  TxProvingResult,
 } from '@aztec/circuit-types';
-import { TxExecutionRequest, TxReceipt, Tx, AztecAddress, Fr } from '@aztec/aztec.js';
-import { serializeExecutionRequestInit, deserializeExecutionRequestInit } from './transaction-utils.js';
+import { GasSettings } from '@aztec/circuits.js';
+import {
+  AuthWitness,
+  AztecAddress,
+  Fr,
+  FunctionSelector,
+  HashedValues,
+  NoFeePaymentMethod,
+  TxExecutionRequest,
+  TxReceipt,
+  Tx,
+} from '@aztec/aztec.js';
+import { AbiTypeSchema, type FunctionType } from '@aztec/foundation/abi';
 
 import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import type { ExecutionRequestInit, FeeOptions } from '@aztec/aztec.js/entrypoint';
+
+interface SerializedFunctionCall {
+  name: string;
+  to: string;
+  selector: string;
+  type: string;
+  isStatic: boolean;
+  args: string[];
+  returnTypes: string[];
+}
 
 /**
  * Serializer for the aztec_createTxExecutionRequest RPC method.
@@ -25,34 +48,96 @@ export class AztecCreateTxExecutionRequestSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_createTxExecutionRequest']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { exec } = value;
+
+      const calls = exec.calls.map((call: FunctionCall) => {
+        return {
+          name: call.name,
+          to: jsonStringify(call.to),
+          selector: jsonStringify(call.selector),
+          type: call.type,
+          isStatic: call.isStatic,
+          args: call.args.map((arg) => jsonStringify(arg)),
+          returnTypes: call.returnTypes.map((r) => jsonStringify(r)),
+        };
+      });
+      const authWitnesses = exec.authWitnesses ? exec.authWitnesses.map((w) => jsonStringify(w)) : undefined;
+      const hashedArguments = exec.hashedArguments
+        ? exec.hashedArguments.map((h) => jsonStringify(h))
+        : undefined;
+      const fee = { gasSettings: jsonStringify(exec.fee.gasSettings) };
+      const nonce = exec.nonce ? jsonStringify(exec.nonce) : undefined;
+
       return {
         method,
-        serialized: serializeExecutionRequestInit(exec),
+        serialized: JSON.stringify({
+          calls,
+          fee,
+          authWitnesses,
+          hashedArguments,
+          nonce,
+          cancellable: exec.cancellable,
+        }),
       };
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_createTxExecutionRequest']['params'] => {
-      const exec = deserializeExecutionRequestInit(data.serialized);
+    ): Promise<AztecWalletMethodMap['aztec_createTxExecutionRequest']['params']> => {
+      const parsed = JSON.parse(data.serialized);
+
+      const calls: FunctionCall[] = await Promise.all(
+        parsed.calls.map(async (call: SerializedFunctionCall) => {
+          return new FunctionCall(
+            call.name,
+            await jsonParseWithSchema(call.to, AztecAddress.schema),
+            await jsonParseWithSchema(call.selector, FunctionSelector.schema),
+            call.type as FunctionType,
+            call.isStatic,
+            await Promise.all(call.args.map(async (arg: string) => jsonParseWithSchema(arg, Fr.schema))),
+            await Promise.all(
+              call.returnTypes.map(async (t: string) => jsonParseWithSchema(t, AbiTypeSchema)),
+            ),
+          );
+        }),
+      );
+      const authWitnesses = parsed.authWitnesses
+        ? parsed.authWitnesses.map(async (w: string) => await jsonParseWithSchema(w, AuthWitness.schema))
+        : undefined;
+      const hashedArguments = parsed.hashedArguments
+        ? parsed.hashedArguments.map(async (h: string) => await jsonParseWithSchema(h, HashedValues.schema))
+        : undefined;
+      const cancellable = parsed.cancellable;
+      const nonce = parsed.nonce ? await jsonParseWithSchema(parsed.nonce, Fr.schema) : undefined;
+
+      const fee: FeeOptions = {
+        paymentMethod: new NoFeePaymentMethod(), // Default, caller should override
+        gasSettings: await jsonParseWithSchema(parsed.fee.gasSettings, GasSettings.schema),
+      };
+
+      const exec: ExecutionRequestInit = { calls, fee };
+      if (authWitnesses) exec.authWitnesses = authWitnesses;
+      if (hashedArguments) exec.hashedArguments = hashedArguments;
+      if (nonce) exec.nonce = nonce;
+      if (cancellable) exec.cancellable = cancellable;
+
       return { exec };
     },
   };
 
   result = {
-    serialize: (method: string, value: TxExecutionRequest): JSONRPCSerializedData => {
+    serialize: async (method: string, value: TxExecutionRequest): Promise<JSONRPCSerializedData> => {
       return {
         method,
         serialized: jsonStringify(value),
       };
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): TxExecutionRequest => {
-      return jsonParseWithSchema(data.serialized, TxExecutionRequest.schema);
+    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<TxExecutionRequest> => {
+      return await jsonParseWithSchema(data.serialized, TxExecutionRequest.schema);
     },
   };
 }
@@ -69,10 +154,10 @@ export class AztecProveTxSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_proveTx']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { txRequest, privateExecutionResult } = value;
       return {
         method,
@@ -82,27 +167,30 @@ export class AztecProveTxSerializer
         }),
       };
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_proveTx']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_proveTx']['params']> => {
       const { txRequest, privateExecutionResult } = JSON.parse(data.serialized);
       return {
-        txRequest: jsonParseWithSchema(txRequest, TxExecutionRequest.schema),
-        privateExecutionResult: jsonParseWithSchema(privateExecutionResult, PrivateExecutionResult.schema),
+        txRequest: await jsonParseWithSchema(txRequest, TxExecutionRequest.schema),
+        privateExecutionResult: await jsonParseWithSchema(
+          privateExecutionResult,
+          PrivateExecutionResult.schema,
+        ),
       };
     },
   };
 
   result = {
-    serialize: (method: string, value: TxProvingResult): JSONRPCSerializedData => {
+    serialize: async (method: string, value: TxProvingResult): Promise<JSONRPCSerializedData> => {
       return {
         method,
         serialized: jsonStringify(value),
       };
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): TxProvingResult => {
-      return jsonParseWithSchema(data.serialized, TxProvingResult.schema);
+    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<TxProvingResult> => {
+      return await jsonParseWithSchema(data.serialized, TxProvingResult.schema);
     },
   };
 }
@@ -119,39 +207,39 @@ export class AztecSendTxSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_sendTx']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { tx } = value;
       return {
         method,
         serialized: jsonStringify(tx),
       };
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_sendTx']['params'] => {
-      return { tx: jsonParseWithSchema(data.serialized, Tx.schema) };
+    ): Promise<AztecWalletMethodMap['aztec_sendTx']['params']> => {
+      return { tx: await jsonParseWithSchema(data.serialized, Tx.schema) };
     },
   };
 
   result = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_sendTx']['result'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       return {
         method,
         serialized: jsonStringify(value),
       };
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_sendTx']['result'] => {
-      return jsonParseWithSchema(data.serialized, TxHash.schema);
+    ): Promise<AztecWalletMethodMap['aztec_sendTx']['result']> => {
+      return await jsonParseWithSchema(data.serialized, TxHash.schema);
     },
   };
 }
@@ -168,40 +256,40 @@ export class AztecGetTxEffectSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getTxEffect']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { txHash } = value;
       return {
         method,
         serialized: jsonStringify(txHash),
       };
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getTxEffect']['params'] => {
-      const txHash = jsonParseWithSchema(data.serialized, TxHash.schema);
+    ): Promise<AztecWalletMethodMap['aztec_getTxEffect']['params']> => {
+      const txHash = await jsonParseWithSchema(data.serialized, TxHash.schema);
       return { txHash };
     },
   };
 
   result = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getTxEffect']['result'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       return {
         method,
         serialized: jsonStringify(value),
       };
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getTxEffect']['result'] => {
-      return jsonParseWithSchema(data.serialized, inBlockSchemaFor(TxEffect.schema));
+    ): Promise<AztecWalletMethodMap['aztec_getTxEffect']['result']> => {
+      return await jsonParseWithSchema(data.serialized, inBlockSchemaFor(TxEffect.schema));
     },
   };
 }
@@ -218,34 +306,34 @@ export class AztecGetTxReceiptSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getTxReceipt']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { txHash } = value;
       return {
         method,
         serialized: jsonStringify(txHash),
       };
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getTxReceipt']['params'] => {
-      const txHash = jsonParseWithSchema(data.serialized, TxHash.schema);
+    ): Promise<AztecWalletMethodMap['aztec_getTxReceipt']['params']> => {
+      const txHash = await jsonParseWithSchema(data.serialized, TxHash.schema);
       return { txHash };
     },
   };
 
   result = {
-    serialize: (method: string, value: TxReceipt): JSONRPCSerializedData => {
+    serialize: async (method: string, value: TxReceipt): Promise<JSONRPCSerializedData> => {
       return {
         method,
         serialized: jsonStringify(value),
       };
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): TxReceipt => {
-      return jsonParseWithSchema(data.serialized, TxReceipt.schema);
+    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<TxReceipt> => {
+      return await jsonParseWithSchema(data.serialized, TxReceipt.schema);
     },
   };
 }
@@ -262,10 +350,10 @@ export class AztecSimulateTxSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_simulateTx']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile } = value;
       return {
         method,
@@ -279,16 +367,16 @@ export class AztecSimulateTxSerializer
         }),
       };
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_simulateTx']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_simulateTx']['params']> => {
       const { txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile } =
         JSON.parse(data.serialized);
       return {
-        txRequest: jsonParseWithSchema(txRequest, TxExecutionRequest.schema),
+        txRequest: await jsonParseWithSchema(txRequest, TxExecutionRequest.schema),
         simulatePublic,
-        msgSender: jsonParseWithSchema(msgSender, AztecAddress.schema),
+        msgSender: await jsonParseWithSchema(msgSender, AztecAddress.schema),
         skipTxValidation,
         enforceFeePayment,
         profile,
@@ -297,14 +385,14 @@ export class AztecSimulateTxSerializer
   };
 
   result = {
-    serialize: (method: string, value: TxSimulationResult): JSONRPCSerializedData => {
+    serialize: async (method: string, value: TxSimulationResult): Promise<JSONRPCSerializedData> => {
       return {
         method,
         serialized: jsonStringify(value),
       };
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): TxSimulationResult => {
-      return jsonParseWithSchema(data.serialized, TxSimulationResult.schema);
+    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<TxSimulationResult> => {
+      return await jsonParseWithSchema(data.serialized, TxSimulationResult.schema);
     },
   };
 }

package/src/types.ts

@@ -2,7 +2,6 @@ import type {
   AuthWitness,
   AztecAddress,
   ContractArtifact,
-  ContractClassWithId,
   ContractInstanceWithAddress,
   ExtendedNote,
   Fr,
@@ -35,6 +34,8 @@ import type {
   TxSimulationResult,
   GetPublicLogsResponse,
   GetContractClassLogsResponse,
+  ContractMetadata,
+  ContractClassMetadata,
 } from '@aztec/circuit-types';
 import type { GasFees, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
 import type { JSONRPCEventMap, JSONRPCMiddleware } from '@walletmesh/jsonrpc';
@@ -213,12 +214,11 @@ export interface AztecWalletMethodMap extends AztecWalletBaseMethodMap {
   /* Contracts */
 
   aztec_getContracts: { result: AztecAddress[] };
-  aztec_getContractInstance: { params: { address: AztecAddress }; result: ContractInstanceWithAddress };
-  aztec_getContractClass: { params: { id: Fr }; result: ContractClassWithId };
-  aztec_getContractArtifact: { params: { id: Fr }; result: ContractArtifact };
-  aztec_isContractClassPubliclyRegistered: { params: { id: Fr }; result: boolean };
-  aztec_isContractPubliclyDeployed: { params: { address: AztecAddress }; result: boolean };
-  aztec_isContractInitialized: { params: { address: AztecAddress }; result: boolean };
+  aztec_getContractMetadata: { params: { address: AztecAddress }; result: ContractMetadata };
+  aztec_getContractClassMetadata: {
+    params: { id: Fr; includeArtifact?: boolean };
+    result: ContractClassMetadata;
+  };
 
   /**
    * Registers a contract instance in the user's PXE.
@@ -226,7 +226,7 @@ export interface AztecWalletMethodMap extends AztecWalletBaseMethodMap {
    * @returns True if registration was successful
    */
   aztec_registerContract: {
-    params: { instance: ContractInstanceWithAddress; artifact?: ContractArtifact };
+    params: { instance: ContractInstanceWithAddress; artifact?: ContractArtifact | undefined };
     result: boolean;
   };