@aztec/txe 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/dest/oracle/txe_oracle.js

@@ -1,770 +0,0 @@
-import { Body, L2Block, Note } from '@aztec/aztec.js';
-import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT, DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Aes128, Schnorr } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
-import { TestDateProvider } from '@aztec/foundation/timer';
-import { ORACLE_VERSION, PXEOracleInterface, enrichPublicSimulationError } from '@aztec/pxe/server';
-import { ExecutionNoteCache, HashedValuesCache, Oracle, PrivateExecutionOracle, UtilityExecutionOracle, executePrivateFunction, generateSimulatedProvingResult, pickNotes } from '@aztec/pxe/simulator';
-import { WASMSimulator, extractCallStack, toACVMWitness, witnessMapToFields } from '@aztec/simulator/client';
-import { ExecutionError, GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor, PublicTxSimulator, createSimulationError, resolveAssertionMessageFromError } from '@aztec/simulator/server';
-import { FunctionSelector, FunctionType, countArgumentsSize } from '@aztec/stdlib/abi';
-import { AuthWitness } from '@aztec/stdlib/auth-witness';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { computePartialAddress } from '@aztec/stdlib/contract';
-import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
-import { computeCalldataHash, computeNoteHashNonce, computePublicDataTreeLeafSlot, computeUniqueNoteHash, computeVarArgsHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
-import { PartialPrivateTailPublicInputsForPublic, PrivateContextInputs, PrivateKernelTailCircuitPublicInputs, PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
-import { makeAppendOnlyTreeSnapshot, makeContentCommitment, makeGlobalVariables, makeHeader } from '@aztec/stdlib/testing';
-import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import { BlockHeader, CallContext, HashedValues, PrivateExecutionResult, Tx, TxConstantData, TxContext, TxEffect, TxHash, collectNested } from '@aztec/stdlib/tx';
-import { ForkCheckpoint } from '@aztec/world-state/native';
-import { GENESIS_TIMESTAMP } from '../txe_constants.js';
-import { TXEPublicContractDataSource } from '../util/txe_public_contract_data_source.js';
-import { TXETypedOracle } from './txe_typed_oracle.js';
-export class TXE extends TXETypedOracle {
-    keyStore;
-    contractDataProvider;
-    noteDataProvider;
-    capsuleDataProvider;
-    taggingDataProvider;
-    addressDataProvider;
-    privateEventDataProvider;
-    accountDataProvider;
-    contractAddress;
-    baseFork;
-    stateMachine;
-    logger;
-    blockNumber;
-    timestamp;
-    sideEffectCounter;
-    msgSender;
-    functionSelector;
-    pxeOracleInterface;
-    privateLogs;
-    committedBlocks;
-    ROLLUP_VERSION;
-    CHAIN_ID;
-    node;
-    simulator;
-    noteCache;
-    authwits;
-    // Used by privateSetSenderForTags and privateGetSenderForTags oracles.
-    senderForTags;
-    executionCache;
-    constructor(keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, accountDataProvider, contractAddress, baseFork, stateMachine){
-        super(), this.keyStore = keyStore, this.contractDataProvider = contractDataProvider, this.noteDataProvider = noteDataProvider, this.capsuleDataProvider = capsuleDataProvider, this.taggingDataProvider = taggingDataProvider, this.addressDataProvider = addressDataProvider, this.privateEventDataProvider = privateEventDataProvider, this.accountDataProvider = accountDataProvider, this.contractAddress = contractAddress, this.baseFork = baseFork, this.stateMachine = stateMachine, this.blockNumber = 1, this.timestamp = GENESIS_TIMESTAMP, this.sideEffectCounter = 0, this.functionSelector = FunctionSelector.fromField(new Fr(0)), this.privateLogs = [], this.committedBlocks = new Set(), this.ROLLUP_VERSION = 1, this.CHAIN_ID = 1, this.simulator = new WASMSimulator(), this.authwits = new Map();
-        this.logger = createLogger('txe:oracle');
-        this.noteCache = new ExecutionNoteCache(this.getTxRequestHash());
-        this.node = stateMachine.node;
-        // Default msg_sender (for entrypoints) is now Fr.max_value rather than 0 addr (see #7190 & #7404)
-        this.msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE);
-        this.executionCache = new HashedValuesCache();
-        this.pxeOracleInterface = new PXEOracleInterface(this.node, this.keyStore, this.contractDataProvider, this.noteDataProvider, this.capsuleDataProvider, this.stateMachine.syncDataProvider, this.taggingDataProvider, this.addressDataProvider, this.privateEventDataProvider, this.logger);
-    }
-    // Utils
-    utilityGetChainId() {
-        return Promise.resolve(new Fr(this.CHAIN_ID));
-    }
-    utilityGetVersion() {
-        return Promise.resolve(new Fr(this.ROLLUP_VERSION));
-    }
-    getMsgSender() {
-        return this.msgSender;
-    }
-    txeSetContractAddress(contractAddress) {
-        this.contractAddress = contractAddress;
-    }
-    // TODO: Currently this is only ever used to increment this.blockNumber by 1. Refactor this as `advanceBlock()`.
-    setBlockNumber(blockNumber) {
-        this.blockNumber = blockNumber;
-    }
-    async txeAdvanceBlocksBy(blocks) {
-        this.logger.debug(`time traveling ${blocks} blocks`);
-        for(let i = 0; i < blocks; i++){
-            const blockNumber = await this.utilityGetBlockNumber();
-            await this.commitState();
-            this.setBlockNumber(blockNumber + 1);
-        }
-    }
-    txeAdvanceTimestampBy(duration) {
-        this.logger.debug(`time traveling ${duration} seconds`);
-        this.timestamp = this.timestamp + duration;
-    }
-    async txeDeploy(artifact, instance, secret) {
-        // Emit deployment nullifier
-        await this.noteCache.nullifierCreated(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), instance.address.toField());
-        // Make sure the deployment nullifier gets included in a tx in a block
-        const blockNumber = await this.utilityGetBlockNumber();
-        await this.commitState();
-        this.setBlockNumber(blockNumber + 1);
-        if (!secret.equals(Fr.ZERO)) {
-            await this.txeAddAccount(artifact, instance, secret);
-        } else {
-            await this.addContractInstance(instance);
-            await this.addContractArtifact(instance.currentContractClassId, artifact);
-            this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
-        }
-    }
-    async txeAddAccount(artifact, instance, secret) {
-        const partialAddress = await computePartialAddress(instance);
-        this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
-        await this.addContractInstance(instance);
-        await this.addContractArtifact(instance.currentContractClassId, artifact);
-        const keyStore = this.getKeyStore();
-        const completeAddress = await keyStore.addAccount(secret, partialAddress);
-        const accountDataProvider = this.getAccountDataProvider();
-        await accountDataProvider.setAccount(completeAddress.address, completeAddress);
-        const addressDataProvider = this.getAddressDataProvider();
-        await addressDataProvider.addCompleteAddress(completeAddress);
-        this.logger.debug(`Created account ${completeAddress.address}`);
-        return completeAddress;
-    }
-    async txeCreateAccount(secret) {
-        const keyStore = this.getKeyStore();
-        // This is a footgun !
-        const completeAddress = await keyStore.addAccount(secret, secret);
-        const accountDataProvider = this.getAccountDataProvider();
-        await accountDataProvider.setAccount(completeAddress.address, completeAddress);
-        const addressDataProvider = this.getAddressDataProvider();
-        await addressDataProvider.addCompleteAddress(completeAddress);
-        this.logger.debug(`Created account ${completeAddress.address}`);
-        return completeAddress;
-    }
-    getContractDataProvider() {
-        return this.contractDataProvider;
-    }
-    getKeyStore() {
-        return this.keyStore;
-    }
-    getAccountDataProvider() {
-        return this.accountDataProvider;
-    }
-    getAddressDataProvider() {
-        return this.addressDataProvider;
-    }
-    async addContractInstance(contractInstance) {
-        await this.contractDataProvider.addContractInstance(contractInstance);
-    }
-    async addContractArtifact(contractClassId, artifact) {
-        await this.contractDataProvider.addContractArtifact(contractClassId, artifact);
-    }
-    async txeGetPrivateContextInputs(blockNumber, sideEffectsCounter = this.sideEffectCounter, isStaticCall = false) {
-        // If blockNumber or timestamp is null, use the values corresponding to the latest historical block (number of
-        // the block being built - 1)
-        blockNumber = blockNumber ?? this.blockNumber - 1;
-        const snap = this.stateMachine.synchronizer.nativeWorldStateService.getSnapshot(blockNumber);
-        const previousBlockState = this.stateMachine.synchronizer.nativeWorldStateService.getSnapshot(blockNumber - 1);
-        const stateReference = await snap.getStateReference();
-        const inputs = PrivateContextInputs.empty();
-        inputs.txContext.chainId = new Fr(this.CHAIN_ID);
-        inputs.txContext.version = new Fr(this.ROLLUP_VERSION);
-        inputs.historicalHeader.globalVariables.blockNumber = blockNumber;
-        inputs.historicalHeader.globalVariables.timestamp = await this.getBlockTimestamp(blockNumber);
-        inputs.historicalHeader.state = stateReference;
-        inputs.historicalHeader.lastArchive.root = Fr.fromBuffer((await previousBlockState.getTreeInfo(MerkleTreeId.ARCHIVE)).root);
-        inputs.callContext = new CallContext(this.msgSender, this.contractAddress, this.functionSelector, isStaticCall);
-        inputs.startSideEffectCounter = sideEffectsCounter;
-        this.logger.info(`Created private context for block ${blockNumber}`);
-        return inputs;
-    }
-    async txeAddAuthWitness(address, messageHash) {
-        const account = await this.accountDataProvider.getAccount(address);
-        const privateKey = await this.keyStore.getMasterSecretKey(account.publicKeys.masterIncomingViewingPublicKey);
-        const schnorr = new Schnorr();
-        const signature = await schnorr.constructSignature(messageHash.toBuffer(), privateKey);
-        const authWitness = new AuthWitness(messageHash, [
-            ...signature.toBuffer()
-        ]);
-        this.authwits.set(authWitness.requestHash.toString(), authWitness);
-    }
-    async checkNullifiersNotInTree(contractAddress, nullifiers) {
-        const siloedNullifiers = await Promise.all(nullifiers.map((nullifier)=>siloNullifier(contractAddress, nullifier)));
-        const db = this.baseFork;
-        const nullifierIndexesInTree = await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, siloedNullifiers.map((n)=>n.toBuffer()));
-        if (nullifierIndexesInTree.some((index)=>index !== undefined)) {
-            throw new Error(`Rejecting tx for emitting duplicate nullifiers`);
-        }
-    }
-    // TypedOracle
-    utilityAssertCompatibleOracleVersion(version) {
-        if (version !== ORACLE_VERSION) {
-            throw new Error(`Incompatible oracle version. PXE is using version '${ORACLE_VERSION}', but got a request for '${version}'.`);
-        }
-    }
-    utilityGetBlockNumber() {
-        return Promise.resolve(this.blockNumber);
-    }
-    utilityGetTimestamp() {
-        return Promise.resolve(this.timestamp);
-    }
-    txeGetLastBlockTimestamp() {
-        return this.getBlockTimestamp(this.blockNumber - 1);
-    }
-    utilityGetContractAddress() {
-        return Promise.resolve(this.contractAddress);
-    }
-    utilityGetRandomField() {
-        return Fr.random();
-    }
-    privateStoreInExecutionCache(values, hash) {
-        return this.executionCache.store(values, hash);
-    }
-    privateLoadFromExecutionCache(hash) {
-        const preimage = this.executionCache.getPreimage(hash);
-        if (!preimage) {
-            throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
-        }
-        return Promise.resolve(preimage);
-    }
-    utilityGetKeyValidationRequest(pkMHash) {
-        return this.keyStore.getKeyValidationRequest(pkMHash, this.contractAddress);
-    }
-    utilityGetContractInstance(address) {
-        return this.pxeOracleInterface.getContractInstance(address);
-    }
-    utilityGetMembershipWitness(blockNumber, treeId, leafValue) {
-        return this.pxeOracleInterface.getMembershipWitness(blockNumber, treeId, leafValue);
-    }
-    utilityGetNullifierMembershipWitness(blockNumber, nullifier) {
-        return this.pxeOracleInterface.getNullifierMembershipWitness(blockNumber, nullifier);
-    }
-    utilityGetPublicDataWitness(blockNumber, leafSlot) {
-        return this.pxeOracleInterface.getPublicDataWitness(blockNumber, leafSlot);
-    }
-    utilityGetLowNullifierMembershipWitness(blockNumber, nullifier) {
-        return this.pxeOracleInterface.getLowNullifierMembershipWitness(blockNumber, nullifier);
-    }
-    utilityGetBlockHeader(blockNumber) {
-        return this.stateMachine.archiver.getBlockHeader(blockNumber);
-    }
-    utilityGetCompleteAddress(account) {
-        return Promise.resolve(this.accountDataProvider.getAccount(account));
-    }
-    utilityGetAuthWitness(messageHash) {
-        const authwit = this.authwits.get(messageHash.toString());
-        return Promise.resolve(authwit?.witness);
-    }
-    async utilityGetNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status) {
-        // Nullified pending notes are already removed from the list.
-        const pendingNotes = this.noteCache.getNotes(this.contractAddress, storageSlot);
-        const pendingNullifiers = this.noteCache.getNullifiers(this.contractAddress);
-        const dbNotes = await this.pxeOracleInterface.getNotes(this.contractAddress, storageSlot, status);
-        const dbNotesFiltered = dbNotes.filter((n)=>!pendingNullifiers.has(n.siloedNullifier.value));
-        const notes = pickNotes([
-            ...dbNotesFiltered,
-            ...pendingNotes
-        ], {
-            selects: selectByIndexes.slice(0, numSelects).map((index, i)=>({
-                    selector: {
-                        index,
-                        offset: selectByOffsets[i],
-                        length: selectByLengths[i]
-                    },
-                    value: selectValues[i],
-                    comparator: selectComparators[i]
-                })),
-            sorts: sortByIndexes.map((index, i)=>({
-                    selector: {
-                        index,
-                        offset: sortByOffsets[i],
-                        length: sortByLengths[i]
-                    },
-                    order: sortOrder[i]
-                })),
-            limit,
-            offset
-        });
-        this.logger.debug(`Returning ${notes.length} notes for ${this.contractAddress} at ${storageSlot}: ${notes.map((n)=>`${n.noteNonce.toString()}:[${n.note.items.map((i)=>i.toString()).join(',')}]`).join(', ')}`);
-        if (notes.length > 0) {
-            const noteLength = notes[0].note.items.length;
-            if (!notes.every(({ note })=>noteLength === note.items.length)) {
-                throw new Error('Notes should all be the same length.');
-            }
-        }
-        return notes;
-    }
-    privateNotifyCreatedNote(storageSlot, _noteTypeId, noteItems, noteHash, counter) {
-        const note = new Note(noteItems);
-        this.noteCache.addNewNote({
-            contractAddress: this.contractAddress,
-            storageSlot,
-            noteNonce: Fr.ZERO,
-            note,
-            siloedNullifier: undefined,
-            noteHash
-        }, counter);
-        this.sideEffectCounter = counter + 1;
-    }
-    async privateNotifyNullifiedNote(innerNullifier, noteHash, counter) {
-        await this.checkNullifiersNotInTree(this.contractAddress, [
-            innerNullifier
-        ]);
-        await this.noteCache.nullifyNote(this.contractAddress, innerNullifier, noteHash);
-        this.sideEffectCounter = counter + 1;
-    }
-    async privateNotifyCreatedNullifier(innerNullifier) {
-        await this.checkNullifiersNotInTree(this.contractAddress, [
-            innerNullifier
-        ]);
-        await this.noteCache.nullifierCreated(this.contractAddress, innerNullifier);
-    }
-    async utilityCheckNullifierExists(innerNullifier) {
-        const snap = this.stateMachine.synchronizer.nativeWorldStateService.getSnapshot(this.blockNumber - 1);
-        const nullifier = await siloNullifier(this.contractAddress, innerNullifier);
-        const [index] = await snap.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [
-            nullifier.toBuffer()
-        ]);
-        const inPendingCache = this.noteCache.getNullifiers(this.contractAddress).has(nullifier.toBigInt());
-        return index !== undefined || inPendingCache;
-    }
-    getL1ToL2MembershipWitness(_contractAddress, _messageHash, _secret) {
-        throw new Error('Method not implemented.');
-    }
-    async utilityStorageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
-        let db;
-        if (blockNumber === this.blockNumber) {
-            db = this.baseFork;
-        } else {
-            db = this.stateMachine.synchronizer.nativeWorldStateService.getSnapshot(blockNumber);
-        }
-        const values = [];
-        for(let i = 0n; i < numberOfElements; i++){
-            const storageSlot = startStorageSlot.add(new Fr(i));
-            const leafSlot = (await computePublicDataTreeLeafSlot(contractAddress, storageSlot)).toBigInt();
-            const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
-            let value = Fr.ZERO;
-            if (lowLeafResult && lowLeafResult.alreadyPresent) {
-                const preimage = await db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-                value = preimage.leaf.value;
-            }
-            this.logger.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
-            values.push(value);
-        }
-        return values;
-    }
-    async commitState() {
-        const blockNumber = await this.utilityGetBlockNumber();
-        const { usedTxRequestHashForNonces } = this.noteCache.finish();
-        if (this.committedBlocks.has(blockNumber)) {
-            throw new Error('Already committed state');
-        } else {
-            this.committedBlocks.add(blockNumber);
-        }
-        const fork = this.baseFork;
-        const txEffect = TxEffect.empty();
-        const nonceGenerator = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
-        let i = 0;
-        const uniqueNoteHashesFromPrivate = await Promise.all(this.noteCache.getAllNotes().map(async (pendingNote)=>computeUniqueNoteHash(await computeNoteHashNonce(nonceGenerator, i++), await siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption))));
-        txEffect.noteHashes = uniqueNoteHashesFromPrivate;
-        txEffect.nullifiers = this.noteCache.getAllNullifiers();
-        if (usedTxRequestHashForNonces) {
-            txEffect.nullifiers.unshift(this.getTxRequestHash());
-        }
-        txEffect.privateLogs = this.privateLogs;
-        txEffect.txHash = new TxHash(new Fr(blockNumber));
-        const body = new Body([
-            txEffect
-        ]);
-        const l2Block = new L2Block(makeAppendOnlyTreeSnapshot(blockNumber + 1), makeHeader(0, blockNumber, blockNumber), body);
-        const paddedTxEffects = l2Block.body.txEffects;
-        const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
-        {
-            const noteHashesPadded = paddedTxEffects.flatMap((txEffect)=>padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
-            await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
-            await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
-        }
-        {
-            for (const txEffect of paddedTxEffects){
-                // We do not need to add public data writes because we apply them as we go. We use the sequentialInsert because
-                // the batchInsert was not working when updating a previously updated slot.
-                // FIXME: public data writes, note hashes, nullifiers, messages should all be handled in the same way.
-                // They are all relevant to subsequent enqueued calls and txs.
-                const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
-                await fork.batchInsert(MerkleTreeId.NULLIFIER_TREE, nullifiersPadded.map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
-            }
-        }
-        const stateReference = await fork.getStateReference();
-        const archiveInfo = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
-        const header = new BlockHeader(new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)), makeContentCommitment(), stateReference, makeGlobalVariables(), Fr.ZERO, Fr.ZERO);
-        header.globalVariables.blockNumber = blockNumber;
-        header.globalVariables.timestamp = await this.utilityGetTimestamp();
-        header.globalVariables.version = new Fr(this.ROLLUP_VERSION);
-        header.globalVariables.chainId = new Fr(this.CHAIN_ID);
-        this.logger.info(`Created block ${blockNumber} with timestamp ${header.globalVariables.timestamp}`);
-        l2Block.header = header;
-        await fork.updateArchive(l2Block.header);
-        await this.stateMachine.handleL2Block(l2Block);
-        this.privateLogs = [];
-        this.noteCache = new ExecutionNoteCache(this.getTxRequestHash());
-    }
-    getTxRequestHash() {
-        // Using block number itself is invalid since indexed trees come prefilled with the first slots.
-        return new Fr(this.blockNumber + 6969);
-    }
-    notifyCreatedContractClassLog(_log, _counter) {
-        throw new Error('Method not implemented.');
-    }
-    async simulateUtilityFunction(targetContractAddress, functionSelector, argsHash) {
-        const artifact = await this.contractDataProvider.getFunctionArtifact(targetContractAddress, functionSelector);
-        if (!artifact) {
-            throw new Error(`Cannot call ${functionSelector} as there is artifact found at ${targetContractAddress}.`);
-        }
-        const call = {
-            name: artifact.name,
-            selector: functionSelector,
-            to: targetContractAddress
-        };
-        const entryPointArtifact = await this.pxeOracleInterface.getFunctionArtifact(call.to, call.selector);
-        if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
-            throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
-        }
-        const oracle = new UtilityExecutionOracle(call.to, [], [], this.pxeOracleInterface, undefined, undefined);
-        try {
-            this.logger.verbose(`Executing utility function ${entryPointArtifact.name}`, {
-                contract: call.to,
-                selector: call.selector
-            });
-            const args = await this.privateLoadFromExecutionCache(argsHash);
-            const initialWitness = toACVMWitness(0, args);
-            const acirExecutionResult = await this.simulator.executeUserCircuit(initialWitness, entryPointArtifact, new Oracle(oracle).toACIRCallback()).catch((err)=>{
-                err.message = resolveAssertionMessageFromError(err, entryPointArtifact);
-                throw new ExecutionError(err.message, {
-                    contractAddress: call.to,
-                    functionSelector: call.selector
-                }, extractCallStack(err, entryPointArtifact.debug), {
-                    cause: err
-                });
-            });
-            const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
-            this.logger.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
-            const returnHash = await computeVarArgsHash(returnWitness);
-            this.privateStoreInExecutionCache(returnWitness, returnHash);
-            return returnHash;
-        } catch (err) {
-            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
-        }
-    }
-    async getInitialWitness(abi, argsHash, sideEffectCounter, isStaticCall) {
-        const argumentsSize = countArgumentsSize(abi);
-        const args = this.executionCache.getPreimage(argsHash);
-        if (args?.length !== argumentsSize) {
-            throw new Error('Invalid arguments size');
-        }
-        const historicalBlockNumber = this.blockNumber - 1; // i.e. last
-        const privateContextInputs = await this.txeGetPrivateContextInputs(historicalBlockNumber, sideEffectCounter, isStaticCall);
-        const privateContextInputsAsFields = privateContextInputs.toFields();
-        if (privateContextInputsAsFields.length !== PRIVATE_CONTEXT_INPUTS_LENGTH) {
-            throw new Error('Invalid private context inputs size');
-        }
-        const fields = [
-            ...privateContextInputsAsFields,
-            ...args
-        ];
-        return toACVMWitness(0, fields);
-    }
-    async getDebugFunctionName(address, selector) {
-        return await this.contractDataProvider.getDebugFunctionName(address, selector);
-    }
-    utilityDebugLog(message, fields) {
-        this.logger.verbose(`${applyStringFormatting(message, fields)}`, {
-            module: `${this.logger.module}:debug_log`
-        });
-    }
-    async privateIncrementAppTaggingSecretIndexAsSender(sender, recipient) {
-        await this.pxeOracleInterface.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
-    }
-    async utilityGetIndexedTaggingSecretAsSender(sender, recipient) {
-        return await this.pxeOracleInterface.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
-    }
-    async utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
-        await this.pxeOracleInterface.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot);
-        await this.pxeOracleInterface.removeNullifiedNotes(this.contractAddress);
-        return Promise.resolve();
-    }
-    async utilityValidateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot) {
-        await this.pxeOracleInterface.validateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot);
-    }
-    async utilityBulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
-        return await this.pxeOracleInterface.bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot);
-    }
-    utilityStoreCapsule(contractAddress, slot, capsule) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
-        return this.pxeOracleInterface.storeCapsule(this.contractAddress, slot, capsule);
-    }
-    utilityLoadCapsule(contractAddress, slot) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
-        return this.pxeOracleInterface.loadCapsule(this.contractAddress, slot);
-    }
-    utilityDeleteCapsule(contractAddress, slot) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
-        return this.pxeOracleInterface.deleteCapsule(this.contractAddress, slot);
-    }
-    utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
-        return this.pxeOracleInterface.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries);
-    }
-    utilityAes128Decrypt(ciphertext, iv, symKey) {
-        const aes128 = new Aes128();
-        return aes128.decryptBufferCBC(ciphertext, iv, symKey);
-    }
-    utilityGetSharedSecret(address, ephPk) {
-        return this.pxeOracleInterface.getSharedSecret(address, ephPk);
-    }
-    privateGetSenderForTags() {
-        return Promise.resolve(this.senderForTags);
-    }
-    privateSetSenderForTags(senderForTags) {
-        this.senderForTags = senderForTags;
-        return Promise.resolve();
-    }
-    async txePrivateCallNewFlow(from, targetContractAddress = AztecAddress.zero(), functionSelector = FunctionSelector.empty(), args, argsHash = Fr.zero(), isStaticCall = false) {
-        this.logger.verbose(`Executing external function ${await this.getDebugFunctionName(targetContractAddress, functionSelector)}@${targetContractAddress} isStaticCall=${isStaticCall}`);
-        const artifact = await this.contractDataProvider.getFunctionArtifact(targetContractAddress, functionSelector);
-        if (artifact === undefined) {
-            if (functionSelector.equals(await FunctionSelector.fromSignature('verify_private_authwit(Field)'))) {
-                throw new Error('Found no account contract artifact for a private authwit check - use `create_contract_account` instead of `create_light_account` for authwit support.');
-            } else {
-                throw new Error('Function Artifact does not exist');
-            }
-        }
-        const callContext = new CallContext(from, targetContractAddress, functionSelector, isStaticCall);
-        const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
-        const teardownGasLimits = new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT);
-        const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
-        const txContext = new TxContext(this.CHAIN_ID, this.ROLLUP_VERSION, gasSettings);
-        const blockHeader = await this.pxeOracleInterface.getBlockHeader();
-        const noteCache = new ExecutionNoteCache(this.getTxRequestHash());
-        const privateExecutionOracle = new PrivateExecutionOracle(argsHash, txContext, callContext, /** Header of a block whose state is used during private execution (not the block the transaction is included in). */ blockHeader, /** List of transient auth witnesses to be used during this simulation */ Array.from(this.authwits.values()), /** List of transient auth witnesses to be used during this simulation */ [], HashedValuesCache.create(), noteCache, this.pxeOracleInterface, this.simulator, 0, 1, undefined, undefined, /**
-       * In TXE, the typical transaction entrypoint is skipped, so we need to simulate the actions that such a
-       * contract would perform, including setting senderForTags.
-       */ from);
-        privateExecutionOracle.privateStoreInExecutionCache(args, argsHash);
-        // Note: This is a slight modification of simulator.run without any of the checks. Maybe we should modify simulator.run with a boolean value to skip checks.
-        let result;
-        let executionResult;
-        try {
-            executionResult = await executePrivateFunction(this.simulator, privateExecutionOracle, artifact, targetContractAddress, functionSelector);
-            const { usedTxRequestHashForNonces } = noteCache.finish();
-            const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
-            const publicCallRequests = collectNested([
-                executionResult
-            ], (r)=>r.publicInputs.publicCallRequests.getActiveItems().map((r)=>r.inner).concat(r.publicInputs.publicTeardownCallRequest.isEmpty() ? [] : [
-                    r.publicInputs.publicTeardownCallRequest
-                ]));
-            const publicFunctionsCalldata = await Promise.all(publicCallRequests.map(async (r)=>{
-                const calldata = await privateExecutionOracle.privateLoadFromExecutionCache(r.calldataHash);
-                return new HashedValues(calldata, r.calldataHash);
-            }));
-            result = new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
-        } catch (err) {
-            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
-        }
-        if (executionResult.returnValues !== undefined) {
-            const { returnValues } = executionResult;
-            // This is a bit of a hack to not deal with returning a slice in nr which is what normally happens.
-            // Investigate whether it is faster to do this or return from the oracle directly.
-            const returnValuesHash = await computeVarArgsHash(returnValues);
-            this.privateStoreInExecutionCache(returnValues, returnValuesHash);
-        }
-        // According to the protocol rules, the nonce generator for the note hashes
-        // can either be the first nullifier in the tx or the hash of the initial tx request
-        // if there are none.
-        const nonceGenerator = result.firstNullifier.equals(Fr.ZERO) ? this.getTxRequestHash() : result.firstNullifier;
-        const { publicInputs } = await generateSimulatedProvingResult(result, nonceGenerator, this.contractDataProvider);
-        const globals = makeGlobalVariables();
-        globals.blockNumber = this.blockNumber;
-        globals.timestamp = this.timestamp;
-        globals.chainId = new Fr(this.CHAIN_ID);
-        globals.version = new Fr(this.ROLLUP_VERSION);
-        globals.gasFees = GasFees.empty();
-        const contractsDB = new PublicContractsDB(new TXEPublicContractDataSource(this));
-        const guardedMerkleTrees = new GuardedMerkleTreeOperations(this.baseFork);
-        const simulator = new PublicTxSimulator(guardedMerkleTrees, contractsDB, globals, true, true);
-        const processor = new PublicProcessor(globals, guardedMerkleTrees, contractsDB, simulator, new TestDateProvider());
-        const tx = await Tx.create({
-            data: publicInputs,
-            clientIvcProof: ClientIvcProof.empty(),
-            contractClassLogFields: [],
-            publicFunctionCalldata: result.publicFunctionCalldata
-        });
-        let checkpoint;
-        if (isStaticCall) {
-            checkpoint = await ForkCheckpoint.new(this.baseFork);
-        }
-        const results = await processor.process([
-            tx
-        ]);
-        const [processedTx] = results[0];
-        const failedTxs = results[1];
-        if (failedTxs.length !== 0) {
-            throw new Error(`Public execution has failed: ${failedTxs[0].error}`);
-        } else if (!processedTx.revertCode.isOK()) {
-            if (processedTx.revertReason) {
-                await enrichPublicSimulationError(processedTx.revertReason, this.contractDataProvider, this.logger);
-                throw new Error(`Contract execution has reverted: ${processedTx.revertReason.getMessage()}`);
-            } else {
-                throw new Error('Contract execution has reverted');
-            }
-        }
-        if (isStaticCall) {
-            await checkpoint.revert();
-            return {
-                endSideEffectCounter: result.entrypoint.publicInputs.endSideEffectCounter,
-                returnsHash: result.entrypoint.publicInputs.returnsHash,
-                txHash: tx.getTxHash()
-            };
-        }
-        const fork = this.baseFork;
-        const txEffect = TxEffect.empty();
-        txEffect.noteHashes = processedTx.txEffect.noteHashes;
-        txEffect.nullifiers = processedTx.txEffect.nullifiers;
-        txEffect.privateLogs = processedTx.txEffect.privateLogs;
-        txEffect.publicLogs = processedTx.txEffect.publicLogs;
-        txEffect.publicDataWrites = processedTx.txEffect.publicDataWrites;
-        txEffect.txHash = new TxHash(new Fr(this.blockNumber));
-        const body = new Body([
-            txEffect
-        ]);
-        const l2Block = new L2Block(makeAppendOnlyTreeSnapshot(this.blockNumber + 1), makeHeader(0, this.blockNumber, this.blockNumber), body);
-        const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
-        await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
-        const stateReference = await fork.getStateReference();
-        const archiveInfo = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
-        const header = new BlockHeader(new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)), makeContentCommitment(), stateReference, globals, Fr.ZERO, Fr.ZERO);
-        header.globalVariables.blockNumber = this.blockNumber;
-        l2Block.header = header;
-        await fork.updateArchive(l2Block.header);
-        await this.stateMachine.handleL2Block(l2Block);
-        this.setBlockNumber(this.blockNumber + 1);
-        return {
-            endSideEffectCounter: result.entrypoint.publicInputs.endSideEffectCounter,
-            returnsHash: result.entrypoint.publicInputs.returnsHash,
-            txHash: tx.getTxHash()
-        };
-    }
-    async txePublicCallNewFlow(from, targetContractAddress, calldata, isStaticCall) {
-        this.logger.verbose(`Executing public function ${await this.getDebugFunctionName(targetContractAddress, FunctionSelector.fromField(calldata[0]))}@${targetContractAddress} isStaticCall=${isStaticCall}`);
-        const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
-        const teardownGasLimits = new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT);
-        const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
-        const txContext = new TxContext(this.CHAIN_ID, this.ROLLUP_VERSION, gasSettings);
-        const blockHeader = await this.pxeOracleInterface.getBlockHeader();
-        const calldataHash = await computeCalldataHash(calldata);
-        const calldataHashedValues = new HashedValues(calldata, calldataHash);
-        const globals = makeGlobalVariables();
-        globals.blockNumber = this.blockNumber;
-        globals.timestamp = this.timestamp;
-        globals.chainId = new Fr(this.CHAIN_ID);
-        globals.version = new Fr(this.ROLLUP_VERSION);
-        globals.gasFees = GasFees.empty();
-        const contractsDB = new PublicContractsDB(new TXEPublicContractDataSource(this));
-        const guardedMerkleTrees = new GuardedMerkleTreeOperations(this.baseFork);
-        const simulator = new PublicTxSimulator(guardedMerkleTrees, contractsDB, globals, true, true);
-        const processor = new PublicProcessor(globals, guardedMerkleTrees, contractsDB, simulator, new TestDateProvider());
-        // We're simulating a scenario in which private execution immediately enqueues a public call and halts. The private
-        // kernel init would in this case inject a nullifier with the transaction request hash as a non-revertible
-        // side-effect, which the AVM then expects to exist in order to use it as the nonce generator when siloing notes as
-        // unique.
-        const nonRevertibleAccumulatedData = PrivateToPublicAccumulatedData.empty();
-        if (!isStaticCall) {
-            nonRevertibleAccumulatedData.nullifiers[0] = this.getTxRequestHash();
-        }
-        // The enqueued public call itself we make be revertible so that the public execution is itself revertible, as tests
-        // may require producing reverts.
-        const revertibleAccumulatedData = PrivateToPublicAccumulatedData.empty();
-        revertibleAccumulatedData.publicCallRequests[0] = new PublicCallRequest(from, targetContractAddress, isStaticCall, calldataHash);
-        const inputsForPublic = new PartialPrivateTailPublicInputsForPublic(nonRevertibleAccumulatedData, revertibleAccumulatedData, PublicCallRequest.empty());
-        const constantData = new TxConstantData(blockHeader, txContext, Fr.zero(), Fr.zero());
-        const txData = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ new Gas(0, 0), /*feePayer=*/ AztecAddress.zero(), /*includeByTimestamp=*/ 0n, inputsForPublic, undefined);
-        const tx = await Tx.create({
-            data: txData,
-            clientIvcProof: ClientIvcProof.empty(),
-            contractClassLogFields: [],
-            publicFunctionCalldata: [
-                calldataHashedValues
-            ]
-        });
-        let checkpoint;
-        if (isStaticCall) {
-            checkpoint = await ForkCheckpoint.new(this.baseFork);
-        }
-        const results = await processor.process([
-            tx
-        ]);
-        const [processedTx] = results[0];
-        const failedTxs = results[1];
-        if (failedTxs.length !== 0) {
-            throw new Error(`Public execution has failed: ${failedTxs[0].error}`);
-        } else if (!processedTx.revertCode.isOK()) {
-            if (processedTx.revertReason) {
-                await enrichPublicSimulationError(processedTx.revertReason, this.contractDataProvider, this.logger);
-                throw new Error(`Contract execution has reverted: ${processedTx.revertReason.getMessage()}`);
-            } else {
-                throw new Error('Contract execution has reverted');
-            }
-        }
-        const returnValues = results[3][0].values;
-        let returnValuesHash;
-        if (returnValues !== undefined) {
-            // This is a bit of a hack to not deal with returning a slice in nr which is what normally happens.
-            // Investigate whether it is faster to do this or return from the oracle directly.
-            returnValuesHash = await computeVarArgsHash(returnValues);
-            this.privateStoreInExecutionCache(returnValues, returnValuesHash);
-        }
-        if (isStaticCall) {
-            await checkpoint.revert();
-            return {
-                returnsHash: returnValuesHash ?? Fr.ZERO,
-                txHash: tx.getTxHash()
-            };
-        }
-        const fork = this.baseFork;
-        const txEffect = TxEffect.empty();
-        txEffect.noteHashes = processedTx.txEffect.noteHashes;
-        txEffect.nullifiers = processedTx.txEffect.nullifiers;
-        txEffect.privateLogs = processedTx.txEffect.privateLogs;
-        txEffect.publicLogs = processedTx.txEffect.publicLogs;
-        txEffect.publicDataWrites = processedTx.txEffect.publicDataWrites;
-        txEffect.txHash = new TxHash(new Fr(this.blockNumber));
-        const body = new Body([
-            txEffect
-        ]);
-        const l2Block = new L2Block(makeAppendOnlyTreeSnapshot(this.blockNumber + 1), makeHeader(0, this.blockNumber, this.blockNumber), body);
-        const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
-        await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
-        const stateReference = await fork.getStateReference();
-        const archiveInfo = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
-        const header = new BlockHeader(new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)), makeContentCommitment(), stateReference, globals, Fr.ZERO, Fr.ZERO);
-        header.globalVariables.blockNumber = this.blockNumber;
-        l2Block.header = header;
-        await fork.updateArchive(l2Block.header);
-        await this.stateMachine.handleL2Block(l2Block);
-        this.setBlockNumber(this.blockNumber + 1);
-        return {
-            returnsHash: returnValuesHash ?? Fr.ZERO,
-            txHash: tx.getTxHash()
-        };
-    }
-    async getBlockTimestamp(blockNumber) {
-        const blockHeader = await this.stateMachine.archiver.getBlockHeader(blockNumber);
-        if (!blockHeader) {
-            throw new Error(`Requested timestamp for block ${blockNumber}, which does not exist`);
-        }
-        return blockHeader.globalVariables.timestamp;
-    }
-}