@walletmesh/aztec-rpc-wallet 0.1.0 → 0.2.0

package/src/serializers/transaction.test.ts

@@ -1,7 +1,18 @@
 import { describe, expect, it } from 'vitest';
-import { AztecAddress, TxHash, Tx } from '@aztec/aztec.js';
-
-import { PrivateExecutionResult, TxProvingResult } from '@aztec/circuit-types';
+import { AztecAddress, TxHash, Tx, NoFeePaymentMethod, TxReceipt } from '@aztec/aztec.js';
+import {
+  PrivateExecutionResult,
+  TxProvingResult,
+  FunctionCall,
+  TxEffect,
+  TxSimulationResult,
+  TxStatus,
+  PublicSimulationOutput,
+  SimulationError,
+} from '@aztec/circuit-types';
+import { Fr, FunctionSelector, PrivateKernelTailCircuitPublicInputs } from '@aztec/circuits.js';
+import type { ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
+import { FunctionType } from '@aztec/foundation/abi';
 import {
   aztecCreateTxExecutionRequestSerializer,
   aztecSendTxSerializer,
@@ -12,16 +23,22 @@ import {
 } from './transaction.js';
 import { TxExecutionRequest } from '@aztec/aztec.js';
 
-import { comparePrivateExecutionResults, compareTxProvingResults } from './transaction-utils.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
 
 describe('Transaction Serializers', () => {
   describe('aztec_createTxExecutionRequest', () => {
     const METHOD = 'aztec_createTxExecutionRequest';
 
-    it('should serialize and deserialize params', () => {
-      // Create a request using random() and convert to plain object
-      const request = TxExecutionRequest.random();
-      const params = { exec: JSON.parse(JSON.stringify(request)) };
+    it('should serialize and deserialize params', async () => {
+      const randomTx = await TxExecutionRequest.random();
+      const exec = {
+        calls: [], // Empty calls array since we're just testing serialization
+        fee: {
+          gasSettings: randomTx.txContext.gasSettings,
+          paymentMethod: new NoFeePaymentMethod(),
+        },
+      };
+      const params = { exec };
 
       const serialized = aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
@@ -30,8 +47,38 @@ describe('Transaction Serializers', () => {
       expect(JSON.stringify(deserialized.exec)).toBe(JSON.stringify(params.exec));
     });
 
-    it('should serialize and deserialize result', () => {
-      const result = TxExecutionRequest.random();
+    it('should handle complex function calls in params', async () => {
+      const randomTx = await TxExecutionRequest.random();
+      const address = await AztecAddress.random();
+      const selector = FunctionSelector.random();
+      const functionCall = new FunctionCall(
+        'transfer',
+        address,
+        selector,
+        FunctionType.PRIVATE,
+        false,
+        [await Fr.random(), await Fr.random()],
+        [{ kind: 'field' }, { kind: 'boolean' }],
+      );
+      const exec: ExecutionRequestInit = {
+        calls: [functionCall],
+        fee: {
+          gasSettings: randomTx.txContext.gasSettings,
+          paymentMethod: new NoFeePaymentMethod(),
+        },
+      };
+      const params = { exec };
+
+      const serialized = aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
+      const deserialized = 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);
+    });
+
+    it('should serialize and deserialize result', async () => {
+      const result = await TxExecutionRequest.random();
 
       const serialized = aztecCreateTxExecutionRequestSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
@@ -39,13 +86,20 @@ describe('Transaction Serializers', () => {
       const deserialized = 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', () => {
     const METHOD = 'aztec_getTxEffect';
 
-    it('should serialize and deserialize params', () => {
-      const txHash = TxHash.random();
+    it('should serialize and deserialize params', async () => {
+      const txHash = await TxHash.random();
       const params = { txHash };
 
       const serialized = aztecGetTxEffectSerializer.params.serialize(METHOD, params);
@@ -54,13 +108,31 @@ describe('Transaction Serializers', () => {
       const deserialized = aztecGetTxEffectSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txHash.toString()).toBe(txHash.toString());
     });
+
+    it('should serialize and deserialize result', async () => {
+      const txHash = await TxHash.random();
+      const effect = await TxEffect.random();
+      const blockHash = await Fr.random();
+      const result = {
+        txHash,
+        l2BlockNumber: 123,
+        l2BlockHash: blockHash.toString(),
+        data: effect,
+      };
+
+      const serialized = aztecGetTxEffectSerializer.result.serialize(METHOD, result);
+      const deserialized = aztecGetTxEffectSerializer.result.deserialize(METHOD, serialized);
+
+      expect(deserialized.l2BlockNumber).toBe(result.l2BlockNumber);
+      expect(deserialized.data).toBeDefined();
+    });
   });
 
   describe('aztec_getTxReceipt', () => {
     const METHOD = 'aztec_getTxReceipt';
 
-    it('should serialize and deserialize params', () => {
-      const txHash = TxHash.random();
+    it('should serialize and deserialize params', async () => {
+      const txHash = await TxHash.random();
       const params = { txHash };
 
       const serialized = aztecGetTxReceiptSerializer.params.serialize(METHOD, params);
@@ -69,13 +141,30 @@ describe('Transaction Serializers', () => {
       const deserialized = aztecGetTxReceiptSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txHash.toString()).toBe(txHash.toString());
     });
+
+    it('should serialize and deserialize result', async () => {
+      const receipt = new TxReceipt(
+        TxHash.random(),
+        TxStatus.DROPPED,
+        'error',
+        undefined,
+        undefined,
+        undefined,
+      );
+
+      const serialized = aztecGetTxReceiptSerializer.result.serialize(METHOD, receipt);
+      const deserialized = aztecGetTxReceiptSerializer.result.deserialize(METHOD, serialized);
+
+      expect(deserialized.txHash.toString()).toBe(receipt.txHash.toString());
+      expect(deserialized.error).toBe(receipt.error);
+    });
   });
 
   describe('aztec_sendTx', () => {
     const METHOD = 'aztec_sendTx';
 
-    it('should serialize and deserialize params', () => {
-      const tx = Tx.random();
+    it('should serialize and deserialize params', async () => {
+      const tx = await Tx.random();
       const params = { tx };
 
       const serialized = aztecSendTxSerializer.params.serialize(METHOD, params);
@@ -85,8 +174,8 @@ describe('Transaction Serializers', () => {
       expect(deserialized.tx.toBuffer().toString('hex')).toBe(tx.toBuffer().toString('hex'));
     });
 
-    it('should serialize and deserialize result', () => {
-      const result = TxHash.random();
+    it('should serialize and deserialize result', async () => {
+      const result = await TxHash.random();
 
       const serialized = aztecSendTxSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
@@ -99,11 +188,11 @@ describe('Transaction Serializers', () => {
   describe('aztec_simulateTx', () => {
     const METHOD = 'aztec_simulateTx';
 
-    it('should serialize and deserialize params', () => {
+    it('should serialize and deserialize params', async () => {
       const params = {
-        txRequest: TxExecutionRequest.random(),
+        txRequest: await TxExecutionRequest.random(),
         simulatePublic: true,
-        msgSender: AztecAddress.random(),
+        msgSender: await AztecAddress.random(),
         skipTxValidation: false,
         enforceFeePayment: true,
         profile: false,
@@ -120,14 +209,68 @@ describe('Transaction Serializers', () => {
       expect(deserialized.enforceFeePayment).toBe(params.enforceFeePayment);
       expect(deserialized.profile).toBe(params.profile);
     });
+
+    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);
+
+      expect(deserialized.privateExecutionResult).toBeDefined();
+      expect(deserialized.publicInputs).toBeDefined();
+      expect(deserialized.publicOutput).toBeDefined();
+
+      expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
+        jsonStringify(result.privateExecutionResult),
+      );
+      expect(jsonStringify(deserialized.publicInputs)).toEqual(jsonStringify(result.publicInputs));
+      if (!result.publicOutput || !deserialized.publicOutput) {
+        // Should never happen
+        throw new Error('Public output is undefined');
+      }
+      expect(jsonStringify(deserialized.publicOutput.constants)).toEqual(
+        jsonStringify(result.publicOutput.constants),
+      );
+      expect(jsonStringify(deserialized.publicOutput.constants)).toEqual(
+        jsonStringify(result.publicOutput.constants),
+      );
+      expect(jsonStringify(deserialized.publicOutput.gasUsed.publicGas)).toEqual(
+        jsonStringify(result.publicOutput.gasUsed.publicGas),
+      );
+      expect(jsonStringify(deserialized.publicOutput.gasUsed.teardownGas)).toEqual(
+        jsonStringify(result.publicOutput.gasUsed.teardownGas),
+      );
+      expect(jsonStringify(deserialized.publicOutput.gasUsed.totalGas)).toEqual(
+        jsonStringify(result.publicOutput.gasUsed.totalGas),
+      );
+    });
+
+    it('should handle simulation errors in result', async () => {
+      const privateExecutionResult = await PrivateExecutionResult.random();
+      const publicInputs = PrivateKernelTailCircuitPublicInputs.empty();
+      const publicOutput = await PublicSimulationOutput.random();
+      // Simulate an error by setting revertReason
+      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 output = deserialized.publicOutput;
+      expect(output).toBeDefined();
+      if (output && result.publicOutput) {
+        expect(output.revertReason).toBeDefined();
+        expect(output.gasUsed).toEqual(result.publicOutput.gasUsed);
+      }
+    });
   });
 
   describe('aztec_proveTx', () => {
     const METHOD = 'aztec_proveTx';
 
-    it('should serialize and deserialize params', () => {
-      const txRequest = TxExecutionRequest.random();
-      const privateExecutionResult = PrivateExecutionResult.random();
+    it('should serialize and deserialize params', async () => {
+      const txRequest = await TxExecutionRequest.random();
+      const privateExecutionResult = await PrivateExecutionResult.random();
       const params = { txRequest, privateExecutionResult };
 
       const serialized = aztecProveTxSerializer.params.serialize(METHOD, params);
@@ -135,19 +278,36 @@ describe('Transaction Serializers', () => {
 
       const deserialized = aztecProveTxSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txRequest.toString()).toBe(txRequest.toString());
-      expect(
-        comparePrivateExecutionResults(privateExecutionResult, deserialized.privateExecutionResult),
-      ).toBe(true);
+      expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
+        jsonStringify(privateExecutionResult),
+      );
     });
 
-    it('should serialize and deserialize result', () => {
-      const result = TxProvingResult.random();
+    it('should serialize and deserialize result', async () => {
+      const result = await TxProvingResult.random();
 
       const serialized = aztecProveTxSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
       const deserialized = aztecProveTxSerializer.result.deserialize(METHOD, serialized);
-      expect(compareTxProvingResults(result, deserialized)).toBe(true);
+      expect(jsonStringify(deserialized)).toEqual(jsonStringify(result));
+    });
+
+    it('should handle complex private execution results', async () => {
+      const txRequest = await TxExecutionRequest.random();
+      const privateExecutionResult = await PrivateExecutionResult.random();
+
+      // Add nested executions and complex data
+      const nestedExecution = await PrivateExecutionResult.random();
+      privateExecutionResult.entrypoint.nestedExecutions.push(nestedExecution.entrypoint);
+
+      const params = { txRequest, privateExecutionResult };
+      const serialized = aztecProveTxSerializer.params.serialize(METHOD, params);
+      const deserialized = aztecProveTxSerializer.params.deserialize(METHOD, serialized);
+
+      expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
+        jsonStringify(privateExecutionResult),
+      );
     });
   });
 });

package/src/serializers/transaction.ts

@@ -1,11 +1,17 @@
 import type { AztecWalletMethodMap } from '../types.js';
-import type { JSONRPCSerializedData, JSONRPCSerializer } from './types.js';
-import { encodeBase64, decodeBase64 } from './types.js';
-import { txHashSerializer } from './core.js';
-import { TxEffect, TxSimulationResult, inBlockSchemaFor, type TxProvingResult } from '@aztec/circuit-types';
+import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
+import { TxProvingResult } from '@aztec/circuit-types';
+import {
+  PrivateExecutionResult,
+  TxEffect,
+  TxSimulationResult,
+  inBlockSchemaFor,
+  TxHash,
+} from '@aztec/circuit-types';
 import { TxExecutionRequest, TxReceipt, Tx, AztecAddress } from '@aztec/aztec.js';
+import { serializeExecutionRequestInit, deserializeExecutionRequestInit } from './transaction-utils.js';
 
-import { SerializablePrivateExecutionResult, SerializableTxProvingResult } from './transaction-utils.js';
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
 
 /**
  * Serializer for the aztec_createTxExecutionRequest RPC method.
@@ -26,14 +32,14 @@ export class AztecCreateTxExecutionRequestSerializer
       const { exec } = value;
       return {
         method,
-        serialized: encodeBase64(JSON.stringify(exec)),
+        serialized: serializeExecutionRequestInit(exec),
       };
     },
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_createTxExecutionRequest']['params'] => {
-      const exec = JSON.parse(decodeBase64(data.serialized));
+      const exec = deserializeExecutionRequestInit(data.serialized);
       return { exec };
     },
   };
@@ -42,11 +48,11 @@ export class AztecCreateTxExecutionRequestSerializer
     serialize: (method: string, value: TxExecutionRequest): JSONRPCSerializedData => {
       return {
         method,
-        serialized: encodeBase64(value.toString()),
+        serialized: jsonStringify(value),
       };
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): TxExecutionRequest => {
-      return TxExecutionRequest.fromString(decodeBase64(data.serialized));
+    deserialize: (_method: string, data: JSONRPCSerializedData): TxExecutionRequest => {
+      return jsonParseWithSchema(data.serialized, TxExecutionRequest.schema);
     },
   };
 }
@@ -54,7 +60,6 @@ export class AztecCreateTxExecutionRequestSerializer
 /**
  * Serializer for the aztec_proveTx RPC method.
  * Handles serialization of transaction proving requests and results between JSON-RPC format and native Aztec types.
- * Includes handling of private execution results and proving outcomes.
  */
 export class AztecProveTxSerializer
   implements
@@ -69,35 +74,35 @@ export class AztecProveTxSerializer
       value: AztecWalletMethodMap['aztec_proveTx']['params'],
     ): JSONRPCSerializedData => {
       const { txRequest, privateExecutionResult } = value;
-      const serializablePrivateExecutionResult =
-        SerializablePrivateExecutionResult.from(privateExecutionResult);
       return {
         method,
-        serialized: encodeBase64(JSON.stringify([txRequest.toString(), serializablePrivateExecutionResult])),
+        serialized: JSON.stringify({
+          txRequest: jsonStringify(txRequest),
+          privateExecutionResult: jsonStringify(privateExecutionResult),
+        }),
       };
     },
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_proveTx']['params'] => {
-      const [txRequest, privateExecutionResult] = JSON.parse(decodeBase64(data.serialized));
+      const { txRequest, privateExecutionResult } = JSON.parse(data.serialized);
       return {
-        txRequest: TxExecutionRequest.fromString(txRequest),
-        privateExecutionResult: SerializablePrivateExecutionResult.fromJSON(privateExecutionResult),
+        txRequest: jsonParseWithSchema(txRequest, TxExecutionRequest.schema),
+        privateExecutionResult: jsonParseWithSchema(privateExecutionResult, PrivateExecutionResult.schema),
       };
     },
   };
 
   result = {
     serialize: (method: string, value: TxProvingResult): JSONRPCSerializedData => {
-      const serializableTxProvingResult = SerializableTxProvingResult.from(value);
       return {
         method,
-        serialized: encodeBase64(JSON.stringify(serializableTxProvingResult)),
+        serialized: jsonStringify(value),
       };
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): TxProvingResult => {
-      return SerializableTxProvingResult.fromJSON(JSON.parse(decodeBase64(data.serialized)));
+    deserialize: (_method: string, data: JSONRPCSerializedData): TxProvingResult => {
+      return jsonParseWithSchema(data.serialized, TxProvingResult.schema);
     },
   };
 }
@@ -121,15 +126,14 @@ export class AztecSendTxSerializer
       const { tx } = value;
       return {
         method,
-        serialized: encodeBase64(tx.toBuffer().toString('hex')),
+        serialized: jsonStringify(tx),
       };
     },
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_sendTx']['params'] => {
-      const tx = Tx.fromBuffer(Buffer.from(decodeBase64(data.serialized), 'hex'));
-      return { tx };
+      return { tx: jsonParseWithSchema(data.serialized, Tx.schema) };
     },
   };
 
@@ -140,14 +144,14 @@ export class AztecSendTxSerializer
     ): JSONRPCSerializedData => {
       return {
         method,
-        serialized: encodeBase64(txHashSerializer.serialize(value)),
+        serialized: jsonStringify(value),
       };
     },
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_sendTx']['result'] => {
-      return txHashSerializer.deserialize(decodeBase64(data.serialized));
+      return jsonParseWithSchema(data.serialized, TxHash.schema);
     },
   };
 }
@@ -155,7 +159,6 @@ export class AztecSendTxSerializer
 /**
  * Serializer for the aztec_getTxEffect RPC method.
  * Handles serialization of transaction effect queries and results between JSON-RPC format and native Aztec types.
- * Transaction effects represent the outcome and state changes caused by a transaction.
  */
 export class AztecGetTxEffectSerializer
   implements
@@ -172,14 +175,14 @@ export class AztecGetTxEffectSerializer
       const { txHash } = value;
       return {
         method,
-        serialized: encodeBase64(txHashSerializer.serialize(txHash)),
+        serialized: jsonStringify(txHash),
       };
     },
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_getTxEffect']['params'] => {
-      const txHash = txHashSerializer.deserialize(decodeBase64(data.serialized));
+      const txHash = jsonParseWithSchema(data.serialized, TxHash.schema);
       return { txHash };
     },
   };
@@ -191,14 +194,14 @@ export class AztecGetTxEffectSerializer
     ): JSONRPCSerializedData => {
       return {
         method,
-        serialized: encodeBase64(JSON.stringify(TxEffect.schema.parse(value))),
+        serialized: jsonStringify(value),
       };
     },
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_getTxEffect']['result'] => {
-      return inBlockSchemaFor(TxEffect.schema).parse(JSON.parse(decodeBase64(data.serialized)));
+      return jsonParseWithSchema(data.serialized, inBlockSchemaFor(TxEffect.schema));
     },
   };
 }
@@ -206,7 +209,6 @@ export class AztecGetTxEffectSerializer
 /**
  * Serializer for the aztec_getTxReceipt RPC method.
  * Handles serialization of transaction receipt queries and results between JSON-RPC format and native Aztec types.
- * Transaction receipts contain detailed information about executed transactions.
  */
 export class AztecGetTxReceiptSerializer
   implements
@@ -223,14 +225,14 @@ export class AztecGetTxReceiptSerializer
       const { txHash } = value;
       return {
         method,
-        serialized: encodeBase64(txHashSerializer.serialize(txHash)),
+        serialized: jsonStringify(txHash),
       };
     },
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_getTxReceipt']['params'] => {
-      const txHash = txHashSerializer.deserialize(decodeBase64(data.serialized));
+      const txHash = jsonParseWithSchema(data.serialized, TxHash.schema);
       return { txHash };
     },
   };
@@ -239,11 +241,11 @@ export class AztecGetTxReceiptSerializer
     serialize: (method: string, value: TxReceipt): JSONRPCSerializedData => {
       return {
         method,
-        serialized: encodeBase64(JSON.stringify(TxReceipt.schema.parse(value))),
+        serialized: jsonStringify(value),
       };
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): TxReceipt => {
-      return TxReceipt.schema.parse(JSON.parse(decodeBase64(data.serialized)));
+    deserialize: (_method: string, data: JSONRPCSerializedData): TxReceipt => {
+      return jsonParseWithSchema(data.serialized, TxReceipt.schema);
     },
   };
 }
@@ -251,7 +253,6 @@ export class AztecGetTxReceiptSerializer
 /**
  * Serializer for the aztec_simulateTx RPC method.
  * Handles serialization of transaction simulation requests and results between JSON-RPC format and native Aztec types.
- * Supports simulation configuration including public simulation, custom sender, validation options, and profiling.
  */
 export class AztecSimulateTxSerializer
   implements
@@ -268,29 +269,26 @@ export class AztecSimulateTxSerializer
       const { txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile } = value;
       return {
         method,
-        serialized: encodeBase64(
-          JSON.stringify([
-            txRequest.toString(),
-            simulatePublic,
-            msgSender,
-            skipTxValidation,
-            enforceFeePayment,
-            profile,
-          ]),
-        ),
+        serialized: JSON.stringify({
+          txRequest: jsonStringify(txRequest),
+          simulatePublic,
+          msgSender: JSON.stringify(msgSender),
+          skipTxValidation,
+          enforceFeePayment,
+          profile,
+        }),
       };
     },
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_simulateTx']['params'] => {
-      const [txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile] = JSON.parse(
-        decodeBase64(data.serialized),
-      );
+      const { txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile } =
+        JSON.parse(data.serialized);
       return {
-        txRequest: TxExecutionRequest.fromString(txRequest),
+        txRequest: jsonParseWithSchema(txRequest, TxExecutionRequest.schema),
         simulatePublic,
-        msgSender: msgSender ? AztecAddress.fromString(msgSender) : undefined,
+        msgSender: jsonParseWithSchema(msgSender, AztecAddress.schema),
         skipTxValidation,
         enforceFeePayment,
         profile,
@@ -300,32 +298,13 @@ export class AztecSimulateTxSerializer
 
   result = {
     serialize: (method: string, value: TxSimulationResult): JSONRPCSerializedData => {
-      const serializablePrivateExecutionResult = SerializablePrivateExecutionResult.from(
-        value.privateExecutionResult,
-      );
-
       return {
         method,
-        serialized: encodeBase64(
-          JSON.stringify({
-            privateExecutionResult: serializablePrivateExecutionResult,
-            publicInputs: value.publicInputs,
-            publicOutput: value.publicOutput,
-            profileResult: value.profileResult,
-          }),
-        ),
+        serialized: jsonStringify(value),
       };
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): TxSimulationResult => {
-      const { privateExecutionResult, publicInputs, publicOutput, profileResult } = JSON.parse(
-        decodeBase64(data.serialized),
-      );
-      return new TxSimulationResult(
-        SerializablePrivateExecutionResult.fromJSON(privateExecutionResult),
-        publicInputs,
-        publicOutput,
-        profileResult,
-      );
+    deserialize: (_method: string, data: JSONRPCSerializedData): TxSimulationResult => {
+      return jsonParseWithSchema(data.serialized, TxSimulationResult.schema);
     },
   };
 }