@aztec/simulator 0.80.0 → 0.81.0

package/dest/public/avm/journal/journal.js

@@ -4,14 +4,13 @@ import { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { AvmPublicDataReadTreeHint, PublicDataWrite } from '@aztec/stdlib/avm';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { SerializableContractInstance } from '@aztec/stdlib/contract';
 import { computeNoteHashNonce, computePublicDataTreeLeafSlot, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { strict as assert } from 'assert';
-import cloneDeep from 'lodash.clonedeep';
 import { getPublicFunctionDebugName } from '../../../common/debug_fn_name.js';
 import { NullifierCollisionError, NullifierManager } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
@@ -24,39 +23,43 @@ import { PublicStorage } from './public_storage.js';
  *
  * Manages merging of successful/reverted child state into current state.
  */ export class AvmPersistableStateManager {
-    worldStateDB;
+    treesDB;
+    contractsDB;
     trace;
+    firstNullifier;
+    blockNumber;
+    doMerkleOperations;
     publicStorage;
     nullifiers;
-    doMerkleOperations;
-    db;
-    firstNullifier;
     log;
     /** Make sure a forked state is never merged twice. */ alreadyMergedIntoParent;
-    constructor(/** Reference to node storage */ worldStateDB, /** Side effect trace */ // TODO(5818): make private once no longer accessed in executor
-    trace, /** Public storage, including cached writes */ publicStorage = new PublicStorage(worldStateDB), /** Nullifier set, including cached/recently-emitted nullifiers */ nullifiers = new NullifierManager(worldStateDB), doMerkleOperations = false, /** DB interface for merkle tree operations */ db, firstNullifier){
-        this.worldStateDB = worldStateDB;
+    constructor(treesDB, contractsDB, trace, firstNullifier, blockNumber, doMerkleOperations = false, publicStorage = new PublicStorage(treesDB), nullifiers = new NullifierManager(treesDB)){
+        this.treesDB = treesDB;
+        this.contractsDB = contractsDB;
         this.trace = trace;
+        this.firstNullifier = firstNullifier;
+        this.blockNumber = blockNumber;
+        this.doMerkleOperations = doMerkleOperations;
         this.publicStorage = publicStorage;
         this.nullifiers = nullifiers;
-        this.doMerkleOperations = doMerkleOperations;
-        this.db = db;
-        this.firstNullifier = firstNullifier;
         this.log = createLogger('simulator:avm:state_manager');
         this.alreadyMergedIntoParent = false;
     }
     /**
    * Create a new state manager
-   */ static create(worldStateDB, trace, doMerkleOperations = false, firstNullifier) {
-        // TODO(dbanks12): temporary until we establish a better world state interface
-        const db = worldStateDB.getMerkleInterface();
-        return new AvmPersistableStateManager(worldStateDB, trace, /*publicStorage=*/ new PublicStorage(worldStateDB), /*nullifiers=*/ new NullifierManager(worldStateDB), /*doMerkleOperations=*/ doMerkleOperations, db, firstNullifier);
+   */ static create(treesDB, contractsDB, trace, doMerkleOperations = false, firstNullifier, blockNumber) {
+        return new AvmPersistableStateManager(treesDB, contractsDB, trace, firstNullifier, blockNumber, doMerkleOperations);
+    }
+    // DO NOT USE!
+    // FIXME(fcarreiro): refactor and remove this.
+    deprecatedGetTreesForPIGeneration() {
+        return this.treesDB;
     }
     /**
    * Create a new state manager forked from this one
    */ async fork() {
-        await this.worldStateDB.createCheckpoint();
-        return new AvmPersistableStateManager(this.worldStateDB, this.trace.fork(), this.publicStorage.fork(), this.nullifiers.fork(), this.doMerkleOperations, this.db, this.firstNullifier);
+        await this.treesDB.createCheckpoint();
+        return new AvmPersistableStateManager(this.treesDB, this.contractsDB, this.trace.fork(), this.firstNullifier, this.blockNumber, this.doMerkleOperations, this.publicStorage.fork(), this.nullifiers.fork());
     }
     /**
    * Accept forked world state modifications & traced side effects / hints
@@ -76,13 +79,13 @@ import { PublicStorage } from './public_storage.js';
         this.nullifiers.acceptAndMerge(forkedState.nullifiers);
         this.trace.merge(forkedState.trace, reverted);
         if (reverted) {
-            await this.worldStateDB.revertCheckpoint();
+            await this.treesDB.revertCheckpoint();
             if (this.doMerkleOperations) {
-                this.log.trace(`Rolled back nullifier tree to root ${new Fr((await this.db.getTreeInfo(MerkleTreeId.NULLIFIER_TREE)).root)}`);
+                this.log.trace(`Rolled back nullifier tree to root ${new Fr((await this.treesDB.getTreeInfo(MerkleTreeId.NULLIFIER_TREE)).root)}`);
             }
         } else {
             this.log.trace('Merging forked state into parent...');
-            await this.worldStateDB.commitCheckpoint();
+            await this.treesDB.commitCheckpoint();
         }
     }
     /**
@@ -97,89 +100,34 @@ import { PublicStorage } from './public_storage.js';
         if (this.doMerkleOperations) {
             // write to native merkle trees
             const publicDataWrite = new PublicDataWrite(leafSlot, value);
-            const result = await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+            const result = await this.treesDB.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
                 publicDataWrite.toBuffer()
             ]);
             assert(result !== undefined, 'Public data tree insertion error. You might want to disable doMerkleOperations.');
             this.log.trace(`Inserted public data tree leaf at leafSlot ${leafSlot}, value: ${value}`);
-            // low leaf hint
-            const lowLeafPreimage = result.lowLeavesWitnessData[0].leafPreimage;
-            const lowLeafIndex = result.lowLeavesWitnessData[0].index;
-            const lowLeafPath = result.lowLeavesWitnessData[0].siblingPath.toFields();
-            // new leaf insertion
-            const newLeafPreimage = cloneDeep(lowLeafPreimage);
-            let insertionPath;
-            if (result.insertionWitnessData.length === 0) {
-                assert(newLeafPreimage.value.equals(value), `Value mismatch when performing public data write (got value: ${value}, value in tree: ${newLeafPreimage.value})`);
-            } else {
-                // The new leaf preimage should have the new value and slot
-                newLeafPreimage.slot = leafSlot;
-                newLeafPreimage.value = value;
-                // TODO: is this necessary?! Why doesn't sequentialInsert return the newLeafPreimage via
-                // result.insertionWitnessData[0].leafPreimage?
-                this.log.trace(`newLeafPreimage.slot: ${newLeafPreimage.slot}, newLeafPreimage.value: ${newLeafPreimage.value}, insertionIndex: ${result.insertionWitnessData[0].index}`);
-                insertionPath = result.insertionWitnessData[0].siblingPath.toFields();
-            }
-            await this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite, lowLeafPreimage, new Fr(lowLeafIndex), lowLeafPath, newLeafPreimage, insertionPath);
         } else {
             // Cache storage writes for later reference/reads
             this.publicStorage.write(contractAddress, slot, value);
-            await this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite);
         }
+        await this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite);
     }
     /**
-   * Read from public storage, trace the read.
+   * Read from public storage.
    *
    * @param contractAddress - the address of the contract whose storage is being read from
    * @param slot - the slot in the contract's storage being read from
    * @returns the latest value written to slot, or 0 if never written to before
    */ async readStorage(contractAddress, slot) {
         if (this.doMerkleOperations) {
-            const { value, leafPreimage, leafIndex, leafPath } = await this.getPublicDataMembership(contractAddress, slot);
-            this.trace.tracePublicStorageRead(contractAddress, slot, value, leafPreimage, leafIndex, leafPath);
+            const value = await this.treesDB.storageRead(contractAddress, slot);
             return value;
         } else {
+            // TODO(fcarreiro): I don't get this. PublicStorage CAN end up reading the tree. Why is it in the "dont do merkle operations" branch?
             const read = await this.publicStorage.read(contractAddress, slot);
             this.log.trace(`Storage read results (address=${contractAddress}, slot=${slot}): value=${read.value}, cached=${read.cached}`);
-            this.trace.tracePublicStorageRead(contractAddress, slot, read.value);
             return read.value;
         }
     }
-    async getPublicDataMembership(contractAddress, slot) {
-        const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
-        const treeId = MerkleTreeId.PUBLIC_DATA_TREE;
-        // Get leaf if present, low leaf if absent
-        // If leaf is present, hint/trace it. Otherwise, hint/trace the low leaf.
-        const { preimage, leafOrLowLeafIndex, alreadyPresent } = await this.getLeafOrLowLeafInfo(treeId, leafSlot.toBigInt());
-        // The index and preimage here is either the low leaf or the leaf itself (depending on the value of update flag)
-        // In either case, we just want the sibling path to this leaf - it's up to the avm to distinguish if it's a low leaf or not
-        const leafPath = await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, leafOrLowLeafIndex);
-        const leafPreimage = preimage;
-        const value = alreadyPresent ? leafPreimage.value : Fr.zero(); // default value of 0
-        if (!alreadyPresent) {
-            this.log.trace(`Slot has never been written before!`);
-            // Sanity check that the leaf slot is skipped by low leaf when it doesn't exist
-            assert(leafPreimage.slot.toBigInt() < leafSlot.toBigInt() && (leafPreimage.nextIndex === 0n || leafPreimage.nextSlot.toBigInt() > leafSlot.toBigInt()), 'Public data tree low leaf should skip the target leaf slot when the target leaf does not exist or is the max value.');
-        }
-        this.log.trace(`Storage read results (address=${contractAddress}, slot=${slot}, leafSlot=${leafSlot}): value=${value}, previouslyWritten=${alreadyPresent}`);
-        return {
-            value,
-            leafPreimage,
-            leafIndex: new Fr(leafOrLowLeafIndex),
-            leafPath: leafPath.toFields()
-        };
-    }
-    /**
-   * Read from public storage, don't trace the read.
-   *
-   * @param contractAddress - the address of the contract whose storage is being read from
-   * @param slot - the slot in the contract's storage being read from
-   * @returns the latest value written to slot, or 0 if never written to before
-   */ async peekStorage(contractAddress, slot) {
-        const { value, cached } = await this.publicStorage.read(contractAddress, slot);
-        this.log.trace(`Storage peek  (address=${contractAddress}, slot=${slot}): value=${value},  cached=${cached}`);
-        return Promise.resolve(value);
-    }
     // TODO(4886): We currently don't silo note hashes.
     /**
    * Check if a note hash exists at the given leaf index, trace the check.
@@ -189,15 +137,9 @@ import { PublicStorage } from './public_storage.js';
    * @param leafIndex - the leaf index being checked
    * @returns true if the note hash exists at the given leaf index, false otherwise
    */ async checkNoteHashExists(contractAddress, noteHash, leafIndex) {
-        const gotLeafValue = await this.worldStateDB.getCommitmentValue(leafIndex.toBigInt()) ?? Fr.ZERO;
+        const gotLeafValue = await this.treesDB.getCommitmentValue(leafIndex.toBigInt()) ?? Fr.ZERO;
         const exists = gotLeafValue.equals(noteHash);
         this.log.trace(`noteHashes(${contractAddress})@${noteHash} ?? leafIndex: ${leafIndex} | gotLeafValue: ${gotLeafValue}, exists: ${exists}.`);
-        if (this.doMerkleOperations) {
-            const path = await this.db.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex.toBigInt());
-            this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists, path.toFields());
-        } else {
-            this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists);
-        }
         return Promise.resolve(exists);
     }
     /**
@@ -222,17 +164,11 @@ import { PublicStorage } from './public_storage.js';
    */ async writeUniqueNoteHash(uniqueNoteHash) {
         this.log.trace(`noteHashes += @${uniqueNoteHash}.`);
         if (this.doMerkleOperations) {
-            // Should write a helper for this
-            const treeInfo = await this.db.getTreeInfo(MerkleTreeId.NOTE_HASH_TREE);
-            const leafIndex = new Fr(treeInfo.size);
-            await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [
+            await this.treesDB.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [
                 uniqueNoteHash
             ]);
-            const insertionPath = await this.db.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex.toBigInt());
-            this.trace.traceNewNoteHash(uniqueNoteHash, leafIndex, insertionPath.toFields());
-        } else {
-            this.trace.traceNewNoteHash(uniqueNoteHash);
         }
+        this.trace.traceNewNoteHash(uniqueNoteHash);
     }
     /**
    * Check if a nullifier exists, trace the check.
@@ -243,47 +179,17 @@ import { PublicStorage } from './public_storage.js';
         this.log.trace(`Checking existence of nullifier (address=${contractAddress}, nullifier=${nullifier})`);
         const siloedNullifier = await siloNullifier(contractAddress, nullifier);
         if (this.doMerkleOperations) {
-            const { exists, leafOrLowLeafPreimage, leafOrLowLeafIndex, leafOrLowLeafPath } = await this.getNullifierMembership(siloedNullifier);
-            this.trace.traceNullifierCheck(siloedNullifier, exists, leafOrLowLeafPreimage, new Fr(leafOrLowLeafIndex), leafOrLowLeafPath);
+            const exists = await this.treesDB.getNullifierIndex(siloedNullifier) !== undefined;
+            this.log.trace(`Checked siloed nullifier ${siloedNullifier} (exists=${exists})`);
             return Promise.resolve(exists);
         } else {
+            // TODO: same here, this CAN hit the db.
             const { exists, cacheHit } = await this.nullifiers.checkExists(siloedNullifier);
             this.log.trace(`Checked siloed nullifier ${siloedNullifier} (exists=${exists}), cacheHit=${cacheHit}`);
-            this.trace.traceNullifierCheck(siloedNullifier, exists);
             return Promise.resolve(exists);
         }
     }
     /**
-   * Helper to get membership information for a siloed nullifier when checking its existence.
-   * Optionally trace the nullifier check.
-   *
-   * @param siloedNullifier - the siloed nullifier to get membership information for
-   * @returns
-   *     - exists - whether the nullifier exists in the nullifier set
-   *     - leafOrLowLeafPreimage - the preimage of the nullifier leaf or its low-leaf if it doesn't exist
-   *     - leafOrLowLeafIndex - the leaf index of the nullifier leaf or its low-leaf if it doesn't exist
-   *     - leafOrLowLeafPath - the sibling path of the nullifier leaf or its low-leaf if it doesn't exist
-   */ async getNullifierMembership(siloedNullifier) {
-        // Get leaf if present, low leaf if absent
-        // If leaf is present, hint/trace it. Otherwise, hint/trace the low leaf.
-        const treeId = MerkleTreeId.NULLIFIER_TREE;
-        const { preimage: leafPreimage, leafOrLowLeafIndex, alreadyPresent } = await this.getLeafOrLowLeafInfo(treeId, siloedNullifier.toBigInt());
-        this.log.trace(`Checked siloed nullifier ${siloedNullifier} (exists=${alreadyPresent})`);
-        const leafPath = await this.db.getSiblingPath(treeId, leafOrLowLeafIndex);
-        if (alreadyPresent) {
-            this.log.trace(`Siloed nullifier ${siloedNullifier} exists at leafIndex=${leafOrLowLeafIndex}`);
-        } else {
-            // Sanity check that the leaf value is skipped by low leaf when it doesn't exist
-            assert(leafPreimage.nullifier.toBigInt() < siloedNullifier.toBigInt() && (leafPreimage.nextIndex === 0n || leafPreimage.nextNullifier.toBigInt() > siloedNullifier.toBigInt()), 'Nullifier tree low leaf should skip the target leaf nullifier when the target leaf does not exist.');
-        }
-        return {
-            exists: alreadyPresent,
-            leafOrLowLeafPreimage: leafPreimage,
-            leafOrLowLeafIndex,
-            leafOrLowLeafPath: leafPath.toFields()
-        };
-    }
-    /**
    * Write a nullifier to the nullifier set, trace the write.
    * @param contractAddress - address of the contract that the nullifier is associated with
    * @param nullifier - the unsiloed nullifier to write
@@ -298,32 +204,20 @@ import { PublicStorage } from './public_storage.js';
    */ async writeSiloedNullifier(siloedNullifier) {
         this.log.trace(`Inserting siloed nullifier=${siloedNullifier}`);
         if (this.doMerkleOperations) {
-            const treeId = MerkleTreeId.NULLIFIER_TREE;
-            const { preimage: leafPreimage, leafOrLowLeafIndex, alreadyPresent } = await this.getLeafOrLowLeafInfo(treeId, siloedNullifier.toBigInt());
-            if (alreadyPresent) {
-                this.log.verbose(`Siloed nullifier ${siloedNullifier} already present in tree at index ${leafOrLowLeafIndex}!`);
-                // If the nullifier is already present, we should not insert it again
-                // instead we provide the direct membership path
-                const membershipPath = await this.db.getSiblingPath(treeId, leafOrLowLeafIndex);
-                // This just becomes a nullifier read hint
-                this.trace.traceNullifierCheck(siloedNullifier, /*exists=*/ alreadyPresent, leafPreimage, new Fr(leafOrLowLeafIndex), membershipPath.toFields());
+            const index = await this.treesDB.getNullifierIndex(siloedNullifier);
+            if (index !== undefined) {
+                this.log.verbose(`Siloed nullifier ${siloedNullifier} already present in tree at index ${index}!`);
                 throw new NullifierCollisionError(`Siloed nullifier ${siloedNullifier} already exists in parent cache or host.`);
             } else {
-                const appendResult = await this.db.sequentialInsert(treeId, [
+                await this.treesDB.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [
                     siloedNullifier.toBuffer()
                 ]);
-                const lowLeafWitnessData = appendResult.lowLeavesWitnessData[0];
-                const lowLeafPreimage = lowLeafWitnessData.leafPreimage;
-                const lowLeafIndex = lowLeafWitnessData.index;
-                const lowLeafPath = lowLeafWitnessData.siblingPath.toFields();
-                const insertionPath = appendResult.insertionWitnessData[0].siblingPath.toFields();
-                this.trace.traceNewNullifier(siloedNullifier, lowLeafPreimage, new Fr(lowLeafIndex), lowLeafPath, insertionPath);
             }
         } else {
             // Cache pending nullifiers for later access
             await this.nullifiers.append(siloedNullifier);
-            this.trace.traceNewNullifier(siloedNullifier);
         }
+        this.trace.traceNewNullifier(siloedNullifier);
     }
     async writeSiloedNullifiersFromPrivate(siloedNullifiers) {
         for (const siloedNullifier of siloedNullifiers.filter((n)=>!n.isEmpty())){
@@ -336,15 +230,9 @@ import { PublicStorage } from './public_storage.js';
    * @param msgLeafIndex - the message leaf index to use in the check
    * @returns exists - whether the message exists in the L1 to L2 Messages tree
    */ async checkL1ToL2MessageExists(contractAddress, msgHash, msgLeafIndex) {
-        const valueAtIndex = await this.worldStateDB.getL1ToL2LeafValue(msgLeafIndex.toBigInt()) ?? Fr.ZERO;
+        const valueAtIndex = await this.treesDB.getL1ToL2LeafValue(msgLeafIndex.toBigInt()) ?? Fr.ZERO;
         const exists = valueAtIndex.equals(msgHash);
         this.log.trace(`l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`);
-        if (this.doMerkleOperations) {
-            const path = await this.db.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, msgLeafIndex.toBigInt());
-            this.trace.traceL1ToL2MessageCheck(contractAddress, valueAtIndex, msgLeafIndex, exists, path.toFields());
-        } else {
-            this.trace.traceL1ToL2MessageCheck(contractAddress, valueAtIndex, msgLeafIndex, exists);
-        }
         return Promise.resolve(exists);
     }
     /**
@@ -370,31 +258,61 @@ import { PublicStorage } from './public_storage.js';
    * @returns the contract instance or undefined if it does not exist.
    */ async getContractInstance(contractAddress) {
         this.log.trace(`Getting contract instance for address ${contractAddress}`);
-        const instanceWithAddress = await this.worldStateDB.getContractInstance(contractAddress);
+        const instanceWithAddress = await this.contractsDB.getContractInstance(contractAddress, this.blockNumber);
         const exists = instanceWithAddress !== undefined;
         const instance = exists ? new SerializableContractInstance(instanceWithAddress) : undefined;
         if (!exists) {
             this.log.debug(`Contract instance NOT FOUND (address=${contractAddress})`);
-            this.trace.traceGetContractInstance(contractAddress, exists);
             return undefined;
         }
         this.log.trace(`Got contract instance (address=${contractAddress}): instance=${jsonStringify(instance)}`);
-        // Canonical addresses do not trigger nullifier & public storage checks
+        // Canonical addresses do not trigger nullifier and update checks.
         if (contractAddressIsCanonical(contractAddress)) {
-            this.trace.traceGetContractInstance(contractAddress, exists, instance);
             return instance;
         }
         // This will decide internally whether to check the nullifier tree or not depending on doMerkleOperations.
         const nullifierExistsInTree = await this.checkNullifierExists(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), contractAddress.toField());
-        assert(exists == nullifierExistsInTree, 'WorldStateDB contains contract instance, but nullifier tree does not contain contract address (or vice versa).... This is a bug!');
+        assert(exists == nullifierExistsInTree, 'treesDB contains contract instance, but nullifier tree does not contain contract address (or vice versa).... This is a bug!');
+        // All that is left is tocheck that the contract updatability information is correct.
+        // That is, that the current and original contract class ids are correct.
+        await this.checkContractUpdateInformation(instanceWithAddress);
+        return instance;
+    }
+    async checkContractUpdateInformation(instance) {
+        // If "merkle operations" are not requested, we trust the DB.
+        // Otherwise we check that the contract updatability information is correct.
+        // That is, that the current and original contract class ids are correct.
+        // All failures are fatal and the simulation is not expected to be provable.
         if (this.doMerkleOperations) {
-            // TODO(fcarreiro): this should be done via a public read.
-            const { updateMembership, updatePreimage } = await this.getContractUpdateHints(contractAddress);
-            this.trace.traceGetContractInstance(contractAddress, exists, instance, updateMembership, updatePreimage);
-        } else {
-            this.trace.traceGetContractInstance(contractAddress, exists, instance);
+            // Conceptually, we want to do the following:
+            // * Read a SharedMutable at the contract update slot.
+            // * Obtain the expected current class id from the SharedMutable, at the current block.
+            // * if expectedId == 0 then currentClassId should be original contract class id
+            // * if expectedId != 0 then currentClassId should be expectedId
+            //
+            // However, we will also be checking the hash of the shared mutable values.
+            // This is a bit of a leak of information, since the circuit will use it to prove
+            // one public read insted of N of the shared mutable values.
+            const { sharedMutableSlot, sharedMutableHashSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(instance.address);
+            const readDeployerStorage = async (storageSlot)=>await this.readStorage(ProtocolContractAddress.ContractInstanceDeployer, storageSlot);
+            const hash = await readDeployerStorage(sharedMutableHashSlot);
+            const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, readDeployerStorage);
+            const preImage = sharedMutableValues.toFields();
+            // 1) update never scheduled: hash == 0 and preimage should be empty (but poseidon2hash(preimage) will not be 0s)
+            if (hash.isZero()) {
+                assert(preImage.every((f)=>f.isZero()), `Found updatability hash 0 but preimage is not empty for contract instance ${instance.address}.`);
+                assert(instance.currentContractClassId.equals(instance.originalContractClassId), `Found updatability hash 0 for contract instance ${instance.address} but original class id ${instance.originalContractClassId} != current class id ${instance.currentContractClassId}.`);
+                return;
+            }
+            // 2) At this point we know that the hash is not zero and this means that an update has at some point been scheduled.
+            const computedHash = await poseidon2Hash(preImage);
+            assert(hash.equals(computedHash), `Shared mutable values hash mismatch for contract instance ${instance.address}. Expected: ${hash}, computed: ${computedHash}`);
+            // We now check that, depending on the current block, the current class id is correct.
+            const expectedClassIdRaw = sharedMutableValues.svc.getCurrentAt(this.blockNumber).at(0);
+            const expectedClassId = expectedClassIdRaw.isZero() ? instance.originalContractClassId : expectedClassIdRaw;
+            assert(instance.currentContractClassId.equals(expectedClassId), `Current class id mismatch
+        for contract instance ${instance.address}. Expected: ${expectedClassId}, current: ${instance.currentContractClassId}`);
         }
-        return instance;
     }
     /**
    * Get a contract class.
@@ -402,7 +320,7 @@ import { PublicStorage } from './public_storage.js';
    * @returns the contract class or undefined if it does not exist.
    */ async getContractClass(classId) {
         this.log.trace(`Getting contract class for id ${classId}`);
-        const klass = await this.worldStateDB.getContractClass(classId);
+        const klass = await this.contractsDB.getContractClass(classId);
         const exists = klass !== undefined;
         let extendedClass = undefined;
         // Note: We currently do not generate info to check the nullifier tree, because
@@ -410,7 +328,7 @@ import { PublicStorage } from './public_storage.js';
         if (exists) {
             this.log.trace(`Got contract class (id=${classId})`);
             // Extend class information with public bytecode commitment.
-            const bytecodeCommitment = await this.worldStateDB.getBytecodeCommitment(classId);
+            const bytecodeCommitment = await this.contractsDB.getBytecodeCommitment(classId);
             assert(bytecodeCommitment, `Bytecode commitment was not found in DB for contract class (${classId}). This should not happen!`);
             extendedClass = {
                 ...klass,
@@ -419,7 +337,7 @@ import { PublicStorage } from './public_storage.js';
         } else {
             this.log.debug(`Contract instance NOT FOUND (id=${classId})`);
         }
-        this.trace.traceGetContractClass(classId, exists, extendedClass);
+        this.trace.traceGetContractClass(classId, exists);
         return extendedClass;
     }
     /**
@@ -432,53 +350,13 @@ import { PublicStorage } from './public_storage.js';
         }
         const contractClass = await this.getContractClass(contractInstance.currentContractClassId);
         assert(contractClass, `Contract class not found in DB, but a contract instance was found with this class ID (${contractInstance.currentContractClassId}). This should not happen!`);
-        // NOTE: If the contract instance is not found, we assume it has not been deployed.
-        // It doesnt matter what the values of the contract instance are in this case, as long as we tag it with exists=false.
-        // This will hint to the avm circuit to just perform the non-membership check on the address and disregard the bytecode hash
         return contractClass.packedBytecode;
     }
-    async getContractUpdateHints(contractAddress) {
-        const { sharedMutableSlot, sharedMutableHashSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-        const { value: hash, leafPreimage, leafIndex, leafPath } = await this.getPublicDataMembership(ProtocolContractAddress.ContractInstanceDeployer, sharedMutableHashSlot);
-        const updateMembership = new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, leafPath);
-        const readStorage = async (storageSlot)=>(await this.publicStorage.read(ProtocolContractAddress.ContractInstanceDeployer, storageSlot)).value;
-        const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, readStorage);
-        const updatePreimage = sharedMutableValues.toFields();
-        if (!hash.isZero()) {
-            const hashed = await poseidon2Hash(updatePreimage);
-            if (!hashed.equals(hash)) {
-                throw new Error(`Update hint hash mismatch: ${hash} != ${hashed}`);
-            }
-            this.log.trace(`Non empty update hint found for contract ${contractAddress}`);
-        } else {
-            if (updatePreimage.some((f)=>!f.isZero())) {
-                throw new Error(`Update hint hash is zero, but update preimage is not: ${updatePreimage}`);
-            }
-            this.log.trace(`No update hint found for contract ${contractAddress}`);
-        }
-        return {
-            updateMembership,
-            updatePreimage
-        };
-    }
-    traceEnqueuedCall(publicCallRequest, calldata, reverted) {
-        this.trace.traceEnqueuedCall(publicCallRequest, calldata, reverted);
+    traceEnqueuedCall(publicCallRequest) {
+        this.trace.traceEnqueuedCall(publicCallRequest);
     }
     async getPublicFunctionDebugName(avmEnvironment) {
-        return await getPublicFunctionDebugName(this.worldStateDB, avmEnvironment.address, avmEnvironment.calldata);
-    }
-    async getLeafOrLowLeafInfo(treeId, key) {
-        // "key" is siloed slot (leafSlot) or siloed nullifier
-        const leafOrLowLeafInfo = await this.db.getPreviousValueIndex(treeId, key);
-        assert(leafOrLowLeafInfo !== undefined, `${MerkleTreeId[treeId]} low leaf index should always be found (even if target leaf does not exist)`);
-        const { index: leafOrLowLeafIndex, alreadyPresent } = leafOrLowLeafInfo;
-        const leafPreimage = await this.db.getLeafPreimage(treeId, leafOrLowLeafIndex);
-        assert(leafPreimage !== undefined, `${MerkleTreeId[treeId]}  low leaf preimage should never be undefined (even if target leaf does not exist)`);
-        return {
-            preimage: leafPreimage,
-            leafOrLowLeafIndex,
-            alreadyPresent
-        };
+        return await getPublicFunctionDebugName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
     }
 }
 function contractAddressIsCanonical(contractAddress) {

package/dest/public/avm/journal/nullifiers.d.ts

@@ -1,5 +1,5 @@
 import type { Fr } from '@aztec/foundation/fields';
-import type { WorldStateDB } from '../../public_db_sources.js';
+import type { PublicTreesDB } from '../../public_db_sources.js';
 /**
  * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
  * Maintains a siloed nullifier cache, and ensures that existence checks fall back to the correct source.
@@ -14,7 +14,7 @@ export declare class NullifierManager {
     private readonly parent?;
     constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    hostNullifiers: WorldStateDB, 
+    hostNullifiers: PublicTreesDB, 
     /** Cache of siloed nullifiers. */
     cache?: Set<bigint>, 
     /** Parent nullifier manager to fall back on */

package/dest/public/avm/journal/nullifiers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nullifiers.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/journal/nullifiers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;GAIG;AACH,qBAAa,gBAAgB;IAEzB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,kCAAkC;IAClC,OAAO,CAAC,KAAK;IACb,+CAA+C;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;;IALxB,+DAA+D;IAC9C,cAAc,EAAE,YAAY;IAC7C,kCAAkC;IAC1B,KAAK,GAAE,GAAG,CAAC,MAAM,CAAa;IACtC,+CAA+C;IAC9B,MAAM,CAAC,8BAAkB;IAG5C;;OAEG;IACI,IAAI;IAIX;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;;;;;;;;OAUG;IACU,WAAW,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IAmB9F;;;;OAIG;IACU,MAAM,CAAC,eAAe,EAAE,EAAE;IAQvC;;;;OAIG;IACI,cAAc,CAAC,kBAAkB,EAAE,gBAAgB;CAU3D;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;CAI5C"}
+{"version":3,"file":"nullifiers.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/journal/nullifiers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE;;;;GAIG;AACH,qBAAa,gBAAgB;IAEzB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,kCAAkC;IAClC,OAAO,CAAC,KAAK;IACb,+CAA+C;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;;IALxB,+DAA+D;IAC9C,cAAc,EAAE,aAAa;IAC9C,kCAAkC;IAC1B,KAAK,GAAE,GAAG,CAAC,MAAM,CAAa;IACtC,+CAA+C;IAC9B,MAAM,CAAC,8BAAkB;IAG5C;;OAEG;IACI,IAAI;IAIX;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;;;;;;;;OAUG;IACU,WAAW,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IAmB9F;;;;OAIG;IACU,MAAM,CAAC,eAAe,EAAE,EAAE;IAQvC;;;;OAIG;IACI,cAAc,CAAC,kBAAkB,EAAE,gBAAgB;CAU3D;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;CAI5C"}

package/dest/public/avm/journal/public_storage.d.ts

@@ -1,6 +1,6 @@
 import { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PublicStateDB } from '../../../common/db_interfaces.js';
+import type { PublicStateDBInterface } from '../../../common/db_interfaces.js';
 type PublicStorageReadResult = {
     value: Fr;
     cached: boolean;
@@ -19,7 +19,7 @@ export declare class PublicStorage {
     private readonly cache;
     constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    hostPublicStorage: PublicStateDB, 
+    hostPublicStorage: PublicStateDBInterface, 
     /** Parent's storage. Checked on this' cache-miss. */
     parent?: PublicStorage | undefined);
     /**

package/dest/public/avm/journal/public_storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public_storage.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/journal/public_storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEtE,KAAK,uBAAuB,GAAG;IAC7B,KAAK,EAAE,EAAE,CAAC;IACV,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,aAAa;IAKtB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,6BAA6B;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;;IAGzC,+DAA+D;IAC9C,iBAAiB,EAAE,aAAa;IACjD,qDAAqD;IACpC,MAAM,CAAC,2BAAe;IAKzC;;OAEG;IACI,IAAI;IAIX;;;;;;;OAOG;IACI,gBAAgB,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,SAAS;IAWhF;;;;;;;;;;OAUG;IACU,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAmB5F;;;;;;OAMG;IACI,KAAK,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;IAI/D;;;;OAIG;IACI,cAAc,CAAC,qBAAqB,EAAE,aAAa;CAG3D"}
+{"version":3,"file":"public_storage.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/journal/public_storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE/E,KAAK,uBAAuB,GAAG;IAC7B,KAAK,EAAE,EAAE,CAAC;IACV,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,aAAa;IAKtB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,6BAA6B;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;;IAGzC,+DAA+D;IAC9C,iBAAiB,EAAE,sBAAsB;IAC1D,qDAAqD;IACpC,MAAM,CAAC,2BAAe;IAKzC;;OAEG;IACI,IAAI;IAIX;;;;;;;OAOG;IACI,gBAAgB,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,SAAS;IAWhF;;;;;;;;;;OAUG;IACU,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAmB5F;;;;;;OAMG;IACI,KAAK,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;IAI/D;;;;OAIG;IACI,cAAc,CAAC,qBAAqB,EAAE,aAAa;CAG3D"}

package/dest/public/avm/test_utils.d.ts

@@ -1,18 +1,15 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { Fr } from '@aztec/foundation/fields';
-import { type ContractClassPublic, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { WorldStateDB } from '../../public/public_db_sources.js';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { PublicContractsDB, PublicTreesDB } from '../../public/public_db_sources.js';
 import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
-export declare function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer): Promise<void>;
 export declare function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface): void;
-export declare function mockStorageRead(worldStateDB: WorldStateDB, value: Fr): void;
+export declare function mockStorageRead(worldStateDB: PublicTreesDB, value: Fr): void;
 export declare function mockNoteHashCount(mockedTrace: PublicSideEffectTraceInterface, count: number): void;
-export declare function mockStorageReadWithMap(worldStateDB: WorldStateDB, mockedStorage: Map<bigint, Fr>): void;
-export declare function mockGetBytecodeCommitment(worldStateDB: WorldStateDB, commitment: Fr): void;
-export declare function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, value?: Fr): void;
-export declare function mockGetNullifierIndex(worldStateDB: WorldStateDB, leafIndex: Fr, _ignoredValue?: Fr): void;
-export declare function mockL1ToL2MessageExists(worldStateDB: WorldStateDB, leafIndex: Fr, value: Fr, valueAtOtherIndices?: Fr): void;
-export declare function mockGetContractInstance(worldStateDB: WorldStateDB, contractInstance: ContractInstanceWithAddress): void;
-export declare function mockGetContractClass(worldStateDB: WorldStateDB, contractClass: ContractClassPublic): void;
+export declare function mockStorageReadWithMap(worldStateDB: PublicTreesDB, mockedStorage: Map<bigint, Fr>): void;
+export declare function mockNoteHashExists(worldStateDB: PublicTreesDB, _leafIndex: Fr, value?: Fr): void;
+export declare function mockGetNullifierIndex(worldStateDB: PublicTreesDB, leafIndex: Fr, _ignoredValue?: Fr): void;
+export declare function mockL1ToL2MessageExists(worldStateDB: PublicTreesDB, leafIndex: Fr, value: Fr, valueAtOtherIndices?: Fr): void;
+export declare function mockGetContractInstance(contractsDB: PublicContractsDB, contractInstance: ContractInstanceWithAddress): void;
+export declare function mockGetContractClass(contractsDB: PublicContractsDB, contractClass: ContractClassPublic): void;
+export declare function mockGetBytecodeCommitment(contractsDB: PublicContractsDB, commitment: Fr): void;
 //# sourceMappingURL=test_utils.d.ts.map

package/dest/public/avm/test_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../src/public/avm/test_utils.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAEjC,MAAM,wBAAwB,CAAC;AAKhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AAExF,wBAAsB,eAAe,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAGjF;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,8BAA8B,EAAE,WAAW,CAAC,EAAE,8BAA8B,QAIhH;AAED,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,QAEpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,8BAA8B,EAAE,KAAK,EAAE,MAAM,QAE3F;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,QAIhG;AAED,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,QAEnF;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,QASxF;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,EAAE,EAAE,aAAa,CAAC,EAAE,EAAE,QAElG;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,EAAE,EACb,KAAK,EAAE,EAAE,EACT,mBAAmB,CAAC,EAAE,EAAE,QAWzB;AAED,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,2BAA2B,QAEhH;AAED,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,mBAAmB,QAElG"}
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../src/public/avm/test_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAK/F,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC1F,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AAExF,wBAAgB,aAAa,CAAC,KAAK,EAAE,8BAA8B,EAAE,WAAW,CAAC,EAAE,8BAA8B,QAIhH;AAED,wBAAgB,eAAe,CAAC,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,EAAE,QAErE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,8BAA8B,EAAE,KAAK,EAAE,MAAM,QAE3F;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,QAIjG;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,QASzF;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,EAAE,EAAE,aAAa,CAAC,EAAE,EAAE,QAEnG;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,aAAa,EAC3B,SAAS,EAAE,EAAE,EACb,KAAK,EAAE,EAAE,EACT,mBAAmB,CAAC,EAAE,EAAE,QAWzB;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,2BAA2B,QAEpH;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,QAEtG;AAED,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,iBAAiB,EAAE,UAAU,EAAE,EAAE,QAEvF"}

package/dest/public/avm/test_utils.js

@@ -1,10 +1,5 @@
 import { Fr } from '@aztec/foundation/fields';
-import { computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
 import { mock } from 'jest-mock-extended';
-export async function mockGetBytecode(worldStateDB, bytecode) {
-    const commitment = await computePublicBytecodeCommitment(bytecode);
-    worldStateDB.getBytecodeCommitment.mockResolvedValue(commitment);
-}
 export function mockTraceFork(trace, nestedTrace) {
     trace.fork.mockReturnValue(nestedTrace ?? mock());
 }
@@ -17,9 +12,6 @@ export function mockNoteHashCount(mockedTrace, count) {
 export function mockStorageReadWithMap(worldStateDB, mockedStorage) {
     worldStateDB.storageRead.mockImplementation((_address, slot)=>Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO));
 }
-export function mockGetBytecodeCommitment(worldStateDB, commitment) {
-    worldStateDB.getBytecodeCommitment.mockResolvedValue(commitment);
-}
 export function mockNoteHashExists(worldStateDB, _leafIndex, value) {
     worldStateDB.getCommitmentValue.mockImplementation((index)=>{
         if (index == _leafIndex.toBigInt()) {
@@ -44,9 +36,12 @@ export function mockL1ToL2MessageExists(worldStateDB, leafIndex, value, valueAtO
         }
     });
 }
-export function mockGetContractInstance(worldStateDB, contractInstance) {
-    worldStateDB.getContractInstance.mockResolvedValue(contractInstance);
+export function mockGetContractInstance(contractsDB, contractInstance) {
+    contractsDB.getContractInstance.mockResolvedValue(contractInstance);
+}
+export function mockGetContractClass(contractsDB, contractClass) {
+    contractsDB.getContractClass.mockResolvedValue(contractClass);
 }
-export function mockGetContractClass(worldStateDB, contractClass) {
-    worldStateDB.getContractClass.mockResolvedValue(contractClass);
+export function mockGetBytecodeCommitment(contractsDB, commitment) {
+    contractsDB.getBytecodeCommitment.mockResolvedValue(commitment);
 }