@aztec/stdlib 0.77.0-testnet-ignition.17 → 0.77.0-testnet-ignition.21

package/src/avm/avm_accumulated_data.ts

@@ -8,10 +8,12 @@ import {
 import { makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, type Tuple, assertLength, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
+import { z } from 'zod';
 
 import { PublicLog } from '../logs/public_log.js';
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
@@ -41,6 +43,30 @@ export class AvmAccumulatedData {
     public publicDataWrites: Tuple<PublicDataWrite, typeof MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX>,
   ) {}
 
+  static get schema() {
+    return z
+      .object({
+        noteHashes: schemas.Fr.array().min(MAX_NOTE_HASHES_PER_TX).max(MAX_NOTE_HASHES_PER_TX),
+        nullifiers: schemas.Fr.array().min(MAX_NULLIFIERS_PER_TX).max(MAX_NULLIFIERS_PER_TX),
+        l2ToL1Msgs: ScopedL2ToL1Message.schema.array().min(MAX_L2_TO_L1_MSGS_PER_TX).max(MAX_L2_TO_L1_MSGS_PER_TX),
+        publicLogs: PublicLog.schema.array().min(MAX_PUBLIC_LOGS_PER_TX).max(MAX_PUBLIC_LOGS_PER_TX),
+        publicDataWrites: PublicDataWrite.schema
+          .array()
+          .min(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX)
+          .max(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX),
+      })
+      .transform(
+        ({ noteHashes, nullifiers, l2ToL1Msgs, publicLogs, publicDataWrites }) =>
+          new AvmAccumulatedData(
+            assertLength(noteHashes, MAX_NOTE_HASHES_PER_TX),
+            assertLength(nullifiers, MAX_NULLIFIERS_PER_TX),
+            assertLength(l2ToL1Msgs, MAX_L2_TO_L1_MSGS_PER_TX),
+            assertLength(publicLogs, MAX_PUBLIC_LOGS_PER_TX),
+            assertLength(publicDataWrites, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX),
+          ),
+      );
+  }
+
   getSize() {
     return (
       arraySerializedSizeOfNonEmpty(this.noteHashes) +

package/src/avm/avm_circuit_public_inputs.ts

@@ -1,10 +1,12 @@
 import { MAX_ENQUEUED_CALLS_PER_TX } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, type Tuple, assertLength, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
+import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { Gas, GasSettings } from '../gas/index.js';
@@ -16,7 +18,10 @@ import { PublicCallRequest } from '../kernel/public_call_request.js';
 import { GlobalVariables } from '../tx/global_variables.js';
 import { TreeSnapshots } from '../tx/tree_snapshots.js';
 import { AvmAccumulatedData } from './avm_accumulated_data.js';
+import { serializeWithMessagePack } from './message_pack.js';
 
+// Note: the {from,to}{Buffer,Fields,String} methods are needed by AvmProofData and PublicBaseRollupInputs.
+// At some point it might be worth writing Zod schemas for all dependent types and get rid of that.
 export class AvmCircuitPublicInputs {
   constructor(
     public globalVariables: GlobalVariables,
@@ -38,6 +43,69 @@ export class AvmCircuitPublicInputs {
     public reverted: boolean,
   ) {}
 
+  static get schema() {
+    return z
+      .object({
+        globalVariables: GlobalVariables.schema,
+        startTreeSnapshots: TreeSnapshots.schema,
+        startGasUsed: Gas.schema,
+        gasSettings: GasSettings.schema,
+        feePayer: AztecAddress.schema,
+        publicSetupCallRequests: PublicCallRequest.schema.array().max(MAX_ENQUEUED_CALLS_PER_TX),
+        publicAppLogicCallRequests: PublicCallRequest.schema.array().max(MAX_ENQUEUED_CALLS_PER_TX),
+        publicTeardownCallRequest: PublicCallRequest.schema,
+        previousNonRevertibleAccumulatedDataArrayLengths: PrivateToAvmAccumulatedDataArrayLengths.schema,
+        previousRevertibleAccumulatedDataArrayLengths: PrivateToAvmAccumulatedDataArrayLengths.schema,
+        previousNonRevertibleAccumulatedData: PrivateToAvmAccumulatedData.schema,
+        previousRevertibleAccumulatedData: PrivateToAvmAccumulatedData.schema,
+        endTreeSnapshots: TreeSnapshots.schema,
+        endGasUsed: Gas.schema,
+        accumulatedData: AvmAccumulatedData.schema,
+        transactionFee: schemas.Fr,
+        reverted: z.boolean(),
+      })
+      .transform(
+        ({
+          globalVariables,
+          startTreeSnapshots,
+          startGasUsed,
+          gasSettings,
+          feePayer,
+          publicSetupCallRequests,
+          publicAppLogicCallRequests,
+          publicTeardownCallRequest,
+          previousNonRevertibleAccumulatedDataArrayLengths,
+          previousRevertibleAccumulatedDataArrayLengths,
+          previousNonRevertibleAccumulatedData,
+          previousRevertibleAccumulatedData,
+          endTreeSnapshots,
+          endGasUsed,
+          accumulatedData,
+          transactionFee,
+          reverted,
+        }) =>
+          new AvmCircuitPublicInputs(
+            globalVariables,
+            startTreeSnapshots,
+            startGasUsed,
+            gasSettings,
+            feePayer,
+            assertLength(publicSetupCallRequests, MAX_ENQUEUED_CALLS_PER_TX),
+            assertLength(publicAppLogicCallRequests, MAX_ENQUEUED_CALLS_PER_TX),
+            publicTeardownCallRequest,
+            previousNonRevertibleAccumulatedDataArrayLengths,
+            previousRevertibleAccumulatedDataArrayLengths,
+            previousNonRevertibleAccumulatedData,
+            previousRevertibleAccumulatedData,
+            endTreeSnapshots,
+            endGasUsed,
+            accumulatedData,
+            transactionFee,
+            reverted,
+          ),
+      );
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new AvmCircuitPublicInputs(
@@ -136,6 +204,10 @@ export class AvmCircuitPublicInputs {
     );
   }
 
+  public serializeWithMessagePack(): Buffer {
+    return serializeWithMessagePack(this);
+  }
+
   [inspect.custom]() {
     return `AvmCircuitPublicInputs {
       globalVariables: ${inspect(this.globalVariables)},

package/src/avm/message_pack.ts

@@ -0,0 +1,48 @@
+import { Fq, Fr, Point } from '@aztec/foundation/fields';
+
+import { strict as assert } from 'assert';
+import { Encoder, addExtension } from 'msgpackr';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+export function serializeWithMessagePack(obj: any): Buffer {
+  setUpMessagePackExtensions();
+  const encoder = new Encoder({
+    // always encode JS objects as MessagePack maps
+    // this makes it compatible with other MessagePack decoders
+    useRecords: false,
+    int64AsType: 'bigint',
+  });
+  return encoder.encode(obj);
+}
+
+let messagePackWasSetUp = false;
+function setUpMessagePackExtensions() {
+  if (messagePackWasSetUp) {
+    return;
+  }
+  // C++ Fr and Fq classes work well with the buffer serialization.
+  addExtension({
+    Class: Fr,
+    write: (fr: Fr) => fr.toBuffer(),
+  });
+  addExtension({
+    Class: Fq,
+    write: (fq: Fq) => fq.toBuffer(),
+  });
+  // AztecAddress is a class that has a field in TS, but just a field in C++.
+  addExtension({
+    Class: AztecAddress,
+    write: (addr: AztecAddress) => addr.toField(),
+  });
+  // Affine points are a mess, we do our best.
+  addExtension({
+    Class: Point,
+    write: (p: Point) => {
+      assert(!p.inf, 'Cannot serialize infinity');
+      // TODO: should these be Frs?
+      return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
+    },
+  });
+  messagePackWasSetUp = true;
+}

package/src/block/l2_block_source.ts

@@ -1,5 +1,6 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
 
+import type { EventEmitter } from 'events';
 import { z } from 'zod';
 
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
@@ -115,6 +116,12 @@ export interface L2BlockSource {
   getL1Constants(): Promise<L1RollupConstants>;
 }
 
+/**
+ * L2BlockSource that emits events upon pending / proven chain changes.
+ * see L2BlockSourceEvents for the events emitted.
+ */
+export interface L2BlockSourceEventEmitter extends L2BlockSource, EventEmitter {}
+
 /**
  * Identifier for L2 block tags.
  * - latest: Latest block pushed to L1.
@@ -146,3 +153,14 @@ export const L2TipsSchema = z.object({
   proven: L2BlockIdSchema,
   finalized: L2BlockIdSchema,
 }) satisfies z.ZodType<L2Tips>;
+
+export enum L2BlockSourceEvents {
+  L2PruneDetected = 'l2PruneDetected',
+}
+
+export type L2BlockSourceEvent = {
+  type: 'l2PruneDetected';
+  blockNumber: bigint;
+  slotNumber: bigint;
+  epochNumber: bigint;
+};

package/src/kernel/private_to_avm_accumulated_data.ts

@@ -7,15 +7,18 @@ import {
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
 import {
   BufferReader,
   FieldReader,
   type Tuple,
+  assertLength,
   serializeToBuffer,
   serializeToFields,
 } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
+import { z } from 'zod';
 
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import type { UInt32 } from '../types/shared.js';
@@ -27,6 +30,23 @@ export class PrivateToAvmAccumulatedData {
     public l2ToL1Msgs: Tuple<ScopedL2ToL1Message, typeof MAX_L2_TO_L1_MSGS_PER_TX>,
   ) {}
 
+  static get schema() {
+    return z
+      .object({
+        noteHashes: schemas.Fr.array().min(MAX_NOTE_HASHES_PER_TX).max(MAX_NOTE_HASHES_PER_TX),
+        nullifiers: schemas.Fr.array().min(MAX_NULLIFIERS_PER_TX).max(MAX_NULLIFIERS_PER_TX),
+        l2ToL1Msgs: ScopedL2ToL1Message.schema.array().min(MAX_L2_TO_L1_MSGS_PER_TX).max(MAX_L2_TO_L1_MSGS_PER_TX),
+      })
+      .transform(
+        ({ noteHashes, nullifiers, l2ToL1Msgs }) =>
+          new PrivateToAvmAccumulatedData(
+            assertLength(noteHashes, MAX_NOTE_HASHES_PER_TX),
+            assertLength(nullifiers, MAX_NULLIFIERS_PER_TX),
+            assertLength(l2ToL1Msgs, MAX_L2_TO_L1_MSGS_PER_TX),
+          ),
+      );
+  }
+
   getSize() {
     return (
       arraySerializedSizeOfNonEmpty(this.noteHashes) +
@@ -104,6 +124,19 @@ export class PrivateToAvmAccumulatedData {
 export class PrivateToAvmAccumulatedDataArrayLengths {
   constructor(public noteHashes: UInt32, public nullifiers: UInt32, public l2ToL1Msgs: UInt32) {}
 
+  static get schema() {
+    return z
+      .object({
+        noteHashes: schemas.UInt32,
+        nullifiers: schemas.UInt32,
+        l2ToL1Msgs: schemas.UInt32,
+      })
+      .transform(
+        ({ noteHashes, nullifiers, l2ToL1Msgs }) =>
+          new PrivateToAvmAccumulatedDataArrayLengths(noteHashes, nullifiers, l2ToL1Msgs),
+      );
+  }
+
   getSize() {
     return 4 * 3;
   }

package/src/kernel/public_call_request.ts

@@ -1,9 +1,11 @@
 import { COUNTED_PUBLIC_CALL_REQUEST_LENGTH, PUBLIC_CALL_REQUEST_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
+import { z } from 'zod';
 
 import { FunctionSelector } from '../abi/index.js';
 import { AztecAddress } from '../aztec-address/index.js';
@@ -33,6 +35,20 @@ export class PublicCallRequest {
     public argsHash: Fr,
   ) {}
 
+  static get schema() {
+    return z
+      .object({
+        msgSender: AztecAddress.schema,
+        contractAddress: AztecAddress.schema,
+        functionSelector: FunctionSelector.schema,
+        isStaticCall: z.boolean(),
+        argsHash: schemas.Fr,
+      })
+      .transform(({ msgSender, contractAddress, functionSelector, isStaticCall, argsHash }) => {
+        return new PublicCallRequest(msgSender, contractAddress, functionSelector, isStaticCall, argsHash);
+      });
+  }
+
   getSize() {
     return this.isEmpty() ? 0 : this.toBuffer().length;
   }

package/src/messaging/l2_to_l1_message.ts

@@ -1,14 +1,27 @@
 import { L2_TO_L1_MESSAGE_LENGTH, SCOPED_L2_TO_L1_MESSAGE_LENGTH } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { z } from 'zod';
+
 import { AztecAddress } from '../aztec-address/index.js';
 
 export class L2ToL1Message {
   constructor(public recipient: EthAddress, public content: Fr, public counter: number) {}
 
+  static get schema() {
+    return z
+      .object({
+        recipient: schemas.EthAddress,
+        content: schemas.Fr,
+        counter: z.number(),
+      })
+      .transform(({ recipient, content, counter }) => new L2ToL1Message(recipient, content, counter));
+  }
+
   /**
    * Creates an empty L2ToL1Message with default values.
    * @returns An instance of L2ToL1Message with empty fields.
@@ -86,6 +99,15 @@ export class L2ToL1Message {
 export class ScopedL2ToL1Message {
   constructor(public message: L2ToL1Message, public contractAddress: AztecAddress) {}
 
+  static get schema() {
+    return z
+      .object({
+        message: L2ToL1Message.schema,
+        contractAddress: AztecAddress.schema,
+      })
+      .transform(({ message, contractAddress }) => new ScopedL2ToL1Message(message, contractAddress));
+  }
+
   static getFields(fields: FieldsOf<ScopedL2ToL1Message>) {
     return [fields.message, fields.contractAddress] as const;
   }

package/src/p2p/consensus_payload.ts

@@ -1,4 +1,5 @@
 import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -26,7 +27,7 @@ export class ConsensusPayload implements Signable {
     return z
       .object({
         header: BlockHeader.schema,
-        archive: Fr.schema,
+        archive: schemas.Fr,
         txHashes: z.array(TxHash.schema),
       })
       .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.txHashes));

package/src/tests/factories.ts

@@ -1209,11 +1209,11 @@ function makeContractClassPrivateFunction(seed = 0): PrivateFunction {
   };
 }
 
-export function makeArray<T extends Bufferable>(length: number, fn: (i: number) => T, offset = 0) {
+export function makeArray<T>(length: number, fn: (i: number) => T, offset = 0) {
   return Array.from({ length }, (_: any, i: number) => fn(i + offset));
 }
 
-export function makeArrayAsync<T extends Bufferable>(length: number, fn: (i: number) => Promise<T>, offset = 0) {
+export function makeArrayAsync<T>(length: number, fn: (i: number) => Promise<T>, offset = 0) {
   return Promise.all(
     Array(length)
       .fill(0)
@@ -1229,15 +1229,11 @@ export async function makeVectorAsync<T extends Bufferable>(length: number, fn:
   return new Vector(await makeArrayAsync(length, fn, offset));
 }
 
-export function makeMap<T extends Bufferable>(size: number, fn: (i: number) => [string, T], offset = 0) {
+export function makeMap<T>(size: number, fn: (i: number) => [string, T], offset = 0) {
   return new Map(makeArray(size, i => fn(i + offset)));
 }
 
-export async function makeMapAsync<T extends Bufferable>(
-  size: number,
-  fn: (i: number) => Promise<[string, T]>,
-  offset = 0,
-) {
+export async function makeMapAsync<T>(size: number, fn: (i: number) => Promise<[string, T]>, offset = 0) {
   return new Map(await makeArrayAsync(size, i => fn(i + offset)));
 }
 
@@ -1375,10 +1371,10 @@ export async function makeAvmContractClassHint(seed = 0): Promise<AvmContractCla
 }
 
 export function makeAvmEnqueuedCallHint(seed = 0): AvmEnqueuedCallHint {
-  return AvmEnqueuedCallHint.from({
-    contractAddress: new AztecAddress(new Fr(seed)),
-    calldata: makeVector((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
-  });
+  return new AvmEnqueuedCallHint(
+    new AztecAddress(new Fr(seed)),
+    makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
+  );
 }
 
 /**
@@ -1394,19 +1390,32 @@ export async function makeAvmExecutionHints(
   const lengthSeedMod = 10;
   const baseLength = lengthOffset + (seed % lengthSeedMod);
 
-  return AvmExecutionHints.from({
-    enqueuedCalls: makeVector(baseLength, makeAvmEnqueuedCallHint, seed + 0x4100),
-    contractInstances: makeVector(baseLength + 5, makeAvmContractInstanceHint, seed + 0x4700),
-    contractClasses: await makeVectorAsync(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
-    publicDataReads: makeVector(baseLength + 7, makeAvmStorageReadTreeHints, seed + 0x4900),
-    publicDataWrites: makeVector(baseLength + 8, makeAvmStorageUpdateTreeHints, seed + 0x4a00),
-    nullifierReads: makeVector(baseLength + 9, makeAvmNullifierReadTreeHints, seed + 0x4b00),
-    nullifierWrites: makeVector(baseLength + 10, makeAvmNullifierInsertionTreeHints, seed + 0x4c00),
-    noteHashReads: makeVector(baseLength + 11, makeAvmTreeHints, seed + 0x4d00),
-    noteHashWrites: makeVector(baseLength + 12, makeAvmTreeHints, seed + 0x4e00),
-    l1ToL2MessageReads: makeVector(baseLength + 13, makeAvmTreeHints, seed + 0x4f00),
+  const fields = {
+    enqueuedCalls: makeArray(baseLength, makeAvmEnqueuedCallHint, seed + 0x4100),
+    contractInstances: makeArray(baseLength + 5, makeAvmContractInstanceHint, seed + 0x4700),
+    contractClasses: await makeArrayAsync(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
+    publicDataReads: makeArray(baseLength + 7, makeAvmStorageReadTreeHints, seed + 0x4900),
+    publicDataWrites: makeArray(baseLength + 8, makeAvmStorageUpdateTreeHints, seed + 0x4a00),
+    nullifierReads: makeArray(baseLength + 9, makeAvmNullifierReadTreeHints, seed + 0x4b00),
+    nullifierWrites: makeArray(baseLength + 10, makeAvmNullifierInsertionTreeHints, seed + 0x4c00),
+    noteHashReads: makeArray(baseLength + 11, makeAvmTreeHints, seed + 0x4d00),
+    noteHashWrites: makeArray(baseLength + 12, makeAvmTreeHints, seed + 0x4e00),
+    l1ToL2MessageReads: makeArray(baseLength + 13, makeAvmTreeHints, seed + 0x4f00),
     ...overrides,
-  });
+  };
+
+  return new AvmExecutionHints(
+    fields.enqueuedCalls,
+    fields.contractInstances,
+    fields.contractClasses,
+    fields.publicDataReads,
+    fields.publicDataWrites,
+    fields.nullifierReads,
+    fields.nullifierWrites,
+    fields.noteHashReads,
+    fields.noteHashWrites,
+    fields.l1ToL2MessageReads,
+  );
 }
 
 /**
@@ -1418,13 +1427,15 @@ export async function makeAvmCircuitInputs(
   seed = 0,
   overrides: Partial<FieldsOf<AvmCircuitInputs>> = {},
 ): Promise<AvmCircuitInputs> {
-  return AvmCircuitInputs.from({
+  const fields = {
     functionName: `function${seed}`,
     calldata: makeArray((seed % 100) + 10, i => new Fr(i), seed + 0x1000),
     avmHints: await makeAvmExecutionHints(seed + 0x3000),
     publicInputs: makeAvmCircuitPublicInputs(seed + 0x4000),
     ...overrides,
-  });
+  };
+
+  return new AvmCircuitInputs(fields.functionName, fields.calldata, fields.avmHints, fields.publicInputs);
 }
 
 /**
@@ -1525,8 +1536,7 @@ export async function makeBloatedProcessedTx({
       seed + 0x2000,
     );
 
-    const avmCircuitInputs = new AvmCircuitInputs('', [], AvmExecutionHints.empty(), avmOutput);
-
+    const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, { publicInputs: avmOutput });
     const gasUsed = {
       totalGas: Gas.empty(),
       teardownGas: Gas.empty(),

package/src/tx/private_execution_result.ts

@@ -103,7 +103,7 @@ export class PrivateExecutionResult {
     return z
       .object({
         entrypoint: PrivateCallExecutionResult.schema,
-        firstNullifier: Fr.schema,
+        firstNullifier: schemas.Fr,
       })
       .transform(PrivateExecutionResult.from);
   }

package/src/tx/processed_tx.ts

@@ -54,6 +54,10 @@ export type ProcessedTx = {
    * Gas used by the entire transaction.
    */
   gasUsed: GasUsed;
+  /**
+   * Code the tx was reverted (or OK).
+   */
+  revertCode: RevertCode;
   /**
    * Reason the tx was reverted.
    */
@@ -114,6 +118,7 @@ export async function makeProcessedTxFromPrivateOnlyTx(
     constants,
     txEffect,
     gasUsed,
+    revertCode: RevertCode.OK,
     revertReason: undefined,
   };
 }
@@ -170,6 +175,7 @@ export async function makeProcessedTxFromTxWithPublicCalls(
     constants,
     txEffect,
     gasUsed,
+    revertCode,
     revertReason,
   };
 }

package/src/tx/tree_snapshots.ts

@@ -3,6 +3,7 @@ import type { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
+import { z } from 'zod';
 
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 
@@ -17,6 +18,20 @@ export class TreeSnapshots {
     public readonly publicDataTree: AppendOnlyTreeSnapshot,
   ) {}
 
+  static get schema() {
+    return z
+      .object({
+        l1ToL2MessageTree: AppendOnlyTreeSnapshot.schema,
+        noteHashTree: AppendOnlyTreeSnapshot.schema,
+        nullifierTree: AppendOnlyTreeSnapshot.schema,
+        publicDataTree: AppendOnlyTreeSnapshot.schema,
+      })
+      .transform(
+        ({ l1ToL2MessageTree, noteHashTree, nullifierTree, publicDataTree }) =>
+          new TreeSnapshots(l1ToL2MessageTree, noteHashTree, nullifierTree, publicDataTree),
+      );
+  }
+
   getSize() {
     return (
       this.l1ToL2MessageTree.getSize() +