@aztec/simulator 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/dest/public/state_manager/state_manager.d.ts

@@ -1,164 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { type LogLevel } from '@aztec/foundation/log';
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { SerializableContractInstance } from '@aztec/stdlib/contract';
-import type { DebugLog } from '@aztec/stdlib/logs';
-import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { TreeSnapshots } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
-import type { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
-import type { PublicContractsDBInterface } from '../db_interfaces.js';
-import type { PublicTreesDB } from '../public_db_sources.js';
-import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
-import { 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 declare class PublicPersistableStateManager {
-    private readonly treesDB;
-    private readonly contractsDB;
-    private readonly trace;
-    private readonly firstNullifier;
-    private readonly timestamp;
-    private readonly doMerkleOperations;
-    private readonly publicStorage;
-    private readonly nullifiers;
-    private readonly log;
-    /** Make sure a forked state is never merged twice. */
-    private alreadyMergedIntoParent;
-    constructor(treesDB: PublicTreesDB, contractsDB: PublicContractsDBInterface, trace: PublicSideEffectTraceInterface, firstNullifier: Fr, timestamp: UInt64, doMerkleOperations?: boolean, publicStorage?: PublicStorage, nullifiers?: NullifierManager);
-    /**
-     * Create a new state manager
-     */
-    static create(treesDB: PublicTreesDB, contractsDB: PublicContractsDBInterface, trace: PublicSideEffectTraceInterface, firstNullifier: Fr, timestamp: UInt64): PublicPersistableStateManager;
-    /**
-     * Create a new state manager forked from this one
-     */
-    fork(): Promise<PublicPersistableStateManager>;
-    /**
-     * Accept forked world state modifications & traced side effects / hints
-     */
-    merge(forkedState: PublicPersistableStateManager): Promise<void>;
-    /**
-     * Reject forked world state modifications & traced side effects, keep traced hints
-     */
-    reject(forkedState: PublicPersistableStateManager): Promise<void>;
-    private _merge;
-    /**
-     * 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
-     */
-    writeStorage(contractAddress: AztecAddress, slot: Fr, value: Fr, protocolWrite?: boolean): Promise<void>;
-    isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean;
-    /**
-     * 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
-     */
-    readStorage(contractAddress: AztecAddress, slot: Fr): Promise<Fr>;
-    /**
-     * 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
-     */
-    checkNoteHashExists(contractAddress: AztecAddress, noteHash: Fr, leafIndex: bigint): Promise<boolean>;
-    /**
-     * Write a raw note hash, silo it and make it unique, then trace the write.
-     * @param noteHash - the unsiloed note hash to write
-     */
-    writeNoteHash(contractAddress: AztecAddress, noteHash: Fr): Promise<void>;
-    /**
-     * Write a note hash, make it unique, trace the write.
-     * @param siloedNoteHash - the non unique note hash to write
-     */
-    writeSiloedNoteHash(siloedNoteHash: Fr): Promise<void>;
-    /**
-     * Write a note hash, trace the write.
-     * @param uniqueNoteHash - the siloed unique hash to write
-     */
-    writeUniqueNoteHash(uniqueNoteHash: Fr): Promise<void>;
-    /**
-     * 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
-     */
-    checkNullifierExists(contractAddress: AztecAddress, nullifier: Fr): Promise<boolean>;
-    /**
-     * 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
-     */
-    writeNullifier(contractAddress: AztecAddress, nullifier: Fr): Promise<void>;
-    /**
-     * Write a nullifier to the nullifier set, trace the write.
-     * @param siloedNullifier - the siloed nullifier to write
-     */
-    writeSiloedNullifier(siloedNullifier: Fr): Promise<void>;
-    /**
-     * 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
-     */
-    checkL1ToL2MessageExists(msgHash: Fr, msgLeafIndex: Fr): Promise<boolean>;
-    /**
-     * 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: AztecAddress, recipient: Fr, content: Fr): void;
-    /**
-     * Write a scoped L2 to L1 message.
-     * @param l2ToL1Message - The L2 to L1 message to write.
-     */
-    writeScopedL2ToL1Message(l2ToL1Message: ScopedL2ToL1Message): void;
-    writeDebugLog(contractAddress: AztecAddress, level: LogLevel, message: string, fields: Fr[]): void;
-    writeDebugLogMemoryReads(memoryReads: number): void;
-    getDebugLogMemoryReads(): number;
-    getLogs(): DebugLog[];
-    /**
-     * Write a public log
-     * @param contractAddress - address of the contract that emitted the log
-     * @param log - log contents
-     */
-    writePublicLog(contractAddress: AztecAddress, log: Fr[]): void;
-    /**
-     * Get a contract instance.
-     * @param contractAddress - address of the contract instance to retrieve.
-     * @returns the contract instance or undefined if it does not exist.
-     */
-    getContractInstance(contractAddress: AztecAddress): Promise<SerializableContractInstance | undefined>;
-    private checkContractUpdateInformation;
-    private getContractClass;
-    /**
-     * Get a contract's bytecode from the contracts DB, also trace the contract class and instance indirectly.
-     */
-    getBytecode(contractAddress: AztecAddress): Promise<Buffer | undefined>;
-    getPublicFunctionDebugName(avmEnvironment: AvmExecutionEnvironment): Promise<string>;
-    getPublicFunctionSelectorAndName(avmEnvironment: AvmExecutionEnvironment): Promise<{
-        functionSelector?: FunctionSelector;
-        functionName?: string;
-    }>;
-    padTree(treeId: MerkleTreeId, leavesToInsert: number): Promise<void>;
-    getTreeSnapshots(): Promise<TreeSnapshots>;
-}
-//# sourceMappingURL=data:application/json;base64,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

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

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

package/dest/public/state_manager/state_manager.js

@@ -1,395 +0,0 @@
-import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
-import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { SerializableContractInstance } from '@aztec/stdlib/contract';
-import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
-import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
-import { strict as assert } from 'assert';
-import { getPublicFunctionDebugName, getPublicFunctionSelectorAndName } from '../debug_fn_name.js';
-import { L1ToL2MessageIndexOutOfRangeError, MaxCallsToUniqueContractClassIdsError, NoteHashIndexOutOfRangeError, NullifierCollisionError } from '../side_effect_errors.js';
-import { 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 PublicPersistableStateManager {
-    treesDB;
-    contractsDB;
-    trace;
-    firstNullifier;
-    timestamp;
-    doMerkleOperations;
-    publicStorage;
-    nullifiers;
-    log;
-    /** Make sure a forked state is never merged twice. */ alreadyMergedIntoParent;
-    constructor(treesDB, contractsDB, trace, firstNullifier, timestamp, doMerkleOperations = true, publicStorage = new PublicStorage(treesDB), nullifiers = new NullifierManager(treesDB)){
-        this.treesDB = treesDB;
-        this.contractsDB = contractsDB;
-        this.trace = trace;
-        this.firstNullifier = firstNullifier;
-        this.timestamp = timestamp;
-        this.doMerkleOperations = doMerkleOperations;
-        this.publicStorage = publicStorage;
-        this.nullifiers = nullifiers;
-        this.log = createLogger('simulator:state_manager');
-        this.alreadyMergedIntoParent = false;
-    }
-    /**
-   * Create a new state manager
-   */ static create(treesDB, contractsDB, trace, firstNullifier, timestamp) {
-        return new PublicPersistableStateManager(treesDB, contractsDB, trace, firstNullifier, timestamp);
-    }
-    /**
-   * Create a new state manager forked from this one
-   */ async fork() {
-        await this.treesDB.createCheckpoint();
-        return new PublicPersistableStateManager(this.treesDB, this.contractsDB, this.trace.fork(), this.firstNullifier, this.timestamp, this.doMerkleOperations, this.publicStorage.fork(), this.nullifiers.fork());
-    }
-    /**
-   * 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) {
-            this.log.trace('Reverting forked state...');
-            await this.treesDB.revertCheckpoint();
-        } else {
-            this.log.trace('Merging forked state into parent...');
-            await this.treesDB.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) {
-        this.log.trace(`Storage write (address=${contractAddress}, slot=${slot}): value=${value}`);
-        await this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite);
-        if (this.doMerkleOperations) {
-            // write to native merkle trees
-            await this.treesDB.storageWrite(contractAddress, slot, value);
-        } else {
-            // Cache storage writes for later reference/reads
-            this.publicStorage.write(contractAddress, slot, value);
-        }
-    }
-    isStorageCold(contractAddress, slot) {
-        return this.trace.isStorageCold(contractAddress, slot);
-    }
-    /**
-   * 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) {
-            return await this.treesDB.storageRead(contractAddress, slot);
-        } 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}`);
-            return read.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) {
-        try {
-            const gotLeafValue = await this.treesDB.getNoteHash(leafIndex);
-            const exists = gotLeafValue.equals(noteHash);
-            this.log.trace(`noteHashes(${contractAddress})@${noteHash} ?? leafIndex: ${leafIndex} | gotLeafValue: ${gotLeafValue}, exists: ${exists}.`);
-            return Promise.resolve(exists);
-        } catch (error) {
-            // If the index is out of range, note_hash_leaf_in_range = 0 and the circuit returns false:
-            if (error instanceof NoteHashIndexOutOfRangeError) {
-                return Promise.resolve(false);
-            }
-            // Otherwise, unknown error. This is a bug.
-            throw error;
-        }
-    }
-    /**
-   * 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 noteNonce = await computeNoteHashNonce(this.firstNullifier, this.trace.getNoteHashCount());
-        const uniqueNoteHash = await computeUniqueNoteHash(noteNonce, 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}.`);
-        this.trace.traceNewNoteHash(uniqueNoteHash);
-        if (this.doMerkleOperations) {
-            await this.treesDB.writeNoteHash(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 = await this.treesDB.checkNullifierExists(siloedNullifier);
-            this.log.trace(`Checked siloed nullifier ${siloedNullifier} (exists=${exists})`);
-            return Promise.resolve(exists);
-        } else {
-            const { exists, cacheHit } = await this.nullifiers.checkExists(siloedNullifier);
-            this.log.trace(`Checked siloed nullifier ${siloedNullifier} (exists=${exists}), cacheHit=${cacheHit}`);
-            return Promise.resolve(exists);
-        }
-    }
-    /**
-   * 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}`);
-        this.trace.traceNewNullifier(siloedNullifier);
-        if (this.doMerkleOperations) {
-            const exists = await this.treesDB.checkNullifierExists(siloedNullifier);
-            if (exists) {
-                this.log.verbose(`Siloed nullifier ${siloedNullifier} already present in tree!`);
-                throw new NullifierCollisionError(`Siloed nullifier ${siloedNullifier} already exists in parent cache or host.`);
-            } else {
-                await this.treesDB.writeNullifier(siloedNullifier);
-            }
-        } else {
-            // Cache pending nullifiers for later access
-            await this.nullifiers.append(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(msgHash, msgLeafIndex) {
-        try {
-            const valueAtIndex = await this.treesDB.getL1ToL2LeafValue(msgLeafIndex.toBigInt());
-            const exists = valueAtIndex.equals(msgHash);
-            this.log.trace(`l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`);
-            return Promise.resolve(exists);
-        } catch (error) {
-            // If the index is out of range, l1_to_l2_msg_leaf_in_range = 0 and the circuit returns false:
-            if (error instanceof L1ToL2MessageIndexOutOfRangeError) {
-                return Promise.resolve(false);
-            }
-            // Otherwise, unknown error. This is a bug.
-            throw error;
-        }
-    }
-    /**
-   * 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 scoped L2 to L1 message.
-   * @param l2ToL1Message - The L2 to L1 message to write.
-   */ writeScopedL2ToL1Message(l2ToL1Message) {
-        this.writeL2ToL1Message(l2ToL1Message.contractAddress, l2ToL1Message.message.recipient.toField(), l2ToL1Message.message.content);
-    }
-    writeDebugLog(contractAddress, level, message, fields) {
-        this.trace.traceDebugLog(contractAddress, level, message, fields);
-    }
-    writeDebugLogMemoryReads(memoryReads) {
-        this.trace.traceDebugLogMemoryReads(memoryReads);
-    }
-    getDebugLogMemoryReads() {
-        return this.trace.getDebugLogMemoryReads();
-    }
-    getLogs() {
-        return this.trace.getDebugLogs();
-    }
-    /**
-   * 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.contractsDB.getContractInstance(contractAddress, this.timestamp);
-        const exists = instanceWithAddress !== undefined;
-        const instance = exists ? new SerializableContractInstance(instanceWithAddress) : undefined;
-        if (contractAddressIsCanonical(contractAddress)) {
-            this.log.trace(`Got canonical contract instance (address=${contractAddress}): instance=${jsonStringify(instance)}`);
-            return instance;
-        }
-        // Nullifier check! We do this regardless of whether or not the instance exists,
-        // as even for non-existence, we need to generate nullifier check hints.
-        // This will internally decide whether to check the nullifier tree or not depending on doMerkleOperations.
-        const nullifierExistsInTree = await this.checkNullifierExists(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), contractAddress.toField());
-        assert(exists == nullifierExistsInTree, `Contract instance for address ${contractAddress} in DB: ${exists} != nullifier tree: ${nullifierExistsInTree}. This is a bug!`);
-        if (!exists) {
-            this.log.debug(`Contract instance NOT FOUND (address=${contractAddress})`);
-            return undefined;
-        }
-        this.log.trace(`Got contract instance (address=${contractAddress}): instance=${jsonStringify(instance)}`);
-        // All that is left is to check 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) {
-            // Conceptually, we want to do the following:
-            // * Read a DelayedPublicMutable at the contract update slot.
-            // * Obtain the expected current class id from the DelayedPublicMutable, 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 delayed public mutable values.
-            // This is a bit of a leak of information, since the circuit will use it to prove
-            // one public read instead of N of the delayed public mutable values.
-            const { delayedPublicMutableSlot, delayedPublicMutableHashSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(instance.address);
-            const readDeployerStorage = async (storageSlot)=>await this.readStorage(ProtocolContractAddress.ContractInstanceRegistry, storageSlot);
-            const hash = await readDeployerStorage(delayedPublicMutableHashSlot);
-            // NOTE: The below reads are either not performed (if hash.isZero()) or only performed in unconstrained in c++ simulation.
-            // See UpdateCheck::check_current_class_id documentation - this means if we generate hints from the merkle db, they are unused:
-            const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, readDeployerStorage);
-            const preImage = delayedPublicMutableValues.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), `Delayed public 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 = delayedPublicMutableValues.svc.getCurrentAt(this.timestamp).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}`);
-        }
-    }
-    /**
-   * 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 contractClass = await this.contractsDB.getContractClass(classId);
-        const exists = contractClass !== 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.contractsDB.getBytecodeCommitment(classId);
-            assert(bytecodeCommitment, `Bytecode commitment was not found in DB for contract class (${classId}). This should not happen!`);
-            extendedClass = {
-                ...contractClass,
-                publicBytecodeCommitment: bytecodeCommitment
-            };
-        } else {
-            this.log.debug(`Contract class NOT FOUND (id=${classId})`);
-        }
-        // TODO(dbanks12): does this need to be moved to before the DB accesses as was done with writeNullifier?
-        this.trace.traceGetContractClass(classId, exists);
-        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;
-        }
-        try {
-            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!`);
-            return contractClass.packedBytecode;
-        } catch (error) {
-            if (error instanceof MaxCallsToUniqueContractClassIdsError) {
-                return undefined;
-            }
-            // Otherwise, unknown error. This is a bug.
-            throw error;
-        }
-    }
-    async getPublicFunctionDebugName(avmEnvironment) {
-        return await getPublicFunctionDebugName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
-    }
-    async getPublicFunctionSelectorAndName(avmEnvironment) {
-        return await getPublicFunctionSelectorAndName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
-    }
-    async padTree(treeId, leavesToInsert) {
-        await this.treesDB.padTree(treeId, leavesToInsert);
-    }
-    async getTreeSnapshots() {
-        return await this.treesDB.getTreeSnapshots();
-    }
-}
-function contractAddressIsCanonical(contractAddress) {
-    return contractAddress.toBigInt() >= 1 && contractAddress.toBigInt() <= MAX_PROTOCOL_CONTRACTS;
-}

package/src/public/avm/avm_context.ts

@@ -1,61 +0,0 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
-import type { AvmExecutionEnvironment } from './avm_execution_environment.js';
-import { type Gas, gasToGasLeft } from './avm_gas.js';
-import { AvmMachineState } from './avm_machine_state.js';
-import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
-
-/**
- * An execution context includes the information necessary to initiate AVM
- * execution along with all state maintained by the AVM throughout execution.
- */
-export class AvmContext {
-  /**
-   * Create a new AVM context
-   * @param persistableState - Manages world state and accrued substate during execution - (caching, fetching, tracing)
-   * @param environment - Contains constant variables provided by the kernel
-   * @param machineState - VM state that is modified on an instruction-by-instruction basis
-   * @returns new AvmContext instance
-   */
-  constructor(
-    public persistableState: PublicPersistableStateManager,
-    public environment: AvmExecutionEnvironment,
-    public machineState: AvmMachineState,
-  ) {}
-
-  // This is needed to break a dependency cycle created by the CALL opcode,
-  // which needs to create a new simulator but cannot depend directly on AvmSimulator.
-  public provideSimulator?: (context: AvmContext) => Promise<AvmSimulatorInterface>;
-
-  /**
-   * Prepare a new AVM context that will be ready for an external/nested call
-   * - Fork the world state journal
-   * - Derive a machine state from the current state
-   *   - E.g., gas metering is preserved but pc is reset
-   * - Derive an execution environment from the caller/parent
-   *   - Alter address
-   *
-   * @param address - The contract instance to initialize a context for
-   * @param calldata - Data/arguments for nested call
-   * @param allocatedGas - Gas allocated for the nested call
-   * @param callType - Type of call (CALL or STATICCALL)
-   * @returns new AvmContext instance
-   */
-  public async createNestedContractCallContext(
-    address: AztecAddress,
-    calldata: Fr[],
-    allocatedGas: Gas,
-    callType: 'CALL' | 'STATICCALL',
-  ): Promise<AvmContext> {
-    const deriveFn =
-      callType === 'CALL'
-        ? this.environment.deriveEnvironmentForNestedCall
-        : this.environment.deriveEnvironmentForNestedStaticCall;
-    const newExecutionEnvironment = deriveFn.call(this.environment, address, calldata);
-    const forkedWorldState = await this.persistableState.fork();
-    const machineState = AvmMachineState.fromState(gasToGasLeft(allocatedGas));
-    return new AvmContext(forkedWorldState, newExecutionEnvironment, machineState);
-  }
-}