@aztec/pxe 0.0.1-commit.d3ec352c → 0.0.1-commit.fcb71a6

package/src/bin/check_oracle_version.ts

@@ -1,6 +1,10 @@
-import { keccak256String } from '@aztec/foundation/crypto';
+import { keccak256String } from '@aztec/foundation/crypto/keccak';
+
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import ts from 'typescript';
+import { fileURLToPath } from 'url';
 
-import { Oracle } from '../contract_function_simulator/oracle/oracle.js';
 import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
 
 /**
@@ -16,6 +20,22 @@ import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
  * oracle interface like we do in PXE (i.e., there is no single Oracle class that contains only the oracles).
  */
 function assertOracleInterfaceMatches(): void {
+  const oracleInterfaceSignature = getOracleInterfaceSignature();
+
+  // We use keccak256 here just because we already have it in the dependencies.
+  const oracleInterfaceHash = keccak256String(oracleInterfaceSignature);
+  if (oracleInterfaceHash !== ORACLE_INTERFACE_HASH) {
+    // This check exists only to notify you when you need to update the ORACLE_VERSION constant.
+    throw new Error(
+      `The Oracle interface has changed, which implies a breaking change in the aztec.nr/PXE oracle interface. Update ORACLE_INTERFACE_HASH to ${oracleInterfaceHash} and bump ORACLE_VERSION in pxe/src/oracle_version.ts.`,
+    );
+  }
+}
+
+/**
+ * Constructs a signature of the Oracle interface while ignoring methods that are not foreign call handlers.
+ */
+function getOracleInterfaceSignature(): string {
   const excludedProps = [
     'handler',
     'constructor',
@@ -25,26 +45,116 @@ function assertOracleInterfaceMatches(): void {
     'handlerAsPrivate',
   ] as const;
 
-  // Create a hashable representation of the oracle interface by concatenating its method names. Return values are
-  // excluded from the hash calculation since they are typically arrays of fields and I didn't manage to reliably
-  // stringify them.
-  // TODO(#16581): we're only checking the functions implemented by the Oracle object, which is really an ACVM
-  // translator, akin to TXE's RPC translator. This is correct in that it is ultimately the foreign interface that
-  // matters, but incorrect in that it does not take into consideration TXE's extended interface. An improvement would
-  // be to check RPCTranslator from TXE, though that still seems a bit fragile.
-  const oracleInterfaceMethodNames = Object.getOwnPropertyNames(Oracle.prototype)
-    .filter(name => !excludedProps.includes(name as (typeof excludedProps)[number]))
-    .sort()
-    .join('');
+  // Get the path to Oracle.ts source file
+  // The script runs from dest/bin/ after compilation, so we need to go up to the package root
+  // then into src/ to find the source file
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  // Go up from dest/bin/ or src/bin/ to the package root (pxe/), then into src/
+  const packageRoot = dirname(dirname(currentDir)); // Go up from bin/ to pxe/
+  const oracleSourcePath = join(packageRoot, 'src/contract_function_simulator/oracle/oracle.ts');
 
-  // We use keccak256 here just because we already have it in the dependencies.
-  const oracleInterfaceHash = keccak256String(oracleInterfaceMethodNames);
-  if (oracleInterfaceHash !== ORACLE_INTERFACE_HASH) {
-    // This check exists only to notify you when you need to update the ORACLE_VERSION constant.
-    throw new Error(
-      `The Oracle interface has changed, which implies a breaking change in the aztec.nr/PXE oracle interface. Update ORACLE_INTERFACE_HASH to ${oracleInterfaceHash} and bump ORACLE_VERSION in pxe/src/oracle_version.ts.`,
-    );
+  // Read and parse the TypeScript source file
+  const sourceCode = readFileSync(oracleSourcePath, 'utf-8');
+  const sourceFile = ts.createSourceFile('oracle.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+
+  // Extract method signatures from the Oracle class
+  const methodSignatures: string[] = [];
+
+  function visit(node: ts.Node) {
+    // Look for class declaration named "Oracle"
+    if (ts.isClassDeclaration(node) && node.name?.text === 'Oracle') {
+      // Visit all members of the class
+      node.members.forEach(member => {
+        if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+          const methodName = member.name.text;
+
+          // Skip excluded methods
+          if (excludedProps.includes(methodName as (typeof excludedProps)[number])) {
+            return;
+          }
+
+          // Extract parameter signatures
+          const paramSignatures: string[] = [];
+          member.parameters.forEach(param => {
+            const paramName = extractParameterName(param, sourceFile);
+            const paramType = extractTypeString(param.type, sourceFile);
+            paramSignatures.push(`${paramName}: ${paramType}`);
+          });
+
+          // Extract return type
+          const returnType = extractTypeString(member.type, sourceFile);
+
+          // Build full signature: methodName(param1: Type1, param2: Type2): ReturnType
+          const signature = `${methodName}(${paramSignatures.join(', ')}): ${returnType}`;
+          methodSignatures.push(signature);
+        }
+      });
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+
+  // Sort signatures alphabetically for consistent hashing
+  methodSignatures.sort();
+
+  // Create a hashable representation by concatenating all signatures
+  return methodSignatures.join('');
+}
+
+/**
+ * Extracts the parameter name from a parameter node, handling destructured parameters.
+ */
+function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.SourceFile): string {
+  const name = param.name;
+
+  if (ts.isIdentifier(name)) {
+    return name.text;
   }
+
+  if (ts.isArrayBindingPattern(name)) {
+    // Handle destructured parameters like [blockNumber]: ACVMField[]
+    // Extract the first element name
+    if (name.elements.length > 0) {
+      const element = name.elements[0];
+      if (ts.isBindingElement(element)) {
+        const elementName = element.name;
+        if (ts.isIdentifier(elementName)) {
+          return elementName.text;
+        }
+        // Nested destructuring - use text representation
+        if (ts.isArrayBindingPattern(elementName) || ts.isObjectBindingPattern(elementName)) {
+          return elementName.getText(sourceFile);
+        }
+      }
+    }
+    // Fallback: return the text representation
+    return name.getText(sourceFile);
+  }
+
+  if (ts.isObjectBindingPattern(name)) {
+    // Handle object destructuring
+    return name.getText(sourceFile);
+  }
+
+  // Fallback for any other case - this should never happen but TypeScript needs it
+  return (name as ts.Node).getText(sourceFile);
+}
+
+/**
+ * Extracts the type string from a type node, normalizing whitespace.
+ */
+function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
+  if (!typeNode) {
+    return 'void';
+  }
+
+  // Get the type text and normalize whitespace
+  let typeText = typeNode.getText(sourceFile);
+  // Normalize whitespace: remove extra spaces, newlines, and tabs
+  typeText = typeText.replace(/\s+/g, ' ').trim();
+  return typeText;
 }
 
 assertOracleInterfaceMatches();

package/src/{synchronizer/synchronizer.ts → block_synchronizer/block_synchronizer.ts}

@@ -5,32 +5,30 @@ import { L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 import type { PXEConfig } from '../config/index.js';
-import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
-import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
-import type { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
+import type { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
 
 /**
- * The Synchronizer class orchestrates synchronization between the PXE and Aztec node, maintaining an up-to-date
+ * The BlockSynchronizer class orchestrates synchronization between PXE and Aztec node, maintaining an up-to-date
  * view of the L2 chain state. It handles block header retrieval, chain reorganizations, and provides an interface
  * for querying sync status.
  */
-export class Synchronizer implements L2BlockStreamEventHandler {
+export class BlockSynchronizer implements L2BlockStreamEventHandler {
   private log: Logger;
   private isSyncing: Promise<void> | undefined;
   protected readonly blockStream: L2BlockStream;
 
   constructor(
     private node: AztecNode,
-    private syncDataProvider: SyncDataProvider,
-    private noteDataProvider: NoteDataProvider,
-    private taggingDataProvider: TaggingDataProvider,
+    private anchorBlockStore: AnchorBlockStore,
+    private noteStore: NoteStore,
     private l2TipsStore: L2TipsKVStore,
     config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>> = {},
     loggerOrSuffix?: string | Logger,
   ) {
     this.log =
       !loggerOrSuffix || typeof loggerOrSuffix === 'string'
-        ? createLogger(loggerOrSuffix ? `pxe:synchronizer:${loggerOrSuffix}` : `pxe:synchronizer`)
+        ? createLogger(loggerOrSuffix ? `pxe:block_synchronizer:${loggerOrSuffix}` : `pxe:block_synchronizer`)
         : loggerOrSuffix;
     this.blockStream = this.createBlockStream(config);
   }
@@ -56,23 +54,20 @@ export class Synchronizer implements L2BlockStreamEventHandler {
           archive: lastBlock.archive.root.toString(),
           header: lastBlock.header.toInspect(),
         });
-        await this.syncDataProvider.setHeader(lastBlock.getBlockHeader());
+        await this.anchorBlockStore.setHeader(lastBlock.getBlockHeader());
         break;
       }
       case 'chain-pruned': {
         this.log.warn(`Pruning data after block ${event.block.number} due to reorg`);
         // We first unnullify and then remove so that unnullified notes that were created after the block number end up deleted.
-        const lastSynchedBlockNumber = await this.syncDataProvider.getBlockNumber();
-        await this.noteDataProvider.rollbackNotesAndNullifiers(event.block.number, lastSynchedBlockNumber);
-        // Remove all note tagging indexes to force a full resync. This is suboptimal, but unless we track the
-        // block number in which each index is used it's all we can do.
-        await this.taggingDataProvider.resetNoteSyncData();
+        const lastSynchedBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
+        await this.noteStore.rollbackNotesAndNullifiers(event.block.number, lastSynchedBlockNumber);
         // Update the header to the last block.
         const newHeader = await this.node.getBlockHeader(event.block.number);
         if (!newHeader) {
           this.log.error(`Block header not found for block number ${event.block.number} during chain prune`);
         } else {
-          await this.syncDataProvider.setHeader(newHeader);
+          await this.anchorBlockStore.setHeader(newHeader);
         }
         break;
       }
@@ -82,6 +77,11 @@ export class Synchronizer implements L2BlockStreamEventHandler {
   /**
    * Syncs PXE and the node by downloading the metadata of the latest blocks, allowing simulations to use
    * recent data (e.g. notes), and handling any reorgs that might have occurred.
+   *
+   * Note this BlockSynchronizer is designed to let its users control when a synchronization is run,
+   * so this component doesn't proactively stay up to date with the blockchain.
+   *
+   * We do this so PXE can ensure data consistency.
    */
   public async sync() {
     if (this.isSyncing !== undefined) {
@@ -104,18 +104,14 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     let currentHeader;
 
     try {
-      currentHeader = await this.syncDataProvider.getBlockHeader();
+      currentHeader = await this.anchorBlockStore.getBlockHeader();
     } catch {
       this.log.debug('Header is not set, requesting from the node');
     }
     if (!currentHeader) {
       // REFACTOR: We should know the header of the genesis block without having to request it from the node.
-      await this.syncDataProvider.setHeader((await this.node.getBlockHeader(BlockNumber.ZERO))!);
+      await this.anchorBlockStore.setHeader((await this.node.getBlockHeader(BlockNumber.ZERO))!);
     }
     await this.blockStream.sync();
   }
-
-  public getSynchedBlockNumber() {
-    return this.syncDataProvider.getBlockNumber();
-  }
 }

package/src/block_synchronizer/index.ts

@@ -0,0 +1 @@
+export * from './block_synchronizer.js';

package/src/config/index.ts

@@ -19,14 +19,14 @@ export interface KernelProverConfig {
 }
 
 /**
- * Configuration settings for the synchronizer.
+ * Configuration settings for the block synchronizer.
  */
-export interface SynchronizerConfig {
+export interface BlockSynchronizerConfig {
   /** Maximum amount of blocks to pull from the stream in one request when synchronizing */
   l2BlockBatchSize: number;
 }
 
-export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & SynchronizerConfig;
+export type PXEConfig = KernelProverConfig & DataStoreConfig & ChainConfig & BlockSynchronizerConfig;
 
 export type CliPXEOptions = {
   /** Custom Aztec Node URL to connect to  */

package/src/contract_function_simulator/contract_function_simulator.ts

@@ -17,10 +17,11 @@ import {
   MAX_PRIVATE_LOGS_PER_TX,
 } from '@aztec/constants';
 import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+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 { protocolContractsHash } from '@aztec/protocol-contracts';
 import {
@@ -44,6 +45,7 @@ import {
   siloNoteHash,
   siloNullifier,
 } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import {
   PartialPrivateTailPublicInputsForPublic,
   PartialPrivateTailPublicInputsForRollup,
@@ -59,6 +61,7 @@ import { PrivateLog } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { ChonkProof } from '@aztec/stdlib/proofs';
 import {
+  BlockHeader,
   CallContext,
   HashedValues,
   PrivateExecutionResult,
@@ -68,8 +71,15 @@ import {
   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';
@@ -77,6 +87,7 @@ 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.
@@ -85,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');
@@ -98,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.
@@ -108,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 anchorBlockHeader = await this.executionDataProvider.getAnchorBlockHeader();
 
-    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`);
@@ -147,12 +173,25 @@ export class ContractFunctionSimulator {
       request.txContext,
       callContext,
       anchorBlockHeader,
+      async call => {
+        await this.runUtility(call, [], anchorBlockHeader, scopes);
+      },
       request.authWitnesses,
       request.capsules,
       HashedValuesCache.create(request.argsOfCalls),
       noteCache,
       taggingIndexCache,
-      this.executionDataProvider,
+      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
@@ -213,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 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<Fr[]> {
-    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}`, {
@@ -258,8 +320,15 @@ export class ContractFunctionSimulator {
   }
   // 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 };
   }
 }
 
@@ -282,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>[] = [];
@@ -365,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,
       ),

package/src/contract_function_simulator/execution_note_cache.ts

@@ -1,4 +1,4 @@
-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';
 
@@ -173,12 +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.
+   * @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, owner: 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.owner.equals(owner) && 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);
   }
 
   /**

package/src/contract_function_simulator/execution_tagging_index_cache.ts

@@ -21,7 +21,7 @@ export class ExecutionTaggingIndexCache {
   }
 
   /**
-   * Returns the pre tags that were used in this execution (and that need to be stored in the db).
+   * 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]) => ({

package/src/contract_function_simulator/hashed_values_cache.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { HashedValues } from '@aztec/stdlib/tx';
 
 /**

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

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { EventSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';

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

@@ -1,6 +1,7 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Tag } from '@aztec/stdlib/logs';
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle expects values of this
@@ -9,19 +10,19 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 export class LogRetrievalRequest {
   constructor(
     public contractAddress: AztecAddress,
-    public unsiloedTag: Fr,
+    public tag: Tag,
   ) {}
 
   toFields(): Fr[] {
-    return [this.contractAddress.toField(), this.unsiloedTag];
+    return [this.contractAddress.toField(), this.tag.value];
   }
 
   static fromFields(fields: Fr[] | FieldReader): LogRetrievalRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
-    const unsiloedTag = reader.readField();
+    const tag = new Tag(reader.readField());
 
-    return new LogRetrievalRequest(contractAddress, unsiloedTag);
+    return new LogRetrievalRequest(contractAddress, tag);
   }
 }

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

@@ -1,6 +1,6 @@
 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 { Fr } from '@aztec/foundation/curves/bn254';
 import type { TxHash } from '@aztec/stdlib/tx';
 
 import { MAX_NOTE_PACKED_LEN } from './note_validation_request.js';

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

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { TxHash } from '@aztec/stdlib/tx';

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

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { FieldsOf } from '@aztec/foundation/types';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { UInt64 } from '@aztec/stdlib/types';