@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.5daedc8

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

@@ -1,486 +0,0 @@
-import { CANONICAL_AUTH_REGISTRY_ADDRESS, DEPLOYER_CONTRACT_ADDRESS, FEE_JUICE_ADDRESS, MULTI_CALL_ENTRYPOINT_ADDRESS, REGISTERER_CONTRACT_ADDRESS, ROUTER_ADDRESS } from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-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 { 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';
-/**
- * A class to manage persistable AVM state for contract calls.
- * Maintains a cache of the current world state,
- * a trace of all side effects.
- *
- * The simulator should make any world state / tree queries through this object.
- *
- * Manages merging of successful/reverted child state into current state.
- */ export class AvmPersistableStateManager {
-    worldStateDB;
-    trace;
-    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;
-        this.trace = trace;
-        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);
-    }
-    /**
-   * 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);
-    }
-    /**
-   * Accept forked world state modifications & traced side effects / hints
-   */ async merge(forkedState) {
-        await this._merge(forkedState, /*reverted=*/ false);
-    }
-    /**
-   * Reject forked world state modifications & traced side effects, keep traced hints
-   */ async reject(forkedState) {
-        await this._merge(forkedState, /*reverted=*/ true);
-    }
-    async _merge(forkedState, reverted) {
-        // sanity check to avoid merging the same forked trace twice
-        assert(!forkedState.alreadyMergedIntoParent, 'Cannot merge forked state that has already been merged into its parent!');
-        forkedState.alreadyMergedIntoParent = true;
-        this.publicStorage.acceptAndMerge(forkedState.publicStorage);
-        this.nullifiers.acceptAndMerge(forkedState.nullifiers);
-        this.trace.merge(forkedState.trace, reverted);
-        if (reverted) {
-            await this.worldStateDB.revertCheckpoint();
-            if (this.doMerkleOperations) {
-                this.log.trace(`Rolled back nullifier tree to root ${new Fr((await this.db.getTreeInfo(MerkleTreeId.NULLIFIER_TREE)).root)}`);
-            }
-        } else {
-            this.log.trace('Merging forked state into parent...');
-            await this.worldStateDB.commitCheckpoint();
-        }
-    }
-    /**
-   * Write to public storage, journal/trace the write.
-   *
-   * @param contractAddress - the address of the contract whose storage is being written to
-   * @param slot - the slot in the contract's storage being written to
-   * @param value - the value being written to the slot
-   */ async writeStorage(contractAddress, slot, value, protocolWrite = false) {
-        const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
-        this.log.trace(`Storage write (address=${contractAddress}, slot=${slot}): value=${value}, leafSlot=${leafSlot}`);
-        if (this.doMerkleOperations) {
-            // write to native merkle trees
-            const publicDataWrite = new PublicDataWrite(leafSlot, value);
-            const result = await this.db.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);
-        }
-    }
-    /**
-   * Read from public storage, 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 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);
-            return value;
-        } else {
-            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.
-   *
-   * @param contractAddress - the address of the contract whose storage is being read from
-   * @param noteHash - the unsiloed note hash being checked
-   * @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 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);
-    }
-    /**
-   * Write a raw note hash, silo it and make it unique, then trace the write.
-   * @param noteHash - the unsiloed note hash to write
-   */ async writeNoteHash(contractAddress, noteHash) {
-        this.log.trace(`noteHashes(${contractAddress}) += ${noteHash}.`);
-        const siloedNoteHash = await siloNoteHash(contractAddress, noteHash);
-        await this.writeSiloedNoteHash(siloedNoteHash);
-    }
-    /**
-   * Write a note hash, make it unique, trace the write.
-   * @param siloedNoteHash - the non unique note hash to write
-   */ async writeSiloedNoteHash(siloedNoteHash) {
-        const nonce = await computeNoteHashNonce(this.firstNullifier, this.trace.getNoteHashCount());
-        const uniqueNoteHash = await computeUniqueNoteHash(nonce, siloedNoteHash);
-        await this.writeUniqueNoteHash(uniqueNoteHash);
-    }
-    /**
-   * Write a note hash, trace the write.
-   * @param uniqueNoteHash - the siloed unique hash to write
-   */ 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, [
-                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);
-        }
-    }
-    /**
-   * Check if a nullifier exists, trace the check.
-   * @param contractAddress - address of the contract that the nullifier is associated with
-   * @param nullifier - the unsiloed nullifier to check
-   * @returns exists - whether the nullifier exists in the nullifier set
-   */ async checkNullifierExists(contractAddress, nullifier) {
-        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);
-            return Promise.resolve(exists);
-        } else {
-            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
-   */ async writeNullifier(contractAddress, nullifier) {
-        this.log.trace(`Inserting new nullifier (address=${nullifier}, nullifier=${contractAddress})`);
-        const siloedNullifier = await siloNullifier(contractAddress, nullifier);
-        await this.writeSiloedNullifier(siloedNullifier);
-    }
-    /**
-   * Write a nullifier to the nullifier set, trace the write.
-   * @param siloedNullifier - the siloed nullifier to write
-   */ 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());
-                throw new NullifierCollisionError(`Siloed nullifier ${siloedNullifier} already exists in parent cache or host.`);
-            } else {
-                const appendResult = await this.db.sequentialInsert(treeId, [
-                    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);
-        }
-    }
-    async writeSiloedNullifiersFromPrivate(siloedNullifiers) {
-        for (const siloedNullifier of siloedNullifiers.filter((n)=>!n.isEmpty())){
-            await this.writeSiloedNullifier(siloedNullifier);
-        }
-    }
-    /**
-   * Check if an L1 to L2 message exists, trace the check.
-   * @param msgHash - the message hash to check existence of
-   * @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 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);
-    }
-    /**
-   * Write an L2 to L1 message.
-   * @param contractAddress - L2 contract address that created this message
-   * @param recipient - L1 contract address to send the message to.
-   * @param content - Message content.
-   */ writeL2ToL1Message(contractAddress, recipient, content) {
-        this.log.trace(`L2ToL1Messages(${contractAddress}) += (recipient: ${recipient}, content: ${content}).`);
-        this.trace.traceNewL2ToL1Message(contractAddress, recipient, content);
-    }
-    /**
-   * Write a public log
-   * @param contractAddress - address of the contract that emitted the log
-   * @param log - log contents
-   */ writePublicLog(contractAddress, log) {
-        this.log.trace(`PublicLog(${contractAddress}) += event with ${log.length} fields.`);
-        this.trace.tracePublicLog(contractAddress, log);
-    }
-    /**
-   * Get a contract instance.
-   * @param contractAddress - address of the contract instance to retrieve.
-   * @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 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
-        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!');
-        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);
-        }
-        return instance;
-    }
-    /**
-   * Get a contract class.
-   * @param classId - class id to retrieve.
-   * @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 exists = klass !== undefined;
-        let extendedClass = undefined;
-        // Note: We currently do not generate info to check the nullifier tree, because
-        // this is not needed for our use cases.
-        if (exists) {
-            this.log.trace(`Got contract class (id=${classId})`);
-            // Extend class information with public bytecode commitment.
-            const bytecodeCommitment = await this.worldStateDB.getBytecodeCommitment(classId);
-            assert(bytecodeCommitment, `Bytecode commitment was not found in DB for contract class (${classId}). This should not happen!`);
-            extendedClass = {
-                ...klass,
-                publicBytecodeCommitment: bytecodeCommitment
-            };
-        } else {
-            this.log.debug(`Contract instance NOT FOUND (id=${classId})`);
-        }
-        this.trace.traceGetContractClass(classId, exists, extendedClass);
-        return extendedClass;
-    }
-    /**
-   * Get a contract's bytecode from the contracts DB, also trace the contract class and instance indirectly.
-   */ async getBytecode(contractAddress) {
-        this.log.debug(`Getting bytecode for contract address ${contractAddress}`);
-        const contractInstance = await this.getContractInstance(contractAddress);
-        if (!contractInstance) {
-            return undefined;
-        }
-        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);
-    }
-    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
-        };
-    }
-}
-function contractAddressIsCanonical(contractAddress) {
-    return contractAddress.equals(AztecAddress.fromNumber(CANONICAL_AUTH_REGISTRY_ADDRESS)) || contractAddress.equals(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS)) || contractAddress.equals(AztecAddress.fromNumber(REGISTERER_CONTRACT_ADDRESS)) || contractAddress.equals(AztecAddress.fromNumber(MULTI_CALL_ENTRYPOINT_ADDRESS)) || contractAddress.equals(AztecAddress.fromNumber(FEE_JUICE_ADDRESS)) || contractAddress.equals(AztecAddress.fromNumber(ROUTER_ADDRESS));
-}

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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1 +0,0 @@
-{"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"}

package/dest/public/bytecode_errors.d.ts

@@ -1,4 +0,0 @@
-export declare class ContractClassBytecodeError extends Error {
-    constructor(contractAddress: string);
-}
-//# sourceMappingURL=bytecode_errors.d.ts.map

package/dest/public/bytecode_errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bytecode_errors.d.ts","sourceRoot":"","sources":["../../src/public/bytecode_errors.ts"],"names":[],"mappings":"AAAA,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,eAAe,EAAE,MAAM;CAIpC"}

package/dest/public/bytecode_errors.js

@@ -1,6 +0,0 @@
-export class ContractClassBytecodeError extends Error {
-    constructor(contractAddress){
-        super(`Failed to get bytecode for contract at address ${contractAddress}`);
-        this.name = 'ContractClassBytecodeError';
-    }
-}

package/dest/public/execution.d.ts

@@ -1,108 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { Fr } from '@aztec/foundation/fields';
-import { type AvmExecutionHints, type ContractStorageRead, type ContractStorageUpdateRequest, type PublicDataUpdateRequest, PublicInnerCallRequest } from '@aztec/stdlib/avm';
-import type { SimulationError } from '@aztec/stdlib/errors';
-import { Gas } from '@aztec/stdlib/gas';
-import type { NoteHash, Nullifier, ReadRequest, TreeLeafReadRequest } from '@aztec/stdlib/kernel';
-import type { PublicLog } from '@aztec/stdlib/logs';
-import type { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import type { PublicExecutionRequest } from '@aztec/stdlib/tx';
-export interface PublicSideEffects {
-    /** The contract storage update requests performed. */
-    publicDataWrites: PublicDataUpdateRequest[];
-    /** The new note hashes to be inserted into the note hashes tree. */
-    noteHashes: NoteHash[];
-    /** The new nullifiers to be inserted into the nullifier tree. */
-    nullifiers: Nullifier[];
-    /** The new l2 to l1 messages generated to be inserted into the messages tree. */
-    l2ToL1Messages: ScopedL2ToL1Message[];
-    /** Public logs emitted during execution. */
-    publicLogs: PublicLog[];
-}
-export interface EnqueuedPublicCallExecutionResult {
-    /** How much gas was left after this public execution. */
-    endGasLeft: Gas;
-    /** The side effect counter after execution */
-    endSideEffectCounter: Fr;
-    /** The return values of the function. */
-    returnValues: Fr[];
-    /** Whether the execution reverted. */
-    reverted: boolean;
-    /** The revert reason if the execution reverted. */
-    revertReason?: SimulationError;
-}
-export interface EnqueuedPublicCallExecutionResultWithSideEffects {
-    /** How much gas was left after this public execution. */
-    endGasLeft: Gas;
-    /** The side effect counter after execution */
-    endSideEffectCounter: Fr;
-    /** The return values of the function. */
-    returnValues: Fr[];
-    /** Whether the execution reverted. */
-    reverted: boolean;
-    /** The revert reason if the execution reverted. */
-    revertReason?: SimulationError;
-    /** The public side effects of the function. */
-    sideEffects: PublicSideEffects;
-}
-/**
- * The public function execution result.
- */
-export interface PublicFunctionCallResult {
-    /** The execution request that triggered this result. */
-    executionRequest: PublicExecutionRequest;
-    /** The side effect counter at the start of the function call. */
-    startSideEffectCounter: Fr;
-    /** The side effect counter after executing this function call */
-    endSideEffectCounter: Fr;
-    /** How much gas was available for this public execution. */
-    startGasLeft: Gas;
-    /** How much gas was left after this public execution. */
-    endGasLeft: Gas;
-    /** Transaction fee set for this tx. */
-    transactionFee: Fr;
-    /** Bytecode used for this execution. */
-    bytecode?: Buffer;
-    /** Calldata used for this execution. */
-    calldata: Fr[];
-    /** The return values of the function. */
-    returnValues: Fr[];
-    /** Whether the execution reverted. */
-    reverted: boolean;
-    /** The revert reason if the execution reverted. */
-    revertReason?: SimulationError;
-    /** The contract storage reads performed by the function. */
-    contractStorageReads: ContractStorageRead[];
-    /** The contract storage update requests performed by the function. */
-    contractStorageUpdateRequests: ContractStorageUpdateRequest[];
-    /** The new note hashes to be inserted into the note hashes tree. */
-    noteHashes: NoteHash[];
-    /** The new l2 to l1 messages generated in this call. */
-    l2ToL1Messages: L2ToL1Message[];
-    /** The new nullifiers to be inserted into the nullifier tree. */
-    nullifiers: Nullifier[];
-    /** The note hash read requests emitted in this call. */
-    noteHashReadRequests: TreeLeafReadRequest[];
-    /** The nullifier read requests emitted in this call. */
-    nullifierReadRequests: ReadRequest[];
-    /** The nullifier non existent read requests emitted in this call. */
-    nullifierNonExistentReadRequests: ReadRequest[];
-    /** L1 to L2 message read requests emitted in this call. */
-    l1ToL2MsgReadRequests: TreeLeafReadRequest[];
-    /**
-     * The public logs emitted in this call.
-     * Note: PublicLog has no counter - unsure if this is needed bc this struct is unused
-     */
-    publicLogs: PublicLog[];
-    /** The requests to call public functions made by this call. */
-    publicCallRequests: PublicInnerCallRequest[];
-    /** The results of nested calls. */
-    nestedExecutions: this[];
-    /** Hints for proving AVM execution. */
-    avmCircuitHints: AvmExecutionHints;
-    /** The name of the function that was executed. Only used for logging. */
-    functionName: string;
-}
-export declare function resultToPublicCallRequest(result: PublicFunctionCallResult): Promise<PublicInnerCallRequest>;
-//# sourceMappingURL=execution.d.ts.map

package/dest/public/execution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../../src/public/execution.ts"],"names":[],"mappings":"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"}

package/dest/public/execution.js

@@ -1,9 +0,0 @@
-import { PublicCallStackItemCompressed, PublicInnerCallRequest, RevertCode } from '@aztec/stdlib/avm';
-import { Gas } from '@aztec/stdlib/gas';
-import { computeVarArgsHash } from '@aztec/stdlib/hash';
-export async function resultToPublicCallRequest(result) {
-    const request = result.executionRequest;
-    const item = new PublicCallStackItemCompressed(request.callContext.contractAddress, request.callContext, await computeVarArgsHash(request.args), await computeVarArgsHash(result.returnValues), // TODO(@just-mitch): need better mapping from simulator to revert code.
-    result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK, Gas.from(result.startGasLeft), Gas.from(result.endGasLeft));
-    return new PublicInnerCallRequest(item, result.startSideEffectCounter.toNumber());
-}