@aztec/pxe 2.1.0-rc.9 → 3.0.0-devnet.2

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,13 @@ import {
   MAX_NULLIFIERS_PER_TX,
   MAX_PRIVATE_LOGS_PER_TX,
 } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 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,
@@ -49,11 +59,13 @@ import {
   TxConstantData,
   TxExecutionRequest,
   collectNested,
+  getFinalMinRevertibleSideEffectCounter,
 } from '@aztec/stdlib/tx';
 
 import type { ContractDataProvider } from '../storage/index.js';
 import type { ExecutionDataProvider } from './execution_data_provider.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';
@@ -94,7 +106,7 @@ export class ContractFunctionSimulator {
     scopes?: AztecAddress[],
   ): Promise<PrivateExecutionResult> {
     const simulatorSetupTimer = new Timer();
-    const header = await this.executionDataProvider.getBlockHeader();
+    const anchorBlockHeader = await this.executionDataProvider.getAnchorBlockHeader();
 
     await verifyCurrentClassId(contractAddress, this.executionDataProvider);
 
@@ -122,23 +134,25 @@ export class ContractFunctionSimulator {
 
     const txRequestHash = await request.toTxRequest().hash();
     const noteCache = new ExecutionNoteCache(txRequestHash);
+    const taggingIndexCache = new ExecutionTaggingIndexCache();
 
     const privateExecutionOracle = new PrivateExecutionOracle(
       request.firstCallArgsHash,
       request.txContext,
       callContext,
-      header,
+      anchorBlockHeader,
       request.authWitnesses,
       request.capsules,
       HashedValuesCache.create(request.argsOfCalls),
       noteCache,
+      taggingIndexCache,
       this.executionDataProvider,
-      this.simulator,
       0, // totalPublicArgsCount
       startSideEffectCounter,
       undefined, // log
       scopes,
       senderForTags,
+      this.simulator,
     );
 
     const setupTime = simulatorSetupTimer.ms();
@@ -358,30 +372,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 +412,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 +425,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 +480,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,
@@ -462,3 +493,56 @@ export async function generateSimulatedProvingResult(
     executionSteps: 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_data_provider.ts

@@ -5,14 +5,13 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
 import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import { IndexedTaggingSecret } from '@aztec/stdlib/logs';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 import type { NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader, NodeStats } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 
+import type { NoteData } from './oracle/interfaces.js';
 import type { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
-import type { NoteData } from './oracle/typed_oracle.js';
 
 /**
  * Error thrown when a contract is not found in the database.
@@ -146,11 +145,12 @@ export interface ExecutionDataProvider {
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
 
   /**
-   * Retrieve the latest block header synchronized by the PXE.
-   * @dev This structure is fed into the circuits simulator and is used to prove against certain historical roots.
-   * @returns The BlockHeader object.
+   * Retrieve the latest block header synchronized by the execution data provider. This block header is referred
+   * to as the anchor block header in Aztec terminology and it defines the state that is used during private function
+   * execution.
+   * @returns The anchor block header.
    */
-  getBlockHeader(): Promise<BlockHeader>;
+  getAnchorBlockHeader(): Promise<BlockHeader>;
 
   /**
    * Fetches the index and sibling path of a leaf at a given block from a given tree.
@@ -215,54 +215,36 @@ export interface ExecutionDataProvider {
   assertCompatibleOracleVersion(version: number): void;
 
   /**
-   * Fetches the latest block number synchronized by the node.
-   * @returns The block number.
-   */
-  getBlockNumber(): Promise<number>;
-
-  /**
-   * Fetches the timestamp of the latest block synchronized by the node.
-   * @returns The timestamp.
-   */
-  getTimestamp(): Promise<UInt64>;
-
-  /**
-   * Fetches the current chain id.
-   * @returns The chain id.
-   */
-  getChainId(): Promise<number>;
-
-  /**
-   * Fetches the current chain id.
-   * @returns The chain id.
-   */
-  getVersion(): Promise<number>;
-
-  /**
-   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivsk_m of the sender must be known.
-   * Includes the next index to be used used for tagging with this secret.
+   * Calculates the directional app tagging secret for a given contract, sender and recipient.
    * @param contractAddress - The contract address to silo the secret for
    * @param sender - The address sending the note
    * @param recipient - The address receiving the note
-   * @returns A tagging secret that can be used to tag notes.
+   * @returns The directional app tagging secret
    */
-  getIndexedTaggingSecretAsSender(
+  calculateDirectionalAppTaggingSecret(
     contractAddress: AztecAddress,
     sender: AztecAddress,
     recipient: AztecAddress,
-  ): Promise<IndexedTaggingSecret>;
+  ): Promise<DirectionalAppTaggingSecret>;
 
   /**
-   * Increments the tagging secret for a given sender and recipient pair. For this to work, the ivsk_m of the sender must be known.
-   * @param contractAddress - The contract address to silo the secret for
-   * @param sender - The address sending the note
-   * @param recipient - The address receiving the note
+   * Updates the local index of the shared tagging secret of a (sender, recipient, contract) tuple if a log with
+   * a larger index is found from the node.
+   * @param secret - The secret that's unique for (sender, recipient, contract) tuple while the direction
+   * of sender -> recipient matters.
+   * @param contractAddress - The address of the contract that the logs are tagged for. Needs to be provided to store
+   * because the function performs second round of siloing which is necessary because kernels do it as well (they silo
+   * first field of the private log which corresponds to the tag).
    */
-  incrementAppTaggingSecretIndexAsSender(
-    contractAddress: AztecAddress,
-    sender: AztecAddress,
-    recipient: AztecAddress,
-  ): Promise<void>;
+  syncTaggedLogsAsSender(secret: DirectionalAppTaggingSecret, contractAddress: AztecAddress): Promise<void>;
+
+  /**
+   * Returns the last used index when sending a log with a given secret.
+   * @param secret - The directional app tagging secret.
+   * @returns The last used index for the given directional app tagging secret, or undefined if we never sent a log
+   * from this sender to a recipient in a given contract (implicitly included in the secret).
+   */
+  getLastUsedIndexAsSender(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
 
   /**
    * Synchronizes the private logs tagged with scoped addresses and all the senders in the address book. Stores the found
@@ -301,9 +283,9 @@ export interface ExecutionDataProvider {
   ): Promise<void>;
 
   /**
-   * Removes all of a contract's notes that have been nullified from the note database.
+   * Looks for nullifiers of active contract notes and marks them as nullified in the db if a nullifier is found.
    */
-  removeNullifiedNotes(contractAddress: AztecAddress): Promise<void>;
+  syncNoteNullifiers(contractAddress: AztecAddress): Promise<void>;
 
   /**
    * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `loadCapsule`.

package/src/contract_function_simulator/execution_note_cache.ts

@@ -2,7 +2,7 @@ import { Fr } from '@aztec/foundation/fields';
 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;
@@ -126,7 +126,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 +158,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);
   }
 
@@ -208,10 +208,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,
+    }));
+  }
+}

package/src/contract_function_simulator/index.ts

@@ -1,7 +1,8 @@
 export { ExecutionNoteCache } from './execution_note_cache.js';
+export { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
 export { HashedValuesCache } from './hashed_values_cache.js';
 export { pickNotes } from './pick_notes.js';
-export { type NoteData, TypedOracle } from './oracle/typed_oracle.js';
+export type { NoteData, IMiscOracle, IUtilityExecutionOracle, IPrivateExecutionOracle } from './oracle/interfaces.js';
 export { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
 export { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
 export { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
@@ -9,3 +10,4 @@ export { Oracle } from './oracle/oracle.js';
 export { executePrivateFunction, extractPrivateCircuitPublicInputs } from './oracle/private_execution.js';
 export { generateSimulatedProvingResult } from './contract_function_simulator.js';
 export { packAsRetrievedNote } from './oracle/note_packing_utils.js';
+export { UtilityContext } from './noir-structs/utility_context.js';

package/src/contract_function_simulator/noir-structs/log_retrieval_response.ts

@@ -1,9 +1,12 @@
-import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN, PUBLIC_LOG_PLAINTEXT_LEN } from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { range } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import type { TxHash } from '@aztec/stdlib/tx';
 
-const MAX_LOG_CONTENT_LEN = Math.max(PUBLIC_LOG_PLAINTEXT_LEN, PRIVATE_LOG_CIPHERTEXT_LEN);
+import { MAX_NOTE_PACKED_LEN } from './note_validation_request.js';
+
+const MAX_PUBLIC_LOG_LEN_FOR_NOTE_COMPLETION = MAX_NOTE_PACKED_LEN;
+const MAX_LOG_CONTENT_LEN = Math.max(MAX_PUBLIC_LOG_LEN_FOR_NOTE_COMPLETION, PRIVATE_LOG_CIPHERTEXT_LEN);
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle stores values of this
@@ -19,7 +22,9 @@ export class LogRetrievalResponse {
 
   toFields(): Fr[] {
     return [
-      ...serializeBoundedVec(this.logPayload, MAX_LOG_CONTENT_LEN),
+      // We need to trim the payload since public logs can be larger than MAX_LOG_CONTENT_LEN.
+      // This is currently not a problem since this class is only used with public logs for note completion.
+      ...serializeBoundedVec(this.logPayload.slice(0, MAX_LOG_CONTENT_LEN), MAX_LOG_CONTENT_LEN),
       this.txHash.hash,
       ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
       this.firstNullifierInTx,

package/src/contract_function_simulator/noir-structs/note_validation_request.ts

@@ -4,7 +4,7 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { TxHash } from '@aztec/stdlib/tx';
 
 // TODO(#14617): should we compute this from constants? This value is aztec-nr specific.
-const MAX_NOTE_PACKED_LEN = 12;
+export const MAX_NOTE_PACKED_LEN = 12;
 
 /**
  * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateEnqueuedNotesAndEvents` oracle

package/src/contract_function_simulator/noir-structs/utility_context.ts

@@ -0,0 +1,42 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+/**
+ * TypeScript counterpart of utility_context.nr. Used only as a return value for the utilityGetUtilityContext oracle.
+ */
+export class UtilityContext {
+  private constructor(
+    public readonly blockNumber: number,
+    public readonly timestamp: UInt64,
+    public readonly contractAddress: AztecAddress,
+    public readonly version: Fr,
+    public readonly chainId: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<UtilityContext>) {
+    return new UtilityContext(
+      fields.blockNumber,
+      fields.timestamp,
+      fields.contractAddress,
+      fields.version,
+      fields.chainId,
+    );
+  }
+
+  /**
+   * Returns a representation of the utility context as expected by intrinsic Noir deserialization.
+   * The order of the fields has to be the same as the order of the fields in the utility_context.nr.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.blockNumber).toString() as string,
+      new Fr(this.timestamp).toString() as string,
+      this.contractAddress.toString() as string,
+      this.version.toString() as string,
+      this.chainId.toString() as string,
+    ];
+  }
+}

package/src/contract_function_simulator/oracle/index.ts

@@ -1,7 +1,7 @@
 import type { Oracle } from './oracle.js';
 
 export * from './oracle.js';
-export * from './typed_oracle.js';
+export * from './interfaces.js';
 
 /**
  * A conditional type that takes a type `T` and returns a union of its method names.