@aztec/pxe 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/contract_function_simulator/contract_function_simulator.ts

@@ -1,4 +1,14 @@
 import {
+  AVM_EMITNOTEHASH_BASE_L2_GAS,
+  AVM_EMITNULLIFIER_BASE_L2_GAS,
+  AVM_SENDL2TOL1MSG_BASE_L2_GAS,
+  DA_BYTES_PER_FIELD,
+  DA_GAS_PER_BYTE,
+  FIXED_AVM_STARTUP_L2_GAS,
+  FIXED_DA_GAS,
+  FIXED_L2_GAS,
+  L2_GAS_PER_CONTRACT_CLASS_LOG,
+  L2_GAS_PER_PRIVATE_LOG,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_ENQUEUED_CALLS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
@@ -6,13 +16,14 @@ import {
   MAX_NULLIFIERS_PER_TX,
   MAX_PRIVATE_LOGS_PER_TX,
 } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import type { KeyStore } from '@aztec/key-store';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import {
   type CircuitSimulator,
   ExecutionError,
@@ -22,12 +33,19 @@ import {
   toACVMWitness,
   witnessMapToFields,
 } from '@aztec/simulator/client';
-import type { AbiDecoded, FunctionCall } from '@aztec/stdlib/abi';
-import { FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Gas } from '@aztec/stdlib/gas';
-import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import {
+  computeNoteHashNonce,
+  computeProtocolNullifier,
+  computeUniqueNoteHash,
+  siloNoteHash,
+  siloNullifier,
+} from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import {
   PartialPrivateTailPublicInputsForPublic,
   PartialPrivateTailPublicInputsForRollup,
@@ -41,24 +59,35 @@ import {
 } from '@aztec/stdlib/kernel';
 import { PrivateLog } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import {
+  BlockHeader,
   CallContext,
   HashedValues,
   PrivateExecutionResult,
   TxConstantData,
   TxExecutionRequest,
   collectNested,
+  getFinalMinRevertibleSideEffectCounter,
 } from '@aztec/stdlib/tx';
 
-import type { ContractDataProvider } from '../storage/index.js';
-import type { ExecutionDataProvider } from './execution_data_provider.js';
+import type { AddressStore } from '../storage/address_store/address_store.js';
+import type { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
+import type { CapsuleStore } from '../storage/capsule_store/capsule_store.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
+import type { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
+import type { RecipientTaggingStore } from '../storage/tagging_store/recipient_tagging_store.js';
+import type { SenderAddressBookStore } from '../storage/tagging_store/sender_address_book_store.js';
+import type { SenderTaggingStore } from '../storage/tagging_store/sender_tagging_store.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
+import { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
 import { HashedValuesCache } from './hashed_values_cache.js';
 import { Oracle } from './oracle/oracle.js';
 import { executePrivateFunction, verifyCurrentClassId } from './oracle/private_execution.js';
 import { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
 import { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
+import type { ProxiedNode } from './proxied_node.js';
 
 /**
  * The contract function simulator.
@@ -67,7 +96,17 @@ export class ContractFunctionSimulator {
   private log: Logger;
 
   constructor(
-    private executionDataProvider: ExecutionDataProvider,
+    private contractStore: ContractStore,
+    private noteStore: NoteStore,
+    private keyStore: KeyStore,
+    private addressStore: AddressStore,
+    private aztecNode: AztecNode,
+    private anchorBlockStore: AnchorBlockStore,
+    private senderTaggingStore: SenderTaggingStore,
+    private recipientTaggingStore: RecipientTaggingStore,
+    private senderAddressBookStore: SenderAddressBookStore,
+    private capsuleStore: CapsuleStore,
+    private privateEventStore: PrivateEventStore,
     private simulator: CircuitSimulator,
   ) {
     this.log = createLogger('simulator');
@@ -80,6 +119,7 @@ export class ContractFunctionSimulator {
    * @param contractAddress - The address of the contract (should match request.origin)
    * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract
    * or a specific account.
+   * @param anchorBlockHeader - The block header to use as base state for this run.
    * @param senderForTags - The address that is used as a tagging sender when emitting private logs. Returned from
    * the `privateGetSenderForTags` oracle.
    * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
@@ -90,15 +130,19 @@ export class ContractFunctionSimulator {
     contractAddress: AztecAddress,
     selector: FunctionSelector,
     msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE),
+    anchorBlockHeader: BlockHeader,
     senderForTags?: AztecAddress,
     scopes?: AztecAddress[],
   ): Promise<PrivateExecutionResult> {
     const simulatorSetupTimer = new Timer();
-    const header = await this.executionDataProvider.getBlockHeader();
 
-    await verifyCurrentClassId(contractAddress, this.executionDataProvider);
+    await this.contractStore.syncPrivateState(contractAddress, selector, privateSyncCall =>
+      this.runUtility(privateSyncCall, [], anchorBlockHeader, scopes),
+    );
+
+    await verifyCurrentClassId(contractAddress, this.aztecNode, this.contractStore, anchorBlockHeader);
 
-    const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
+    const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(contractAddress, selector);
 
     if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
@@ -111,7 +155,7 @@ export class ContractFunctionSimulator {
     }
 
     // reserve the first side effect for the tx hash (inserted by the private kernel)
-    const startSideEffectCounter = 1;
+    const startSideEffectCounter = 2;
 
     const callContext = new CallContext(
       msgSender,
@@ -120,25 +164,40 @@ export class ContractFunctionSimulator {
       entryPointArtifact.isStatic,
     );
 
-    const txRequestHash = await request.toTxRequest().hash();
-    const noteCache = new ExecutionNoteCache(txRequestHash);
+    const protocolNullifier = await computeProtocolNullifier(await request.toTxRequest().hash());
+    const noteCache = new ExecutionNoteCache(protocolNullifier);
+    const taggingIndexCache = new ExecutionTaggingIndexCache();
 
     const privateExecutionOracle = new PrivateExecutionOracle(
       request.firstCallArgsHash,
       request.txContext,
       callContext,
-      header,
+      anchorBlockHeader,
+      async call => {
+        await this.runUtility(call, [], anchorBlockHeader, scopes);
+      },
       request.authWitnesses,
       request.capsules,
       HashedValuesCache.create(request.argsOfCalls),
       noteCache,
-      this.executionDataProvider,
-      this.simulator,
+      taggingIndexCache,
+      this.contractStore,
+      this.noteStore,
+      this.keyStore,
+      this.addressStore,
+      this.aztecNode,
+      this.anchorBlockStore,
+      this.senderTaggingStore,
+      this.recipientTaggingStore,
+      this.senderAddressBookStore,
+      this.capsuleStore,
+      this.privateEventStore,
       0, // totalPublicArgsCount
       startSideEffectCounter,
       undefined, // log
       scopes,
       senderForTags,
+      this.simulator,
     );
 
     const setupTime = simulatorSetupTimer.ms();
@@ -156,8 +215,8 @@ export class ContractFunctionSimulator {
         request.functionSelector,
       );
       const simulatorTeardownTimer = new Timer();
-      const { usedTxRequestHashForNonces } = noteCache.finish();
-      const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
+      const { usedProtocolNullifierForNonces } = noteCache.finish();
+      const firstNullifierHint = usedProtocolNullifierForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
 
       const publicCallRequests = collectNested([executionResult], r =>
         r.publicInputs.publicCallRequests
@@ -193,20 +252,43 @@ export class ContractFunctionSimulator {
    * Runs a utility function.
    * @param call - The function call to execute.
    * @param authwits - Authentication witnesses required for the function call.
+   * @param anchorBlockHeader - The block header to use as base state for this run.
    * @param scopes - Optional array of account addresses whose notes can be accessed in this call. Defaults to all
    * accounts if not specified.
-   * @returns A decoded ABI value containing the function's return data.
+   * @returns A return value of the utility function in a form as returned by the simulator (Noir fields)
    */
-  public async runUtility(call: FunctionCall, authwits: AuthWitness[], scopes?: AztecAddress[]): Promise<AbiDecoded> {
-    await verifyCurrentClassId(call.to, this.executionDataProvider);
+  public async runUtility(
+    call: FunctionCall,
+    authwits: AuthWitness[],
+    anchorBlockHeader: BlockHeader,
+    scopes?: AztecAddress[],
+  ): Promise<Fr[]> {
+    await verifyCurrentClassId(call.to, this.aztecNode, this.contractStore, anchorBlockHeader);
 
-    const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(call.to, call.selector);
+    const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
 
     if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
     }
 
-    const oracle = new UtilityExecutionOracle(call.to, authwits, [], this.executionDataProvider, undefined, scopes);
+    const oracle = new UtilityExecutionOracle(
+      call.to,
+      authwits,
+      [],
+      anchorBlockHeader,
+      this.contractStore,
+      this.noteStore,
+      this.keyStore,
+      this.addressStore,
+      this.aztecNode,
+      this.anchorBlockStore,
+      this.recipientTaggingStore,
+      this.senderAddressBookStore,
+      this.capsuleStore,
+      this.privateEventStore,
+      undefined,
+      scopes,
+    );
 
     try {
       this.log.verbose(`Executing utility function ${entryPointArtifact.name}`, {
@@ -230,17 +312,23 @@ export class ContractFunctionSimulator {
           );
         });
 
-      const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
       this.log.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
-      return decodeFromAbi(entryPointArtifact.returnTypes, returnWitness);
+      return witnessMapToFields(acirExecutionResult.returnWitness);
     } catch (err) {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
   }
   // docs:end:execute_utility_function
 
+  /**
+   * Returns the execution statistics collected during the simulator run.
+   * @returns The execution statistics.
+   */
   getStats() {
-    return this.executionDataProvider.getStats();
+    const nodeRPCCalls =
+      typeof (this.aztecNode as ProxiedNode).getStats === 'function' ? (this.aztecNode as ProxiedNode).getStats() : {};
+
+    return { nodeRPCCalls };
   }
 }
 
@@ -255,7 +343,7 @@ class OrderedSideEffect<T> {
 }
 
 /**
- * Generates the final public inputs of the tail kernel circuit, an empty ClientIVC proof
+ * Generates the final public inputs of the tail kernel circuit, an empty Chonk proof
  * and the execution steps for a `PrivateExecutionResult` as if it had been
  * processed by the private kernel prover. This skips many of the checks performed by the kernels
  * (allowing state overrides) and is much faster, while still generating a valid
@@ -263,13 +351,13 @@ class OrderedSideEffect<T> {
  * @param privateExecutionResult - The result of the private execution.
  * @param nonceGenerator - A nonce generator for note hashes. According to the protocol rules,
  * it can either be the first nullifier in the tx or the hash of the initial tx request if there are none.
- * @param contractDataProvider - A provider for contract data in order to get function names and debug info.
+ * @param contractStore - A provider for contract data in order to get function names and debug info.
  * @returns The simulated proving result.
  */
 export async function generateSimulatedProvingResult(
   privateExecutionResult: PrivateExecutionResult,
   nonceGenerator: Fr,
-  contractDataProvider: ContractDataProvider,
+  contractStore: ContractStore,
 ): Promise<PrivateKernelExecutionProofOutput<PrivateKernelTailCircuitPublicInputs>> {
   const siloedNoteHashes: OrderedSideEffect<Fr>[] = [];
   const nullifiers: OrderedSideEffect<Fr>[] = [];
@@ -346,7 +434,7 @@ export async function generateSimulatedProvingResult(
       : execution.publicInputs.publicTeardownCallRequest;
 
     executionSteps.push({
-      functionName: await contractDataProvider.getDebugFunctionName(
+      functionName: await contractStore.getDebugFunctionName(
         execution.publicInputs.callContext.contractAddress,
         execution.publicInputs.callContext.functionSelector,
       ),
@@ -358,30 +446,35 @@ export async function generateSimulatedProvingResult(
   }
 
   const constantData = new TxConstantData(
-    privateExecutionResult.entrypoint.publicInputs.historicalHeader,
+    privateExecutionResult.entrypoint.publicInputs.anchorBlockHeader,
     privateExecutionResult.entrypoint.publicInputs.txContext,
     getVKTreeRoot(),
-    protocolContractTreeRoot,
+    protocolContractsHash,
   );
 
   const hasPublicCalls = privateExecutionResult.publicFunctionCalldata.length !== 0;
   let inputsForRollup;
   let inputsForPublic;
+  let gasUsed;
 
   const sortByCounter = <T>(a: OrderedSideEffect<T>, b: OrderedSideEffect<T>) => a.counter - b.counter;
   const getEffect = <T>(orderedSideEffect: OrderedSideEffect<T>) => orderedSideEffect.sideEffect;
 
-  const sortedNullifiers = nullifiers.sort(sortByCounter).map(getEffect);
+  const isPrivateOnlyTx = privateExecutionResult.publicFunctionCalldata.length === 0;
+  const minRevertibleSideEffectCounter = getFinalMinRevertibleSideEffectCounter(privateExecutionResult);
 
-  // If the tx generated no nullifiers, the nonce generator (txRequest hash)
-  // is injected as the first nullifier as per protocol rules.
-  if (sortedNullifiers.length === 0) {
-    sortedNullifiers.push(nonceGenerator);
+  const [nonRevertibleNullifiers, revertibleNullifiers] = splitOrderedSideEffects(
+    nullifiers.sort(sortByCounter),
+    minRevertibleSideEffectCounter,
+  );
+  if (nonRevertibleNullifiers.length > 0 && !nonRevertibleNullifiers[0].equals(nonceGenerator)) {
+    throw new Error('The first non revertible nullifier should be equal to the nonce generator. This is a bug!');
+  } else {
+    nonRevertibleNullifiers.unshift(nonceGenerator);
   }
 
-  // Private only
-  if (privateExecutionResult.publicFunctionCalldata.length === 0) {
-    // In case the tx only contains private functions, we must make the note hashes unique by using the
+  if (isPrivateOnlyTx) {
+    // We must make the note hashes unique by using the
     // nonce generator and their index in the tx.
     const uniqueNoteHashes = await Promise.all(
       siloedNoteHashes.sort(sortByCounter).map(async (orderedSideEffect, i) => {
@@ -393,7 +486,7 @@ export async function generateSimulatedProvingResult(
     );
     const accumulatedDataForRollup = new PrivateToRollupAccumulatedData(
       padArrayEnd(uniqueNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-      padArrayEnd(sortedNullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+      padArrayEnd(nonRevertibleNullifiers.concat(revertibleNullifiers), Fr.ZERO, MAX_NULLIFIERS_PER_TX),
       padArrayEnd(
         l2ToL1Messages.sort(sortByCounter).map(getEffect),
         ScopedL2ToL1Message.empty(),
@@ -406,39 +499,51 @@ export async function generateSimulatedProvingResult(
         MAX_CONTRACT_CLASS_LOGS_PER_TX,
       ),
     );
-
+    gasUsed = meterGasUsed(accumulatedDataForRollup);
     inputsForRollup = new PartialPrivateTailPublicInputsForRollup(accumulatedDataForRollup);
   } else {
-    const nonRevertibleData = PrivateToPublicAccumulatedData.empty();
+    const [nonRevertibleNoteHashes, revertibleNoteHashes] = splitOrderedSideEffects(
+      siloedNoteHashes.sort(sortByCounter),
+      minRevertibleSideEffectCounter,
+    );
+    const [nonRevertibleL2ToL1Messages, revertibleL2ToL1Messages] = splitOrderedSideEffects(
+      l2ToL1Messages.sort(sortByCounter),
+      minRevertibleSideEffectCounter,
+    );
+    const [nonRevertibleTaggedPrivateLogs, revertibleTaggedPrivateLogs] = splitOrderedSideEffects(
+      taggedPrivateLogs,
+      minRevertibleSideEffectCounter,
+    );
+    const [nonRevertibleContractClassLogHashes, revertibleContractClassLogHashes] = splitOrderedSideEffects(
+      contractClassLogsHashes.sort(sortByCounter),
+      minRevertibleSideEffectCounter,
+    );
+    const [nonRevertiblePublicCallRequests, revertiblePublicCallRequests] = splitOrderedSideEffects(
+      publicCallRequests.sort(sortByCounter),
+      minRevertibleSideEffectCounter,
+    );
 
-    // The nullifier array contains the nonce generator in position 0
-    // Here we remove it from the revertible data and
-    // add it as the first non-revertible nullifier (we can't have dupes!)
-    // This is because public processor will use that first non-revertible nullifier
-    // as the nonce generator for the note hashes in the revertible part of the tx.
-    const [firstNullifier] = sortedNullifiers.splice(0, 1);
-    nonRevertibleData.nullifiers[0] = firstNullifier;
+    const nonRevertibleData = new PrivateToPublicAccumulatedData(
+      padArrayEnd(nonRevertibleNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+      padArrayEnd(nonRevertibleNullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+      padArrayEnd(nonRevertibleL2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+      padArrayEnd(nonRevertibleTaggedPrivateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
+      padArrayEnd(nonRevertibleContractClassLogHashes, ScopedLogHash.empty(), MAX_CONTRACT_CLASS_LOGS_PER_TX),
+      padArrayEnd(nonRevertiblePublicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX),
+    );
 
     const revertibleData = new PrivateToPublicAccumulatedData(
-      padArrayEnd(siloedNoteHashes.sort(sortByCounter).map(getEffect), Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-      padArrayEnd(sortedNullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
-      padArrayEnd(
-        l2ToL1Messages.sort(sortByCounter).map(getEffect),
-        ScopedL2ToL1Message.empty(),
-        MAX_L2_TO_L1_MSGS_PER_TX,
-      ),
-      padArrayEnd(taggedPrivateLogs.sort(sortByCounter).map(getEffect), PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
-      padArrayEnd(
-        contractClassLogsHashes.sort(sortByCounter).map(getEffect),
-        ScopedLogHash.empty(),
-        MAX_CONTRACT_CLASS_LOGS_PER_TX,
-      ),
-      padArrayEnd(
-        publicCallRequests.sort(sortByCounter).map(getEffect),
-        PublicCallRequest.empty(),
-        MAX_ENQUEUED_CALLS_PER_TX,
-      ),
+      padArrayEnd(revertibleNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+      padArrayEnd(revertibleNullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+      padArrayEnd(revertibleL2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+      padArrayEnd(revertibleTaggedPrivateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
+      padArrayEnd(revertibleContractClassLogHashes, ScopedLogHash.empty(), MAX_CONTRACT_CLASS_LOGS_PER_TX),
+      padArrayEnd(revertiblePublicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX),
     );
+    gasUsed = meterGasUsed(revertibleData).add(meterGasUsed(nonRevertibleData));
+    if (publicTeardownCallRequest) {
+      gasUsed.add(privateExecutionResult.entrypoint.publicInputs.txContext.gasSettings.teardownGasLimits);
+    }
 
     inputsForPublic = new PartialPrivateTailPublicInputsForPublic(
       nonRevertibleData,
@@ -449,7 +554,7 @@ export async function generateSimulatedProvingResult(
 
   const publicInputs = new PrivateKernelTailCircuitPublicInputs(
     constantData,
-    /*gasUsed=*/ new Gas(0, 0),
+    /*gasUsed=*/ gasUsed.add(Gas.from({ l2Gas: FIXED_L2_GAS, daGas: FIXED_DA_GAS })),
     /*feePayer=*/ AztecAddress.zero(),
     /*includeByTimestamp=*/ 0n,
     hasPublicCalls ? inputsForPublic : undefined,
@@ -458,7 +563,60 @@ export async function generateSimulatedProvingResult(
 
   return {
     publicInputs,
-    clientIvcProof: ClientIvcProof.empty(),
-    executionSteps: executionSteps,
+    chonkProof: ChonkProof.empty(),
+    executionSteps,
   };
 }
+
+function splitOrderedSideEffects<T>(effects: OrderedSideEffect<T>[], minRevertibleSideEffectCounter: number) {
+  const revertibleSideEffects: T[] = [];
+  const nonRevertibleSideEffects: T[] = [];
+  effects.forEach(effect => {
+    if (effect.counter < minRevertibleSideEffectCounter) {
+      nonRevertibleSideEffects.push(effect.sideEffect);
+    } else {
+      revertibleSideEffects.push(effect.sideEffect);
+    }
+  });
+  return [nonRevertibleSideEffects, revertibleSideEffects];
+}
+
+function meterGasUsed(data: PrivateToRollupAccumulatedData | PrivateToPublicAccumulatedData) {
+  let meteredDAFields = 0;
+  let meteredL2Gas = 0;
+
+  const numNoteHashes = arrayNonEmptyLength(data.noteHashes, hash => hash.isEmpty());
+  meteredDAFields += numNoteHashes;
+  meteredL2Gas += numNoteHashes * AVM_EMITNOTEHASH_BASE_L2_GAS;
+
+  const numNullifiers = arrayNonEmptyLength(data.nullifiers, nullifier => nullifier.isEmpty());
+  meteredDAFields += numNullifiers;
+  meteredL2Gas += numNullifiers * AVM_EMITNULLIFIER_BASE_L2_GAS;
+
+  const numL2toL1Messages = arrayNonEmptyLength(data.l2ToL1Msgs, msg => msg.isEmpty());
+  meteredDAFields += numL2toL1Messages;
+  meteredL2Gas += numL2toL1Messages * AVM_SENDL2TOL1MSG_BASE_L2_GAS;
+
+  const numPrivatelogs = arrayNonEmptyLength(data.privateLogs, log => log.isEmpty());
+  // Every private log emits its length as an additional field
+  meteredDAFields += data.privateLogs.reduce((acc, log) => (!log.isEmpty() ? acc + log.emittedLength + 1 : acc), 0);
+  meteredL2Gas += numPrivatelogs * L2_GAS_PER_PRIVATE_LOG;
+
+  const numContractClassLogs = arrayNonEmptyLength(data.contractClassLogsHashes, log => log.isEmpty());
+  // Every contract class log emits its length and contract address as additional fields
+  meteredDAFields += data.contractClassLogsHashes.reduce(
+    (acc, log) => (!log.isEmpty() ? acc + log.logHash.length + 2 : acc),
+    0,
+  );
+  meteredL2Gas += numContractClassLogs * L2_GAS_PER_CONTRACT_CLASS_LOG;
+
+  const meteredDAGas = meteredDAFields * DA_BYTES_PER_FIELD * DA_GAS_PER_BYTE;
+
+  if ((data as PrivateToPublicAccumulatedData).publicCallRequests) {
+    const dataForPublic = data as PrivateToPublicAccumulatedData;
+
+    const numPublicCallRequests = arrayNonEmptyLength(dataForPublic.publicCallRequests, req => req.isEmpty());
+    meteredL2Gas += numPublicCallRequests * FIXED_AVM_STARTUP_L2_GAS;
+  }
+  return Gas.from({ l2Gas: meteredL2Gas, daGas: meteredDAGas });
+}

package/src/contract_function_simulator/execution_note_cache.ts

@@ -1,8 +1,8 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 
-import type { NoteData } from './oracle/typed_oracle.js';
+import type { NoteData } from './oracle/interfaces.js';
 
 interface PendingNote {
   note: NoteData;
@@ -44,9 +44,9 @@ export class ExecutionNoteCache {
    * We don't need to use the tx request hash for nonces if another non revertible nullifier is emitted.
    * In that case we disable injecting the tx request hash as a nullifier.
    */
-  private usedTxRequestHashForNonces = true;
+  private usedProtocolNullifierForNonces = true;
 
-  constructor(private readonly txRequestHash: Fr) {}
+  constructor(private readonly protocolNullifier: Fr) {}
 
   /**
    * Enters the revertible phase of the transaction.
@@ -60,12 +60,11 @@ export class ExecutionNoteCache {
     }
     this.inRevertiblePhase = true;
     this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
-
-    let nonceGenerator = this.txRequestHash;
+    let nonceGenerator = this.protocolNullifier;
     const nullifiers = this.getAllNullifiers();
     if (nullifiers.length > 0) {
       nonceGenerator = new Fr(nullifiers[0]);
-      this.usedTxRequestHashForNonces = false;
+      this.usedProtocolNullifierForNonces = false;
     }
 
     // The existing pending notes are all non-revertible.
@@ -92,14 +91,22 @@ export class ExecutionNoteCache {
     updatedNotes.forEach(n => this.#addNote(n));
   }
 
+  public isSideEffectCounterRevertible(sideEffectCounter: number): boolean {
+    if (!this.inRevertiblePhase) {
+      return false;
+    }
+    return sideEffectCounter >= this.minRevertibleSideEffectCounter;
+  }
+
   public finish() {
-    // If we never entered the revertible phase, we need to use the tx request hash as a nonce for the notes if no nullifiers have been emitted.
+    // If we never entered the revertible phase, we need to use the protocol nullifier to compute the nonces for the
+    // notes if no nullifiers have been emitted.
     if (!this.inRevertiblePhase) {
-      this.usedTxRequestHashForNonces = this.getAllNullifiers().length === 0;
+      this.usedProtocolNullifierForNonces = this.getAllNullifiers().length === 0;
     }
     // If we entered the revertible phase, the nonce generator was decided based on wether or not a nullifier was emitted before entering.
     return {
-      usedTxRequestHashForNonces: this.usedTxRequestHashForNonces,
+      usedProtocolNullifierForNonces: this.usedProtocolNullifierForNonces,
     };
   }
 
@@ -126,7 +133,7 @@ export class ExecutionNoteCache {
    * transaction (and thus not a new note).
    */
   public async nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, noteHash: Fr) {
-    const siloedNullifier = await siloNullifier(contractAddress, innerNullifier);
+    const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
     let nullifiedNoteHashCounter: number | undefined = undefined;
     // Find and remove the matching new note and log(s) if the emitted noteHash is not empty.
     if (!noteHash.isEmpty()) {
@@ -158,7 +165,7 @@ export class ExecutionNoteCache {
    * @param innerNullifier
    */
   public async nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
-    const siloedNullifier = await siloNullifier(contractAddress, innerNullifier);
+    const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
     this.recordNullifier(contractAddress, siloedNullifier);
   }
 
@@ -166,11 +173,15 @@ export class ExecutionNoteCache {
    * Return notes created up to current point in execution.
    * If a nullifier for a note in this list is emitted, the note will be deleted.
    * @param contractAddress - Contract address of the notes.
+   * @param owner - Owner of the notes. If undefined, returns all notes regardless of owner.
    * @param storageSlot - Storage slot of the notes.
    **/
-  public getNotes(contractAddress: AztecAddress, storageSlot: Fr) {
+  public getNotes(contractAddress: AztecAddress, owner: AztecAddress | undefined, storageSlot: Fr) {
     const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
-    return notes.filter(n => n.note.storageSlot.equals(storageSlot)).map(n => n.note);
+    return notes
+      .filter(n => owner === undefined || n.note.owner.equals(owner))
+      .filter(n => n.note.storageSlot.equals(storageSlot))
+      .map(n => n.note);
   }
 
   /**
@@ -208,10 +219,15 @@ export class ExecutionNoteCache {
     return [...this.allNullifiers].map(n => new Fr(n));
   }
 
-  recordNullifier(contractAddress: AztecAddress, siloedNullifier: Fr) {
+  recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {
     const nullifiers = this.getNullifiers(contractAddress);
-    nullifiers.add(siloedNullifier.toBigInt());
+
+    if (nullifiers.has(siloedNullifier)) {
+      throw new Error(`Duplicate siloed nullifier ${siloedNullifier} emitted by contract ${contractAddress}`);
+    }
+
+    nullifiers.add(siloedNullifier);
     this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
-    this.allNullifiers.add(siloedNullifier.toBigInt());
+    this.allNullifiers.add(siloedNullifier);
   }
 }

package/src/contract_function_simulator/execution_tagging_index_cache.ts

@@ -0,0 +1,32 @@
+import { DirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
+
+/**
+ * A map that stores the tagging index for a given directional app tagging secret.
+ * Note: The directional app tagging secret is unique for a (sender, recipient, contract) tuple while the direction
+ * of sender -> recipient matters.
+ */
+export class ExecutionTaggingIndexCache {
+  private taggingIndexMap: Map<string, number> = new Map();
+
+  public getLastUsedIndex(secret: DirectionalAppTaggingSecret): number | undefined {
+    return this.taggingIndexMap.get(secret.toString());
+  }
+
+  public setLastUsedIndex(secret: DirectionalAppTaggingSecret, index: number) {
+    const currentValue = this.taggingIndexMap.get(secret.toString());
+    if (currentValue !== undefined && currentValue !== index - 1) {
+      throw new Error(`Invalid tagging index update. Current value: ${currentValue}, new value: ${index}`);
+    }
+    this.taggingIndexMap.set(secret.toString(), index);
+  }
+
+  /**
+   * Returns the pre-tags that were used in this execution (and that need to be stored in the db).
+   */
+  public getUsedPreTags(): PreTag[] {
+    return Array.from(this.taggingIndexMap.entries()).map(([secret, index]) => ({
+      secret: DirectionalAppTaggingSecret.fromString(secret),
+      index,
+    }));
+  }
+}