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

package/src/avm/avm.ts

@@ -1,86 +1,26 @@
-import { Fq, Fr, Point } from '@aztec/foundation/fields';
-import { bufferSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import type { FieldsOf } from '@aztec/foundation/types';
+import { Fr } from '@aztec/foundation/fields';
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import { schemas } from '@aztec/foundation/schemas';
 
-import { strict as assert } from 'assert';
-import { Encoder, addExtension } from 'msgpackr';
+import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { PublicKeys } from '../keys/public_keys.js';
 import { NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
 import { PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
-import { Vector } from '../types/shared.js';
 import { AvmCircuitPublicInputs } from './avm_circuit_public_inputs.js';
+import { serializeWithMessagePack } from './message_pack.js';
 
 export class AvmEnqueuedCallHint {
-  public readonly contractAddress: AztecAddress;
-  public readonly calldata: Vector<Fr>;
+  constructor(public readonly contractAddress: AztecAddress, public readonly calldata: Fr[]) {}
 
-  constructor(contractAddress: AztecAddress, calldata: Fr[]) {
-    this.contractAddress = contractAddress;
-    this.calldata = new Vector(calldata);
-  }
-
-  /* Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmEnqueuedCallHint.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return bufferToHex(this.toBuffer());
-  }
-
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return this.contractAddress.isZero() && this.calldata.items.length == 0;
-  }
-
-  /**
-   * Creates a new instance from fields.
-   * @param fields - Fields to create the instance from.
-   * @returns A new AvmExecutionHints instance.
-   */
-  static from(fields: FieldsOf<AvmEnqueuedCallHint>): AvmEnqueuedCallHint {
-    return new AvmEnqueuedCallHint(fields.contractAddress, fields.calldata.items);
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmEnqueuedCallHint>) {
-    return [fields.contractAddress, fields.calldata] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buff);
-    return new AvmEnqueuedCallHint(AztecAddress.fromBuffer(reader), reader.readVector(Fr));
-  }
-
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmEnqueuedCallHint {
-    return AvmEnqueuedCallHint.fromBuffer(hexToBuffer(str));
+  static get schema() {
+    return z
+      .object({
+        contractAddress: AztecAddress.schema,
+        calldata: schemas.Fr.array(),
+      })
+      .transform(({ contractAddress, calldata }) => new AvmEnqueuedCallHint(contractAddress, calldata));
   }
 }
 
@@ -94,84 +34,31 @@ export class AvmContractClassHint {
     public readonly packedBytecode: Buffer,
   ) {}
 
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmContractClassHint.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return bufferToHex(this.toBuffer());
-  }
-
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return (
-      this.classId.isZero() &&
-      !this.exists &&
-      this.artifactHash.isZero() &&
-      this.privateFunctionsRoot.isZero() &&
-      this.publicBytecodeCommitment.isZero() &&
-      this.packedBytecode.length == 0
-    );
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmContractClassHint>) {
-    return [
-      fields.classId,
-      fields.exists,
-      fields.artifactHash,
-      fields.privateFunctionsRoot,
-      fields.publicBytecodeCommitment,
-      fields.packedBytecode.length, // we need to manually prepend the length...
-      fields.packedBytecode,
-    ] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmContractClassHint {
-    const reader = BufferReader.asReader(buff);
-    return new AvmContractClassHint(
-      Fr.fromBuffer(reader),
-      reader.readBoolean(),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      reader.readBuffer(),
-    );
-  }
-
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmContractClassHint {
-    return AvmContractClassHint.fromBuffer(hexToBuffer(str));
+  static get schema() {
+    return z
+      .object({
+        classId: schemas.Fr,
+        exists: z.boolean(),
+        artifactHash: schemas.Fr,
+        privateFunctionsRoot: schemas.Fr,
+        publicBytecodeCommitment: schemas.Fr,
+        packedBytecode: schemas.Buffer,
+      })
+      .transform(
+        ({ classId, exists, artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode }) =>
+          new AvmContractClassHint(
+            classId,
+            exists,
+            artifactHash,
+            privateFunctionsRoot,
+            publicBytecodeCommitment,
+            packedBytecode,
+          ),
+      );
   }
 }
 
 export class AvmContractInstanceHint {
-  public readonly updatePreimage: Vector<Fr>;
-
   constructor(
     public readonly address: AztecAddress,
     public readonly exists: boolean,
@@ -181,653 +68,207 @@ export class AvmContractInstanceHint {
     public readonly originalContractClassId: Fr,
     public readonly initializationHash: Fr,
     public readonly publicKeys: PublicKeys,
-    public readonly updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
-    updatePreimage: Fr[],
-  ) {
-    this.updatePreimage = new Vector(updatePreimage);
-  }
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmContractInstanceHint.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return bufferToHex(this.toBuffer());
-  }
-
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return (
-      this.address.isZero() &&
-      !this.exists &&
-      this.salt.isZero() &&
-      this.deployer.isZero() &&
-      this.currentContractClassId.isZero() &&
-      this.originalContractClassId.isZero() &&
-      this.initializationHash.isZero() &&
-      this.publicKeys.isEmpty() &&
-      this.updateMembershipHint.isEmpty() &&
-      this.updatePreimage.items.length == 0
-    );
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmContractInstanceHint>) {
-    return [
-      fields.address,
-      fields.exists,
-      fields.salt,
-      fields.deployer,
-      fields.currentContractClassId,
-      fields.originalContractClassId,
-      fields.initializationHash,
-      fields.publicKeys,
-      fields.updateMembershipHint,
-      fields.updatePreimage,
-    ] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmContractInstanceHint {
-    const reader = BufferReader.asReader(buff);
-    return new AvmContractInstanceHint(
-      AztecAddress.fromBuffer(reader),
-      reader.readBoolean(),
-      Fr.fromBuffer(reader),
-      AztecAddress.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      PublicKeys.fromBuffer(reader),
-      AvmPublicDataReadTreeHint.fromBuffer(reader),
-      reader.readVector(Fr),
-    );
-  }
+    // public readonly updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
+    public readonly updateMembershipHint: AvmPublicDataReadTreeHint,
+    public readonly updatePreimage: Fr[] = [],
+  ) {}
 
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmContractInstanceHint {
-    return AvmContractInstanceHint.fromBuffer(hexToBuffer(str));
+  static get schema() {
+    return z
+      .object({
+        address: AztecAddress.schema,
+        exists: z.boolean(),
+        salt: schemas.Fr,
+        deployer: AztecAddress.schema,
+        currentContractClassId: schemas.Fr,
+        originalContractClassId: schemas.Fr,
+        initializationHash: schemas.Fr,
+        publicKeys: PublicKeys.schema,
+        updateMembershipHint: AvmPublicDataReadTreeHint.schema,
+        updatePreimage: schemas.Fr.array(),
+      })
+      .transform(
+        ({
+          address,
+          exists,
+          salt,
+          deployer,
+          currentContractClassId,
+          originalContractClassId,
+          initializationHash,
+          publicKeys,
+          updateMembershipHint,
+          updatePreimage,
+        }) =>
+          new AvmContractInstanceHint(
+            address,
+            exists,
+            salt,
+            deployer,
+            currentContractClassId,
+            originalContractClassId,
+            initializationHash,
+            publicKeys,
+            updateMembershipHint,
+            updatePreimage,
+          ),
+      );
   }
 }
 
 export class AvmAppendTreeHint {
-  readonly siblingPath: Vector<Fr>;
-  /*
-   * @param bytecode the contract bytecode
-   * @param contractInstance the contract instance of the nested call, used to derive the contract address
-   * @param contractClassPreimage the contract class preimage of the nested call, used to derive the class id
-   * */
-  constructor(public readonly leafIndex: Fr, public readonly value: Fr, readonly _siblingPath: Fr[]) {
-    this.siblingPath = new Vector(_siblingPath);
-  }
+  constructor(public readonly leafIndex: Fr, public readonly value: Fr, public readonly siblingPath: Fr[]) {}
 
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmAppendTreeHint.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return this.toBuffer().toString('hex');
-  }
-
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return this.value.isZero() && this.siblingPath.items.length == 0;
-  }
-
-  /**
-   * Creates a new instance from fields.
-   * @param fields - Fields to create the instance from.
-   * @returns A new AvmHint instance.
-   */
-  static from(fields: FieldsOf<AvmAppendTreeHint>): AvmAppendTreeHint {
-    return new AvmAppendTreeHint(fields.leafIndex, fields.value, fields.siblingPath.items);
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmAppendTreeHint>) {
-    return [fields.leafIndex, fields.value, fields.siblingPath] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmAppendTreeHint {
-    return new AvmAppendTreeHint(Fr.fromBuffer(buff), Fr.fromBuffer(buff), BufferReader.asReader(buff).readVector(Fr));
-  }
-
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmAppendTreeHint {
-    return AvmAppendTreeHint.fromBuffer(Buffer.from(str, 'hex'));
+  static get schema() {
+    return z
+      .object({
+        leafIndex: schemas.Fr,
+        value: schemas.Fr,
+        siblingPath: schemas.Fr.array(),
+      })
+      .transform(({ leafIndex, value, siblingPath }) => new AvmAppendTreeHint(leafIndex, value, siblingPath));
   }
 }
 
 export class AvmNullifierWriteTreeHint {
-  readonly insertionPath: Vector<Fr>;
-  /*
-   * @param bytecode the contract bytecode
-   * @param contractInstance the contract instance of the nested call, used to derive the contract address
-   * @param contractClassPreimage the contract class preimage of the nested call, used to derive the class id
-   * */
-  constructor(public lowLeafRead: AvmNullifierReadTreeHint, public _insertionPath: Fr[]) {
-    this.insertionPath = new Vector(_insertionPath);
-  }
-
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmNullifierWriteTreeHint.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return this.toBuffer().toString('hex');
-  }
-
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return this.insertionPath.items.length == 0;
-  }
+  constructor(public lowLeafRead: AvmNullifierReadTreeHint, public readonly insertionPath: Fr[]) {}
 
-  /**
-   * Creates a new instance from fields.
-   * @param fields - Fields to create the instance from.
-   * @returns A new AvmHint instance.
-   */
-  static from(fields: FieldsOf<AvmNullifierWriteTreeHint>): AvmNullifierWriteTreeHint {
-    return new AvmNullifierWriteTreeHint(fields.lowLeafRead, fields.insertionPath.items);
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmNullifierWriteTreeHint>) {
-    return [...AvmNullifierReadTreeHint.getFields(fields.lowLeafRead), fields.insertionPath] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmNullifierWriteTreeHint {
-    const reader = BufferReader.asReader(buff);
-    const lowLeafRead = AvmNullifierReadTreeHint.fromBuffer(reader);
-    const insertionPath = reader.readVector(Fr);
-    return new AvmNullifierWriteTreeHint(lowLeafRead, insertionPath);
-  }
-
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmNullifierWriteTreeHint {
-    return AvmNullifierWriteTreeHint.fromBuffer(Buffer.from(str, 'hex'));
+  static get schema() {
+    return z
+      .object({
+        lowLeafRead: AvmNullifierReadTreeHint.schema,
+        insertionPath: schemas.Fr.array(),
+      })
+      .transform(({ lowLeafRead, insertionPath }) => new AvmNullifierWriteTreeHint(lowLeafRead, insertionPath));
   }
 }
 
 export class AvmNullifierReadTreeHint {
-  readonly lowLeafSiblingPath: Vector<Fr>;
-
   constructor(
     public readonly lowLeafPreimage: NullifierLeafPreimage,
     public readonly lowLeafIndex: Fr,
-    public _lowLeafSiblingPath: Fr[],
-  ) {
-    this.lowLeafSiblingPath = new Vector(_lowLeafSiblingPath);
-  }
-
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmNullifierReadTreeHint.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return this.toBuffer().toString('hex');
-  }
-
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return this.lowLeafSiblingPath.items.length == 0;
-  }
-
-  /**
-   * Creates a new instance from fields.
-   * @param fields - Fields to create the instance from.
-   * @returns A new AvmHint instance.
-   */
-  static from(fields: FieldsOf<AvmNullifierReadTreeHint>): AvmNullifierReadTreeHint {
-    return new AvmNullifierReadTreeHint(fields.lowLeafPreimage, fields.lowLeafIndex, fields.lowLeafSiblingPath.items);
-  }
-
-  static empty(): AvmNullifierReadTreeHint {
-    return new AvmNullifierReadTreeHint(NullifierLeafPreimage.empty(), Fr.ZERO, []);
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmNullifierReadTreeHint>) {
-    return [
-      fields.lowLeafPreimage.nullifier,
-      fields.lowLeafPreimage.nextNullifier,
-      new Fr(fields.lowLeafPreimage.nextIndex),
-      fields.lowLeafIndex,
-      fields.lowLeafSiblingPath,
-    ] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmNullifierReadTreeHint {
-    const reader = BufferReader.asReader(buff);
-    const lowLeafPreimage = reader.readObject<NullifierLeafPreimage>(NullifierLeafPreimage);
-    const lowLeafIndex = Fr.fromBuffer(reader);
-    const lowSiblingPath = reader.readVector(Fr);
-
-    return new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowSiblingPath);
-  }
+    public readonly lowLeafSiblingPath: Fr[],
+  ) {}
 
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmNullifierReadTreeHint {
-    return AvmNullifierReadTreeHint.fromBuffer(Buffer.from(str, 'hex'));
+  static get schema() {
+    return z
+      .object({
+        lowLeafPreimage: NullifierLeafPreimage.schema,
+        lowLeafIndex: schemas.Fr,
+        lowLeafSiblingPath: schemas.Fr.array(),
+      })
+      .transform(
+        ({ lowLeafPreimage, lowLeafIndex, lowLeafSiblingPath }) =>
+          new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafSiblingPath),
+      );
   }
 }
 
 export class AvmPublicDataReadTreeHint {
-  siblingPath: Vector<Fr>;
-
   constructor(
     public readonly leafPreimage: PublicDataTreeLeafPreimage,
     public readonly leafIndex: Fr,
-    public readonly _siblingPath: Fr[],
-  ) {
-    this.siblingPath = new Vector(_siblingPath);
-  }
-
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmPublicDataReadTreeHint.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return this.toBuffer().toString('hex');
-  }
+    public readonly siblingPath: Fr[],
+  ) {}
 
-  static empty(): AvmPublicDataReadTreeHint {
+  static empty() {
     return new AvmPublicDataReadTreeHint(PublicDataTreeLeafPreimage.empty(), Fr.ZERO, []);
   }
 
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return this.siblingPath.items.length == 0;
-  }
-
-  /**
-   * Creates a new instance from fields.
-   * @param fields - Fields to create the instance from.
-   * @returns A new AvmHint instance.
-   */
-  static from(fields: FieldsOf<AvmPublicDataReadTreeHint>): AvmPublicDataReadTreeHint {
-    return new AvmPublicDataReadTreeHint(fields.leafPreimage, fields.leafIndex, fields.siblingPath.items);
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmPublicDataReadTreeHint>) {
-    return [
-      fields.leafPreimage.slot,
-      fields.leafPreimage.value,
-      new Fr(fields.leafPreimage.nextIndex),
-      fields.leafPreimage.nextSlot,
-      fields.leafIndex,
-      fields.siblingPath,
-    ] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmPublicDataReadTreeHint {
-    const reader = BufferReader.asReader(buff);
-    const lowLeafPreimage = reader.readObject<PublicDataTreeLeafPreimage>(PublicDataTreeLeafPreimage);
-    const lowLeafIndex = Fr.fromBuffer(reader);
-    const lowSiblingPath = reader.readVector(Fr);
-
-    return new AvmPublicDataReadTreeHint(lowLeafPreimage, lowLeafIndex, lowSiblingPath);
-  }
-
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmPublicDataReadTreeHint {
-    return AvmPublicDataReadTreeHint.fromBuffer(Buffer.from(str, 'hex'));
+  static get schema() {
+    return z
+      .object({
+        leafPreimage: PublicDataTreeLeafPreimage.schema,
+        leafIndex: schemas.Fr,
+        siblingPath: schemas.Fr.array(),
+      })
+      .transform(
+        ({ leafPreimage, leafIndex, siblingPath }) =>
+          new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, siblingPath),
+      );
   }
 }
 
 export class AvmPublicDataWriteTreeHint {
-  insertionPath: Vector<Fr>;
-
   constructor(
     // To check the current slot has been written to
     public readonly lowLeafRead: AvmPublicDataReadTreeHint,
     public readonly newLeafPreimage: PublicDataTreeLeafPreimage,
-    public readonly _insertionPath: Fr[],
-  ) {
-    this.insertionPath = new Vector(_insertionPath);
-  }
-
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmPublicDataWriteTreeHint.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return this.toBuffer().toString('hex');
-  }
-
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return this.insertionPath.items.length == 0;
-  }
-
-  /**
-   * Creates a new instance from fields.
-   * @param fields - Fields to create the instance from.
-   * @returns A new AvmHint instance.
-   */
-  static from(fields: FieldsOf<AvmPublicDataWriteTreeHint>): AvmPublicDataWriteTreeHint {
-    return new AvmPublicDataWriteTreeHint(fields.lowLeafRead, fields.newLeafPreimage, fields.insertionPath.items);
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmPublicDataWriteTreeHint>) {
-    return [
-      ...AvmPublicDataReadTreeHint.getFields(fields.lowLeafRead),
-      fields.newLeafPreimage.slot,
-      fields.newLeafPreimage.value,
-      new Fr(fields.newLeafPreimage.nextIndex),
-      fields.newLeafPreimage.nextSlot,
-      fields.insertionPath,
-    ] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmPublicDataWriteTreeHint {
-    const reader = BufferReader.asReader(buff);
-    const lowLeafPreimage = reader.readObject<AvmPublicDataReadTreeHint>(AvmPublicDataReadTreeHint);
-    const newLeafPreimage = reader.readObject<PublicDataTreeLeafPreimage>(PublicDataTreeLeafPreimage);
-    const lowSiblingPath = reader.readVector(Fr);
-
-    return new AvmPublicDataWriteTreeHint(lowLeafPreimage, newLeafPreimage, lowSiblingPath);
-  }
+    public readonly insertionPath: Fr[],
+  ) {}
 
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmPublicDataWriteTreeHint {
-    return AvmPublicDataWriteTreeHint.fromBuffer(Buffer.from(str, 'hex'));
+  static get schema() {
+    return z
+      .object({
+        lowLeafRead: AvmPublicDataReadTreeHint.schema,
+        newLeafPreimage: PublicDataTreeLeafPreimage.schema,
+        insertionPath: schemas.Fr.array(),
+      })
+      .transform(
+        ({ lowLeafRead, newLeafPreimage, insertionPath }) =>
+          new AvmPublicDataWriteTreeHint(lowLeafRead, newLeafPreimage, insertionPath),
+      );
   }
 }
 
 export class AvmExecutionHints {
-  public readonly enqueuedCalls: Vector<AvmEnqueuedCallHint>;
-
-  public readonly contractInstances: Vector<AvmContractInstanceHint>;
-  public readonly contractClasses: Vector<AvmContractClassHint>;
-
-  public readonly publicDataReads: Vector<AvmPublicDataReadTreeHint>;
-  public readonly publicDataWrites: Vector<AvmPublicDataWriteTreeHint>;
-  public readonly nullifierReads: Vector<AvmNullifierReadTreeHint>;
-  public readonly nullifierWrites: Vector<AvmNullifierWriteTreeHint>;
-  public readonly noteHashReads: Vector<AvmAppendTreeHint>;
-  public readonly noteHashWrites: Vector<AvmAppendTreeHint>;
-  public readonly l1ToL2MessageReads: Vector<AvmAppendTreeHint>;
-
   constructor(
-    enqueuedCalls: AvmEnqueuedCallHint[],
-    contractInstances: AvmContractInstanceHint[],
-    contractClasses: AvmContractClassHint[],
-    publicDataReads: AvmPublicDataReadTreeHint[],
-    publicDataWrites: AvmPublicDataWriteTreeHint[],
-    nullifierReads: AvmNullifierReadTreeHint[],
-    nullifierWrites: AvmNullifierWriteTreeHint[],
-    noteHashReads: AvmAppendTreeHint[],
-    noteHashWrites: AvmAppendTreeHint[],
-    l1ToL2MessageReads: AvmAppendTreeHint[],
-  ) {
-    this.enqueuedCalls = new Vector(enqueuedCalls);
-    this.contractInstances = new Vector(contractInstances);
-    this.contractClasses = new Vector(contractClasses);
-    this.publicDataReads = new Vector(publicDataReads);
-    this.publicDataWrites = new Vector(publicDataWrites);
-    this.nullifierReads = new Vector(nullifierReads);
-    this.nullifierWrites = new Vector(nullifierWrites);
-    this.noteHashReads = new Vector(noteHashReads);
-    this.noteHashWrites = new Vector(noteHashWrites);
-    this.l1ToL2MessageReads = new Vector(l1ToL2MessageReads);
-  }
+    public readonly enqueuedCalls: AvmEnqueuedCallHint[],
+    public readonly contractInstances: AvmContractInstanceHint[],
+    public readonly contractClasses: AvmContractClassHint[],
+    public readonly publicDataReads: AvmPublicDataReadTreeHint[],
+    public readonly publicDataWrites: AvmPublicDataWriteTreeHint[],
+    public readonly nullifierReads: AvmNullifierReadTreeHint[],
+    public readonly nullifierWrites: AvmNullifierWriteTreeHint[],
+    public readonly noteHashReads: AvmAppendTreeHint[],
+    public readonly noteHashWrites: AvmAppendTreeHint[],
+    public readonly l1ToL2MessageReads: AvmAppendTreeHint[],
+  ) {}
 
-  /**
-   * Return an empty instance.
-   * @returns an empty instance.
-   */
   static empty() {
     return new AvmExecutionHints([], [], [], [], [], [], [], [], [], []);
   }
 
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...AvmExecutionHints.getFields(this));
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return bufferToHex(this.toBuffer());
-  }
-
-  /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */
-  isEmpty(): boolean {
-    return (
-      this.enqueuedCalls.items.length == 0 &&
-      this.contractInstances.items.length == 0 &&
-      this.contractClasses.items.length == 0 &&
-      this.publicDataReads.items.length == 0 &&
-      this.publicDataWrites.items.length == 0 &&
-      this.nullifierReads.items.length == 0 &&
-      this.nullifierWrites.items.length == 0 &&
-      this.noteHashReads.items.length == 0 &&
-      this.noteHashWrites.items.length == 0 &&
-      this.l1ToL2MessageReads.items.length == 0
-    );
-  }
-
-  /**
-   * Creates a new instance from fields.
-   * @param fields - Fields to create the instance from.
-   * @returns A new AvmExecutionHints instance.
-   */
-  static from(fields: FieldsOf<AvmExecutionHints>): AvmExecutionHints {
-    return new AvmExecutionHints(
-      fields.enqueuedCalls.items,
-      fields.contractInstances.items,
-      fields.contractClasses.items,
-      fields.publicDataReads.items,
-      fields.publicDataWrites.items,
-      fields.nullifierReads.items,
-      fields.nullifierWrites.items,
-      fields.noteHashReads.items,
-      fields.noteHashWrites.items,
-      fields.l1ToL2MessageReads.items,
-    );
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmExecutionHints>) {
-    return [
-      fields.enqueuedCalls,
-      fields.contractInstances,
-      fields.contractClasses,
-      fields.publicDataReads,
-      fields.publicDataWrites,
-      fields.nullifierReads,
-      fields.nullifierWrites,
-      fields.noteHashReads,
-      fields.noteHashWrites,
-      fields.l1ToL2MessageReads,
-    ] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmExecutionHints {
-    const reader = BufferReader.asReader(buff);
-    return new AvmExecutionHints(
-      reader.readVector(AvmEnqueuedCallHint),
-      reader.readVector(AvmContractInstanceHint),
-      reader.readVector(AvmContractClassHint),
-      reader.readVector(AvmPublicDataReadTreeHint),
-      reader.readVector(AvmPublicDataWriteTreeHint),
-      reader.readVector(AvmNullifierReadTreeHint),
-      reader.readVector(AvmNullifierWriteTreeHint),
-      reader.readVector(AvmAppendTreeHint),
-      reader.readVector(AvmAppendTreeHint),
-      reader.readVector(AvmAppendTreeHint),
-    );
-  }
-
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmCircuitInputs {
-    return AvmCircuitInputs.fromBuffer(hexToBuffer(str));
+  static get schema() {
+    return z
+      .object({
+        enqueuedCalls: AvmEnqueuedCallHint.schema.array(),
+        contractInstances: AvmContractInstanceHint.schema.array(),
+        contractClasses: AvmContractClassHint.schema.array(),
+        publicDataReads: AvmPublicDataReadTreeHint.schema.array(),
+        publicDataWrites: AvmPublicDataWriteTreeHint.schema.array(),
+        nullifierReads: AvmNullifierReadTreeHint.schema.array(),
+        nullifierWrites: AvmNullifierWriteTreeHint.schema.array(),
+        noteHashReads: AvmAppendTreeHint.schema.array(),
+        noteHashWrites: AvmAppendTreeHint.schema.array(),
+        l1ToL2MessageReads: AvmAppendTreeHint.schema.array(),
+      })
+      .transform(
+        ({
+          enqueuedCalls,
+          contractInstances,
+          contractClasses,
+          publicDataReads,
+          publicDataWrites,
+          nullifierReads,
+          nullifierWrites,
+          noteHashReads,
+          noteHashWrites,
+          l1ToL2MessageReads,
+        }) =>
+          new AvmExecutionHints(
+            enqueuedCalls,
+            contractInstances,
+            contractClasses,
+            publicDataReads,
+            publicDataWrites,
+            nullifierReads,
+            nullifierWrites,
+            noteHashReads,
+            noteHashWrites,
+            l1ToL2MessageReads,
+          ),
+      );
   }
 }
 
@@ -835,176 +276,37 @@ export class AvmCircuitInputs {
   constructor(
     public readonly functionName: string, // only informational
     public readonly calldata: Fr[],
-    public readonly avmHints: AvmExecutionHints,
-    public publicInputs: AvmCircuitPublicInputs, // This should replace the above `publicInputs` eventually.
+    public readonly hints: AvmExecutionHints,
+    public publicInputs: AvmCircuitPublicInputs,
   ) {}
 
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    const functionNameBuffer = Buffer.from(this.functionName);
-    return serializeToBuffer(
-      functionNameBuffer.length,
-      functionNameBuffer,
-      this.calldata.length,
-      this.calldata,
-      this.avmHints.toBuffer(),
-      this.publicInputs,
-    );
-  }
-
-  /**
-   * Serializes the inputs to a hex string.
-   * @returns The instance serialized to a hex string.
-   */
-  toString() {
-    return bufferToHex(this.toBuffer());
-  }
-
-  static empty(): AvmCircuitInputs {
+  static empty() {
     return new AvmCircuitInputs('', [], AvmExecutionHints.empty(), AvmCircuitPublicInputs.empty());
   }
 
-  /**
-   * Creates a new instance from fields.
-   * @param fields - Fields to create the instance from.
-   * @returns A new AvmCircuitInputs instance.
-   */
-  static from(fields: FieldsOf<AvmCircuitInputs>): AvmCircuitInputs {
-    return new AvmCircuitInputs(...AvmCircuitInputs.getFields(fields));
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<AvmCircuitInputs>) {
-    return [fields.functionName, fields.calldata, fields.avmHints, fields.publicInputs] as const;
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buff: Buffer | BufferReader): AvmCircuitInputs {
-    const reader = BufferReader.asReader(buff);
-    return new AvmCircuitInputs(
-      /*functionName=*/ reader.readBuffer().toString(),
-      /*calldata=*/ reader.readVector(Fr),
-      AvmExecutionHints.fromBuffer(reader),
-      AvmCircuitPublicInputs.fromBuffer(reader),
-    );
-  }
-
-  /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */
-  static fromString(str: string): AvmCircuitInputs {
-    return AvmCircuitInputs.fromBuffer(hexToBuffer(str));
+  static get schema() {
+    return z
+      .object({
+        functionName: z.string(),
+        calldata: schemas.Fr.array(),
+        hints: AvmExecutionHints.schema,
+        publicInputs: AvmCircuitPublicInputs.schema,
+      })
+      .transform(
+        ({ functionName, calldata, hints, publicInputs }) =>
+          new AvmCircuitInputs(functionName, calldata, hints, publicInputs),
+      );
   }
 
-  /** Returns a buffer representation for JSON serialization. */
-  toJSON() {
-    return this.toBuffer();
+  public serializeWithMessagePack(): Buffer {
+    return serializeWithMessagePack(this);
   }
 
-  /** Creates an instance from a hex string. */
-  static get schema() {
-    return bufferSchemaFor(AvmCircuitInputs);
+  // These are used by the prover to generate an id, and also gcs_proof_store.ts.
+  public toBuffer(): Buffer {
+    return Buffer.from(jsonStringify(this));
   }
-
-  /** Serializes in format for the Avm2 */
-  serializeForAvm2(): Buffer {
-    // logger(`original: ${inspect(input)}`);
-    // logger.verbose(`original: ${inspect(this.avmHints.enqueuedCalls.items)}`);
-    // Convert the inputs to something that works with vm2 and messagepack.
-    // const inputSubset = {
-    //   ffs: [new Fr(0x123456789), new Fr(0x987654321)],
-    //   affine: new Point(new Fr(0x123456789), new Fr(0x987654321), false),
-    //   fq: new Fq(0x123456789),
-    //   addr: AztecAddress.fromBigInt(0x123456789n),
-    //   contract_instance_hints: this.avmHints.contractInstances,
-    // };
-    const hints = {
-      contractInstances: [] as any[],
-      contractClasses: [] as any[],
-      initialTreeRoots: {
-        publicDataTree: this.publicInputs.startTreeSnapshots.publicDataTree.root,
-        nullifierTree: this.publicInputs.startTreeSnapshots.nullifierTree.root,
-        noteHashTree: this.publicInputs.startTreeSnapshots.noteHashTree.root,
-        l1ToL2MessageTree: this.publicInputs.startTreeSnapshots.l1ToL2MessageTree.root,
-      },
-    };
-    const inputs = {
-      hints: hints,
-      enqueuedCalls: [] as any[],
-      // Placeholder for now.
-      publicInputs: {
-        dummy: [] as any[],
-      },
-    };
-    hints.contractInstances = this.avmHints.contractInstances.items;
-    hints.contractClasses = this.avmHints.contractClasses.items;
-
-    // TODO: for now I only convert app logic requests?
-    for (const enqueuedCall of this.avmHints.enqueuedCalls.items) {
-      inputs.enqueuedCalls.push({
-        contractAddress: enqueuedCall.contractAddress,
-        sender: new Fr(0), // FIXME
-        args: enqueuedCall.calldata.items,
-        isStatic: false, // FIXME
-      });
-    }
-
-    const inputsBuffer = serializeWithMessagePack(inputs);
-
-    return inputsBuffer;
+  static fromBuffer(buf: Buffer) {
+    return jsonParseWithSchema(buf.toString(), this.schema);
   }
 }
-
-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);
-}
-
-function setUpMessagePackExtensions() {
-  // 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(),
-  });
-  // If we find a vector, we just use the underlying list.
-  addExtension({
-    Class: Vector,
-    write: v => v.items,
-  });
-  // Affine points are a mess, we do our best.
-  addExtension({
-    Class: Point,
-    write: (p: Point) => {
-      assert(!p.inf, 'Cannot serialize infinity');
-      return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
-    },
-  });
-}