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

package/src/contract_function_simulator/oracle/oracle.ts

@@ -1,4 +1,6 @@
-import { Fr, Point } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import {
   type ACIRCallback,
   type ACVMField,
@@ -13,21 +15,54 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { ContractClassLog, ContractClassLogFields } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
+import type { IMiscOracle, IPrivateExecutionOracle, IUtilityExecutionOracle } from './interfaces.js';
 import { packAsRetrievedNote } from './note_packing_utils.js';
-import type { TypedOracle } from './typed_oracle.js';
+
+export class UnavailableOracleError extends Error {
+  constructor(oracleName: string) {
+    super(`${oracleName} oracles not available with the current handler`);
+  }
+}
 
 /**
  * A data source that has all the apis required by Aztec.nr.
  */
 export class Oracle {
-  private typedOracle: TypedOracle;
+  constructor(private handler: IMiscOracle | IUtilityExecutionOracle | IPrivateExecutionOracle) {}
+
+  private handlerAsMisc(): IMiscOracle {
+    if (!('isMisc' in this.handler)) {
+      throw new UnavailableOracleError('Misc');
+    }
 
-  constructor(typedOracle: TypedOracle) {
-    this.typedOracle = typedOracle;
+    return this.handler;
+  }
+
+  private handlerAsUtility(): IUtilityExecutionOracle {
+    if (!('isUtility' in this.handler)) {
+      throw new UnavailableOracleError('Utility');
+    }
+
+    return this.handler;
+  }
+
+  private handlerAsPrivate(): IPrivateExecutionOracle {
+    if (!('isPrivate' in this.handler)) {
+      throw new UnavailableOracleError('Private');
+    }
+
+    return this.handler;
   }
 
   toACIRCallback(): ACIRCallback {
-    const excludedProps = ['typedOracle', 'constructor', 'toACIRCallback'] as const;
+    const excludedProps = [
+      'handler',
+      'constructor',
+      'toACIRCallback',
+      'handlerAsMisc',
+      'handlerAsUtility',
+      'handlerAsPrivate',
+    ] as const;
 
     // Get all the oracle function names
     const oracleNames = Object.getOwnPropertyNames(Oracle.prototype).filter(
@@ -58,54 +93,40 @@ export class Oracle {
   }
 
   utilityAssertCompatibleOracleVersion([version]: ACVMField[]) {
-    this.typedOracle.utilityAssertCompatibleOracleVersion(Fr.fromString(version).toNumber());
+    this.handlerAsMisc().utilityAssertCompatibleOracleVersion(Fr.fromString(version).toNumber());
     return Promise.resolve([]);
   }
 
   utilityGetRandomField(): Promise<ACVMField[]> {
-    const val = this.typedOracle.utilityGetRandomField();
+    const val = this.handlerAsMisc().utilityGetRandomField();
     return Promise.resolve([toACVMField(val)]);
   }
 
-  // Since the argument is a slice, noir automatically adds a length field to oracle call.
-  privateStoreInExecutionCache(_length: ACVMField[], values: ACVMField[], [hash]: ACVMField[]): Promise<ACVMField[]> {
-    this.typedOracle.privateStoreInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
+  privateStoreInExecutionCache(values: ACVMField[], [hash]: ACVMField[]): Promise<ACVMField[]> {
+    this.handlerAsPrivate().privateStoreInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
     return Promise.resolve([]);
   }
 
   async privateLoadFromExecutionCache([returnsHash]: ACVMField[]): Promise<ACVMField[][]> {
-    const values = await this.typedOracle.privateLoadFromExecutionCache(Fr.fromString(returnsHash));
+    const values = await this.handlerAsPrivate().privateLoadFromExecutionCache(Fr.fromString(returnsHash));
     return [values.map(toACVMField)];
   }
 
-  async utilityGetBlockNumber(): Promise<ACVMField[]> {
-    return [toACVMField(await this.typedOracle.utilityGetBlockNumber())];
-  }
-
-  async utilityGetTimestamp(): Promise<ACVMField[]> {
-    return [toACVMField(await this.typedOracle.utilityGetTimestamp())];
-  }
-
-  async utilityGetContractAddress(): Promise<ACVMField[]> {
-    return [toACVMField(await this.typedOracle.utilityGetContractAddress())];
-  }
-
-  async utilityGetVersion(): Promise<ACVMField[]> {
-    return [toACVMField(await this.typedOracle.utilityGetVersion())];
-  }
-
-  async utilityGetChainId(): Promise<ACVMField[]> {
-    return [toACVMField(await this.typedOracle.utilityGetChainId())];
+  utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
+    const context = this.handlerAsUtility().utilityGetUtilityContext();
+    return Promise.resolve(context.toNoirRepresentation());
   }
 
   async utilityGetKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {
-    const keyValidationRequest = await this.typedOracle.utilityGetKeyValidationRequest(Fr.fromString(pkMHash));
+    const keyValidationRequest = await this.handlerAsUtility().utilityGetKeyValidationRequest(Fr.fromString(pkMHash));
 
     return keyValidationRequest.toFields().map(toACVMField);
   }
 
   async utilityGetContractInstance([address]: ACVMField[]): Promise<ACVMField[]> {
-    const instance = await this.typedOracle.utilityGetContractInstance(AztecAddress.fromField(Fr.fromString(address)));
+    const instance = await this.handlerAsUtility().utilityGetContractInstance(
+      AztecAddress.fromField(Fr.fromString(address)),
+    );
 
     return [
       instance.salt,
@@ -125,8 +146,8 @@ export class Oracle {
     const parsedTreeId = Fr.fromString(treeId).toNumber();
     const parsedLeafValue = Fr.fromString(leafValue);
 
-    const witness = await this.typedOracle.utilityGetMembershipWitness(
-      parsedBlockNumber,
+    const witness = await this.handlerAsUtility().utilityGetMembershipWitness(
+      BlockNumber(parsedBlockNumber),
       parsedTreeId,
       parsedLeafValue,
     );
@@ -145,7 +166,10 @@ export class Oracle {
     const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
     const parsedNullifier = Fr.fromString(nullifier);
 
-    const witness = await this.typedOracle.utilityGetNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
+    const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(
+      BlockNumber(parsedBlockNumber),
+      parsedNullifier,
+    );
     if (!witness) {
       throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`);
     }
@@ -159,7 +183,10 @@ export class Oracle {
     const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
     const parsedNullifier = Fr.fromString(nullifier);
 
-    const witness = await this.typedOracle.utilityGetLowNullifierMembershipWitness(parsedBlockNumber, parsedNullifier);
+    const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(
+      BlockNumber(parsedBlockNumber),
+      parsedNullifier,
+    );
     if (!witness) {
       throw new Error(
         `Low nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`,
@@ -175,7 +202,10 @@ export class Oracle {
     const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
     const parsedLeafSlot = Fr.fromString(leafSlot);
 
-    const witness = await this.typedOracle.utilityGetPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
+    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(
+      BlockNumber(parsedBlockNumber),
+      parsedLeafSlot,
+    );
     if (!witness) {
       throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
     }
@@ -185,7 +215,7 @@ export class Oracle {
   async utilityGetBlockHeader([blockNumber]: ACVMField[]): Promise<ACVMField[]> {
     const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
 
-    const header = await this.typedOracle.utilityGetBlockHeader(parsedBlockNumber);
+    const header = await this.handlerAsUtility().utilityGetBlockHeader(BlockNumber(parsedBlockNumber));
     if (!header) {
       throw new Error(`Block header not found for block ${parsedBlockNumber}.`);
     }
@@ -194,22 +224,24 @@ export class Oracle {
 
   async utilityGetAuthWitness([messageHash]: ACVMField[]): Promise<ACVMField[][]> {
     const messageHashField = Fr.fromString(messageHash);
-    const witness = await this.typedOracle.utilityGetAuthWitness(messageHashField);
+    const witness = await this.handlerAsUtility().utilityGetAuthWitness(messageHashField);
     if (!witness) {
       throw new Error(`Unknown auth witness for message hash ${messageHashField}`);
     }
     return [witness.map(toACVMField)];
   }
 
-  // TODO(benesjan): This doesn't map to the underlying oracle name which is just ugly.
   async utilityGetPublicKeysAndPartialAddress([address]: ACVMField[]): Promise<ACVMField[][]> {
     const parsedAddress = AztecAddress.fromField(Fr.fromString(address));
-    const { publicKeys, partialAddress } = await this.typedOracle.utilityGetCompleteAddress(parsedAddress);
+    const { publicKeys, partialAddress } =
+      await this.handlerAsUtility().utilityGetPublicKeysAndPartialAddress(parsedAddress);
 
     return [[...publicKeys.toFields(), partialAddress].map(toACVMField)];
   }
 
   async utilityGetNotes(
+    [ownerSome]: ACVMField[],
+    [ownerValue]: ACVMField[],
     [storageSlot]: ACVMField[],
     [numSelects]: ACVMField[],
     selectByIndexes: ACVMField[],
@@ -227,7 +259,10 @@ export class Oracle {
     [maxNotes]: ACVMField[],
     [packedRetrievedNoteLength]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const noteDatas = await this.typedOracle.utilityGetNotes(
+    // Parse Option<AztecAddress>: ownerSome is 0 for None, 1 for Some
+    const owner = Fr.fromString(ownerSome).toNumber() === 1 ? AztecAddress.fromString(ownerValue) : undefined;
+    const noteDatas = await this.handlerAsUtility().utilityGetNotes(
+      owner,
       Fr.fromString(storageSlot),
       +numSelects,
       selectByIndexes.map(s => +s),
@@ -244,7 +279,17 @@ export class Oracle {
       +status,
     );
 
-    const returnDataAsArrayOfPackedRetrievedNotes = noteDatas.map(packAsRetrievedNote);
+    const returnDataAsArrayOfPackedRetrievedNotes = noteDatas.map(noteData =>
+      packAsRetrievedNote({
+        contractAddress: noteData.contractAddress,
+        owner: noteData.owner,
+        randomness: noteData.randomness,
+        storageSlot: noteData.storageSlot,
+        noteNonce: noteData.noteNonce,
+        index: noteData.index,
+        note: noteData.note,
+      }),
+    );
 
     // Now we convert each sub-array to an array of ACVMField
     const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfPackedRetrievedNotes.map(subArray =>
@@ -256,14 +301,18 @@ export class Oracle {
   }
 
   privateNotifyCreatedNote(
+    [owner]: ACVMField[],
     [storageSlot]: ACVMField[],
+    [randomness]: ACVMField[],
     [noteTypeId]: ACVMField[],
     note: ACVMField[],
     [noteHash]: ACVMField[],
     [counter]: ACVMField[],
   ): Promise<ACVMField[]> {
-    this.typedOracle.privateNotifyCreatedNote(
+    this.handlerAsPrivate().privateNotifyCreatedNote(
+      AztecAddress.fromString(owner),
       Fr.fromString(storageSlot),
+      Fr.fromString(randomness),
       NoteSelector.fromField(Fr.fromString(noteTypeId)),
       note.map(Fr.fromString),
       Fr.fromString(noteHash),
@@ -277,17 +326,21 @@ export class Oracle {
     [noteHash]: ACVMField[],
     [counter]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.typedOracle.privateNotifyNullifiedNote(Fr.fromString(innerNullifier), Fr.fromString(noteHash), +counter);
+    await this.handlerAsPrivate().privateNotifyNullifiedNote(
+      Fr.fromString(innerNullifier),
+      Fr.fromString(noteHash),
+      +counter,
+    );
     return [];
   }
 
   async privateNotifyCreatedNullifier([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
-    await this.typedOracle.privateNotifyCreatedNullifier(Fr.fromString(innerNullifier));
+    await this.handlerAsPrivate().privateNotifyCreatedNullifier(Fr.fromString(innerNullifier));
     return [];
   }
 
   async utilityCheckNullifierExists([innerNullifier]: ACVMField[]): Promise<ACVMField[]> {
-    const exists = await this.typedOracle.utilityCheckNullifierExists(Fr.fromString(innerNullifier));
+    const exists = await this.handlerAsUtility().utilityCheckNullifierExists(Fr.fromString(innerNullifier));
     return [toACVMField(exists)];
   }
 
@@ -296,7 +349,7 @@ export class Oracle {
     [messageHash]: ACVMField[],
     [secret]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const message = await this.typedOracle.utilityGetL1ToL2MembershipWitness(
+    const message = await this.handlerAsUtility().utilityGetL1ToL2MembershipWitness(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(messageHash),
       Fr.fromString(secret),
@@ -310,10 +363,10 @@ export class Oracle {
     [blockNumber]: ACVMField[],
     [numberOfElements]: ACVMField[],
   ): Promise<ACVMField[][]> {
-    const values = await this.typedOracle.utilityStorageRead(
+    const values = await this.handlerAsUtility().utilityStorageRead(
       new AztecAddress(Fr.fromString(contractAddress)),
       Fr.fromString(startStorageSlot),
-      +blockNumber,
+      BlockNumber(+blockNumber),
       +numberOfElements,
     );
     return [values.map(toACVMField)];
@@ -328,14 +381,20 @@ export class Oracle {
     const logFields = new ContractClassLogFields(message.map(Fr.fromString));
     const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logFields, +length);
 
-    this.typedOracle.privateNotifyCreatedContractClassLog(log, +counter);
+    this.handlerAsPrivate().privateNotifyCreatedContractClassLog(log, +counter);
     return Promise.resolve([]);
   }
 
-  utilityDebugLog(message: ACVMField[], _ignoredFieldsSize: ACVMField[], fields: ACVMField[]): Promise<ACVMField[]> {
+  utilityDebugLog(
+    level: ACVMField[],
+    message: ACVMField[],
+    _ignoredFieldsSize: ACVMField[],
+    fields: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const levelFr = Fr.fromString(level[0]);
     const messageStr = message.map(acvmField => String.fromCharCode(Fr.fromString(acvmField).toNumber())).join('');
     const fieldsFr = fields.map(Fr.fromString);
-    this.typedOracle.utilityDebugLog(messageStr, fieldsFr);
+    this.handlerAsMisc().utilityDebugLog(levelFr.toNumber(), messageStr, fieldsFr);
     return Promise.resolve([]);
   }
 
@@ -348,7 +407,7 @@ export class Oracle {
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
   ): Promise<ACVMField[][]> {
-    const { endSideEffectCounter, returnsHash } = await this.typedOracle.privateCallPrivateFunction(
+    const { endSideEffectCounter, returnsHash } = await this.handlerAsPrivate().privateCallPrivateFunction(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       FunctionSelector.fromField(Fr.fromString(functionSelector)),
       Fr.fromString(argsHash),
@@ -364,7 +423,7 @@ export class Oracle {
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.typedOracle.privateNotifyEnqueuedPublicFunctionCall(
+    await this.handlerAsPrivate().privateNotifyEnqueuedPublicFunctionCall(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(calldataHash),
       Fr.fromString(sideEffectCounter).toNumber(),
@@ -379,7 +438,7 @@ export class Oracle {
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.typedOracle.privateNotifySetPublicTeardownFunctionCall(
+    await this.handlerAsPrivate().privateNotifySetPublicTeardownFunctionCall(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(calldataHash),
       Fr.fromString(sideEffectCounter).toNumber(),
@@ -391,33 +450,29 @@ export class Oracle {
   async privateNotifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): Promise<
     ACVMField[]
   > {
-    await this.typedOracle.privateNotifySetMinRevertibleSideEffectCounter(
+    await this.handlerAsPrivate().privateNotifySetMinRevertibleSideEffectCounter(
       Fr.fromString(minRevertibleSideEffectCounter).toNumber(),
     );
     return Promise.resolve([]);
   }
 
-  async utilityGetIndexedTaggingSecretAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
-    const taggingSecret = await this.typedOracle.utilityGetIndexedTaggingSecretAsSender(
-      AztecAddress.fromString(sender),
-      AztecAddress.fromString(recipient),
+  async privateIsSideEffectCounterRevertible([sideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
+    const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(
+      Fr.fromString(sideEffectCounter).toNumber(),
     );
-    return taggingSecret.toFields().map(toACVMField);
+    return Promise.resolve([toACVMField(isRevertible)]);
   }
 
-  async privateIncrementAppTaggingSecretIndexAsSender(
-    [sender]: ACVMField[],
-    [recipient]: ACVMField[],
-  ): Promise<ACVMField[]> {
-    await this.typedOracle.privateIncrementAppTaggingSecretIndexAsSender(
+  async privateGetNextAppTagAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
+    const tag = await this.handlerAsPrivate().privateGetNextAppTagAsSender(
       AztecAddress.fromString(sender),
       AztecAddress.fromString(recipient),
     );
-    return [];
+    return [toACVMField(tag.value)];
   }
 
   async utilityFetchTaggedLogs([pendingTaggedLogArrayBaseSlot]: ACVMField[]): Promise<ACVMField[]> {
-    await this.typedOracle.utilityFetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
+    await this.handlerAsUtility().utilityFetchTaggedLogs(Fr.fromString(pendingTaggedLogArrayBaseSlot));
     return [];
   }
 
@@ -426,7 +481,7 @@ export class Oracle {
     [noteValidationRequestsArrayBaseSlot]: ACVMField[],
     [eventValidationRequestsArrayBaseSlot]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.typedOracle.utilityValidateEnqueuedNotesAndEvents(
+    await this.handlerAsUtility().utilityValidateEnqueuedNotesAndEvents(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(noteValidationRequestsArrayBaseSlot),
       Fr.fromString(eventValidationRequestsArrayBaseSlot),
@@ -440,7 +495,7 @@ export class Oracle {
     [logRetrievalRequestsArrayBaseSlot]: ACVMField[],
     [logRetrievalResponsesArrayBaseSlot]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.typedOracle.utilityBulkRetrieveLogs(
+    await this.handlerAsUtility().utilityBulkRetrieveLogs(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(logRetrievalRequestsArrayBaseSlot),
       Fr.fromString(logRetrievalResponsesArrayBaseSlot),
@@ -453,7 +508,7 @@ export class Oracle {
     [slot]: ACVMField[],
     capsule: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.typedOracle.utilityStoreCapsule(
+    await this.handlerAsUtility().utilityStoreCapsule(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       Fr.fromString(slot),
       capsule.map(Fr.fromString),
@@ -466,7 +521,7 @@ export class Oracle {
     [slot]: ACVMField[],
     [tSize]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const values = await this.typedOracle.utilityLoadCapsule(
+    const values = await this.handlerAsUtility().utilityLoadCapsule(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       Fr.fromString(slot),
     );
@@ -483,7 +538,7 @@ export class Oracle {
   }
 
   async utilityDeleteCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[]): Promise<ACVMField[]> {
-    await this.typedOracle.utilityDeleteCapsule(
+    await this.handlerAsUtility().utilityDeleteCapsule(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       Fr.fromString(slot),
     );
@@ -496,7 +551,7 @@ export class Oracle {
     [dstSlot]: ACVMField[],
     [numEntries]: ACVMField[],
   ): Promise<ACVMField[]> {
-    await this.typedOracle.utilityCopyCapsule(
+    await this.handlerAsUtility().utilityCopyCapsule(
       AztecAddress.fromField(Fr.fromString(contractAddress)),
       Fr.fromString(srcSlot),
       Fr.fromString(dstSlot),
@@ -515,7 +570,7 @@ export class Oracle {
     const ivBuffer = fromUintArray(iv, 8);
     const symKeyBuffer = fromUintArray(symKey, 8);
 
-    const plaintext = await this.typedOracle.utilityAes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
+    const plaintext = await this.handlerAsUtility().utilityAes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
     return bufferToBoundedVec(plaintext, ciphertextBVecStorage.length);
   }
 
@@ -525,7 +580,7 @@ export class Oracle {
     [ephPKField1]: ACVMField[],
     [ephPKField2]: ACVMField[],
   ): Promise<ACVMField[]> {
-    const secret = await this.typedOracle.utilityGetSharedSecret(
+    const secret = await this.handlerAsUtility().utilityGetSharedSecret(
       AztecAddress.fromField(Fr.fromString(address)),
       Point.fromFields([ephPKField0, ephPKField1, ephPKField2].map(Fr.fromString)),
     );
@@ -533,18 +588,18 @@ export class Oracle {
   }
 
   async utilityEmitOffchainEffect(data: ACVMField[]) {
-    await this.typedOracle.utilityEmitOffchainEffect(data.map(Fr.fromString));
+    await this.handlerAsPrivate().utilityEmitOffchainEffect(data.map(Fr.fromString));
     return [];
   }
 
   async privateGetSenderForTags(): Promise<ACVMField[]> {
-    const sender = await this.typedOracle.privateGetSenderForTags();
+    const sender = await this.handlerAsPrivate().privateGetSenderForTags();
     // Return [1, address] for Some(address), [0, 0] for None
     return sender ? [toACVMField(1n), toACVMField(sender)] : [toACVMField(0n), toACVMField(0n)];
   }
 
   async privateSetSenderForTags([senderForTags]: ACVMField[]): Promise<ACVMField[]> {
-    await this.typedOracle.privateSetSenderForTags(AztecAddress.fromField(Fr.fromString(senderForTags)));
+    await this.handlerAsPrivate().privateSetSenderForTags(AztecAddress.fromField(Fr.fromString(senderForTags)));
     return [];
   }
 }

package/src/contract_function_simulator/oracle/private_execution.ts

@@ -1,5 +1,6 @@
 import { PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
@@ -26,7 +27,7 @@ import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 import { BlockHeader, PrivateCallExecutionResult } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
-import type { ExecutionDataProvider } from '../execution_data_provider.js';
+import { ContractStore } from '../../storage/contract_store/index.js';
 import { Oracle } from './oracle.js';
 import type { PrivateExecutionOracle } from './private_execution_oracle.js';
 
@@ -88,6 +89,7 @@ export async function executePrivateFunction(
   const newNotes = privateExecutionOracle.getNewNotes();
   const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
   const offchainEffects = privateExecutionOracle.getOffchainEffects();
+  const preTags = privateExecutionOracle.getUsedPreTags();
   const nestedExecutionResults = privateExecutionOracle.getNestedExecutionResults();
 
   let timerSubtractionList = nestedExecutionResults;
@@ -111,6 +113,7 @@ export async function executePrivateFunction(
     noteHashNullifierCounterMap,
     rawReturnValues,
     offchainEffects,
+    preTags,
     nestedExecutionResults,
     contractClassLogs,
     {
@@ -151,7 +154,7 @@ export function extractPrivateCircuitPublicInputs(
  * from the instance is used.
  * @param contractAddress - The address of the contract to read the class id for.
  * @param instance - The instance of the contract.
- * @param executionDataProvider - The execution data provider.
+ * @param executionStore - The execution data provider.
  * @param blockNumber - The block number at which to load the DelayedPublicMutable storing the class id.
  * @param timestamp - The timestamp at which to obtain the class id from the DelayedPublicMutable.
  * @returns The current class id.
@@ -159,13 +162,13 @@ export function extractPrivateCircuitPublicInputs(
 export async function readCurrentClassId(
   contractAddress: AztecAddress,
   instance: ContractInstance,
-  executionDataProvider: ExecutionDataProvider | AztecNode,
-  blockNumber: number,
+  aztecNode: AztecNode,
+  blockNumber: BlockNumber,
   timestamp: UInt64,
 ) {
   const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
   const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, slot =>
-    executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceRegistry, slot),
+    aztecNode.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceRegistry, slot),
   );
   let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
   if (currentClassId.isZero()) {
@@ -175,37 +178,28 @@ export async function readCurrentClassId(
 }
 
 /**
- * Verify that the current class id of a contract obtained from AztecNode is the same as the one in the execution data
- * provider (i.e. PXE).
- * @param contractAddress - The address of the contract to verify class id for.
- * @param executionDataProvider - The execution data provider.
- * @param header - The header of the block at which to verify the current class id. If not provided, the current block
- * number and timestamp from the execution data provider will be used.
+ * Verify that the current class id of a contract obtained from AztecNode is the same as the one in contract data
+ * provider (i.e. PXE's own storage).
+ * @param header - The header of the block at which to verify the current class id. If not provided, the anchor block
+ * header of the execution data provider is used.
  */
 export async function verifyCurrentClassId(
   contractAddress: AztecAddress,
-  executionDataProvider: ExecutionDataProvider,
-  header?: BlockHeader,
+  aztecNode: AztecNode,
+  contractStore: ContractStore,
+  header: BlockHeader,
 ) {
-  let blockNumber: number;
-  let timestamp: UInt64;
-  if (header) {
-    blockNumber = header.globalVariables.blockNumber;
-    timestamp = header.globalVariables.timestamp;
-  } else {
-    [blockNumber, timestamp] = await Promise.all([
-      executionDataProvider.getBlockNumber(),
-      executionDataProvider.getTimestamp(),
-    ]);
+  const instance = await contractStore.getContractInstance(contractAddress);
+  if (!instance) {
+    throw new Error(`No contract instance found for address ${contractAddress.toString()}`);
   }
 
-  const instance = await executionDataProvider.getContractInstance(contractAddress);
   const currentClassId = await readCurrentClassId(
     contractAddress,
     instance,
-    executionDataProvider,
-    blockNumber,
-    timestamp,
+    aztecNode,
+    header.globalVariables.blockNumber,
+    header.globalVariables.timestamp,
   );
   if (!instance.currentContractClassId.equals(currentClassId)) {
     throw new Error(