@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/avm/avm.js

@@ -0,0 +1,794 @@
+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 { 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';
+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));
+    }
+    /**
+   * Deserializes from a hex string.
+   * @param str - Hex string to read from.
+   * @returns The deserialized instance.
+   */ static fromString(str) {
+        return AvmEnqueuedCallHint.fromBuffer(hexToBuffer(str));
+    }
+}
+export class AvmContractClassHint {
+    classId;
+    exists;
+    artifactHash;
+    privateFunctionsRoot;
+    publicBytecodeCommitment;
+    packedBytecode;
+    constructor(classId, exists, artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode){
+        this.classId = classId;
+        this.exists = exists;
+        this.artifactHash = artifactHash;
+        this.privateFunctionsRoot = privateFunctionsRoot;
+        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));
+    }
+}
+export class AvmContractInstanceHint {
+    address;
+    exists;
+    salt;
+    deployer;
+    currentContractClassId;
+    originalContractClassId;
+    initializationHash;
+    publicKeys;
+    updateMembershipHint;
+    updatePreimage;
+    constructor(address, exists, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys, updateMembershipHint = AvmPublicDataReadTreeHint.empty(), updatePreimage){
+        this.address = address;
+        this.exists = exists;
+        this.salt = salt;
+        this.deployer = deployer;
+        this.currentContractClassId = currentContractClassId;
+        this.originalContractClassId = originalContractClassId;
+        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));
+    }
+}
+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){
+        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));
+    }
+    /**
+   * 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'));
+    }
+}
+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){
+        this.lowLeafRead = lowLeafRead;
+        this._insertionPath = _insertionPath;
+        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() {
+        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'));
+    }
+}
+export class AvmNullifierReadTreeHint {
+    lowLeafPreimage;
+    lowLeafIndex;
+    _lowLeafSiblingPath;
+    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');
+    }
+    /**
+   * 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'));
+    }
+}
+export class AvmPublicDataReadTreeHint {
+    leafPreimage;
+    leafIndex;
+    _siblingPath;
+    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');
+    }
+    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'));
+    }
+}
+export class AvmPublicDataWriteTreeHint {
+    lowLeafRead;
+    newLeafPreimage;
+    _insertionPath;
+    insertionPath;
+    constructor(// To check the current slot has been written to
+    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);
+    }
+    /**
+   * 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'));
+    }
+}
+export class AvmExecutionHints {
+    enqueuedCalls;
+    contractInstances;
+    contractClasses;
+    publicDataReads;
+    publicDataWrites;
+    nullifierReads;
+    nullifierWrites;
+    noteHashReads;
+    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);
+    }
+    /**
+   * 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() {
+        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));
+    }
+}
+export class AvmCircuitInputs {
+    functionName;
+    calldata;
+    avmHints;
+    publicInputs;
+    constructor(functionName, calldata, avmHints, publicInputs){
+        this.functionName = functionName;
+        this.calldata = calldata;
+        this.avmHints = avmHints;
+        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
+        ];
+    }
+    /**
+   * 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));
+    }
+    /**
+   * Deserializes from a hex string.
+   * @param str - Hex string to read from.
+   * @returns The deserialized instance.
+   */ static fromString(str) {
+        return AvmCircuitInputs.fromBuffer(hexToBuffer(str));
+    }
+    /** Returns a buffer representation for JSON serialization. */ toJSON() {
+        return this.toBuffer();
+    }
+    /** 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())
+            };
+        }
+    });
+}