@aztec/txe 1.2.0 → 2.0.0-nightly.20250813

package/dest/oracle/txe_oracle.js

@@ -1,34 +1,29 @@
 import { Body, L2Block, Note } from '@aztec/aztec.js';
-import { DEFAULT_GAS_LIMIT, DEFAULT_TEARDOWN_GAS_LIMIT, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_ENQUEUED_CALLS_PER_TX, MAX_L2_GAS_PER_TX_PUBLIC_PORTION, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
+import { DEFAULT_GAS_LIMIT, DEFAULT_TEARDOWN_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION, 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, poseidon2Hash } from '@aztec/foundation/crypto';
+import { Aes128, Schnorr } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { applyStringFormatting } from '@aztec/foundation/log';
-import { TestDateProvider, Timer } from '@aztec/foundation/timer';
+import { TestDateProvider } from '@aztec/foundation/timer';
 import { KeyStore } from '@aztec/key-store';
 import { AddressDataProvider, CapsuleDataProvider, NoteDataProvider, PXEOracleInterface, PrivateEventDataProvider, TaggingDataProvider, enrichPublicSimulationError } from '@aztec/pxe/server';
-import { ExecutionNoteCache, HashedValuesCache, Oracle, PrivateExecutionOracle, UtilityExecutionOracle, executePrivateFunction, extractPrivateCircuitPublicInputs, generateSimulatedProvingResult, pickNotes } from '@aztec/pxe/simulator';
+import { ExecutionNoteCache, HashedValuesCache, Oracle, PrivateExecutionOracle, UtilityExecutionOracle, executePrivateFunction, generateSimulatedProvingResult, pickNotes } from '@aztec/pxe/simulator';
 import { WASMSimulator, extractCallStack, toACVMWitness, witnessMapToFields } from '@aztec/simulator/client';
-import { createTxForPublicCalls } from '@aztec/simulator/public/fixtures';
 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 { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { SimulationError } from '@aztec/stdlib/errors';
 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, RollupValidationRequests, ScopedLogHash } from '@aztec/stdlib/kernel';
-import { deriveKeys } from '@aztec/stdlib/keys';
-import { PrivateLog } from '@aztec/stdlib/logs';
-import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+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, NullifierMembershipWitness, PublicDataTreeLeaf, PublicDataWitness } from '@aztec/stdlib/trees';
-import { BlockHeader, CallContext, GlobalVariables, HashedValues, PrivateExecutionResult, PublicCallRequestWithCalldata, Tx, TxConstantData, TxContext, TxEffect, TxHash, collectNested } from '@aztec/stdlib/tx';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, PublicDataTreeLeaf } 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 { TXEStateMachine } from '../state_machine/index.js';
-import { AZTEC_SLOT_DURATION, GENESIS_TIMESTAMP } from '../txe_constants.js';
+import { GENESIS_TIMESTAMP } from '../txe_constants.js';
 import { TXEAccountDataProvider } from '../util/txe_account_data_provider.js';
 import { TXEContractDataProvider } from '../util/txe_contract_data_provider.js';
 import { TXEPublicContractDataSource } from '../util/txe_public_contract_data_source.js';
@@ -53,10 +48,6 @@ export class TXE {
     sideEffectCounter;
     msgSender;
     functionSelector;
-    isStaticCall;
-    // Return/revert data of the latest nested call.
-    nestedCallReturndata;
-    nestedCallSuccess;
     pxeOracleInterface;
     publicDataWrites;
     uniqueNoteHashesFromPublic;
@@ -70,6 +61,8 @@ export class TXE {
     simulator;
     noteCache;
     authwits;
+    // Used by privateSetSenderForTags and privateGetSenderForTags oracles.
+    senderForTags;
     constructor(logger, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, accountDataProvider, executionCache, contractAddress, nativeWorldStateService, baseFork, stateMachine){
         this.logger = logger;
         this.keyStore = keyStore;
@@ -90,9 +83,6 @@ export class TXE {
         this.timestamp = GENESIS_TIMESTAMP;
         this.sideEffectCounter = 0;
         this.functionSelector = FunctionSelector.fromField(new Fr(0));
-        this.isStaticCall = false;
-        this.nestedCallReturndata = [];
-        this.nestedCallSuccess = false;
         this.publicDataWrites = [];
         this.uniqueNoteHashesFromPublic = [];
         this.siloedNullifiersFromPublic = [];
@@ -137,38 +127,23 @@ export class TXE {
     getBaseFork() {
         return this.baseFork;
     }
-    getChainId() {
+    utilityGetChainId() {
         return Promise.resolve(new Fr(this.CHAIN_ID));
     }
-    getVersion() {
+    utilityGetVersion() {
         return Promise.resolve(new Fr(this.ROLLUP_VERSION));
     }
     getMsgSender() {
         return this.msgSender;
     }
-    getFunctionSelector() {
-        return this.functionSelector;
-    }
-    setMsgSender(msgSender) {
-        this.msgSender = msgSender;
-    }
-    setFunctionSelector(functionSelector) {
-        this.functionSelector = functionSelector;
-    }
-    getSideEffectsCounter() {
-        return this.sideEffectCounter;
-    }
-    setSideEffectsCounter(sideEffectsCounter) {
-        this.sideEffectCounter = sideEffectsCounter;
-    }
-    setContractAddress(contractAddress) {
+    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;
     }
-    advanceTimestampBy(duration) {
+    txeAdvanceTimestampBy(duration) {
         this.timestamp = this.timestamp + duration;
     }
     getContractDataProvider() {
@@ -189,11 +164,10 @@ export class TXE {
     async addContractArtifact(contractClassId, artifact) {
         await this.contractDataProvider.addContractArtifact(contractClassId, artifact);
     }
-    async getPrivateContextInputs(blockNumber, timestamp, sideEffectsCounter = this.sideEffectCounter, isStaticCall = false) {
+    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;
-        timestamp = timestamp ?? this.timestamp - AZTEC_SLOT_DURATION;
         const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
         const previousBlockState = this.nativeWorldStateService.getSnapshot(blockNumber - 1);
         const stateReference = await snap.getStateReference();
@@ -201,17 +175,14 @@ export class TXE {
         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 = timestamp;
+        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;
         return inputs;
     }
-    deriveKeys(secret) {
-        return deriveKeys(secret);
-    }
-    async addAuthWitness(address, messageHash) {
+    async txeAddAuthWitness(address, messageHash) {
         const account = await this.accountDataProvider.getAccount(address);
         const privateKey = await this.keyStore.getMasterSecretKey(account.publicKeys.masterIncomingViewingPublicKey);
         const schnorr = new Schnorr();
@@ -239,139 +210,61 @@ export class TXE {
     addUniqueNoteHashesFromPublic(siloedNoteHashes) {
         this.uniqueNoteHashesFromPublic.push(...siloedNoteHashes);
     }
-    async addPrivateLogs(contractAddress, privateLogs) {
-        for (const privateLog of privateLogs){
-            privateLog.fields[0] = await poseidon2Hash([
-                contractAddress,
-                privateLog.fields[0]
-            ]);
-        }
-        this.privateLogs.push(...privateLogs);
-    }
-    addPublicLogs(logs) {
-        logs.forEach((log)=>{
-            try {
-                const tag = log.fields[0];
-                this.logger.verbose(`Found tagged public log with tag ${tag.toString()} in block ${this.blockNumber}`);
-                this.publicLogs.push(log);
-            } catch (err) {
-                this.logger.warn(`Failed to add tagged log to store: ${err}`);
-            }
-        });
-    }
     // TypedOracle
-    getBlockNumber() {
+    utilityGetBlockNumber() {
         return Promise.resolve(this.blockNumber);
     }
-    getTimestamp() {
+    utilityGetTimestamp() {
         return Promise.resolve(this.timestamp);
     }
-    getContractAddress() {
-        return Promise.resolve(this.contractAddress);
-    }
-    setIsStaticCall(isStatic) {
-        this.isStaticCall = isStatic;
+    txeGetLastBlockTimestamp() {
+        return this.getBlockTimestamp(this.blockNumber - 1);
     }
-    getIsStaticCall() {
-        return this.isStaticCall;
+    utilityGetContractAddress() {
+        return Promise.resolve(this.contractAddress);
     }
-    getRandomField() {
+    utilityGetRandomField() {
         return Fr.random();
     }
-    storeInExecutionCache(values, hash) {
+    privateStoreInExecutionCache(values, hash) {
         return this.executionCache.store(values, hash);
     }
-    loadFromExecutionCache(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);
     }
-    getKeyValidationRequest(pkMHash) {
+    utilityGetKeyValidationRequest(pkMHash) {
         return this.keyStore.getKeyValidationRequest(pkMHash, this.contractAddress);
     }
-    async getContractInstance(address) {
-        const contractInstance = await this.contractDataProvider.getContractInstance(address);
-        if (!contractInstance) {
-            throw new Error(`Contract instance not found for address ${address}`);
-        }
-        return contractInstance;
+    utilityGetContractInstance(address) {
+        return this.pxeOracleInterface.getContractInstance(address);
     }
-    async getMembershipWitness(blockNumber, treeId, leafValue) {
-        const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
-        const index = (await snap.findLeafIndices(treeId, [
-            leafValue.toBuffer()
-        ]))[0];
-        if (index === undefined) {
-            throw new Error(`Leaf value: ${leafValue} not found in ${MerkleTreeId[treeId]} at block ${blockNumber}`);
-        }
-        const siblingPath = await snap.getSiblingPath(treeId, index);
-        return [
-            new Fr(index),
-            ...siblingPath.toFields()
-        ];
+    utilityGetMembershipWitness(blockNumber, treeId, leafValue) {
+        return this.pxeOracleInterface.getMembershipWitness(blockNumber, treeId, leafValue);
     }
-    async getSiblingPath(blockNumber, treeId, leafIndex) {
-        const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
-        const result = await snap.getSiblingPath(treeId, leafIndex.toBigInt());
-        return result.toFields();
+    utilityGetNullifierMembershipWitness(blockNumber, nullifier) {
+        return this.pxeOracleInterface.getNullifierMembershipWitness(blockNumber, nullifier);
     }
-    async getNullifierMembershipWitness(blockNumber, nullifier) {
-        const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
-        const [index] = await snap.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [
-            nullifier.toBuffer()
-        ]);
-        if (!index) {
-            return undefined;
-        }
-        const leafPreimagePromise = snap.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
-        const siblingPathPromise = snap.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, BigInt(index));
-        const [leafPreimage, siblingPath] = await Promise.all([
-            leafPreimagePromise,
-            siblingPathPromise
-        ]);
-        if (!leafPreimage) {
-            return undefined;
-        }
-        return new NullifierMembershipWitness(BigInt(index), leafPreimage, siblingPath);
-    }
-    async getPublicDataWitness(blockNumber, leafSlot) {
-        const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
-        const lowLeafResult = await snap.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
-        if (!lowLeafResult) {
-            return undefined;
-        } else {
-            const preimage = await snap.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-            const path = await snap.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-            return new PublicDataWitness(lowLeafResult.index, preimage, path);
-        }
+    utilityGetPublicDataWitness(blockNumber, leafSlot) {
+        return this.pxeOracleInterface.getPublicDataWitness(blockNumber, leafSlot);
     }
-    async getLowNullifierMembershipWitness(blockNumber, nullifier) {
-        const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
-        const findResult = await snap.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
-        if (!findResult) {
-            return undefined;
-        }
-        const { index, alreadyPresent } = findResult;
-        if (alreadyPresent) {
-            this.logger.warn(`Nullifier ${nullifier.toBigInt()} already exists in the tree`);
-        }
-        const preimageData = await snap.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
-        const siblingPath = await snap.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, BigInt(index));
-        return new NullifierMembershipWitness(BigInt(index), preimageData, siblingPath);
+    utilityGetLowNullifierMembershipWitness(blockNumber, nullifier) {
+        return this.pxeOracleInterface.getLowNullifierMembershipWitness(blockNumber, nullifier);
     }
-    getBlockHeader(blockNumber) {
+    utilityGetBlockHeader(blockNumber) {
         return this.stateMachine.archiver.getBlockHeader(blockNumber);
     }
-    getCompleteAddress(account) {
+    utilityGetCompleteAddress(account) {
         return Promise.resolve(this.accountDataProvider.getAccount(account));
     }
-    getAuthWitness(messageHash) {
+    utilityGetAuthWitness(messageHash) {
         const authwit = this.authwits.get(messageHash.toString());
         return Promise.resolve(authwit?.witness);
     }
-    async getNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status) {
+    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);
@@ -404,7 +297,7 @@ export class TXE {
         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(', ')}`);
         return notes;
     }
-    notifyCreatedNote(storageSlot, _noteTypeId, noteItems, noteHash, counter) {
+    privateNotifyCreatedNote(storageSlot, _noteTypeId, noteItems, noteHash, counter) {
         const note = new Note(noteItems);
         this.noteCache.addNewNote({
             contractAddress: this.contractAddress,
@@ -416,31 +309,32 @@ export class TXE {
         }, counter);
         this.sideEffectCounter = counter + 1;
     }
-    async notifyNullifiedNote(innerNullifier, noteHash, counter) {
+    async privateNotifyNullifiedNote(innerNullifier, noteHash, counter) {
         await this.checkNullifiersNotInTree(this.contractAddress, [
             innerNullifier
         ]);
         await this.noteCache.nullifyNote(this.contractAddress, innerNullifier, noteHash);
         this.sideEffectCounter = counter + 1;
     }
-    async notifyCreatedNullifier(innerNullifier) {
+    async privateNotifyCreatedNullifier(innerNullifier) {
         await this.checkNullifiersNotInTree(this.contractAddress, [
             innerNullifier
         ]);
         await this.noteCache.nullifierCreated(this.contractAddress, innerNullifier);
     }
-    async checkNullifierExists(innerNullifier) {
+    async utilityCheckNullifierExists(innerNullifier) {
         const snap = this.nativeWorldStateService.getSnapshot(this.blockNumber - 1);
         const nullifier = await siloNullifier(this.contractAddress, innerNullifier);
         const [index] = await snap.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [
             nullifier.toBuffer()
         ]);
-        return index !== undefined;
+        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 storageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
+    async utilityStorageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
         let db;
         if (blockNumber === this.blockNumber) {
             db = this.baseFork;
@@ -472,7 +366,7 @@ export class TXE {
         return publicDataWrites.map((write)=>write.value);
     }
     async commitState() {
-        const blockNumber = await this.getBlockNumber();
+        const blockNumber = await this.utilityGetBlockNumber();
         const { usedTxRequestHashForNonces } = this.noteCache.finish();
         if (this.committedBlocks.has(blockNumber)) {
             throw new Error('Already committed state');
@@ -524,7 +418,10 @@ export class TXE {
         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.getTimestamp();
+        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);
@@ -562,7 +459,7 @@ export class TXE {
                 contract: call.to,
                 selector: call.selector
             });
-            const args = await this.loadFromExecutionCache(argsHash);
+            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);
@@ -576,69 +473,20 @@ export class TXE {
             const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
             this.logger.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
             const returnHash = await computeVarArgsHash(returnWitness);
-            this.storeInExecutionCache(returnWitness, returnHash);
+            this.privateStoreInExecutionCache(returnWitness, returnHash);
             return returnHash;
         } catch (err) {
             throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
         }
     }
-    async callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
-        this.logger.verbose(`Executing external function ${await this.getDebugFunctionName(targetContractAddress, functionSelector)}@${targetContractAddress} isStaticCall=${isStaticCall}`);
-        // Store and modify env
-        const currentContractAddress = this.contractAddress;
-        const currentMessageSender = this.msgSender;
-        const currentFunctionSelector = FunctionSelector.fromField(this.functionSelector.toField());
-        this.setMsgSender(this.contractAddress);
-        this.setContractAddress(targetContractAddress);
-        this.setFunctionSelector(functionSelector);
-        const artifact = await this.contractDataProvider.getFunctionArtifact(targetContractAddress, functionSelector);
-        if (!artifact) {
-            throw new Error(`Artifact not found when calling private function. Contract address: ${targetContractAddress}.`);
-        }
-        const initialWitness = await this.getInitialWitness(artifact, argsHash, sideEffectCounter, isStaticCall);
-        const acvmCallback = new Oracle(this);
-        const timer = new Timer();
-        const acirExecutionResult = await this.simulator.executeUserCircuit(initialWitness, artifact, acvmCallback.toACIRCallback()).catch((err)=>{
-            err.message = resolveAssertionMessageFromError(err, artifact);
-            const execError = new ExecutionError(err.message, {
-                contractAddress: targetContractAddress,
-                functionSelector
-            }, extractCallStack(err, artifact.debug), {
-                cause: err
-            });
-            this.logger.debug(`Error executing private function ${targetContractAddress}:${functionSelector}`);
-            throw createSimulationError(execError);
-        });
-        const duration = timer.ms();
-        const publicInputs = extractPrivateCircuitPublicInputs(artifact, acirExecutionResult.partialWitness);
-        const initialWitnessSize = witnessMapToFields(initialWitness).length * Fr.SIZE_IN_BYTES;
-        this.logger.debug(`Ran external function ${targetContractAddress.toString()}:${functionSelector}`, {
-            circuitName: 'app-circuit',
-            duration,
-            eventName: 'circuit-witness-generation',
-            inputSize: initialWitnessSize,
-            outputSize: publicInputs.toBuffer().length,
-            appCircuitName: 'noname'
-        });
-        // Apply side effects
-        const endSideEffectCounter = publicInputs.endSideEffectCounter;
-        this.sideEffectCounter = endSideEffectCounter.toNumber() + 1;
-        await this.addPrivateLogs(targetContractAddress, publicInputs.privateLogs.filter((privateLog)=>!privateLog.isEmpty()).map((privateLog)=>privateLog.log));
-        this.setContractAddress(currentContractAddress);
-        this.setMsgSender(currentMessageSender);
-        this.setFunctionSelector(currentFunctionSelector);
-        return {
-            endSideEffectCounter,
-            returnsHash: publicInputs.returnsHash
-        };
-    }
     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 privateContextInputs = await this.getPrivateContextInputs(this.blockNumber - 1, this.timestamp - AZTEC_SLOT_DURATION, sideEffectCounter, isStaticCall);
+        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');
@@ -652,161 +500,36 @@ export class TXE {
     async getDebugFunctionName(address, selector) {
         return await this.contractDataProvider.getDebugFunctionName(address, selector);
     }
-    async executePublicFunction(calldata, msgSender, contractAddress, isStaticCall, isTeardown = false) {
-        const callRequest = await PublicCallRequest.fromCalldata(msgSender, contractAddress, isStaticCall, calldata);
-        const executionRequest = new PublicCallRequestWithCalldata(callRequest, calldata);
-        const db = this.baseFork;
-        const globalVariables = GlobalVariables.empty();
-        globalVariables.chainId = new Fr(this.CHAIN_ID);
-        globalVariables.version = new Fr(this.ROLLUP_VERSION);
-        globalVariables.blockNumber = this.blockNumber;
-        globalVariables.timestamp = this.timestamp;
-        globalVariables.gasFees = new GasFees(1, 1);
-        let result;
-        // Checkpoint here so that we can revert merkle ops after simulation.
-        // See note at revert below.
-        const checkpoint = await ForkCheckpoint.new(db);
-        try {
-            const contractsDB = new PublicContractsDB(new TXEPublicContractDataSource(this));
-            const simulator = new PublicTxSimulator(this.baseFork, contractsDB, globalVariables, /*doMerkleOperations=*/ false, /*skipFeeEnforcement=*/ false, /*clientInitiatedSimulation=*/ true);
-            const { usedTxRequestHashForNonces } = this.noteCache.finish();
-            const firstNullifier = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
-            // When setting up a teardown call, we tell it that
-            // private execution used Gas(1, 1) so it can compute a tx fee.
-            const gasUsedByPrivate = isTeardown ? new Gas(1, 1) : Gas.empty();
-            const tx = createTxForPublicCalls({
-                nonRevertible: {
-                    nullifiers: [
-                        firstNullifier
-                    ]
-                }
-            }, /*setupExecutionRequests=*/ [], /*appExecutionRequests=*/ isTeardown ? [] : [
-                executionRequest
-            ], /*teardownExecutionRequests=*/ isTeardown ? executionRequest : undefined, /*feePayer=*/ AztecAddress.zero(), gasUsedByPrivate);
-            result = await simulator.simulate(tx);
-        } finally{
-            // NOTE: Don't accept any merkle updates from the AVM since this was just 1 enqueued call
-            // and the TXE will re-apply all txEffects after entire execution (all enqueued calls)
-            // complete.
-            await checkpoint.revert();
-        // If an error is thrown during the above simulation, this revert is the last
-        // thing executed and we skip the postprocessing below.
-        }
-        const noteHashes = result.avmProvingRequest.inputs.publicInputs.accumulatedData.noteHashes.filter((s)=>!s.isEmpty());
-        const publicDataWrites = result.avmProvingRequest.inputs.publicInputs.accumulatedData.publicDataWrites.filter((s)=>!s.isEmpty());
-        // For now, public data writes are the only merkle operations that are readable by later enqueued calls in the TXE.
-        await this.addPublicDataWrites(publicDataWrites);
-        this.addUniqueNoteHashesFromPublic(noteHashes);
-        this.addPublicLogs(result.avmProvingRequest.inputs.publicInputs.accumulatedData.publicLogs.filter((log)=>!log.contractAddress.equals(AztecAddress.ZERO)));
-        return Promise.resolve(result);
-    }
-    async notifyEnqueuedPublicFunctionCall(targetContractAddress, calldataHash, _sideEffectCounter, isStaticCall, isTeardown = false) {
-        // Store and modify env
-        const currentContractAddress = this.contractAddress;
-        const currentMessageSender = this.msgSender;
-        const currentFunctionSelector = FunctionSelector.fromField(this.functionSelector.toField());
-        const calldata = this.executionCache.getPreimage(calldataHash);
-        if (!calldata) {
-            throw new Error('Calldata for enqueued call not found in cache');
-        }
-        const functionSelector = FunctionSelector.fromField(calldata[0]);
-        this.setMsgSender(this.contractAddress);
-        this.setContractAddress(targetContractAddress);
-        this.setFunctionSelector(functionSelector);
-        const executionResult = await this.executePublicFunction(calldata, /* msgSender */ currentContractAddress, targetContractAddress, isStaticCall, isTeardown);
-        // Poor man's revert handling
-        if (!executionResult.revertCode.isOK()) {
-            if (executionResult.revertReason && executionResult.revertReason instanceof SimulationError) {
-                await enrichPublicSimulationError(executionResult.revertReason, this.contractDataProvider, this.logger);
-                throw new Error(executionResult.revertReason.message);
-            } else {
-                throw new Error(`Enqueued public function call reverted: ${executionResult.revertReason}`);
-            }
-        }
-        // Apply side effects
-        const sideEffects = executionResult.avmProvingRequest.inputs.publicInputs.accumulatedData;
-        const { usedTxRequestHashForNonces } = this.noteCache.finish();
-        const firstNullifier = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
-        const nullifiers = sideEffects.nullifiers.filter((s)=>!s.isEmpty()).filter((s)=>!s.equals(firstNullifier));
-        // For some reason we cannot move this up to 'executePublicFunction'. It gives us an error of trying to modify the same nullifier twice.
-        this.addSiloedNullifiersFromPublic(nullifiers);
-        this.setContractAddress(currentContractAddress);
-        this.setMsgSender(currentMessageSender);
-        this.setFunctionSelector(currentFunctionSelector);
-    }
-    async notifySetPublicTeardownFunctionCall(targetContractAddress, calldataHash, sideEffectCounter, isStaticCall) {
-        // Definitely not right, in that the teardown should always be last.
-        // But useful for executing flows.
-        await this.notifyEnqueuedPublicFunctionCall(targetContractAddress, calldataHash, sideEffectCounter, isStaticCall, /*isTeardown=*/ true);
-    }
-    async notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
-        await this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
-    }
-    debugLog(message, fields) {
+    utilityDebugLog(message, fields) {
         this.logger.verbose(`${applyStringFormatting(message, fields)}`, {
             module: `${this.logger.module}:debug_log`
         });
     }
-    async incrementAppTaggingSecretIndexAsSender(sender, recipient) {
+    async privateIncrementAppTaggingSecretIndexAsSender(sender, recipient) {
         await this.pxeOracleInterface.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
     }
-    async getIndexedTaggingSecretAsSender(sender, recipient) {
+    async utilityGetIndexedTaggingSecretAsSender(sender, recipient) {
         return await this.pxeOracleInterface.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
     }
-    async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
+    async utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
         await this.pxeOracleInterface.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot);
         await this.pxeOracleInterface.removeNullifiedNotes(this.contractAddress);
         return Promise.resolve();
     }
-    async validateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot) {
+    async utilityValidateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot) {
         await this.pxeOracleInterface.validateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot);
     }
-    async bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
+    async utilityBulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
         return await this.pxeOracleInterface.bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot);
     }
-    // AVM oracles
-    async avmOpcodeCall(targetContractAddress, calldata, isStaticCall) {
-        // Store and modify env
-        const currentContractAddress = this.contractAddress;
-        const currentMessageSender = this.msgSender;
-        this.setMsgSender(this.contractAddress);
-        this.setContractAddress(targetContractAddress);
-        const executionResult = await this.executePublicFunction(calldata, /* msgSender */ currentContractAddress, targetContractAddress, isStaticCall);
-        // Save return/revert data for later.
-        this.nestedCallReturndata = executionResult.processedPhases[0].returnValues[0].values;
-        this.nestedCallSuccess = executionResult.revertCode.isOK();
-        // Apply side effects
-        if (executionResult.revertCode.isOK()) {
-            const sideEffects = executionResult.avmProvingRequest.inputs.publicInputs.accumulatedData;
-            const publicDataWrites = sideEffects.publicDataWrites.filter((s)=>!s.isEmpty());
-            const noteHashes = sideEffects.noteHashes.filter((s)=>!s.isEmpty());
-            const { usedTxRequestHashForNonces } = this.noteCache.finish();
-            const firstNullifier = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
-            const nullifiers = sideEffects.nullifiers.filter((s)=>!s.isEmpty()).filter((s)=>!s.equals(firstNullifier));
-            await this.addPublicDataWrites(publicDataWrites);
-            this.addUniqueNoteHashesFromPublic(noteHashes);
-            this.addSiloedNullifiersFromPublic(nullifiers);
-        }
-        this.setContractAddress(currentContractAddress);
-        this.setMsgSender(currentMessageSender);
-        return executionResult;
-    }
-    avmOpcodeSuccessCopy() {
-        return this.nestedCallSuccess;
-    }
-    avmOpcodeReturndataSize() {
-        return this.nestedCallReturndata.length;
-    }
-    avmOpcodeReturndataCopy(rdOffset, copySize) {
-        return this.nestedCallReturndata.slice(rdOffset, rdOffset + copySize);
-    }
     async avmOpcodeNullifierExists(innerNullifier, targetAddress) {
         const nullifier = await siloNullifier(targetAddress, innerNullifier);
         const db = this.baseFork;
-        const index = (await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [
+        const treeIndex = (await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [
             nullifier.toBuffer()
         ]))[0];
-        return index !== undefined;
+        const transientIndex = this.siloedNullifiersFromPublic.find((n)=>n.equals(nullifier));
+        return treeIndex !== undefined || transientIndex !== undefined;
     }
     async avmOpcodeEmitNullifier(nullifier) {
         const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
@@ -832,50 +555,57 @@ export class TXE {
         const preimage = await this.baseFork.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
         return preimage.leaf.value;
     }
-    storeCapsule(contractAddress, slot, capsule) {
+    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);
     }
-    loadCapsule(contractAddress, slot) {
+    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);
     }
-    deleteCapsule(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);
     }
-    copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
+    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);
     }
-    aes128Decrypt(ciphertext, iv, symKey) {
+    utilityAes128Decrypt(ciphertext, iv, symKey) {
         const aes128 = new Aes128();
         return aes128.decryptBufferCBC(ciphertext, iv, symKey);
     }
-    getSharedSecret(address, ephPk) {
+    utilityGetSharedSecret(address, ephPk) {
         return this.pxeOracleInterface.getSharedSecret(address, ephPk);
     }
-    emitOffchainEffect(_data) {
-        // Offchain effects are discarded in TXE tests.
+    privateGetSenderForTags() {
+        return Promise.resolve(this.senderForTags);
+    }
+    privateSetSenderForTags(senderForTags) {
+        this.senderForTags = senderForTags;
         return Promise.resolve();
     }
-    async privateCallNewFlow(from, targetContractAddress = AztecAddress.zero(), functionSelector = FunctionSelector.empty(), args, argsHash = Fr.zero(), isStaticCall = false) {
+    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) {
-            throw new Error('Function Artifact does not exist');
+            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_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
@@ -884,8 +614,12 @@ export class TXE {
         const txContext = new TxContext(this.CHAIN_ID, this.ROLLUP_VERSION, gasSettings);
         const blockHeader = await this.pxeOracleInterface.getBlockHeader();
         const noteCache = new ExecutionNoteCache(this.getTxRequestHash());
-        const context = 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 */ [], /** List of transient auth witnesses to be used during this simulation */ [], HashedValuesCache.create(), noteCache, this.pxeOracleInterface, this.simulator, 0, 1);
-        context.storeInExecutionCache(args, argsHash);
+        // TODO(benesjan): Fix stale 'context' name.
+        const context = 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);
+        context.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;
@@ -895,12 +629,11 @@ export class TXE {
             const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
             const publicCallRequests = collectNested([
                 executionResult
-            ], (r)=>[
-                    ...r.publicInputs.publicCallRequests.map((r)=>r.inner),
+            ], (r)=>r.publicInputs.publicCallRequests.getActiveItems().map((r)=>r.inner).concat(r.publicInputs.publicTeardownCallRequest.isEmpty() ? [] : [
                     r.publicInputs.publicTeardownCallRequest
-                ]).filter((r)=>!r.isEmpty());
+                ]));
             const publicFunctionsCalldata = await Promise.all(publicCallRequests.map(async (r)=>{
-                const calldata = await context.loadFromExecutionCache(r.calldataHash);
+                const calldata = await context.privateLoadFromExecutionCache(r.calldataHash);
                 return new HashedValues(calldata, r.calldataHash);
             }));
             result = new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
@@ -912,7 +645,7 @@ export class TXE {
             // 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.storeInExecutionCache(returnValues, returnValuesHash);
+            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
@@ -922,12 +655,19 @@ export class TXE {
         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 = new Tx(publicInputs, ClientIvcProof.empty(), [], result.publicFunctionCalldata);
+        const tx = await Tx.create({
+            data: publicInputs,
+            clientIvcProof: ClientIvcProof.empty(),
+            contractClassLogFields: [],
+            publicFunctionCalldata: result.publicFunctionCalldata
+        });
         let checkpoint;
         if (isStaticCall) {
             checkpoint = await ForkCheckpoint.new(this.baseFork);
@@ -935,27 +675,33 @@ export class TXE {
         const results = await processor.process([
             tx
         ]);
-        const processedTxs = results[0];
+        const [processedTx] = results[0];
         const failedTxs = results[1];
         if (failedTxs.length !== 0) {
-            throw new Error('Public execution has failed');
+            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();
-            const txRequestHash = this.getTxRequestHash();
             return {
                 endSideEffectCounter: result.entrypoint.publicInputs.endSideEffectCounter,
                 returnsHash: result.entrypoint.publicInputs.returnsHash,
-                txHash: txRequestHash
+                txHash: tx.getTxHash()
             };
         }
         const fork = this.baseFork;
         const txEffect = TxEffect.empty();
-        txEffect.noteHashes = processedTxs[0].txEffect.noteHashes;
-        txEffect.nullifiers = processedTxs[0].txEffect.nullifiers;
-        txEffect.privateLogs = processedTxs[0].txEffect.privateLogs;
-        txEffect.publicLogs = processedTxs[0].txEffect.publicLogs;
-        txEffect.publicDataWrites = processedTxs[0].txEffect.publicDataWrites;
+        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
@@ -970,53 +716,55 @@ export class TXE {
         l2Block.header = header;
         await fork.updateArchive(l2Block.header);
         await this.stateMachine.handleL2Block(l2Block);
-        const txRequestHash = this.getTxRequestHash();
         this.setBlockNumber(this.blockNumber + 1);
-        this.advanceTimestampBy(AZTEC_SLOT_DURATION);
         return {
             endSideEffectCounter: result.entrypoint.publicInputs.endSideEffectCounter,
             returnsHash: result.entrypoint.publicInputs.returnsHash,
-            txHash: txRequestHash
+            txHash: tx.getTxHash()
         };
     }
-    async publicCallNewFlow(from, targetContractAddress, calldata, isStaticCall) {
+    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_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
         const teardownGasLimits = new Gas(DEFAULT_TEARDOWN_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
         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 uniqueNoteHashes = [];
-        const taggedPrivateLogs = [];
-        const nullifiers = !isStaticCall ? [
-            this.getTxRequestHash()
-        ] : [];
-        const l2ToL1Messages = [];
-        const contractClassLogsHashes = [];
         const calldataHash = await computeCalldataHash(calldata);
         const calldataHashedValues = new HashedValues(calldata, calldataHash);
-        const publicCallRequest = new PublicCallRequest(from, targetContractAddress, isStaticCall, calldataHash);
-        const publicCallRequests = [
-            publicCallRequest
-        ];
         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 accumulatedDataForPublic = new PrivateToPublicAccumulatedData(padArrayEnd(uniqueNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX), padArrayEnd(nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX), padArrayEnd(l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX), padArrayEnd(taggedPrivateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX), padArrayEnd(contractClassLogsHashes, ScopedLogHash.empty(), MAX_CONTRACT_CLASS_LOGS_PER_TX), padArrayEnd(publicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX));
-        const inputsForPublic = new PartialPrivateTailPublicInputsForPublic(// nonrevertible
-        PrivateToPublicAccumulatedData.empty(), // revertible
-        // We are using revertible (app phase) because only the app-phase returns are exposed.
-        accumulatedDataForPublic, PublicCallRequest.empty());
-        const txData = new PrivateKernelTailCircuitPublicInputs(constantData, RollupValidationRequests.empty(), /*gasUsed=*/ new Gas(0, 0), /*feePayer=*/ AztecAddress.zero(), inputsForPublic, undefined);
-        const tx = new Tx(txData, ClientIvcProof.empty(), [], [
-            calldataHashedValues
-        ]);
+        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);
@@ -1024,10 +772,17 @@ export class TXE {
         const results = await processor.process([
             tx
         ]);
-        const processedTxs = results[0];
+        const [processedTx] = results[0];
         const failedTxs = results[1];
-        if (failedTxs.length !== 0 || !processedTxs[0].revertCode.isOK()) {
-            throw new Error('Public execution has failed');
+        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;
@@ -1035,23 +790,22 @@ export class TXE {
             // 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.storeInExecutionCache(returnValues, returnValuesHash);
+            this.privateStoreInExecutionCache(returnValues, returnValuesHash);
         }
         if (isStaticCall) {
             await checkpoint.revert();
-            const txRequestHash = this.getTxRequestHash();
             return {
                 returnsHash: returnValuesHash ?? Fr.ZERO,
-                txHash: txRequestHash
+                txHash: tx.getTxHash()
             };
         }
         const fork = this.baseFork;
         const txEffect = TxEffect.empty();
-        txEffect.noteHashes = processedTxs[0].txEffect.noteHashes;
-        txEffect.nullifiers = processedTxs[0].txEffect.nullifiers;
-        txEffect.privateLogs = taggedPrivateLogs;
-        txEffect.publicLogs = processedTxs[0].txEffect.publicLogs;
-        txEffect.publicDataWrites = processedTxs[0].txEffect.publicDataWrites;
+        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
@@ -1066,12 +820,17 @@ export class TXE {
         l2Block.header = header;
         await fork.updateArchive(l2Block.header);
         await this.stateMachine.handleL2Block(l2Block);
-        const txRequestHash = this.getTxRequestHash();
         this.setBlockNumber(this.blockNumber + 1);
-        this.advanceTimestampBy(AZTEC_SLOT_DURATION);
         return {
             returnsHash: returnValuesHash ?? Fr.ZERO,
-            txHash: txRequestHash
+            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;
+    }
 }