@aztec/txe 1.2.1 → 2.0.0-nightly.20250813

package/src/oracle/txe_oracle.ts

@@ -3,22 +3,18 @@ import {
   DEFAULT_GAS_LIMIT,
   DEFAULT_TEARDOWN_GAS_LIMIT,
   type L1_TO_L2_MSG_TREE_HEIGHT,
-  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 { padArrayEnd } from '@aztec/foundation/collection';
-import { Aes128, Schnorr, poseidon2Hash } from '@aztec/foundation/crypto';
+import { Aes128, Schnorr } from '@aztec/foundation/crypto';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { type Logger, 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 type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { ProtocolContract } from '@aztec/protocol-contracts';
@@ -39,21 +35,17 @@ import {
   type NoteData,
   Oracle,
   PrivateExecutionOracle,
-  type TypedOracle,
   UtilityExecutionOracle,
   executePrivateFunction,
-  extractPrivateCircuitPublicInputs,
   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,
-  type PublicTxResult,
   PublicTxSimulator,
   createSimulationError,
   resolveAssertionMessageFromError,
@@ -70,7 +62,6 @@ import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstance, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import { SimulationError } from '@aztec/stdlib/errors';
 import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
 import {
   computeCalldataHash,
@@ -89,15 +80,10 @@ import {
   PrivateKernelTailCircuitPublicInputs,
   PrivateToPublicAccumulatedData,
   PublicCallRequest,
-  RollupValidationRequests,
-  ScopedLogHash,
 } from '@aztec/stdlib/kernel';
-import { deriveKeys } from '@aztec/stdlib/keys';
 import { ContractClassLog, IndexedTaggingSecret, PrivateLog, type PublicLog } from '@aztec/stdlib/logs';
-import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import type { NoteStatus } from '@aztec/stdlib/note';
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
-import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 import {
   makeAppendOnlyTreeSnapshot,
   makeContentCommitment,
@@ -107,7 +93,6 @@ import {
 import {
   AppendOnlyTreeSnapshot,
   MerkleTreeId,
-  type NullifierLeafPreimage,
   NullifierMembershipWitness,
   PublicDataTreeLeaf,
   type PublicDataTreeLeafPreimage,
@@ -116,11 +101,9 @@ import {
 import {
   BlockHeader,
   CallContext,
-  GlobalVariables,
   HashedValues,
   PrivateCallExecutionResult,
   PrivateExecutionResult,
-  PublicCallRequestWithCalldata,
   Tx,
   TxConstantData,
   TxContext,
@@ -132,22 +115,18 @@ import type { UInt64 } from '@aztec/stdlib/types';
 import { ForkCheckpoint, NativeWorldStateService } 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';
 
-export class TXE implements TypedOracle {
+export class TXE {
   private blockNumber = 1;
   private timestamp = GENESIS_TIMESTAMP;
 
   private sideEffectCounter = 0;
   private msgSender: AztecAddress;
   private functionSelector = FunctionSelector.fromField(new Fr(0));
-  private isStaticCall = false;
-  // Return/revert data of the latest nested call.
-  private nestedCallReturndata: Fr[] = [];
-  private nestedCallSuccess: boolean = false;
 
   private pxeOracleInterface: PXEOracleInterface;
 
@@ -170,6 +149,9 @@ export class TXE implements TypedOracle {
 
   private authwits: Map<string, AuthWitness> = new Map();
 
+  // Used by privateSetSenderForTags and privateGetSenderForTags oracles.
+  private senderForTags?: AztecAddress;
+
   private constructor(
     private logger: Logger,
     private keyStore: KeyStore,
@@ -261,11 +243,11 @@ export class TXE implements TypedOracle {
     return this.baseFork;
   }
 
-  getChainId(): Promise<Fr> {
+  utilityGetChainId(): Promise<Fr> {
     return Promise.resolve(new Fr(this.CHAIN_ID));
   }
 
-  getVersion(): Promise<Fr> {
+  utilityGetVersion(): Promise<Fr> {
     return Promise.resolve(new Fr(this.ROLLUP_VERSION));
   }
 
@@ -273,27 +255,7 @@ export class TXE implements TypedOracle {
     return this.msgSender;
   }
 
-  getFunctionSelector() {
-    return this.functionSelector;
-  }
-
-  setMsgSender(msgSender: AztecAddress) {
-    this.msgSender = msgSender;
-  }
-
-  setFunctionSelector(functionSelector: FunctionSelector) {
-    this.functionSelector = functionSelector;
-  }
-
-  getSideEffectsCounter() {
-    return this.sideEffectCounter;
-  }
-
-  setSideEffectsCounter(sideEffectsCounter: number) {
-    this.sideEffectCounter = sideEffectsCounter;
-  }
-
-  setContractAddress(contractAddress: AztecAddress) {
+  txeSetContractAddress(contractAddress: AztecAddress) {
     this.contractAddress = contractAddress;
   }
 
@@ -302,7 +264,7 @@ export class TXE implements TypedOracle {
     this.blockNumber = blockNumber;
   }
 
-  advanceTimestampBy(duration: UInt64) {
+  txeAdvanceTimestampBy(duration: UInt64) {
     this.timestamp = this.timestamp + duration;
   }
 
@@ -330,16 +292,14 @@ export class TXE implements TypedOracle {
     await this.contractDataProvider.addContractArtifact(contractClassId, artifact);
   }
 
-  async getPrivateContextInputs(
+  async txeGetPrivateContextInputs(
     blockNumber: number | null,
-    timestamp: UInt64 | null,
     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);
@@ -349,7 +309,7 @@ export class TXE implements TypedOracle {
     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,
@@ -359,11 +319,7 @@ export class TXE implements TypedOracle {
     return inputs;
   }
 
-  deriveKeys(secret: Fr) {
-    return deriveKeys(secret);
-  }
-
-  async addAuthWitness(address: AztecAddress, messageHash: Fr) {
+  async txeAddAuthWitness(address: AztecAddress, messageHash: Fr) {
     const account = await this.accountDataProvider.getAccount(address);
     const privateKey = await this.keyStore.getMasterSecretKey(account.publicKeys.masterIncomingViewingPublicKey);
     const schnorr = new Schnorr();
@@ -401,57 +357,33 @@ export class TXE implements TypedOracle {
     this.uniqueNoteHashesFromPublic.push(...siloedNoteHashes);
   }
 
-  async addPrivateLogs(contractAddress: AztecAddress, privateLogs: PrivateLog[]) {
-    for (const privateLog of privateLogs) {
-      privateLog.fields[0] = await poseidon2Hash([contractAddress, privateLog.fields[0]]);
-    }
-
-    this.privateLogs.push(...privateLogs);
-  }
-
-  addPublicLogs(logs: PublicLog[]) {
-    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: boolean) {
-    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: Fr[], hash: Fr) {
+  privateStoreInExecutionCache(values: Fr[], hash: Fr) {
     return this.executionCache.store(values, hash);
   }
 
-  loadFromExecutionCache(hash: Fr) {
+  privateLoadFromExecutionCache(hash: Fr) {
     const preimage = this.executionCache.getPreimage(hash);
     if (!preimage) {
       throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
@@ -459,109 +391,50 @@ export class TXE implements TypedOracle {
     return Promise.resolve(preimage);
   }
 
-  getKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest> {
+  utilityGetKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest> {
     return this.keyStore.getKeyValidationRequest(pkMHash, this.contractAddress);
   }
 
-  async getContractInstance(address: AztecAddress): Promise<ContractInstance> {
-    const contractInstance = await this.contractDataProvider.getContractInstance(address);
-    if (!contractInstance) {
-      throw new Error(`Contract instance not found for address ${address}`);
-    }
-    return contractInstance;
-  }
-
-  async getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined> {
-    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()];
+  utilityGetContractInstance(address: AztecAddress): Promise<ContractInstance> {
+    return this.pxeOracleInterface.getContractInstance(address);
   }
 
-  async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr) {
-    const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
-
-    const result = await snap.getSiblingPath(treeId, leafIndex.toBigInt());
-    return result.toFields();
+  utilityGetMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined> {
+    return this.pxeOracleInterface.getMembershipWitness(blockNumber, treeId, leafValue);
   }
 
-  async getNullifierMembershipWitness(
+  utilityGetNullifierMembershipWitness(
     blockNumber: number,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    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 as NullifierLeafPreimage, siblingPath);
+    return this.pxeOracleInterface.getNullifierMembershipWitness(blockNumber, nullifier);
   }
 
-  async getPublicDataWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    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,
-      )) as PublicDataTreeLeafPreimage;
-      const path = await snap.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-      return new PublicDataWitness(lowLeafResult.index, preimage, path);
-    }
+  utilityGetPublicDataWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    return this.pxeOracleInterface.getPublicDataWitness(blockNumber, leafSlot);
   }
 
-  async getLowNullifierMembershipWitness(
+  utilityGetLowNullifierMembershipWitness(
     blockNumber: number,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    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 as NullifierLeafPreimage, siblingPath);
+    return this.pxeOracleInterface.getLowNullifierMembershipWitness(blockNumber, nullifier);
   }
 
-  getBlockHeader(blockNumber: number): Promise<BlockHeader | undefined> {
+  utilityGetBlockHeader(blockNumber: number): Promise<BlockHeader | undefined> {
     return this.stateMachine.archiver.getBlockHeader(blockNumber);
   }
 
-  getCompleteAddress(account: AztecAddress) {
+  utilityGetCompleteAddress(account: AztecAddress) {
     return Promise.resolve(this.accountDataProvider.getAccount(account));
   }
 
-  getAuthWitness(messageHash: Fr) {
+  utilityGetAuthWitness(messageHash: Fr) {
     const authwit = this.authwits.get(messageHash.toString());
     return Promise.resolve(authwit?.witness);
   }
 
-  async getNotes(
+  async utilityGetNotes(
     storageSlot: Fr,
     numSelects: number,
     selectByIndexes: number[],
@@ -607,7 +480,7 @@ export class TXE implements TypedOracle {
     return notes;
   }
 
-  notifyCreatedNote(storageSlot: Fr, _noteTypeId: NoteSelector, noteItems: Fr[], noteHash: Fr, counter: number) {
+  privateNotifyCreatedNote(storageSlot: Fr, _noteTypeId: NoteSelector, noteItems: Fr[], noteHash: Fr, counter: number) {
     const note = new Note(noteItems);
     this.noteCache.addNewNote(
       {
@@ -623,23 +496,26 @@ export class TXE implements TypedOracle {
     this.sideEffectCounter = counter + 1;
   }
 
-  async notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
+  async privateNotifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
     await this.checkNullifiersNotInTree(this.contractAddress, [innerNullifier]);
     await this.noteCache.nullifyNote(this.contractAddress, innerNullifier, noteHash);
     this.sideEffectCounter = counter + 1;
   }
 
-  async notifyCreatedNullifier(innerNullifier: Fr): Promise<void> {
+  async privateNotifyCreatedNullifier(innerNullifier: Fr): Promise<void> {
     await this.checkNullifiersNotInTree(this.contractAddress, [innerNullifier]);
     await this.noteCache.nullifierCreated(this.contractAddress, innerNullifier);
   }
 
-  async checkNullifierExists(innerNullifier: Fr): Promise<boolean> {
+  async utilityCheckNullifierExists(innerNullifier: Fr): Promise<boolean> {
     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(
@@ -650,7 +526,7 @@ export class TXE implements TypedOracle {
     throw new Error('Method not implemented.');
   }
 
-  async storageRead(
+  async utilityStorageRead(
     contractAddress: AztecAddress,
     startStorageSlot: Fr,
     blockNumber: number,
@@ -698,7 +574,7 @@ export class TXE implements TypedOracle {
   }
 
   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');
@@ -786,7 +662,11 @@ export class TXE implements TypedOracle {
     );
 
     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;
 
@@ -837,7 +717,7 @@ export class TXE implements TypedOracle {
         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())
@@ -859,89 +739,13 @@ export class TXE implements TypedOracle {
 
       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: AztecAddress,
-    functionSelector: FunctionSelector,
-    argsHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ) {
-    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: Error) => {
-        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',
-    } satisfies CircuitWitnessGenerationStats);
-
-    // 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: FunctionAbi, argsHash: Fr, sideEffectCounter: number, isStaticCall: boolean) {
     const argumentsSize = countArgumentsSize(abi);
 
@@ -951,9 +755,10 @@ export class TXE implements TypedOracle {
       throw new Error('Invalid arguments size');
     }
 
-    const privateContextInputs = await this.getPrivateContextInputs(
-      this.blockNumber - 1,
-      this.timestamp - AZTEC_SLOT_DURATION,
+    const historicalBlockNumber = this.blockNumber - 1; // i.e. last
+
+    const privateContextInputs = await this.txeGetPrivateContextInputs(
+      historicalBlockNumber,
       sideEffectCounter,
       isStaticCall,
     );
@@ -970,179 +775,22 @@ export class TXE implements TypedOracle {
     return await this.contractDataProvider.getDebugFunctionName(address, selector);
   }
 
-  private async executePublicFunction(
-    calldata: Fr[],
-    msgSender: AztecAddress,
-    contractAddress: AztecAddress,
-    isStaticCall: boolean,
-    isTeardown: boolean = 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: PublicTxResult;
-    // 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: AztecAddress,
-    calldataHash: Fr,
-    _sideEffectCounter: number,
-    isStaticCall: boolean,
-    isTeardown = false,
-  ): Promise<void> {
-    // 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: AztecAddress,
-    calldataHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ): Promise<void> {
-    // 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: number) {
-    await this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
-  }
-
-  debugLog(message: string, fields: Fr[]): void {
+  utilityDebugLog(message: string, fields: Fr[]): void {
     this.logger.verbose(`${applyStringFormatting(message, fields)}`, { module: `${this.logger.module}:debug_log` });
   }
 
-  async incrementAppTaggingSecretIndexAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<void> {
+  async privateIncrementAppTaggingSecretIndexAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<void> {
     await this.pxeOracleInterface.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
   }
 
-  async getIndexedTaggingSecretAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<IndexedTaggingSecret> {
+  async utilityGetIndexedTaggingSecretAsSender(
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret> {
     return await this.pxeOracleInterface.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
   }
 
-  async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr) {
+  async utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr) {
     await this.pxeOracleInterface.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot);
 
     await this.pxeOracleInterface.removeNullifiedNotes(this.contractAddress);
@@ -1150,7 +798,7 @@ export class TXE implements TypedOracle {
     return Promise.resolve();
   }
 
-  public async validateEnqueuedNotesAndEvents(
+  public async utilityValidateEnqueuedNotesAndEvents(
     contractAddress: AztecAddress,
     noteValidationRequestsArrayBaseSlot: Fr,
     eventValidationRequestsArrayBaseSlot: Fr,
@@ -1162,7 +810,7 @@ export class TXE implements TypedOracle {
     );
   }
 
-  async bulkRetrieveLogs(
+  async utilityBulkRetrieveLogs(
     contractAddress: AztecAddress,
     logRetrievalRequestsArrayBaseSlot: Fr,
     logRetrievalResponsesArrayBaseSlot: Fr,
@@ -1174,67 +822,14 @@ export class TXE implements TypedOracle {
     );
   }
 
-  // AVM oracles
-
-  async avmOpcodeCall(
-    targetContractAddress: AztecAddress,
-    calldata: Fr[],
-    isStaticCall: boolean,
-  ): Promise<PublicTxResult> {
-    // 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(): boolean {
-    return this.nestedCallSuccess;
-  }
-
-  avmOpcodeReturndataSize(): number {
-    return this.nestedCallReturndata.length;
-  }
-
-  avmOpcodeReturndataCopy(rdOffset: number, copySize: number): Fr[] {
-    return this.nestedCallReturndata.slice(rdOffset, rdOffset + copySize);
-  }
-
   async avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean> {
     const nullifier = await siloNullifier(targetAddress, innerNullifier!);
     const db = this.baseFork;
-    const index = (await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
-    return index !== undefined;
+
+    const treeIndex = (await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
+    const transientIndex = this.siloedNullifiersFromPublic.find(n => n.equals(nullifier));
+
+    return treeIndex !== undefined || transientIndex !== undefined;
   }
 
   async avmOpcodeEmitNullifier(nullifier: Fr) {
@@ -1267,7 +862,7 @@ export class TXE implements TypedOracle {
     return preimage.leaf.value;
   }
 
-  storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
+  utilityStoreCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
     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`);
@@ -1275,7 +870,7 @@ export class TXE implements TypedOracle {
     return this.pxeOracleInterface.storeCapsule(this.contractAddress, slot, capsule);
   }
 
-  loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+  utilityLoadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
     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`);
@@ -1283,7 +878,7 @@ export class TXE implements TypedOracle {
     return this.pxeOracleInterface.loadCapsule(this.contractAddress, slot);
   }
 
-  deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+  utilityDeleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
     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`);
@@ -1291,7 +886,7 @@ export class TXE implements TypedOracle {
     return this.pxeOracleInterface.deleteCapsule(this.contractAddress, slot);
   }
 
-  copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
+  utilityCopyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
     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`);
@@ -1299,21 +894,25 @@ export class TXE implements TypedOracle {
     return this.pxeOracleInterface.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries);
   }
 
-  aes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer> {
+  utilityAes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer> {
     const aes128 = new Aes128();
     return aes128.decryptBufferCBC(ciphertext, iv, symKey);
   }
 
-  getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point> {
+  utilityGetSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point> {
     return this.pxeOracleInterface.getSharedSecret(address, ephPk);
   }
 
-  emitOffchainEffect(_data: Fr[]) {
-    // Offchain effects are discarded in TXE tests.
+  privateGetSenderForTags(): Promise<AztecAddress | undefined> {
+    return Promise.resolve(this.senderForTags);
+  }
+
+  privateSetSenderForTags(senderForTags: AztecAddress): Promise<void> {
+    this.senderForTags = senderForTags;
     return Promise.resolve();
   }
 
-  async privateCallNewFlow(
+  async txePrivateCallNewFlow(
     from: AztecAddress,
     targetContractAddress: AztecAddress = AztecAddress.zero(),
     functionSelector: FunctionSelector = FunctionSelector.empty(),
@@ -1331,7 +930,13 @@ export class TXE implements TypedOracle {
     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);
@@ -1348,6 +953,7 @@ export class TXE implements TypedOracle {
 
     const noteCache = new ExecutionNoteCache(this.getTxRequestHash());
 
+    // TODO(benesjan): Fix stale 'context' name.
     const context = new PrivateExecutionOracle(
       argsHash,
       txContext,
@@ -1355,7 +961,7 @@ export class TXE implements TypedOracle {
       /** 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(),
@@ -1364,9 +970,16 @@ export class TXE implements TypedOracle {
       this.simulator,
       0,
       1,
+      undefined, // log
+      undefined, // scopes
+      /**
+       * 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.storeInExecutionCache(args, argsHash);
+    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: PrivateExecutionResult;
@@ -1382,13 +995,15 @@ export class TXE implements TypedOracle {
       const { usedTxRequestHashForNonces } = noteCache.finish();
       const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
 
-      const publicCallRequests = collectNested([executionResult], r => [
-        ...r.publicInputs.publicCallRequests.map(r => r.inner),
-        r.publicInputs.publicTeardownCallRequest,
-      ]).filter(r => !r.isEmpty());
+      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 context.loadFromExecutionCache(r.calldataHash);
+          const calldata = await context.privateLoadFromExecutionCache(r.calldataHash);
           return new HashedValues(calldata, r.calldataHash);
         }),
       );
@@ -1403,7 +1018,7 @@ export class TXE implements TypedOracle {
       // 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
@@ -1415,6 +1030,8 @@ export class TXE implements TypedOracle {
     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));
@@ -1422,7 +1039,12 @@ export class TXE implements TypedOracle {
     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) {
@@ -1431,21 +1053,27 @@ export class TXE implements TypedOracle {
 
     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(),
       };
     }
 
@@ -1453,11 +1081,11 @@ export class TXE implements TypedOracle {
 
     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));
 
@@ -1492,18 +1120,15 @@ export class TXE implements TypedOracle {
 
     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(
+  async txePublicCallNewFlow(
     from: AztecAddress,
     targetContractAddress: AztecAddress,
     calldata: Fr[],
@@ -1526,22 +1151,14 @@ export class TXE implements TypedOracle {
 
     const blockHeader = await this.pxeOracleInterface.getBlockHeader();
 
-    const uniqueNoteHashes: Fr[] = [];
-    const taggedPrivateLogs: PrivateLog[] = [];
-    const nullifiers: Fr[] = !isStaticCall ? [this.getTxRequestHash()] : [];
-    const l2ToL1Messages: ScopedL2ToL1Message[] = [];
-    const contractClassLogsHashes: ScopedLogHash[] = [];
-
     const calldataHash = await computeCalldataHash(calldata);
-
     const calldataHashedValues = new HashedValues(calldata, calldataHash);
 
-    const publicCallRequest = new PublicCallRequest(from, targetContractAddress, isStaticCall, calldataHash);
-    const publicCallRequests: PublicCallRequest[] = [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));
@@ -1549,36 +1166,48 @@ export class TXE implements TypedOracle {
     const simulator = new PublicTxSimulator(guardedMerkleTrees, contractsDB, globals, true, true);
     const processor = new PublicProcessor(globals, guardedMerkleTrees, contractsDB, simulator, new TestDateProvider());
 
-    const constantData = new TxConstantData(blockHeader, txContext, Fr.zero(), Fr.zero());
+    // 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();
+    }
 
-    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),
+    // 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(
-      // nonrevertible
-      PrivateToPublicAccumulatedData.empty(),
-      // revertible
-      // We are using revertible (app phase) because only the app-phase returns are exposed.
-      accumulatedDataForPublic,
+      nonRevertibleAccumulatedData,
+      revertibleAccumulatedData,
       PublicCallRequest.empty(),
     );
 
+    const constantData = new TxConstantData(blockHeader, txContext, Fr.zero(), Fr.zero());
+
     const txData = new PrivateKernelTailCircuitPublicInputs(
       constantData,
-      RollupValidationRequests.empty(),
       /*gasUsed=*/ new Gas(0, 0),
       /*feePayer=*/ AztecAddress.zero(),
+      /*includeByTimestamp=*/ 0n,
       inputsForPublic,
       undefined,
     );
 
-    const tx = new Tx(txData, ClientIvcProof.empty(), [], [calldataHashedValues]);
+    const tx = await Tx.create({
+      data: txData,
+      clientIvcProof: ClientIvcProof.empty(),
+      contractClassLogFields: [],
+      publicFunctionCalldata: [calldataHashedValues],
+    });
 
     let checkpoint;
     if (isStaticCall) {
@@ -1587,11 +1216,18 @@ export class TXE implements TypedOracle {
 
     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;
@@ -1601,16 +1237,15 @@ export class TXE implements TypedOracle {
       // 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(),
       };
     }
 
@@ -1618,11 +1253,11 @@ export class TXE implements TypedOracle {
 
     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));
 
@@ -1657,14 +1292,20 @@ export class TXE implements TypedOracle {
 
     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(),
     };
   }
+
+  private async getBlockTimestamp(blockNumber: number) {
+    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;
+  }
 }