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

package/dest/avm/avm.js

@@ -1,240 +1,480 @@
-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 { 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 { PublicKeys } from '../keys/public_keys.js';
+import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 import { NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
 import { PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
+import { GlobalVariables, ProtocolContracts, PublicCallRequestWithCalldata, TreeSnapshots } from '../tx/index.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));
-    }
-}
+////////////////////////////////////////////////////////////////////////////
+// Hints (contracts)
+////////////////////////////////////////////////////////////////////////////
 export class AvmContractClassHint {
     classId;
-    exists;
     artifactHash;
     privateFunctionsRoot;
-    publicBytecodeCommitment;
     packedBytecode;
-    constructor(classId, exists, artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode){
+    constructor(classId, artifactHash, privateFunctionsRoot, packedBytecode){
         this.classId = classId;
-        this.exists = exists;
         this.artifactHash = artifactHash;
         this.privateFunctionsRoot = privateFunctionsRoot;
-        this.publicBytecodeCommitment = publicBytecodeCommitment;
         this.packedBytecode = packedBytecode;
     }
     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));
+        }).transform(({ classId, artifactHash, privateFunctionsRoot, packedBytecode })=>new AvmContractClassHint(classId, artifactHash, privateFunctionsRoot, packedBytecode));
+    }
+}
+export class AvmBytecodeCommitmentHint {
+    classId;
+    commitment;
+    constructor(classId, commitment){
+        this.classId = classId;
+        this.commitment = commitment;
+    }
+    static get schema() {
+        return z.object({
+            classId: schemas.Fr,
+            commitment: schemas.Fr
+        }).transform(({ classId, commitment })=>new AvmBytecodeCommitmentHint(classId, commitment));
     }
 }
 export class AvmContractInstanceHint {
     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(address, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys){
         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({
             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(({ address, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys })=>new AvmContractInstanceHint(address, salt, deployer, currentContractClassId, originalContractClassId, initializationHash, publicKeys));
+    }
+}
+////////////////////////////////////////////////////////////////////////////
+// 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));
     }
 }
-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));
     }
 }
-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));
+        }
+    };
+}
+// 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));
     }
 }
-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));
+        }
+    };
+}
+// 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));
     }
 }
-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));
+    }
+}
+// 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));
-    }
-}
-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;
+            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));
+    }
+}
+////////////////////////////////////////////////////////////////////////////
+// Hints (other)
+////////////////////////////////////////////////////////////////////////////
+export class AvmTxHint {
+    hash;
+    gasSettings;
+    effectiveGasFees;
+    nonRevertibleAccumulatedData;
+    revertibleAccumulatedData;
+    setupEnqueuedCalls;
+    appLogicEnqueuedCalls;
+    teardownEnqueuedCall;
+    gasUsedByPrivate;
+    feePayer;
+    constructor(hash, gasSettings, effectiveGasFees, 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.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);
+        // For informational purposes. Assumed quick because it should be cached.
+        const txHash = tx.getTxHash();
+        return new AvmTxHint(txHash.hash.toString(), gasSettings, effectiveGasFees, {
+            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(), {
+            noteHashes: [],
+            nullifiers: [],
+            l2ToL1Messages: []
+        }, {
+            noteHashes: [],
+            nullifiers: [],
+            l2ToL1Messages: []
+        }, [], [], null, Gas.empty(), AztecAddress.zero());
     }
     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,
+            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, nonRevertibleAccumulatedData, revertibleAccumulatedData, setupEnqueuedCalls, appLogicEnqueuedCalls, teardownEnqueuedCall, gasUsedByPrivate, feePayer })=>new AvmTxHint(hash, gasSettings, effectiveGasFees, 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;
+    startingTreeRoots;
+    getSiblingPathHints;
+    getPreviousValueIndexHints;
+    getLeafPreimageHintsPublicDataTree;
+    getLeafPreimageHintsNullifierTree;
+    getLeafValueHints;
+    sequentialInsertHintsPublicDataTree;
+    sequentialInsertHintsNullifierTree;
+    appendLeavesHints;
+    createCheckpointHints;
+    commitCheckpointHints;
+    revertCheckpointHints;
+    constructor(globalVariables, tx, // Protocol contracts.
+    protocolContracts, // Contract hints.
+    contractInstances = [], contractClasses = [], bytecodeCommitments = [], // 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.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;
     }
     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(),
+            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, startingTreeRoots, getSiblingPathHints, getPreviousValueIndexHints, getLeafPreimageHintsPublicDataTree, getLeafPreimageHintsNullifierTree, getLeafValueHints, sequentialInsertHintsPublicDataTree, sequentialInsertHintsNullifierTree, appendLeavesHints, createCheckpointHints, commitCheckpointHints, revertCheckpointHints })=>new AvmExecutionHints(globalVariables, tx, protocolContracts, contractInstances, contractClasses, bytecodeCommitments, 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 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);