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

package/dest/avm/avm.js

@@ -1,240 +1,728 @@
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 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 { AllContractDeploymentData, ContractDeploymentData } from '../contract/index.js';
+import { SimulationError } from '../errors/simulation_error.js';
+import { computeEffectiveGasFees } from '../fees/transaction_fee.js';
+import { Gas } from '../gas/gas.js';
+import { GasFees } from '../gas/gas_fees.js';
+import { GasSettings } from '../gas/gas_settings.js';
+import { GasUsed } from '../gas/gas_used.js';
 import { PublicKeys } from '../keys/public_keys.js';
-import { NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
-import { PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
+import { DebugLog } from '../logs/debug_log.js';
+import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+import { NullishToUndefined, schemas } from '../schemas/schemas.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { MerkleTreeId } from '../trees/merkle_tree_id.js';
+import { NullifierLeaf, NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
+import { PublicDataTreeLeaf, PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
+import { GlobalVariables, NestedProcessReturnValues, ProtocolContracts, PublicCallRequestWithCalldata, TreeSnapshots } from '../tx/index.js';
+import { WorldStateRevision } from '../world-state/world_state_revision.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 = calldata;
-    }
-    static get schema() {
-        return z.object({
-            contractAddress: AztecAddress.schema,
-            calldata: schemas.Fr.array()
-        }).transform(({ contractAddress, calldata })=>new AvmEnqueuedCallHint(contractAddress, calldata));
-    }
-}
+import { RevertCode } from './revert_code.js';
+////////////////////////////////////////////////////////////////////////////
+// Hints (contracts)
+////////////////////////////////////////////////////////////////////////////
 export class AvmContractClassHint {
+    hintKey;
     classId;
-    exists;
     artifactHash;
     privateFunctionsRoot;
-    publicBytecodeCommitment;
     packedBytecode;
-    constructor(classId, exists, artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode){
+    constructor(hintKey, classId, artifactHash, privateFunctionsRoot, packedBytecode){
+        this.hintKey = hintKey;
         this.classId = classId;
-        this.exists = exists;
         this.artifactHash = artifactHash;
         this.privateFunctionsRoot = privateFunctionsRoot;
-        this.publicBytecodeCommitment = publicBytecodeCommitment;
         this.packedBytecode = packedBytecode;
     }
     static get schema() {
         return z.object({
+            hintKey: z.number().int().nonnegative(),
             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));
+        }).transform(({ hintKey, classId, artifactHash, privateFunctionsRoot, packedBytecode })=>new AvmContractClassHint(hintKey, classId, artifactHash, privateFunctionsRoot, packedBytecode));
+    }
+    /**
+   * Creates an AvmContractClassHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmContractClassHint fields
+   * @returns An AvmContractClassHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmContractClassHint) {
+            return obj;
+        }
+        return new AvmContractClassHint(obj.hintKey, Fr.fromPlainObject(obj.classId), Fr.fromPlainObject(obj.artifactHash), Fr.fromPlainObject(obj.privateFunctionsRoot), obj.packedBytecode instanceof Buffer ? obj.packedBytecode : Buffer.from(obj.packedBytecode));
+    }
+}
+export class AvmBytecodeCommitmentHint {
+    hintKey;
+    classId;
+    commitment;
+    constructor(hintKey, classId, commitment){
+        this.hintKey = hintKey;
+        this.classId = classId;
+        this.commitment = commitment;
+    }
+    static get schema() {
+        return z.object({
+            hintKey: z.number().int().nonnegative(),
+            classId: schemas.Fr,
+            commitment: schemas.Fr
+        }).transform(({ hintKey, classId, commitment })=>new AvmBytecodeCommitmentHint(hintKey, classId, commitment));
+    }
+    /**
+   * Creates an AvmBytecodeCommitmentHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmBytecodeCommitmentHint fields
+   * @returns An AvmBytecodeCommitmentHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmBytecodeCommitmentHint) {
+            return obj;
+        }
+        return new AvmBytecodeCommitmentHint(obj.hintKey, Fr.fromPlainObject(obj.classId), Fr.fromPlainObject(obj.commitment));
     }
 }
 export class AvmContractInstanceHint {
+    hintKey;
     address;
-    exists;
     salt;
     deployer;
     currentContractClassId;
     originalContractClassId;
     initializationHash;
     publicKeys;
-    updateMembershipHint;
-    updatePreimage;
-    constructor(address, exists, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys, // public readonly updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
-    updateMembershipHint, updatePreimage = []){
+    constructor(hintKey, address, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys){
+        this.hintKey = hintKey;
         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 = updatePreimage;
     }
     static get schema() {
         return z.object({
+            hintKey: z.number().int().nonnegative(),
             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));
+            publicKeys: PublicKeys.schema
+        }).transform(({ hintKey, address, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys })=>new AvmContractInstanceHint(hintKey, address, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys));
+    }
+    /**
+   * Creates an AvmContractInstanceHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmContractInstanceHint fields
+   * @returns An AvmContractInstanceHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmContractInstanceHint) {
+            return obj;
+        }
+        return new AvmContractInstanceHint(obj.hintKey, AztecAddress.fromPlainObject(obj.address), Fr.fromPlainObject(obj.salt), AztecAddress.fromPlainObject(obj.deployer), Fr.fromPlainObject(obj.currentContractClassId), Fr.fromPlainObject(obj.originalContractClassId), Fr.fromPlainObject(obj.initializationHash), PublicKeys.fromPlainObject(obj.publicKeys));
+    }
+}
+export class AvmDebugFunctionNameHint {
+    address;
+    selector;
+    name;
+    constructor(address, selector, name){
+        this.address = address;
+        this.selector = selector;
+        this.name = name;
+    }
+    static get schema() {
+        return z.object({
+            address: AztecAddress.schema,
+            selector: schemas.Fr,
+            name: z.string()
+        }).transform(({ address, selector, name })=>new AvmDebugFunctionNameHint(address, selector, name));
+    }
+    /**
+   * Creates an AvmDebugFunctionNameHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmDebugFunctionNameHint fields
+   * @returns An AvmDebugFunctionNameHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmDebugFunctionNameHint) {
+            return obj;
+        }
+        return new AvmDebugFunctionNameHint(AztecAddress.fromPlainObject(obj.address), Fr.fromPlainObject(obj.selector), obj.name);
+    }
+}
+////////////////////////////////////////////////////////////////////////////
+// Hints (merkle db)
+////////////////////////////////////////////////////////////////////////////
+// Hint for MerkleTreeDB.getSiblingPath.
+export class AvmGetSiblingPathHint {
+    hintKey;
+    treeId;
+    index;
+    path;
+    constructor(hintKey, // params
+    treeId, index, // return
+    path){
+        this.hintKey = hintKey;
+        this.treeId = treeId;
+        this.index = index;
+        this.path = path;
+    }
+    static get schema() {
+        return z.object({
+            hintKey: AppendOnlyTreeSnapshot.schema,
+            treeId: z.number().int().nonnegative(),
+            index: schemas.BigInt,
+            path: schemas.Fr.array()
+        }).transform(({ hintKey, treeId, index, path })=>new AvmGetSiblingPathHint(hintKey, treeId, index, path));
+    }
+    /**
+   * Creates an AvmGetSiblingPathHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmGetSiblingPathHint fields
+   * @returns An AvmGetSiblingPathHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmGetSiblingPathHint) {
+            return obj;
+        }
+        return new AvmGetSiblingPathHint(AppendOnlyTreeSnapshot.fromPlainObject(obj.hintKey), obj.treeId, typeof obj.index === 'bigint' ? obj.index : BigInt(obj.index), obj.path.map((p)=>Fr.fromPlainObject(p)));
     }
 }
-export class AvmAppendTreeHint {
-    leafIndex;
+// Hint for MerkleTreeDB.getPreviousValueIndex.
+export class AvmGetPreviousValueIndexHint {
+    hintKey;
+    treeId;
     value;
-    siblingPath;
-    constructor(leafIndex, value, siblingPath){
-        this.leafIndex = leafIndex;
+    index;
+    alreadyPresent;
+    constructor(hintKey, // params
+    treeId, value, // return
+    index, alreadyPresent){
+        this.hintKey = hintKey;
+        this.treeId = treeId;
         this.value = value;
-        this.siblingPath = siblingPath;
+        this.index = index;
+        this.alreadyPresent = alreadyPresent;
     }
     static get schema() {
         return z.object({
-            leafIndex: schemas.Fr,
+            hintKey: AppendOnlyTreeSnapshot.schema,
+            treeId: z.number().int().nonnegative(),
             value: schemas.Fr,
-            siblingPath: schemas.Fr.array()
-        }).transform(({ leafIndex, value, siblingPath })=>new AvmAppendTreeHint(leafIndex, value, siblingPath));
+            index: schemas.BigInt,
+            alreadyPresent: z.boolean()
+        }).transform(({ hintKey, treeId, value, index, alreadyPresent })=>new AvmGetPreviousValueIndexHint(hintKey, treeId, value, index, alreadyPresent));
+    }
+    /**
+   * Creates an AvmGetPreviousValueIndexHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmGetPreviousValueIndexHint fields
+   * @returns An AvmGetPreviousValueIndexHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmGetPreviousValueIndexHint) {
+            return obj;
+        }
+        return new AvmGetPreviousValueIndexHint(AppendOnlyTreeSnapshot.fromPlainObject(obj.hintKey), obj.treeId, Fr.fromPlainObject(obj.value), typeof obj.index === 'bigint' ? obj.index : BigInt(obj.index), obj.alreadyPresent);
     }
 }
-export class AvmNullifierWriteTreeHint {
-    lowLeafRead;
-    insertionPath;
-    constructor(lowLeafRead, insertionPath){
-        this.lowLeafRead = lowLeafRead;
-        this.insertionPath = insertionPath;
+// Hint for MerkleTreeDB.getLeafPreimage.
+// NOTE: I need this factory because in order to get hold of the schema, I need an actual instance of the class,
+// having the type doesn't suffice since TS does type erasure in the end.
+function AvmGetLeafPreimageHintFactory(klass) {
+    return class {
+        hintKey;
+        index;
+        leafPreimage;
+        constructor(hintKey, // params (tree id will be implicit)
+        index, // return
+        leafPreimage){
+            this.hintKey = hintKey;
+            this.index = index;
+            this.leafPreimage = leafPreimage;
+        }
+        static get schema() {
+            return z.object({
+                hintKey: AppendOnlyTreeSnapshot.schema,
+                index: schemas.BigInt,
+                leafPreimage: klass.schema
+            }).transform(({ hintKey, index, leafPreimage })=>new this(hintKey, index, leafPreimage));
+        }
+        /**
+     * Creates an instance from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * @param obj - Plain object containing hint fields
+     * @returns An instance
+     */ static fromPlainObject(obj) {
+            if (obj instanceof this) {
+                return obj;
+            }
+            return new this(AppendOnlyTreeSnapshot.fromPlainObject(obj.hintKey), typeof obj.index === 'bigint' ? obj.index : BigInt(obj.index), klass.fromPlainObject(obj.leafPreimage));
+        }
+    };
+}
+// Note: only supported for PUBLIC_DATA_TREE and NULLIFIER_TREE.
+export class AvmGetLeafPreimageHintPublicDataTree extends AvmGetLeafPreimageHintFactory(PublicDataTreeLeafPreimage) {
+}
+export class AvmGetLeafPreimageHintNullifierTree extends AvmGetLeafPreimageHintFactory(NullifierLeafPreimage) {
+}
+// Hint for MerkleTreeDB.getLeafValue.
+// Note: only supported for NOTE_HASH_TREE and L1_TO_L2_MESSAGE_TREE.
+export class AvmGetLeafValueHint {
+    hintKey;
+    treeId;
+    index;
+    value;
+    constructor(hintKey, // params
+    treeId, index, // return
+    value){
+        this.hintKey = hintKey;
+        this.treeId = treeId;
+        this.index = index;
+        this.value = value;
     }
     static get schema() {
         return z.object({
-            lowLeafRead: AvmNullifierReadTreeHint.schema,
-            insertionPath: schemas.Fr.array()
-        }).transform(({ lowLeafRead, insertionPath })=>new AvmNullifierWriteTreeHint(lowLeafRead, insertionPath));
+            hintKey: AppendOnlyTreeSnapshot.schema,
+            treeId: z.number().int().nonnegative(),
+            index: schemas.BigInt,
+            value: schemas.Fr
+        }).transform(({ hintKey, treeId, index, value })=>new AvmGetLeafValueHint(hintKey, treeId, index, value));
+    }
+    /**
+   * Creates an AvmGetLeafValueHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmGetLeafValueHint fields
+   * @returns An AvmGetLeafValueHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmGetLeafValueHint) {
+            return obj;
+        }
+        return new AvmGetLeafValueHint(AppendOnlyTreeSnapshot.fromPlainObject(obj.hintKey), obj.treeId, typeof obj.index === 'bigint' ? obj.index : BigInt(obj.index), Fr.fromPlainObject(obj.value));
     }
 }
-export class AvmNullifierReadTreeHint {
-    lowLeafPreimage;
-    lowLeafIndex;
-    lowLeafSiblingPath;
-    constructor(lowLeafPreimage, lowLeafIndex, lowLeafSiblingPath){
-        this.lowLeafPreimage = lowLeafPreimage;
-        this.lowLeafIndex = lowLeafIndex;
-        this.lowLeafSiblingPath = lowLeafSiblingPath;
+// Hint for MerkleTreeDB.sequentialInsert.
+// NOTE: I need this factory because in order to get hold of the schema, I need an actual instance of the class,
+// having the type doesn't suffice since TS does type erasure in the end.
+function AvmSequentialInsertHintFactory(klass) {
+    return class {
+        hintKey;
+        stateAfter;
+        treeId;
+        leaf;
+        lowLeavesWitnessData;
+        insertionWitnessData;
+        constructor(hintKey, stateAfter, // params
+        treeId, leaf, // return
+        lowLeavesWitnessData, insertionWitnessData){
+            this.hintKey = hintKey;
+            this.stateAfter = stateAfter;
+            this.treeId = treeId;
+            this.leaf = leaf;
+            this.lowLeavesWitnessData = lowLeavesWitnessData;
+            this.insertionWitnessData = insertionWitnessData;
+        }
+        static get schema() {
+            return z.object({
+                hintKey: AppendOnlyTreeSnapshot.schema,
+                stateAfter: AppendOnlyTreeSnapshot.schema,
+                treeId: z.number().int().nonnegative(),
+                leaf: klass.leafSchema,
+                lowLeavesWitnessData: z.object({
+                    leaf: klass.schema,
+                    index: schemas.BigInt,
+                    path: schemas.Fr.array()
+                }),
+                insertionWitnessData: z.object({
+                    leaf: klass.schema,
+                    index: schemas.BigInt,
+                    path: schemas.Fr.array()
+                })
+            }).transform(({ hintKey, stateAfter, treeId, leaf, lowLeavesWitnessData, insertionWitnessData })=>new this(hintKey, stateAfter, treeId, leaf, lowLeavesWitnessData, insertionWitnessData));
+        }
+        /**
+     * Creates an instance from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * @param obj - Plain object containing hint fields
+     * @returns An instance
+     */ static fromPlainObject(obj) {
+            if (obj instanceof this) {
+                return obj;
+            }
+            // Determine the leaf class based on the klass parameter
+            const LeafClass = klass === PublicDataTreeLeafPreimage ? PublicDataTreeLeaf : NullifierLeaf;
+            return new this(AppendOnlyTreeSnapshot.fromPlainObject(obj.hintKey), AppendOnlyTreeSnapshot.fromPlainObject(obj.stateAfter), obj.treeId, LeafClass.fromPlainObject(obj.leaf), {
+                leaf: klass.fromPlainObject(obj.lowLeavesWitnessData.leaf),
+                index: typeof obj.lowLeavesWitnessData.index === 'bigint' ? obj.lowLeavesWitnessData.index : BigInt(obj.lowLeavesWitnessData.index),
+                path: obj.lowLeavesWitnessData.path.map((p)=>Fr.fromPlainObject(p))
+            }, {
+                leaf: klass.fromPlainObject(obj.insertionWitnessData.leaf),
+                index: typeof obj.insertionWitnessData.index === 'bigint' ? obj.insertionWitnessData.index : BigInt(obj.insertionWitnessData.index),
+                path: obj.insertionWitnessData.path.map((p)=>Fr.fromPlainObject(p))
+            });
+        }
+    };
+}
+// Note: only supported for PUBLIC_DATA_TREE and NULLIFIER_TREE.
+export class AvmSequentialInsertHintPublicDataTree extends AvmSequentialInsertHintFactory(PublicDataTreeLeafPreimage) {
+}
+export class AvmSequentialInsertHintNullifierTree extends AvmSequentialInsertHintFactory(NullifierLeafPreimage) {
+}
+// Hint for MerkleTreeDB.appendLeaves.
+// Note: only supported for NOTE_HASH_TREE and L1_TO_L2_MESSAGE_TREE.
+export class AvmAppendLeavesHint {
+    hintKey;
+    stateAfter;
+    treeId;
+    leaves;
+    constructor(hintKey, stateAfter, // params
+    treeId, leaves){
+        this.hintKey = hintKey;
+        this.stateAfter = stateAfter;
+        this.treeId = treeId;
+        this.leaves = leaves;
     }
     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));
+            hintKey: AppendOnlyTreeSnapshot.schema,
+            stateAfter: AppendOnlyTreeSnapshot.schema,
+            treeId: z.number().int().nonnegative(),
+            leaves: schemas.Fr.array()
+        }).transform(({ hintKey, stateAfter, treeId, leaves })=>new AvmAppendLeavesHint(hintKey, stateAfter, treeId, leaves));
+    }
+    /**
+   * Creates an AvmAppendLeavesHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmAppendLeavesHint fields
+   * @returns An AvmAppendLeavesHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmAppendLeavesHint) {
+            return obj;
+        }
+        return new AvmAppendLeavesHint(AppendOnlyTreeSnapshot.fromPlainObject(obj.hintKey), AppendOnlyTreeSnapshot.fromPlainObject(obj.stateAfter), obj.treeId, obj.leaves.map((l)=>Fr.fromPlainObject(l)));
     }
 }
-export class AvmPublicDataReadTreeHint {
-    leafPreimage;
-    leafIndex;
-    siblingPath;
-    constructor(leafPreimage, leafIndex, siblingPath){
-        this.leafPreimage = leafPreimage;
-        this.leafIndex = leafIndex;
-        this.siblingPath = siblingPath;
+// Hint for checkpoint actions that don't change the state.
+class AvmCheckpointActionNoStateChangeHint {
+    actionCounter;
+    oldCheckpointId;
+    newCheckpointId;
+    constructor(// key
+    actionCounter, // current checkpoint evolution
+    oldCheckpointId, newCheckpointId){
+        this.actionCounter = actionCounter;
+        this.oldCheckpointId = oldCheckpointId;
+        this.newCheckpointId = newCheckpointId;
     }
-    static empty() {
-        return new AvmPublicDataReadTreeHint(PublicDataTreeLeafPreimage.empty(), Fr.ZERO, []);
+    static get schema() {
+        return z.object({
+            actionCounter: z.number().int().nonnegative(),
+            oldCheckpointId: z.number().int().nonnegative(),
+            newCheckpointId: z.number().int().nonnegative()
+        }).transform(({ actionCounter, oldCheckpointId, newCheckpointId })=>new this(actionCounter, oldCheckpointId, newCheckpointId));
+    }
+    /**
+   * Creates an instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing hint fields
+   * @returns An instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof this) {
+            return obj;
+        }
+        return new this(obj.actionCounter, obj.oldCheckpointId, obj.newCheckpointId);
+    }
+}
+// Hint for MerkleTreeDB.createCheckpoint.
+export class AvmCreateCheckpointHint extends AvmCheckpointActionNoStateChangeHint {
+}
+// Hint for MerkleTreeDB.commitCheckpoint.
+export class AvmCommitCheckpointHint extends AvmCheckpointActionNoStateChangeHint {
+}
+// Hint for MerkleTreeDB.revertCheckpoint.
+export class AvmRevertCheckpointHint {
+    actionCounter;
+    oldCheckpointId;
+    newCheckpointId;
+    stateBefore;
+    stateAfter;
+    // We use explicit fields for MessagePack.
+    constructor(// key
+    actionCounter, // current checkpoint evolution
+    oldCheckpointId, newCheckpointId, // state evolution
+    stateBefore, stateAfter){
+        this.actionCounter = actionCounter;
+        this.oldCheckpointId = oldCheckpointId;
+        this.newCheckpointId = newCheckpointId;
+        this.stateBefore = stateBefore;
+        this.stateAfter = stateAfter;
+    }
+    static create(actionCounter, oldCheckpointId, newCheckpointId, stateBefore, stateAfter) {
+        return new AvmRevertCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId, new TreeSnapshots(stateBefore[MerkleTreeId.L1_TO_L2_MESSAGE_TREE], stateBefore[MerkleTreeId.NOTE_HASH_TREE], stateBefore[MerkleTreeId.NULLIFIER_TREE], stateBefore[MerkleTreeId.PUBLIC_DATA_TREE]), new TreeSnapshots(stateAfter[MerkleTreeId.L1_TO_L2_MESSAGE_TREE], stateAfter[MerkleTreeId.NOTE_HASH_TREE], stateAfter[MerkleTreeId.NULLIFIER_TREE], stateAfter[MerkleTreeId.PUBLIC_DATA_TREE]));
     }
     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));
+            actionCounter: z.number().int().nonnegative(),
+            oldCheckpointId: z.number().int().nonnegative(),
+            newCheckpointId: z.number().int().nonnegative(),
+            stateBefore: TreeSnapshots.schema,
+            stateAfter: TreeSnapshots.schema
+        }).transform(({ actionCounter, oldCheckpointId, newCheckpointId, stateBefore, stateAfter })=>new AvmRevertCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId, stateBefore, stateAfter));
+    }
+    /**
+   * Creates an AvmRevertCheckpointHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmRevertCheckpointHint fields
+   * @returns An AvmRevertCheckpointHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmRevertCheckpointHint) {
+            return obj;
+        }
+        return new AvmRevertCheckpointHint(obj.actionCounter, obj.oldCheckpointId, obj.newCheckpointId, TreeSnapshots.fromPlainObject(obj.stateBefore), TreeSnapshots.fromPlainObject(obj.stateAfter));
     }
 }
-export class AvmPublicDataWriteTreeHint {
-    lowLeafRead;
-    newLeafPreimage;
-    insertionPath;
-    constructor(// To check the current slot has been written to
-    lowLeafRead, newLeafPreimage, insertionPath){
-        this.lowLeafRead = lowLeafRead;
-        this.newLeafPreimage = newLeafPreimage;
-        this.insertionPath = insertionPath;
+export class AvmContractDbCreateCheckpointHint extends AvmCheckpointActionNoStateChangeHint {
+}
+export class AvmContractDbCommitCheckpointHint extends AvmCheckpointActionNoStateChangeHint {
+}
+export class AvmContractDbRevertCheckpointHint extends AvmCheckpointActionNoStateChangeHint {
+}
+////////////////////////////////////////////////////////////////////////////
+// Hints (other)
+////////////////////////////////////////////////////////////////////////////
+export class AvmTxHint {
+    hash;
+    gasSettings;
+    effectiveGasFees;
+    nonRevertibleContractDeploymentData;
+    revertibleContractDeploymentData;
+    nonRevertibleAccumulatedData;
+    revertibleAccumulatedData;
+    setupEnqueuedCalls;
+    appLogicEnqueuedCalls;
+    teardownEnqueuedCall;
+    gasUsedByPrivate;
+    feePayer;
+    constructor(hash, gasSettings, effectiveGasFees, nonRevertibleContractDeploymentData, revertibleContractDeploymentData, nonRevertibleAccumulatedData, revertibleAccumulatedData, setupEnqueuedCalls, appLogicEnqueuedCalls, // We need this to be null and not undefined because that's what
+    // MessagePack expects for an std::optional.
+    teardownEnqueuedCall, gasUsedByPrivate, feePayer){
+        this.hash = hash;
+        this.gasSettings = gasSettings;
+        this.effectiveGasFees = effectiveGasFees;
+        this.nonRevertibleContractDeploymentData = nonRevertibleContractDeploymentData;
+        this.revertibleContractDeploymentData = revertibleContractDeploymentData;
+        this.nonRevertibleAccumulatedData = nonRevertibleAccumulatedData;
+        this.revertibleAccumulatedData = revertibleAccumulatedData;
+        this.setupEnqueuedCalls = setupEnqueuedCalls;
+        this.appLogicEnqueuedCalls = appLogicEnqueuedCalls;
+        this.teardownEnqueuedCall = teardownEnqueuedCall;
+        this.gasUsedByPrivate = gasUsedByPrivate;
+        this.feePayer = feePayer;
+    }
+    static fromTx(tx, gasFees) {
+        const setupCallRequests = tx.getNonRevertiblePublicCallRequestsWithCalldata();
+        const appLogicCallRequests = tx.getRevertiblePublicCallRequestsWithCalldata();
+        const teardownCallRequest = tx.getTeardownPublicCallRequestWithCalldata();
+        const gasSettings = tx.data.constants.txContext.gasSettings;
+        const effectiveGasFees = computeEffectiveGasFees(gasFees, gasSettings);
+        const allContractDeploymentData = AllContractDeploymentData.fromTx(tx);
+        // For informational purposes. Assumed quick because it should be cached.
+        const txHash = tx.getTxHash();
+        return new AvmTxHint(txHash.hash.toString(), gasSettings, effectiveGasFees, allContractDeploymentData.getNonRevertibleContractDeploymentData(), allContractDeploymentData.getRevertibleContractDeploymentData(), {
+            noteHashes: tx.data.forPublic.nonRevertibleAccumulatedData.noteHashes.filter((x)=>!x.isZero()),
+            nullifiers: tx.data.forPublic.nonRevertibleAccumulatedData.nullifiers.filter((x)=>!x.isZero()),
+            l2ToL1Messages: tx.data.forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs.filter((x)=>!x.isEmpty())
+        }, {
+            noteHashes: tx.data.forPublic.revertibleAccumulatedData.noteHashes.filter((x)=>!x.isZero()),
+            nullifiers: tx.data.forPublic.revertibleAccumulatedData.nullifiers.filter((x)=>!x.isZero()),
+            l2ToL1Messages: tx.data.forPublic.revertibleAccumulatedData.l2ToL1Msgs.filter((x)=>!x.isEmpty())
+        }, setupCallRequests, appLogicCallRequests, teardownCallRequest ?? null, tx.data.gasUsed, tx.data.feePayer);
+    }
+    static empty() {
+        return new AvmTxHint('', GasSettings.empty(), GasFees.empty(), ContractDeploymentData.empty(), ContractDeploymentData.empty(), {
+            noteHashes: [],
+            nullifiers: [],
+            l2ToL1Messages: []
+        }, {
+            noteHashes: [],
+            nullifiers: [],
+            l2ToL1Messages: []
+        }, [], [], null, Gas.empty(), AztecAddress.zero());
+    }
+    /**
+   * Creates an AvmTxHint from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmTxHint fields
+   * @returns An AvmTxHint instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmTxHint) {
+            return obj;
+        }
+        return new AvmTxHint(obj.hash, GasSettings.fromPlainObject(obj.gasSettings), GasFees.fromPlainObject(obj.effectiveGasFees), ContractDeploymentData.fromPlainObject(obj.nonRevertibleContractDeploymentData), ContractDeploymentData.fromPlainObject(obj.revertibleContractDeploymentData), {
+            noteHashes: obj.nonRevertibleAccumulatedData.noteHashes.map((h)=>Fr.fromPlainObject(h)),
+            nullifiers: obj.nonRevertibleAccumulatedData.nullifiers.map((n)=>Fr.fromPlainObject(n)),
+            l2ToL1Messages: obj.nonRevertibleAccumulatedData.l2ToL1Messages.map((m)=>ScopedL2ToL1Message.fromPlainObject(m))
+        }, {
+            noteHashes: obj.revertibleAccumulatedData.noteHashes.map((h)=>Fr.fromPlainObject(h)),
+            nullifiers: obj.revertibleAccumulatedData.nullifiers.map((n)=>Fr.fromPlainObject(n)),
+            l2ToL1Messages: obj.revertibleAccumulatedData.l2ToL1Messages.map((m)=>ScopedL2ToL1Message.fromPlainObject(m))
+        }, obj.setupEnqueuedCalls.map((c)=>PublicCallRequestWithCalldata.fromPlainObject(c)), obj.appLogicEnqueuedCalls.map((c)=>PublicCallRequestWithCalldata.fromPlainObject(c)), obj.teardownEnqueuedCall ? PublicCallRequestWithCalldata.fromPlainObject(obj.teardownEnqueuedCall) : null, Gas.fromPlainObject(obj.gasUsedByPrivate), AztecAddress.fromPlainObject(obj.feePayer));
     }
     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));
+            hash: z.string(),
+            gasSettings: GasSettings.schema,
+            effectiveGasFees: GasFees.schema,
+            nonRevertibleContractDeploymentData: ContractDeploymentData.schema,
+            revertibleContractDeploymentData: ContractDeploymentData.schema,
+            nonRevertibleAccumulatedData: z.object({
+                noteHashes: schemas.Fr.array(),
+                nullifiers: schemas.Fr.array(),
+                l2ToL1Messages: ScopedL2ToL1Message.schema.array()
+            }),
+            revertibleAccumulatedData: z.object({
+                noteHashes: schemas.Fr.array(),
+                nullifiers: schemas.Fr.array(),
+                l2ToL1Messages: ScopedL2ToL1Message.schema.array()
+            }),
+            setupEnqueuedCalls: PublicCallRequestWithCalldata.schema.array(),
+            appLogicEnqueuedCalls: PublicCallRequestWithCalldata.schema.array(),
+            teardownEnqueuedCall: PublicCallRequestWithCalldata.schema.nullable(),
+            gasUsedByPrivate: Gas.schema,
+            feePayer: AztecAddress.schema
+        }).transform(({ hash, gasSettings, effectiveGasFees, nonRevertibleContractDeploymentData, revertibleContractDeploymentData, nonRevertibleAccumulatedData, revertibleAccumulatedData, setupEnqueuedCalls, appLogicEnqueuedCalls, teardownEnqueuedCall, gasUsedByPrivate, feePayer })=>new AvmTxHint(hash, gasSettings, effectiveGasFees, nonRevertibleContractDeploymentData, revertibleContractDeploymentData, nonRevertibleAccumulatedData, revertibleAccumulatedData, setupEnqueuedCalls, appLogicEnqueuedCalls, teardownEnqueuedCall, gasUsedByPrivate, feePayer));
     }
 }
 export class AvmExecutionHints {
-    enqueuedCalls;
+    globalVariables;
+    tx;
+    protocolContracts;
     contractInstances;
     contractClasses;
-    publicDataReads;
-    publicDataWrites;
-    nullifierReads;
-    nullifierWrites;
-    noteHashReads;
-    noteHashWrites;
-    l1ToL2MessageReads;
-    constructor(enqueuedCalls, contractInstances, contractClasses, publicDataReads, publicDataWrites, nullifierReads, nullifierWrites, noteHashReads, noteHashWrites, l1ToL2MessageReads){
-        this.enqueuedCalls = enqueuedCalls;
+    bytecodeCommitments;
+    debugFunctionNames;
+    contractDbCreateCheckpointHints;
+    contractDbCommitCheckpointHints;
+    contractDbRevertCheckpointHints;
+    startingTreeRoots;
+    getSiblingPathHints;
+    getPreviousValueIndexHints;
+    getLeafPreimageHintsPublicDataTree;
+    getLeafPreimageHintsNullifierTree;
+    getLeafValueHints;
+    sequentialInsertHintsPublicDataTree;
+    sequentialInsertHintsNullifierTree;
+    appendLeavesHints;
+    createCheckpointHints;
+    commitCheckpointHints;
+    revertCheckpointHints;
+    constructor(globalVariables, tx, // Protocol contracts.
+    protocolContracts, // Contract hints.
+    contractInstances = [], contractClasses = [], bytecodeCommitments = [], debugFunctionNames = [], contractDbCreateCheckpointHints = [], contractDbCommitCheckpointHints = [], contractDbRevertCheckpointHints = [], // Merkle DB hints.
+    startingTreeRoots = TreeSnapshots.empty(), getSiblingPathHints = [], getPreviousValueIndexHints = [], getLeafPreimageHintsPublicDataTree = [], getLeafPreimageHintsNullifierTree = [], getLeafValueHints = [], sequentialInsertHintsPublicDataTree = [], sequentialInsertHintsNullifierTree = [], appendLeavesHints = [], createCheckpointHints = [], commitCheckpointHints = [], revertCheckpointHints = []){
+        this.globalVariables = globalVariables;
+        this.tx = tx;
+        this.protocolContracts = protocolContracts;
         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;
+        this.bytecodeCommitments = bytecodeCommitments;
+        this.debugFunctionNames = debugFunctionNames;
+        this.contractDbCreateCheckpointHints = contractDbCreateCheckpointHints;
+        this.contractDbCommitCheckpointHints = contractDbCommitCheckpointHints;
+        this.contractDbRevertCheckpointHints = contractDbRevertCheckpointHints;
+        this.startingTreeRoots = startingTreeRoots;
+        this.getSiblingPathHints = getSiblingPathHints;
+        this.getPreviousValueIndexHints = getPreviousValueIndexHints;
+        this.getLeafPreimageHintsPublicDataTree = getLeafPreimageHintsPublicDataTree;
+        this.getLeafPreimageHintsNullifierTree = getLeafPreimageHintsNullifierTree;
+        this.getLeafValueHints = getLeafValueHints;
+        this.sequentialInsertHintsPublicDataTree = sequentialInsertHintsPublicDataTree;
+        this.sequentialInsertHintsNullifierTree = sequentialInsertHintsNullifierTree;
+        this.appendLeavesHints = appendLeavesHints;
+        this.createCheckpointHints = createCheckpointHints;
+        this.commitCheckpointHints = commitCheckpointHints;
+        this.revertCheckpointHints = revertCheckpointHints;
+    }
+    /**
+   * Creates an AvmExecutionHints from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmExecutionHints fields
+   * @returns An AvmExecutionHints instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof AvmExecutionHints) {
+            return obj;
+        }
+        return new AvmExecutionHints(GlobalVariables.fromPlainObject(obj.globalVariables), AvmTxHint.fromPlainObject(obj.tx), ProtocolContracts.fromPlainObject(obj.protocolContracts), obj.contractInstances?.map((i)=>AvmContractInstanceHint.fromPlainObject(i)) || [], obj.contractClasses?.map((c)=>AvmContractClassHint.fromPlainObject(c)) || [], obj.bytecodeCommitments?.map((b)=>AvmBytecodeCommitmentHint.fromPlainObject(b)) || [], obj.debugFunctionNames?.map((d)=>AvmDebugFunctionNameHint.fromPlainObject(d)) || [], obj.contractDbCreateCheckpointHints?.map((h)=>AvmContractDbCreateCheckpointHint.fromPlainObject(h)) || [], obj.contractDbCommitCheckpointHints?.map((h)=>AvmContractDbCommitCheckpointHint.fromPlainObject(h)) || [], obj.contractDbRevertCheckpointHints?.map((h)=>AvmContractDbRevertCheckpointHint.fromPlainObject(h)) || [], obj.startingTreeRoots ? TreeSnapshots.fromPlainObject(obj.startingTreeRoots) : TreeSnapshots.empty(), obj.getSiblingPathHints?.map((h)=>AvmGetSiblingPathHint.fromPlainObject(h)) || [], obj.getPreviousValueIndexHints?.map((h)=>AvmGetPreviousValueIndexHint.fromPlainObject(h)) || [], obj.getLeafPreimageHintsPublicDataTree?.map((h)=>AvmGetLeafPreimageHintPublicDataTree.fromPlainObject(h)) || [], obj.getLeafPreimageHintsNullifierTree?.map((h)=>AvmGetLeafPreimageHintNullifierTree.fromPlainObject(h)) || [], obj.getLeafValueHints?.map((h)=>AvmGetLeafValueHint.fromPlainObject(h)) || [], obj.sequentialInsertHintsPublicDataTree?.map((h)=>AvmSequentialInsertHintPublicDataTree.fromPlainObject(h)) || [], obj.sequentialInsertHintsNullifierTree?.map((h)=>AvmSequentialInsertHintNullifierTree.fromPlainObject(h)) || [], obj.appendLeavesHints?.map((h)=>AvmAppendLeavesHint.fromPlainObject(h)) || [], obj.createCheckpointHints?.map((h)=>AvmCreateCheckpointHint.fromPlainObject(h)) || [], obj.commitCheckpointHints?.map((h)=>AvmCommitCheckpointHint.fromPlainObject(h)) || [], obj.revertCheckpointHints?.map((h)=>AvmRevertCheckpointHint.fromPlainObject(h)) || []);
     }
     static empty() {
-        return new AvmExecutionHints([], [], [], [], [], [], [], [], [], []);
+        return new AvmExecutionHints(GlobalVariables.empty(), AvmTxHint.empty(), ProtocolContracts.empty());
     }
     static get schema() {
         return z.object({
-            enqueuedCalls: AvmEnqueuedCallHint.schema.array(),
+            globalVariables: GlobalVariables.schema,
+            tx: AvmTxHint.schema,
+            protocolContracts: ProtocolContracts.schema,
             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));
+            bytecodeCommitments: AvmBytecodeCommitmentHint.schema.array(),
+            debugFunctionNames: AvmDebugFunctionNameHint.schema.array(),
+            contractDbCreateCheckpointHints: AvmContractDbCreateCheckpointHint.schema.array(),
+            contractDbCommitCheckpointHints: AvmContractDbCommitCheckpointHint.schema.array(),
+            contractDbRevertCheckpointHints: AvmContractDbRevertCheckpointHint.schema.array(),
+            startingTreeRoots: TreeSnapshots.schema,
+            getSiblingPathHints: AvmGetSiblingPathHint.schema.array(),
+            getPreviousValueIndexHints: AvmGetPreviousValueIndexHint.schema.array(),
+            getLeafPreimageHintsPublicDataTree: AvmGetLeafPreimageHintPublicDataTree.schema.array(),
+            getLeafPreimageHintsNullifierTree: AvmGetLeafPreimageHintNullifierTree.schema.array(),
+            getLeafValueHints: AvmGetLeafValueHint.schema.array(),
+            sequentialInsertHintsPublicDataTree: AvmSequentialInsertHintPublicDataTree.schema.array(),
+            sequentialInsertHintsNullifierTree: AvmSequentialInsertHintNullifierTree.schema.array(),
+            appendLeavesHints: AvmAppendLeavesHint.schema.array(),
+            createCheckpointHints: AvmCreateCheckpointHint.schema.array(),
+            commitCheckpointHints: AvmCommitCheckpointHint.schema.array(),
+            revertCheckpointHints: AvmRevertCheckpointHint.schema.array()
+        }).transform(({ globalVariables, tx, protocolContracts, contractInstances, contractClasses, bytecodeCommitments, debugFunctionNames, contractDbCreateCheckpointHints, contractDbCommitCheckpointHints, contractDbRevertCheckpointHints, startingTreeRoots, getSiblingPathHints, getPreviousValueIndexHints, getLeafPreimageHintsPublicDataTree, getLeafPreimageHintsNullifierTree, getLeafValueHints, sequentialInsertHintsPublicDataTree, sequentialInsertHintsNullifierTree, appendLeavesHints, createCheckpointHints, commitCheckpointHints, revertCheckpointHints })=>new AvmExecutionHints(globalVariables, tx, protocolContracts, contractInstances, contractClasses, bytecodeCommitments, debugFunctionNames, contractDbCreateCheckpointHints, contractDbCommitCheckpointHints, contractDbRevertCheckpointHints, startingTreeRoots, getSiblingPathHints, getPreviousValueIndexHints, getLeafPreimageHintsPublicDataTree, getLeafPreimageHintsNullifierTree, getLeafValueHints, sequentialInsertHintsPublicDataTree, sequentialInsertHintsNullifierTree, appendLeavesHints, createCheckpointHints, commitCheckpointHints, revertCheckpointHints));
     }
 }
 export class AvmCircuitInputs {
-    functionName;
-    calldata;
     hints;
     publicInputs;
-    constructor(functionName, calldata, hints, publicInputs){
-        this.functionName = functionName;
-        this.calldata = calldata;
+    constructor(hints, publicInputs){
         this.hints = hints;
         this.publicInputs = publicInputs;
     }
     static empty() {
-        return new AvmCircuitInputs('', [], AvmExecutionHints.empty(), AvmCircuitPublicInputs.empty());
+        return new AvmCircuitInputs(AvmExecutionHints.empty(), AvmCircuitPublicInputs.empty());
+    }
+    static fromPlainObject(obj) {
+        return new AvmCircuitInputs(AvmExecutionHints.fromPlainObject(obj.hints), AvmCircuitPublicInputs.fromPlainObject(obj.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));
+        }).transform(({ hints, publicInputs })=>new AvmCircuitInputs(hints, publicInputs));
     }
     serializeWithMessagePack() {
         return serializeWithMessagePack(this);
@@ -247,3 +735,114 @@ export class AvmCircuitInputs {
         return jsonParseWithSchema(buf.toString(), this.schema);
     }
 }
+export class PublicTxResult {
+    gasUsed;
+    revertCode;
+    revertReason;
+    appLogicReturnValues;
+    logs;
+    hints;
+    publicInputs;
+    constructor(// Simulation result.
+    gasUsed, revertCode, revertReason, // These are only guaranteed to be present if the simulator is configured to collect them.
+    // NOTE: This list will be populated with one NestedProcessReturnValues per app logic enqueued call.
+    // IMPORTANT: The nesting will only be 1 level deep! You will get one result per enqueued call
+    // but no information about nested calls. This can be added later.
+    appLogicReturnValues, logs, // For the proving request.
+    hints, publicInputs){
+        this.gasUsed = gasUsed;
+        this.revertCode = revertCode;
+        this.revertReason = revertReason;
+        this.appLogicReturnValues = appLogicReturnValues;
+        this.logs = logs;
+        this.hints = hints;
+        this.publicInputs = publicInputs;
+    }
+    static empty() {
+        return new PublicTxResult({
+            totalGas: Gas.empty(),
+            teardownGas: Gas.empty(),
+            publicGas: Gas.empty(),
+            billedGas: Gas.empty()
+        }, RevertCode.OK, /*revertReason=*/ undefined, /*appLogicReturnValues=*/ [], /*logs=*/ [], /*hints=*/ AvmExecutionHints.empty(), /*publicInputs=*/ AvmCircuitPublicInputs.empty());
+    }
+    static get schema() {
+        return z.object({
+            gasUsed: schemas.GasUsed,
+            revertCode: RevertCode.schema,
+            revertReason: NullishToUndefined(SimulationError.schema),
+            appLogicReturnValues: NestedProcessReturnValues.schema.array(),
+            logs: NullishToUndefined(DebugLog.schema.array()),
+            // For the proving request.
+            publicInputs: AvmCircuitPublicInputs.schema,
+            hints: NullishToUndefined(AvmExecutionHints.schema)
+        }).transform(({ gasUsed, revertCode, revertReason, appLogicReturnValues, logs, hints, publicInputs })=>new PublicTxResult(gasUsed, revertCode, revertReason, appLogicReturnValues, logs, hints, publicInputs));
+    }
+    static fromPlainObject(obj) {
+        return new PublicTxResult(GasUsed.fromPlainObject(obj.gasUsed), RevertCode.fromPlainObject(obj.revertCode), /*revertReason=*/ undefined, /*appLogicReturnValues=*/ obj.appLogicReturnValues.map(NestedProcessReturnValues.fromPlainObject), obj.logs?.map(DebugLog.fromPlainObject), obj.hints ? AvmExecutionHints.fromPlainObject(obj.hints) : undefined, AvmCircuitPublicInputs.fromPlainObject(obj.publicInputs));
+    }
+}
+export class PublicSimulatorConfig {
+    proverId;
+    skipFeeEnforcement;
+    collectCallMetadata;
+    collectHints;
+    collectDebugLogs;
+    maxDebugLogMemoryReads;
+    collectStatistics;
+    constructor(proverId, skipFeeEnforcement, collectCallMetadata, collectHints, collectDebugLogs, maxDebugLogMemoryReads, collectStatistics){
+        this.proverId = proverId;
+        this.skipFeeEnforcement = skipFeeEnforcement;
+        this.collectCallMetadata = collectCallMetadata;
+        this.collectHints = collectHints;
+        this.collectDebugLogs = collectDebugLogs;
+        this.maxDebugLogMemoryReads = maxDebugLogMemoryReads;
+        this.collectStatistics = collectStatistics;
+    }
+    static from(obj) {
+        return new PublicSimulatorConfig(obj.proverId ?? Fr.ZERO, obj.skipFeeEnforcement ?? false, obj.collectCallMetadata ?? false, obj.collectHints ?? false, obj.collectDebugLogs ?? false, obj.maxDebugLogMemoryReads ?? DEFAULT_MAX_DEBUG_LOG_MEMORY_READS, obj.collectStatistics ?? false);
+    }
+    static empty() {
+        return PublicSimulatorConfig.from({});
+    }
+    static get schema() {
+        return z.object({
+            proverId: Fr.schema,
+            skipFeeEnforcement: z.boolean(),
+            collectCallMetadata: z.boolean(),
+            collectHints: z.boolean(),
+            collectDebugLogs: z.boolean(),
+            maxDebugLogMemoryReads: z.number(),
+            collectStatistics: z.boolean()
+        }).transform(PublicSimulatorConfig.from);
+    }
+}
+export class AvmFastSimulationInputs {
+    wsRevision;
+    config;
+    tx;
+    globalVariables;
+    protocolContracts;
+    constructor(wsRevision, config, tx, globalVariables, protocolContracts){
+        this.wsRevision = wsRevision;
+        this.config = config;
+        this.tx = tx;
+        this.globalVariables = globalVariables;
+        this.protocolContracts = protocolContracts;
+    }
+    static empty() {
+        return new AvmFastSimulationInputs(WorldStateRevision.empty(), PublicSimulatorConfig.empty(), AvmTxHint.empty(), GlobalVariables.empty(), ProtocolContracts.empty());
+    }
+    static get schema() {
+        return z.object({
+            wsRevision: WorldStateRevision.schema,
+            config: PublicSimulatorConfig.schema,
+            tx: AvmTxHint.schema,
+            globalVariables: GlobalVariables.schema,
+            protocolContracts: ProtocolContracts.schema
+        }).transform(({ wsRevision, config, tx, globalVariables, protocolContracts })=>new AvmFastSimulationInputs(wsRevision, config, tx, globalVariables, protocolContracts));
+    }
+    serializeWithMessagePack() {
+        return serializeWithMessagePack(this);
+    }
+}