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

package/dest/avm/avm.js

@@ -1,70 +1,25 @@
-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 { strict as assert } from 'assert';
-import { Encoder, addExtension } from 'msgpackr';
+import { Fr } from '@aztec/foundation/fields';
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import { schemas } from '@aztec/foundation/schemas';
+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 {
     contractAddress;
     calldata;
     constructor(contractAddress, calldata){
         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() {
-        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) {
-        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) {
-        return [
-            fields.contractAddress,
-            fields.calldata
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        const reader = BufferReader.asReader(buff);
-        return new AvmEnqueuedCallHint(AztecAddress.fromBuffer(reader), reader.readVector(Fr));
+        this.calldata = calldata;
     }
-    /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */ static fromString(str) {
-        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));
     }
 }
 export class AvmContractClassHint {
@@ -82,53 +37,15 @@ export class AvmContractClassHint {
         this.publicBytecodeCommitment = publicBytecodeCommitment;
         this.packedBytecode = packedBytecode;
     }
-    /**
-   * 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() {
-        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) {
-        return [
-            fields.classId,
-            fields.exists,
-            fields.artifactHash,
-            fields.privateFunctionsRoot,
-            fields.publicBytecodeCommitment,
-            fields.packedBytecode.length,
-            fields.packedBytecode
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        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) {
-        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 {
@@ -142,7 +59,8 @@ export class AvmContractInstanceHint {
     publicKeys;
     updateMembershipHint;
     updatePreimage;
-    constructor(address, exists, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys, updateMembershipHint = AvmPublicDataReadTreeHint.empty(), updatePreimage){
+    constructor(address, exists, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys, // public readonly updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
+    updateMembershipHint, updatePreimage = []){
         this.address = address;
         this.exists = exists;
         this.salt = salt;
@@ -152,403 +70,107 @@ export class AvmContractInstanceHint {
         this.initializationHash = initializationHash;
         this.publicKeys = publicKeys;
         this.updateMembershipHint = updateMembershipHint;
-        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() {
-        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) {
-        return [
-            fields.address,
-            fields.exists,
-            fields.salt,
-            fields.deployer,
-            fields.currentContractClassId,
-            fields.originalContractClassId,
-            fields.initializationHash,
-            fields.publicKeys,
-            fields.updateMembershipHint,
-            fields.updatePreimage
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        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));
-    }
-    /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */ static fromString(str) {
-        return AvmContractInstanceHint.fromBuffer(hexToBuffer(str));
+        this.updatePreimage = updatePreimage;
+    }
+    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 {
     leafIndex;
     value;
-    _siblingPath;
     siblingPath;
-    /*
-   * @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(leafIndex, value, _siblingPath){
+    constructor(leafIndex, value, siblingPath){
         this.leafIndex = leafIndex;
         this.value = value;
-        this._siblingPath = _siblingPath;
-        this.siblingPath = new Vector(_siblingPath);
-    }
-    /**
-   * 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() {
-        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) {
-        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) {
-        return [
-            fields.leafIndex,
-            fields.value,
-            fields.siblingPath
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        return new AvmAppendTreeHint(Fr.fromBuffer(buff), Fr.fromBuffer(buff), BufferReader.asReader(buff).readVector(Fr));
+        this.siblingPath = siblingPath;
     }
-    /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */ static fromString(str) {
-        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 {
     lowLeafRead;
-    _insertionPath;
     insertionPath;
-    /*
-   * @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(lowLeafRead, _insertionPath){
+    constructor(lowLeafRead, insertionPath){
         this.lowLeafRead = lowLeafRead;
-        this._insertionPath = _insertionPath;
-        this.insertionPath = new Vector(_insertionPath);
+        this.insertionPath = 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() {
-        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) {
-        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) {
-        return [
-            ...AvmNullifierReadTreeHint.getFields(fields.lowLeafRead),
-            fields.insertionPath
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        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) {
-        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 {
     lowLeafPreimage;
     lowLeafIndex;
-    _lowLeafSiblingPath;
     lowLeafSiblingPath;
-    constructor(lowLeafPreimage, lowLeafIndex, _lowLeafSiblingPath){
+    constructor(lowLeafPreimage, lowLeafIndex, lowLeafSiblingPath){
         this.lowLeafPreimage = lowLeafPreimage;
         this.lowLeafIndex = lowLeafIndex;
-        this._lowLeafSiblingPath = _lowLeafSiblingPath;
-        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');
+        this.lowLeafSiblingPath = lowLeafSiblingPath;
     }
-    /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */ isEmpty() {
-        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) {
-        return new AvmNullifierReadTreeHint(fields.lowLeafPreimage, fields.lowLeafIndex, fields.lowLeafSiblingPath.items);
-    }
-    static empty() {
-        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) {
-        return [
-            fields.lowLeafPreimage.nullifier,
-            fields.lowLeafPreimage.nextNullifier,
-            new Fr(fields.lowLeafPreimage.nextIndex),
-            fields.lowLeafIndex,
-            fields.lowLeafSiblingPath
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        const reader = BufferReader.asReader(buff);
-        const lowLeafPreimage = reader.readObject(NullifierLeafPreimage);
-        const lowLeafIndex = Fr.fromBuffer(reader);
-        const lowSiblingPath = reader.readVector(Fr);
-        return new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowSiblingPath);
-    }
-    /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */ static fromString(str) {
-        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 {
     leafPreimage;
     leafIndex;
-    _siblingPath;
     siblingPath;
-    constructor(leafPreimage, leafIndex, _siblingPath){
+    constructor(leafPreimage, leafIndex, siblingPath){
         this.leafPreimage = leafPreimage;
         this.leafIndex = leafIndex;
-        this._siblingPath = _siblingPath;
-        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');
+        this.siblingPath = siblingPath;
     }
     static empty() {
         return new AvmPublicDataReadTreeHint(PublicDataTreeLeafPreimage.empty(), Fr.ZERO, []);
     }
-    /**
-   * Is the struct empty?
-   * @returns whether all members are empty.
-   */ isEmpty() {
-        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) {
-        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) {
-        return [
-            fields.leafPreimage.slot,
-            fields.leafPreimage.value,
-            new Fr(fields.leafPreimage.nextIndex),
-            fields.leafPreimage.nextSlot,
-            fields.leafIndex,
-            fields.siblingPath
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        const reader = BufferReader.asReader(buff);
-        const lowLeafPreimage = reader.readObject(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) {
-        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 {
     lowLeafRead;
     newLeafPreimage;
-    _insertionPath;
     insertionPath;
     constructor(// To check the current slot has been written to
-    lowLeafRead, newLeafPreimage, _insertionPath){
+    lowLeafRead, newLeafPreimage, insertionPath){
         this.lowLeafRead = lowLeafRead;
         this.newLeafPreimage = newLeafPreimage;
-        this._insertionPath = _insertionPath;
-        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() {
-        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) {
-        return new AvmPublicDataWriteTreeHint(fields.lowLeafRead, fields.newLeafPreimage, fields.insertionPath.items);
+        this.insertionPath = insertionPath;
     }
-    /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */ static getFields(fields) {
-        return [
-            ...AvmPublicDataReadTreeHint.getFields(fields.lowLeafRead),
-            fields.newLeafPreimage.slot,
-            fields.newLeafPreimage.value,
-            new Fr(fields.newLeafPreimage.nextIndex),
-            fields.newLeafPreimage.nextSlot,
-            fields.insertionPath
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        const reader = BufferReader.asReader(buff);
-        const lowLeafPreimage = reader.readObject(AvmPublicDataReadTreeHint);
-        const newLeafPreimage = reader.readObject(PublicDataTreeLeafPreimage);
-        const lowSiblingPath = reader.readVector(Fr);
-        return new AvmPublicDataWriteTreeHint(lowLeafPreimage, newLeafPreimage, lowSiblingPath);
-    }
-    /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */ static fromString(str) {
-        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 {
@@ -563,232 +185,65 @@ export class AvmExecutionHints {
     noteHashWrites;
     l1ToL2MessageReads;
     constructor(enqueuedCalls, contractInstances, contractClasses, publicDataReads, publicDataWrites, nullifierReads, nullifierWrites, noteHashReads, noteHashWrites, l1ToL2MessageReads){
-        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);
+        this.enqueuedCalls = enqueuedCalls;
+        this.contractInstances = contractInstances;
+        this.contractClasses = contractClasses;
+        this.publicDataReads = publicDataReads;
+        this.publicDataWrites = publicDataWrites;
+        this.nullifierReads = nullifierReads;
+        this.nullifierWrites = nullifierWrites;
+        this.noteHashReads = noteHashReads;
+        this.noteHashWrites = noteHashWrites;
+        this.l1ToL2MessageReads = l1ToL2MessageReads;
     }
-    /**
-   * Return an empty instance.
-   * @returns an empty instance.
-   */ static empty() {
+    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() {
-        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) {
-        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) {
-        return [
-            fields.enqueuedCalls,
-            fields.contractInstances,
-            fields.contractClasses,
-            fields.publicDataReads,
-            fields.publicDataWrites,
-            fields.nullifierReads,
-            fields.nullifierWrites,
-            fields.noteHashReads,
-            fields.noteHashWrites,
-            fields.l1ToL2MessageReads
-        ];
-    }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        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) {
-        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));
     }
 }
 export class AvmCircuitInputs {
     functionName;
     calldata;
-    avmHints;
+    hints;
     publicInputs;
-    constructor(functionName, calldata, avmHints, publicInputs){
+    constructor(functionName, calldata, hints, publicInputs){
         this.functionName = functionName;
         this.calldata = calldata;
-        this.avmHints = avmHints;
+        this.hints = hints;
         this.publicInputs = publicInputs;
     }
-    /**
-   * 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() {
         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) {
-        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) {
-        return [
-            fields.functionName,
-            fields.calldata,
-            fields.avmHints,
-            fields.publicInputs
-        ];
+    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));
     }
-    /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */ static fromBuffer(buff) {
-        const reader = BufferReader.asReader(buff);
-        return new AvmCircuitInputs(/*functionName=*/ reader.readBuffer().toString(), /*calldata=*/ reader.readVector(Fr), AvmExecutionHints.fromBuffer(reader), AvmCircuitPublicInputs.fromBuffer(reader));
+    serializeWithMessagePack() {
+        return serializeWithMessagePack(this);
     }
-    /**
-   * Deserializes from a hex string.
-   * @param str - Hex string to read from.
-   * @returns The deserialized instance.
-   */ static fromString(str) {
-        return AvmCircuitInputs.fromBuffer(hexToBuffer(str));
+    // These are used by the prover to generate an id, and also gcs_proof_store.ts.
+    toBuffer() {
+        return Buffer.from(jsonStringify(this));
     }
-    /** Returns a buffer representation for JSON serialization. */ toJSON() {
-        return this.toBuffer();
+    static fromBuffer(buf) {
+        return jsonParseWithSchema(buf.toString(), this.schema);
     }
-    /** Creates an instance from a hex string. */ static get schema() {
-        return bufferSchemaFor(AvmCircuitInputs);
-    }
-    /** Serializes in format for the Avm2 */ serializeForAvm2() {
-        // 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: [],
-            contractClasses: [],
-            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: [],
-            // Placeholder for now.
-            publicInputs: {
-                dummy: []
-            }
-        };
-        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),
-                args: enqueuedCall.calldata.items,
-                isStatic: false
-            });
-        }
-        const inputsBuffer = serializeWithMessagePack(inputs);
-        return inputsBuffer;
-    }
-}
-export function serializeWithMessagePack(obj) {
-    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.toBuffer()
-    });
-    addExtension({
-        Class: Fq,
-        write: (fq)=>fq.toBuffer()
-    });
-    // AztecAddress is a class that has a field in TS, but just a field in C++.
-    addExtension({
-        Class: AztecAddress,
-        write: (addr)=>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)=>{
-            assert(!p.inf, 'Cannot serialize infinity');
-            return {
-                x: new Fq(p.x.toBigInt()),
-                y: new Fq(p.y.toBigInt())
-            };
-        }
-    });
 }