@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/avm/avm_accumulated_data.ts

@@ -1,21 +1,29 @@
 import {
+  AVM_ACCUMULATED_DATA_LENGTH,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
+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 } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  assertLength,
+  serializeToBuffer,
+  serializeToFields,
+} 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 { countAccumulatedItems } from '../kernel/utils/index.js';
+import { FlatPublicLogs } from '../logs/public_log.js';
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { PublicDataWrite } from './public_data_write.js';
 
@@ -36,7 +44,7 @@ export class AvmAccumulatedData {
     /**
      * The public logs emitted from the AVM execution.
      */
-    public publicLogs: Tuple<PublicLog, typeof MAX_PUBLIC_LOGS_PER_TX>,
+    public publicLogs: FlatPublicLogs,
     /**
      * The public data writes made in the AVM execution.
      */
@@ -49,7 +57,7 @@ export class AvmAccumulatedData {
         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),
+        publicLogs: FlatPublicLogs.schema,
         publicDataWrites: PublicDataWrite.schema
           .array()
           .min(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX)
@@ -61,7 +69,7 @@ export class 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),
+            publicLogs,
             assertLength(publicDataWrites, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX),
           ),
       );
@@ -72,7 +80,7 @@ export class AvmAccumulatedData {
       arraySerializedSizeOfNonEmpty(this.noteHashes) +
       arraySerializedSizeOfNonEmpty(this.nullifiers) +
       arraySerializedSizeOfNonEmpty(this.l2ToL1Msgs) +
-      arraySerializedSizeOfNonEmpty(this.publicLogs) +
+      this.publicLogs.toBuffer().length +
       arraySerializedSizeOfNonEmpty(this.publicDataWrites)
     );
   }
@@ -83,7 +91,7 @@ export class AvmAccumulatedData {
       reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
       reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
       reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
-      reader.readArray(MAX_PUBLIC_LOGS_PER_TX, PublicLog),
+      reader.readObject(FlatPublicLogs),
       reader.readArray(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
     );
   }
@@ -92,17 +100,37 @@ export class AvmAccumulatedData {
     return serializeToBuffer(this.noteHashes, this.nullifiers, this.l2ToL1Msgs, this.publicLogs, this.publicDataWrites);
   }
 
+  static getFields(fields: FieldsOf<AvmAccumulatedData>) {
+    return [
+      fields.noteHashes,
+      fields.nullifiers,
+      fields.l2ToL1Msgs,
+      fields.publicLogs,
+      fields.publicDataWrites,
+    ] as const;
+  }
+
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     return new this(
       reader.readFieldArray(MAX_NOTE_HASHES_PER_TX),
       reader.readFieldArray(MAX_NULLIFIERS_PER_TX),
       reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
-      reader.readArray(MAX_PUBLIC_LOGS_PER_TX, PublicLog),
+      reader.readObject(FlatPublicLogs),
       reader.readArray(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
     );
   }
 
+  toFields(): Fr[] {
+    const fields = serializeToFields(...AvmAccumulatedData.getFields(this));
+    if (fields.length !== AVM_ACCUMULATED_DATA_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for AvmAccumulatedData. Expected ${AVM_ACCUMULATED_DATA_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
   static fromString(str: string) {
     return this.fromBuffer(hexToBuffer(str));
   }
@@ -116,7 +144,7 @@ export class AvmAccumulatedData {
       makeTuple(MAX_NOTE_HASHES_PER_TX, Fr.zero),
       makeTuple(MAX_NULLIFIERS_PER_TX, Fr.zero),
       makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message.empty),
-      makeTuple(MAX_PUBLIC_LOGS_PER_TX, PublicLog.empty),
+      FlatPublicLogs.empty(),
       makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite.empty),
     );
   }
@@ -126,7 +154,7 @@ export class AvmAccumulatedData {
       this.noteHashes.every(x => x.isZero()) &&
       this.nullifiers.every(x => x.isZero()) &&
       this.l2ToL1Msgs.every(x => x.isEmpty()) &&
-      this.publicLogs.every(x => x.isEmpty()) &&
+      this.publicLogs.isEmpty() &&
       this.publicDataWrites.every(x => x.isEmpty())
     );
   }
@@ -147,6 +175,7 @@ export class AvmAccumulatedData {
     .map(h => inspect(h))
     .join(', ')}],
   publicLogs: [${this.publicLogs
+    .toLogs()
     .filter(x => !x.isEmpty())
     .map(h => inspect(h))
     .join(', ')}],
@@ -154,6 +183,94 @@ export class AvmAccumulatedData {
     .filter(x => !x.isEmpty())
     .map(h => inspect(h))
     .join(', ')}],
+}`;
+  }
+
+  getArrayLengths() {
+    return new AvmAccumulatedDataArrayLengths(
+      countAccumulatedItems(this.noteHashes),
+      countAccumulatedItems(this.nullifiers),
+      countAccumulatedItems(this.l2ToL1Msgs),
+      countAccumulatedItems(this.publicDataWrites),
+    );
+  }
+}
+
+/**
+ * Represents the lengths of arrays in AVM accumulated data
+ */
+export class AvmAccumulatedDataArrayLengths {
+  constructor(
+    /**
+     * Number of note hashes
+     */
+    public noteHashes: number,
+    /**
+     * Number of nullifiers
+     */
+    public nullifiers: number,
+    /**
+     * Number of L2 to L1 messages
+     */
+    public l2ToL1Msgs: number,
+    /**
+     * Number of public data writes
+     */
+    public publicDataWrites: number,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        noteHashes: z.number(),
+        nullifiers: z.number(),
+        l2ToL1Msgs: z.number(),
+        publicDataWrites: z.number(),
+      })
+      .transform(
+        ({ noteHashes, nullifiers, l2ToL1Msgs, publicDataWrites }) =>
+          new AvmAccumulatedDataArrayLengths(noteHashes, nullifiers, l2ToL1Msgs, publicDataWrites),
+      );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new AvmAccumulatedDataArrayLengths(
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readNumber(),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.noteHashes, this.nullifiers, this.l2ToL1Msgs, this.publicDataWrites);
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new AvmAccumulatedDataArrayLengths(
+      Number(reader.readField()),
+      Number(reader.readField()),
+      Number(reader.readField()),
+      Number(reader.readField()),
+    );
+  }
+
+  toFields(): Fr[] {
+    return [new Fr(this.noteHashes), new Fr(this.nullifiers), new Fr(this.l2ToL1Msgs), new Fr(this.publicDataWrites)];
+  }
+
+  static empty() {
+    return new AvmAccumulatedDataArrayLengths(0, 0, 0, 0);
+  }
+
+  [inspect.custom]() {
+    return `AvmAccumulatedDataArrayLengths {
+  noteHashes: ${this.noteHashes},
+  nullifiers: ${this.nullifiers},
+  l2ToL1Msgs: ${this.l2ToL1Msgs},
+  publicDataWrites: ${this.publicDataWrites},
 }`;
   }
 }

package/src/avm/avm_circuit_public_inputs.ts

@@ -9,26 +9,33 @@ import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import { Gas, GasSettings } from '../gas/index.js';
+import { Gas, GasFees, GasSettings } from '../gas/index.js';
 import {
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
 } from '../kernel/private_to_avm_accumulated_data.js';
-import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { PublicCallRequest, PublicCallRequestArrayLengths } from '../kernel/public_call_request.js';
 import { GlobalVariables } from '../tx/global_variables.js';
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
 import { TreeSnapshots } from '../tx/tree_snapshots.js';
-import { AvmAccumulatedData } from './avm_accumulated_data.js';
+import { AvmAccumulatedData, AvmAccumulatedDataArrayLengths } 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(
+    ///////////////////////////////////
+    // Inputs.
     public globalVariables: GlobalVariables,
+    public protocolContracts: ProtocolContracts,
     public startTreeSnapshots: TreeSnapshots,
     public startGasUsed: Gas,
     public gasSettings: GasSettings,
+    public effectiveGasFees: GasFees,
     public feePayer: AztecAddress,
+    public proverId: Fr,
+    public publicCallRequestArrayLengths: PublicCallRequestArrayLengths,
     public publicSetupCallRequests: Tuple<PublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_TX>,
     public publicAppLogicCallRequests: Tuple<PublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_TX>,
     public publicTeardownCallRequest: PublicCallRequest,
@@ -36,8 +43,11 @@ export class AvmCircuitPublicInputs {
     public previousRevertibleAccumulatedDataArrayLengths: PrivateToAvmAccumulatedDataArrayLengths,
     public previousNonRevertibleAccumulatedData: PrivateToAvmAccumulatedData,
     public previousRevertibleAccumulatedData: PrivateToAvmAccumulatedData,
+    ///////////////////////////////////
+    // Outputs.
     public endTreeSnapshots: TreeSnapshots,
     public endGasUsed: Gas,
+    public accumulatedDataArrayLengths: AvmAccumulatedDataArrayLengths,
     public accumulatedData: AvmAccumulatedData,
     public transactionFee: Fr,
     public reverted: boolean,
@@ -47,10 +57,14 @@ export class AvmCircuitPublicInputs {
     return z
       .object({
         globalVariables: GlobalVariables.schema,
+        protocolContracts: ProtocolContracts.schema,
         startTreeSnapshots: TreeSnapshots.schema,
         startGasUsed: Gas.schema,
         gasSettings: GasSettings.schema,
+        effectiveGasFees: GasFees.schema,
         feePayer: AztecAddress.schema,
+        proverId: Fr.schema,
+        publicCallRequestArrayLengths: PublicCallRequestArrayLengths.schema,
         publicSetupCallRequests: PublicCallRequest.schema.array().max(MAX_ENQUEUED_CALLS_PER_TX),
         publicAppLogicCallRequests: PublicCallRequest.schema.array().max(MAX_ENQUEUED_CALLS_PER_TX),
         publicTeardownCallRequest: PublicCallRequest.schema,
@@ -60,6 +74,7 @@ export class AvmCircuitPublicInputs {
         previousRevertibleAccumulatedData: PrivateToAvmAccumulatedData.schema,
         endTreeSnapshots: TreeSnapshots.schema,
         endGasUsed: Gas.schema,
+        accumulatedDataArrayLengths: AvmAccumulatedDataArrayLengths.schema,
         accumulatedData: AvmAccumulatedData.schema,
         transactionFee: schemas.Fr,
         reverted: z.boolean(),
@@ -67,10 +82,14 @@ export class AvmCircuitPublicInputs {
       .transform(
         ({
           globalVariables,
+          protocolContracts,
           startTreeSnapshots,
           startGasUsed,
           gasSettings,
+          effectiveGasFees,
           feePayer,
+          proverId,
+          publicCallRequestArrayLengths,
           publicSetupCallRequests,
           publicAppLogicCallRequests,
           publicTeardownCallRequest,
@@ -80,16 +99,21 @@ export class AvmCircuitPublicInputs {
           previousRevertibleAccumulatedData,
           endTreeSnapshots,
           endGasUsed,
+          accumulatedDataArrayLengths,
           accumulatedData,
           transactionFee,
           reverted,
         }) =>
           new AvmCircuitPublicInputs(
             globalVariables,
+            protocolContracts,
             startTreeSnapshots,
             startGasUsed,
             gasSettings,
+            effectiveGasFees,
             feePayer,
+            proverId,
+            publicCallRequestArrayLengths,
             assertLength(publicSetupCallRequests, MAX_ENQUEUED_CALLS_PER_TX),
             assertLength(publicAppLogicCallRequests, MAX_ENQUEUED_CALLS_PER_TX),
             publicTeardownCallRequest,
@@ -99,6 +123,7 @@ export class AvmCircuitPublicInputs {
             previousRevertibleAccumulatedData,
             endTreeSnapshots,
             endGasUsed,
+            accumulatedDataArrayLengths,
             accumulatedData,
             transactionFee,
             reverted,
@@ -110,10 +135,14 @@ export class AvmCircuitPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new AvmCircuitPublicInputs(
       reader.readObject(GlobalVariables),
+      reader.readObject(ProtocolContracts),
       reader.readObject(TreeSnapshots),
       reader.readObject(Gas),
       reader.readObject(GasSettings),
+      reader.readObject(GasFees),
       reader.readObject(AztecAddress),
+      reader.readObject(Fr),
+      reader.readObject(PublicCallRequestArrayLengths),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readObject(PublicCallRequest),
@@ -123,6 +152,7 @@ export class AvmCircuitPublicInputs {
       reader.readObject(PrivateToAvmAccumulatedData),
       reader.readObject(TreeSnapshots),
       reader.readObject(Gas),
+      reader.readObject(AvmAccumulatedDataArrayLengths),
       reader.readObject(AvmAccumulatedData),
       reader.readObject(Fr),
       reader.readBoolean(),
@@ -132,10 +162,14 @@ export class AvmCircuitPublicInputs {
   toBuffer() {
     return serializeToBuffer(
       this.globalVariables,
+      this.protocolContracts,
       this.startTreeSnapshots,
       this.startGasUsed,
       this.gasSettings,
+      this.effectiveGasFees,
       this.feePayer,
+      this.proverId,
+      this.publicCallRequestArrayLengths,
       this.publicSetupCallRequests,
       this.publicAppLogicCallRequests,
       this.publicTeardownCallRequest,
@@ -145,6 +179,7 @@ export class AvmCircuitPublicInputs {
       this.previousRevertibleAccumulatedData,
       this.endTreeSnapshots,
       this.endGasUsed,
+      this.accumulatedDataArrayLengths,
       this.accumulatedData,
       this.transactionFee,
       this.reverted,
@@ -163,10 +198,14 @@ export class AvmCircuitPublicInputs {
     const reader = FieldReader.asReader(fields);
     return new AvmCircuitPublicInputs(
       GlobalVariables.fromFields(reader),
+      ProtocolContracts.fromFields(reader),
       TreeSnapshots.fromFields(reader),
       Gas.fromFields(reader),
       GasSettings.fromFields(reader),
+      GasFees.fromFields(reader),
       AztecAddress.fromFields(reader),
+      reader.readField(),
+      PublicCallRequestArrayLengths.fromFields(reader),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       PublicCallRequest.fromFields(reader),
@@ -176,19 +215,51 @@ export class AvmCircuitPublicInputs {
       PrivateToAvmAccumulatedData.fromFields(reader),
       TreeSnapshots.fromFields(reader),
       Gas.fromFields(reader),
+      AvmAccumulatedDataArrayLengths.fromFields(reader),
       AvmAccumulatedData.fromFields(reader),
       reader.readField(),
       reader.readBoolean(),
     );
   }
 
+  toFields() {
+    return [
+      ...this.globalVariables.toFields(),
+      ...this.protocolContracts.toFields(),
+      ...this.startTreeSnapshots.toFields(),
+      ...this.startGasUsed.toFields(),
+      ...this.gasSettings.toFields(),
+      ...this.effectiveGasFees.toFields(),
+      this.feePayer,
+      this.proverId,
+      ...this.publicCallRequestArrayLengths.toFields(),
+      ...this.publicSetupCallRequests.map(request => request.toFields()),
+      ...this.publicAppLogicCallRequests.map(request => request.toFields()),
+      ...this.publicTeardownCallRequest.toFields(),
+      ...this.previousNonRevertibleAccumulatedDataArrayLengths.toFields(),
+      ...this.previousRevertibleAccumulatedDataArrayLengths.toFields(),
+      ...this.previousNonRevertibleAccumulatedData.toFields(),
+      ...this.previousRevertibleAccumulatedData.toFields(),
+      ...this.endTreeSnapshots.toFields(),
+      ...this.endGasUsed.toFields(),
+      ...this.accumulatedDataArrayLengths.toFields(),
+      ...this.accumulatedData.toFields(),
+      this.transactionFee,
+      this.reverted,
+    ];
+  }
+
   static empty() {
     return new AvmCircuitPublicInputs(
       GlobalVariables.empty(),
+      ProtocolContracts.empty(),
       TreeSnapshots.empty(),
       Gas.empty(),
       GasSettings.empty(),
+      GasFees.empty(),
       AztecAddress.zero(),
+      Fr.zero(),
+      PublicCallRequestArrayLengths.empty(),
       makeTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest.empty),
       makeTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest.empty),
       PublicCallRequest.empty(),
@@ -198,6 +269,7 @@ export class AvmCircuitPublicInputs {
       PrivateToAvmAccumulatedData.empty(),
       TreeSnapshots.empty(),
       Gas.empty(),
+      AvmAccumulatedDataArrayLengths.empty(),
       AvmAccumulatedData.empty(),
       Fr.zero(),
       false,
@@ -211,10 +283,14 @@ export class AvmCircuitPublicInputs {
   [inspect.custom]() {
     return `AvmCircuitPublicInputs {
       globalVariables: ${inspect(this.globalVariables)},
+      protocolContracts: ${inspect(this.protocolContracts)},
       startTreeSnapshots: ${inspect(this.startTreeSnapshots)},
       startGasUsed: ${inspect(this.startGasUsed)},
       gasSettings: ${inspect(this.gasSettings)},
+      effectiveGasFees: ${inspect(this.effectiveGasFees)},
       feePayer: ${inspect(this.feePayer)},
+      proverId: ${inspect(this.proverId)},
+      publicCallRequestArrayLengths: ${inspect(this.publicCallRequestArrayLengths)},
       publicSetupCallRequests: [${this.publicSetupCallRequests
         .filter(x => !x.isEmpty())
         .map(h => inspect(h))
@@ -232,6 +308,7 @@ export class AvmCircuitPublicInputs {
       previousRevertibleAccumulatedData: ${inspect(this.previousRevertibleAccumulatedData)},
       endTreeSnapshots: ${inspect(this.endTreeSnapshots)},
       endGasUsed: ${inspect(this.endGasUsed)},
+      accumulatedDataArrayLengths: ${inspect(this.accumulatedDataArrayLengths)},
       accumulatedData: ${inspect(this.accumulatedData)},
       transactionFee: ${inspect(this.transactionFee)},
       reverted: ${this.reverted},

package/src/avm/index.ts

@@ -3,10 +3,10 @@ export * from './avm_accumulated_data.js';
 export * from './avm_circuit_public_inputs.js';
 export * from './revert_code.js';
 export * from './public_data_write.js';
-export * from './public_data_hint.js';
 export * from './public_data_update_request.js';
 export * from './contract_storage_update_request.js';
 export * from './contract_storage_read.js';
 export * from './public_inner_call_request.js';
 export * from './public_call_stack_item_compressed.js';
 export * from './avm_proving_request.js';
+export * from './message_pack.js';

package/src/avm/message_pack.ts

@@ -1,7 +1,8 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fq, Fr, Point } from '@aztec/foundation/fields';
 
 import { strict as assert } from 'assert';
-import { Encoder, addExtension } from 'msgpackr';
+import { Decoder, Encoder, addExtension } from 'msgpackr';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
@@ -12,10 +13,21 @@ export function serializeWithMessagePack(obj: any): Buffer {
     // this makes it compatible with other MessagePack decoders
     useRecords: false,
     int64AsType: 'bigint',
+    largeBigIntToString: true,
   });
   return encoder.encode(obj);
 }
 
+export function deserializeFromMessagePack<T>(buffer: Buffer): T {
+  setUpMessagePackExtensions();
+  const decoder = new Decoder({
+    useRecords: false,
+    int64AsType: 'bigint',
+    largeBigIntToString: true,
+  });
+  return decoder.decode(buffer);
+}
+
 let messagePackWasSetUp = false;
 function setUpMessagePackExtensions() {
   if (messagePackWasSetUp) {
@@ -25,15 +37,24 @@ function setUpMessagePackExtensions() {
   addExtension({
     Class: Fr,
     write: (fr: Fr) => fr.toBuffer(),
+    read: (data: Buffer) => Fr.fromBuffer(data),
   });
   addExtension({
     Class: Fq,
     write: (fq: Fq) => fq.toBuffer(),
+    read: (data: Buffer) => Fq.fromBuffer(data),
   });
-  // AztecAddress is a class that has a field in TS, but just a field in C++.
+  // AztecAddress is a class that has a field in TS, but is itself a field in C++.
   addExtension({
     Class: AztecAddress,
     write: (addr: AztecAddress) => addr.toField(),
+    read: (data: Fr | Buffer) => {
+      // If C++ sent it as Fr, wrap it. If as buffer, construct from buffer.
+      if (data instanceof Fr) {
+        return new AztecAddress(data);
+      }
+      return new AztecAddress(Fr.fromBuffer(data));
+    },
   });
   // Affine points are a mess, we do our best.
   addExtension({
@@ -43,6 +64,16 @@ function setUpMessagePackExtensions() {
       // TODO: should these be Frs?
       return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
     },
+    read: (data: { x: Fq; y: Fq }) => {
+      // Convert Fq back to Fr for Point constructor
+      return new Point(new Fr(data.x.toBigInt()), new Fr(data.y.toBigInt()), false);
+    },
+  });
+  // EthAddress is a class that has a buffer in TS, but is itself just a field in C++.
+  addExtension({
+    Class: EthAddress,
+    write: (addr: EthAddress) => addr.toField().toBuffer(),
+    read: (data: Buffer) => EthAddress.fromField(Fr.fromBuffer(data)),
   });
   messagePackWasSetUp = true;
 }

package/src/avm/public_data_write.ts

@@ -1,6 +1,7 @@
+import { PUBLIC_DATA_WRITE_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -45,6 +46,25 @@ export class PublicDataWrite {
     return new PublicDataWrite(reader.readField(), reader.readField());
   }
 
+  toFields(): Fr[] {
+    const fields = serializeToFields(...PublicDataWrite.getFields(this));
+    if (fields.length !== PUBLIC_DATA_WRITE_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for PublicDataWrite. Expected ${PUBLIC_DATA_WRITE_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  static fromBlobFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new PublicDataWrite(reader.readField(), reader.readField());
+  }
+
+  toBlobFields(): Fr[] {
+    return [this.leafSlot, this.value];
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PublicDataWrite(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
@@ -77,4 +97,8 @@ export class PublicDataWrite {
   isEmpty() {
     return this.leafSlot.isZero() && this.value.isZero();
   }
+
+  equals(other: PublicDataWrite): boolean {
+    return this.leafSlot.equals(other.leafSlot) && this.value.equals(other.value);
+  }
 }

package/src/avm/public_inner_call_request.ts

@@ -78,7 +78,7 @@ export class PublicInnerCallRequest {
 
   [inspect.custom]() {
     return `PublicInnerCallRequest {
-      item: ${this.item}
+      item: ${this.item.toFields()}
       counter: ${this.counter}
     }`;
   }

package/src/avm/revert_code.ts

@@ -13,10 +13,10 @@ export enum RevertCodeEnum {
 
 function isRevertCodeEnum(value: number): value is RevertCodeEnum {
   return (
-    value === RevertCodeEnum.OK ||
-    value === RevertCodeEnum.APP_LOGIC_REVERTED ||
-    value === RevertCodeEnum.TEARDOWN_REVERTED ||
-    value === RevertCodeEnum.BOTH_REVERTED
+    (value as RevertCodeEnum) === RevertCodeEnum.OK ||
+    (value as RevertCodeEnum) === RevertCodeEnum.APP_LOGIC_REVERTED ||
+    (value as RevertCodeEnum) === RevertCodeEnum.TEARDOWN_REVERTED ||
+    (value as RevertCodeEnum) === RevertCodeEnum.BOTH_REVERTED
   );
 }
 
@@ -46,7 +46,7 @@ export class RevertCode {
   }
 
   public getDescription() {
-    switch (this.code) {
+    switch (this.code as RevertCodeEnum) {
       case RevertCodeEnum.OK:
         return 'OK';
       case RevertCodeEnum.APP_LOGIC_REVERTED: