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

package/src/debug/pxe_debug_utils.ts

@@ -0,0 +1,48 @@
+import type { NoteDao, NotesFilter } from '@aztec/stdlib/note';
+
+import type { PXE } from '../pxe.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
+
+/**
+ * Methods provided by this class might help debugging but must not be used in production.
+ * No backwards compatibility or API stability should be expected. Use at your own risk.
+ */
+export class PXEDebugUtils {
+  #pxe: PXE | undefined = undefined;
+
+  constructor(
+    private contractStore: ContractStore,
+    private noteStore: NoteStore,
+  ) {}
+
+  /**
+   * Not injected through constructor since they're are co-dependant.
+   */
+  public setPXE(pxe: PXE) {
+    this.#pxe = pxe;
+  }
+
+  /**
+   * A debugging utility to get notes based on the provided filter.
+   *
+   * Note that this should not be used in production code because the structure of notes is considered to be
+   * an implementation detail of contracts. This is only meant to be used for debugging purposes. If you need to obtain
+   * note-related information in production code, please implement a custom utility function on your contract and call
+   * that function instead (e.g. `get_balance(owner: AztecAddress) -> u128` utility function on a Token contract).
+   *
+   * @param filter - The filter to apply to the notes.
+   * @returns The requested notes.
+   */
+  public async getNotes(filter: NotesFilter): Promise<NoteDao[]> {
+    if (!this.#pxe) {
+      throw new Error('Cannot getNotes because no PXE is set');
+    }
+
+    // We need to manually trigger private state sync to have a guarantee that all the notes are available.
+    const call = await this.contractStore.getFunctionCall('sync_private_state', [], filter.contractAddress);
+    await this.#pxe.simulateUtility(call);
+
+    return this.noteStore.getNotes(filter);
+  }
+}

package/src/entrypoints/client/bundle/index.ts

@@ -1,5 +1,6 @@
-export * from '../../../pxe_service/index.js';
+export * from '../../../pxe.js';
 export * from '../../../config/index.js';
+export * from '../../../error_enriching.js';
 export * from '../../../storage/index.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../../contract_function_simulator/pxe_oracle_interface.js';
+export type { PXECreationOptions } from '../../pxe_creation_options.js';

package/src/entrypoints/client/bundle/utils.ts

@@ -1,28 +1,29 @@
-import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { BBPrivateKernelProver } from '@aztec/bb-prover/client';
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { WASMSimulator } from '@aztec/simulator/client';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
-import type { PXEServiceConfig } from '../../../config/index.js';
-import { PXEService } from '../../../pxe_service/pxe_service.js';
+import type { PXEConfig } from '../../../config/index.js';
+import { PXE } from '../../../pxe.js';
 import type { PXECreationOptions } from '../../pxe_creation_options.js';
 
 /**
- * Create and start an PXEService instance with the given AztecNode.
+ * Create and start an PXE instance with the given AztecNode.
  * If no keyStore or database is provided, it will use KeyStore and MemoryDB as default values.
- * Returns a Promise that resolves to the started PXEService instance.
+ * Returns a Promise that resolves to the started PXE instance.
  *
  * @param aztecNode - The AztecNode instance to be used by the server.
- * @param config - The PXE Service Config to use
- * @param options - (Optional) Optional information for creating an PXEService.
- * @returns A Promise that resolves to the started PXEService instance.
+ * @param config - The PXE Config to use
+ * @param options - (Optional) Optional information for creating an PXE.
+ * @returns A Promise that resolves to the started PXE instance.
  */
-export async function createPXEService(
+export async function createPXE(
   aztecNode: AztecNode,
-  config: PXEServiceConfig,
+  config: PXEConfig,
   options: PXECreationOptions = { loggers: {} },
 ) {
   const logSuffix =
@@ -38,29 +39,26 @@ export async function createPXEService(
   const configWithContracts = {
     ...config,
     l1Contracts,
-  } as PXEServiceConfig;
+  } as PXEConfig;
 
   const storeLogger = loggers.store ? loggers.store : createLogger('pxe:data:idb' + (logSuffix ? `:${logSuffix}` : ''));
 
   const store = options.store ?? (await createStore('pxe_data', configWithContracts, storeLogger));
 
-  const simulator = new WASMSimulator();
+  const simulator = options.simulator ?? new WASMSimulator();
   const proverLogger = loggers.prover
     ? loggers.prover
     : createLogger('pxe:bb:wasm:bundle' + (logSuffix ? `:${logSuffix}` : ''));
 
-  const prover = options.prover ?? new BBWASMBundlePrivateKernelProver(simulator, 16, proverLogger);
+  let prover;
+  if (options.proverOrOptions instanceof BBPrivateKernelProver) {
+    prover = options.proverOrOptions;
+  } else {
+    prover = new BBBundlePrivateKernelProver(simulator, { ...options.proverOrOptions, logger: proverLogger });
+  }
   const protocolContractsProvider = new BundledProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
-  const pxe = await PXEService.create(
-    aztecNode,
-    store,
-    prover,
-    simulator,
-    protocolContractsProvider,
-    config,
-    pxeLogger,
-  );
+  const pxe = await PXE.create(aztecNode, store, prover, simulator, protocolContractsProvider, config, pxeLogger);
   return pxe;
 }

package/src/entrypoints/client/lazy/index.ts

@@ -1,5 +1,6 @@
-export * from '../../../pxe_service/index.js';
+export * from '../../../pxe.js';
 export * from '../../../config/index.js';
 export * from '../../../storage/index.js';
+export * from '../../../error_enriching.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../../contract_function_simulator/pxe_oracle_interface.js';
+export { type PXECreationOptions } from '../../pxe_creation_options.js';

package/src/entrypoints/client/lazy/utils.ts

@@ -1,27 +1,28 @@
-import { BBWASMLazyPrivateKernelProver } from '@aztec/bb-prover/client/wasm/lazy';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { BBPrivateKernelProver } from '@aztec/bb-prover/client';
+import { BBLazyPrivateKernelProver } from '@aztec/bb-prover/client/lazy';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/indexeddb';
 import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/providers/lazy';
 import { WASMSimulator } from '@aztec/simulator/client';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
-import type { PXEServiceConfig } from '../../../config/index.js';
-import { PXEService } from '../../../pxe_service/pxe_service.js';
+import type { PXEConfig } from '../../../config/index.js';
+import { PXE } from '../../../pxe.js';
 import type { PXECreationOptions } from '../../pxe_creation_options.js';
 
 /**
- * Create and start an PXEService instance with the given AztecNode.
- * Returns a Promise that resolves to the started PXEService instance.
+ * Create and start an PXE instance with the given AztecNode.
+ * Returns a Promise that resolves to the started PXE instance.
  *
  * @param aztecNode - The AztecNode instance to be used by the server.
- * @param config - The PXE Service Config to use
+ * @param config - The PXE Config to use
  * @param
- * @returns A Promise that resolves to the started PXEService instance.
+ * @returns A Promise that resolves to the started PXE instance.
  */
-export async function createPXEService(
+export async function createPXE(
   aztecNode: AztecNode,
-  config: PXEServiceConfig,
+  config: PXEConfig,
   options: PXECreationOptions = { loggers: {} },
 ) {
   const logSuffix =
@@ -35,7 +36,7 @@ export async function createPXEService(
   const configWithContracts = {
     ...config,
     l1Contracts,
-  } as PXEServiceConfig;
+  } as PXEConfig;
 
   const loggers = options.loggers ?? {};
 
@@ -43,24 +44,20 @@ export async function createPXEService(
 
   const store = options.store ?? (await createStore('pxe_data', configWithContracts, storeLogger));
 
-  const simulator = new WASMSimulator();
+  const simulator = options.simulator ?? new WASMSimulator();
   const proverLogger = loggers.prover
     ? loggers.prover
     : createLogger('pxe:bb:wasm:bundle' + (logSuffix ? `:${logSuffix}` : ''));
 
-  const prover = options.prover ?? new BBWASMLazyPrivateKernelProver(simulator, 16, proverLogger);
-
+  let prover;
+  if (options.proverOrOptions instanceof BBPrivateKernelProver) {
+    prover = options.proverOrOptions;
+  } else {
+    prover = new BBLazyPrivateKernelProver(simulator, { ...options.proverOrOptions, logger: proverLogger });
+  }
   const protocolContractsProvider = new LazyProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
-  const pxe = await PXEService.create(
-    aztecNode,
-    store,
-    prover,
-    simulator,
-    protocolContractsProvider,
-    config,
-    pxeLogger,
-  );
+  const pxe = await PXE.create(aztecNode, store, prover, simulator, protocolContractsProvider, config, pxeLogger);
   return pxe;
 }

package/src/entrypoints/pxe_creation_options.ts

@@ -1,10 +1,13 @@
+import type { BBPrivateKernelProverOptions } from '@aztec/bb-prover/client';
 import type { Logger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { CircuitSimulator } from '@aztec/simulator/client';
 import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 
 export type PXECreationOptions = {
   loggers?: { store?: Logger; pxe?: Logger; prover?: Logger };
   useLogSuffix?: boolean | string;
-  prover?: PrivateKernelProver;
+  proverOrOptions?: PrivateKernelProver | BBPrivateKernelProverOptions;
   store?: AztecAsyncKVStore;
+  simulator?: CircuitSimulator;
 };

package/src/entrypoints/server/index.ts

@@ -1,6 +1,8 @@
-export * from '../../pxe_service/index.js';
+export * from '../../pxe.js';
 export * from '../../config/index.js';
+export * from '../../error_enriching.js';
 export * from '../../storage/index.js';
 export * from './utils.js';
-export { PXEOracleInterface } from '../../contract_function_simulator/pxe_oracle_interface.js';
+export { NoteService } from '../../notes/note_service.js';
 export { ORACLE_VERSION } from '../../oracle_version.js';
+export { type PXECreationOptions } from '../pxe_creation_options.js';

package/src/entrypoints/server/utils.ts

@@ -1,63 +1,30 @@
-import { BBNativePrivateKernelProver } from '@aztec/bb-prover/client/native';
-import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
-import { randomBytes } from '@aztec/foundation/crypto';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { BBPrivateKernelProver } from '@aztec/bb-prover/client';
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
-import {
-  type CircuitSimulator,
-  MemoryCircuitRecorder,
-  SimulatorRecorderWrapper,
-  WASMSimulator,
-} from '@aztec/simulator/client';
+import { MemoryCircuitRecorder, SimulatorRecorderWrapper, WASMSimulator } from '@aztec/simulator/client';
 import { FileCircuitRecorder } from '@aztec/simulator/testing';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
-import type { PXEServiceConfig } from '../../config/index.js';
-import { PXEService } from '../../pxe_service/pxe_service.js';
+import type { PXEConfig } from '../../config/index.js';
+import { PXE } from '../../pxe.js';
 import { PXE_DATA_SCHEMA_VERSION } from '../../storage/index.js';
 import type { PXECreationOptions } from '../pxe_creation_options.js';
 
-type PXEConfigWithoutDefaults = Omit<
-  PXEServiceConfig,
-  'l1Contracts' | 'l1ChainId' | 'l2BlockBatchSize' | 'rollupVersion'
->;
+type PXEConfigWithoutDefaults = Omit<PXEConfig, 'l1Contracts' | 'l1ChainId' | 'l2BlockBatchSize' | 'rollupVersion'>;
 
-/**
- * Create and start an PXEService instance with the given AztecNode and config.
- *
- * @param aztecNode - The AztecNode instance to be used by the server.
- * @param config - The PXE Service Config to use
- * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
- * @returns A Promise that resolves to the started PXEService instance.
- */
-export function createPXEService(
+export async function createPXE(
   aztecNode: AztecNode,
   config: PXEConfigWithoutDefaults,
   options: PXECreationOptions = { loggers: {} },
 ) {
-  const simulator = new WASMSimulator();
   const recorder = process.env.CIRCUIT_RECORD_DIR
     ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR)
     : new MemoryCircuitRecorder();
-  const simulatorWithRecorder = new SimulatorRecorderWrapper(simulator, recorder);
-  return createPXEServiceWithSimulator(aztecNode, simulatorWithRecorder, config, options);
-}
+  const simulator = new SimulatorRecorderWrapper(new WASMSimulator(), recorder);
 
-/**
- * Create and start an PXEService instance with the given AztecNode, Simulator and config.
- *
- * @param aztecNode - The AztecNode instance to be used by the server.
- * @param simulator - The Simulator to use
- * @param config - The PXE Service Config to use
- * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
- * @returns A Promise that resolves to the started PXEService instance.
- */
-export async function createPXEServiceWithSimulator(
-  aztecNode: AztecNode,
-  simulator: CircuitSimulator,
-  config: PXEConfigWithoutDefaults,
-  options: PXECreationOptions = { loggers: {} },
-) {
   const logSuffix =
     typeof options.useLogSuffix === 'boolean'
       ? options.useLogSuffix
@@ -67,7 +34,7 @@ export async function createPXEServiceWithSimulator(
   const loggers = options.loggers ?? {};
 
   const { l1ChainId, l1ContractAddresses: l1Contracts, rollupVersion } = await aztecNode.getNodeInfo();
-  const configWithContracts: PXEServiceConfig = {
+  const configWithContracts: PXEConfig = {
     ...config,
     l1Contracts,
     l1ChainId,
@@ -76,9 +43,6 @@ export async function createPXEServiceWithSimulator(
   };
 
   if (!options.store) {
-    // TODO once https://github.com/AztecProtocol/aztec-packages/issues/13656 is fixed, we can remove this and always
-    // import the lmdb-v2 version
-    const { createStore } = await import('@aztec/kv-store/lmdb-v2');
     const storeLogger = loggers.store
       ? loggers.store
       : createLogger('pxe:data:lmdb' + (logSuffix ? `:${logSuffix}` : ''));
@@ -88,11 +52,17 @@ export async function createPXEServiceWithSimulator(
     ? loggers.prover
     : createLogger('pxe:bb:native' + (logSuffix ? `:${logSuffix}` : ''));
 
-  const prover = options.prover ?? (await createProver(config, simulator, proverLogger));
+  let prover;
+  if (options.proverOrOptions instanceof BBPrivateKernelProver) {
+    prover = options.proverOrOptions;
+  } else {
+    prover = new BBBundlePrivateKernelProver(simulator, { ...options.proverOrOptions, logger: proverLogger });
+  }
+
   const protocolContractsProvider = new BundledProtocolContractsProvider();
 
   const pxeLogger = loggers.pxe ? loggers.pxe : createLogger('pxe:service' + (logSuffix ? `:${logSuffix}` : ''));
-  const pxe = await PXEService.create(
+  const pxe = await PXE.create(
     aztecNode,
     options.store,
     prover,
@@ -103,21 +73,3 @@ export async function createPXEServiceWithSimulator(
   );
   return pxe;
 }
-
-function createProver(
-  config: Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>,
-  simulator: CircuitSimulator,
-  logger?: Logger,
-) {
-  if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return new BBWASMBundlePrivateKernelProver(simulator, 16, logger);
-  } else {
-    const bbConfig = config as Required<Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> &
-      PXEServiceConfig;
-    return BBNativePrivateKernelProver.new(
-      { bbSkipCleanup: false, numConcurrentIVCVerifiers: 1, bbIVCConcurrency: 1, ...bbConfig },
-      simulator,
-      logger,
-    );
-  }
-}

package/src/{pxe_service/error_enriching.ts → error_enriching.ts}

@@ -4,18 +4,14 @@ import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type SimulationError, isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
 
-import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
+import type { ContractStore } from './storage/contract_store/contract_store.js';
 
 /**
  * Adds contract and function names to a simulation error, if they
  * can be found in the PXE database
  * @param err - The error to enrich.
  */
-export async function enrichSimulationError(
-  err: SimulationError,
-  contractDataProvider: ContractDataProvider,
-  logger: Logger,
-) {
+export async function enrichSimulationError(err: SimulationError, contractStore: ContractStore, logger: Logger) {
   // Maps contract addresses to the set of function selectors that were in error.
   // Map and Set do reference equality for their keys instead of value equality, so we store the string
   // representation to get e.g. different contract address objects with the same address value to match.
@@ -34,7 +30,7 @@ export async function enrichSimulationError(
   await Promise.all(
     [...mentionedFunctions.entries()].map(async ([contractAddress, fnSelectors]) => {
       const parsedContractAddress = AztecAddress.fromString(contractAddress);
-      const contract = await contractDataProvider.getContract(parsedContractAddress);
+      const contract = await contractStore.getContract(parsedContractAddress);
       if (contract) {
         err.enrichWithContractName(parsedContractAddress, contract.name);
         // Map from function selector to function name. It uses a stringified key for the same reason as mentionedFunctions.
@@ -68,15 +64,15 @@ export async function enrichSimulationError(
   );
 }
 
-export async function enrichPublicSimulationError(
-  err: SimulationError,
-  contractDataProvider: ContractDataProvider,
-  logger: Logger,
-) {
+export async function enrichPublicSimulationError(err: SimulationError, contractStore: ContractStore, logger: Logger) {
   const callStack = err.getCallStack();
   const originalFailingFunction = callStack[callStack.length - 1];
 
-  const artifact = await contractDataProvider.getPublicFunctionArtifact(originalFailingFunction.contractAddress);
+  if (!originalFailingFunction) {
+    throw new Error(`Original failing function not found when enriching public simulation, missing callstack`);
+  }
+
+  const artifact = await contractStore.getPublicFunctionArtifact(originalFailingFunction.contractAddress);
   if (!artifact) {
     throw new Error(
       `Artifact not found when enriching public simulation error. Contract address: ${originalFailingFunction.contractAddress}.`,
@@ -88,7 +84,7 @@ export async function enrichPublicSimulationError(
     err.setOriginalMessage(err.getOriginalMessage() + `${assertionMessage}`);
   }
 
-  const debugInfo = await contractDataProvider.getPublicFunctionDebugMetadata(originalFailingFunction.contractAddress);
+  const debugInfo = await contractStore.getPublicFunctionDebugMetadata(originalFailingFunction.contractAddress);
 
   const noirCallStack = err.getNoirCallStack();
   if (debugInfo) {
@@ -106,6 +102,6 @@ export async function enrichPublicSimulationError(
         );
       }
     }
-    await enrichSimulationError(err, contractDataProvider, logger);
+    await enrichSimulationError(err, contractStore, logger);
   }
 }

package/src/events/event_service.ts

@@ -0,0 +1,77 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EventSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
+import { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
+
+export class EventService {
+  constructor(
+    private readonly anchorBlockStore: AnchorBlockStore,
+    private readonly aztecNode: AztecNode,
+    private readonly privateEventStore: PrivateEventStore,
+  ) {}
+
+  public async deliverEvent(
+    contractAddress: AztecAddress,
+    selector: EventSelector,
+    content: Fr[],
+    eventCommitment: Fr,
+    txHash: TxHash,
+    scope: AztecAddress,
+  ): Promise<void> {
+    // While using 'latest' block number would be fine for private events since they cannot be accessed from Aztec.nr
+    // (and thus we're less concerned about being ahead of the synced block), we use the synced block number to
+    // maintain consistent behavior in the PXE. Additionally, events should never be ahead of the synced block here
+    // since `fetchTaggedLogs` only processes logs up to the synced block.
+    const [syncedBlockHeader, siloedEventCommitment, txEffect] = await Promise.all([
+      this.anchorBlockStore.getBlockHeader(),
+      siloNullifier(contractAddress, eventCommitment),
+      this.aztecNode.getTxEffect(txHash),
+    ]);
+
+    const syncedBlockNumber = syncedBlockHeader.getBlockNumber();
+
+    if (!txEffect) {
+      throw new Error(`Could not find tx effect for tx hash ${txHash}`);
+    }
+
+    if (txEffect.l2BlockNumber > syncedBlockNumber) {
+      throw new Error(`Could not find tx effect for tx hash ${txHash} as of block number ${syncedBlockNumber}`);
+    }
+
+    const eventInTx = txEffect.data.nullifiers.some(n => n.equals(siloedEventCommitment));
+    if (!eventInTx) {
+      throw new Error(
+        `Event commitment ${eventCommitment} (siloed as ${siloedEventCommitment}) is not present in tx ${txHash}`,
+      );
+    }
+
+    const [nullifierIndex] = await this.aztecNode.findLeavesIndexes(syncedBlockNumber, MerkleTreeId.NULLIFIER_TREE, [
+      siloedEventCommitment,
+    ]);
+
+    if (nullifierIndex === undefined) {
+      throw new Error(
+        `Event commitment ${eventCommitment} (siloed as ${siloedEventCommitment}) is not present on the nullifier tree at block ${syncedBlockNumber} (from tx ${txHash})`,
+      );
+    }
+
+    return this.privateEventStore.storePrivateEventLog(
+      selector,
+      content,
+      Number(nullifierIndex.data), // Index of the event commitment in the nullifier tree
+      {
+        contractAddress,
+        scope,
+        txHash,
+        l2BlockNumber: nullifierIndex.l2BlockNumber, // Block number in which the event was emitted
+        l2BlockHash: nullifierIndex.l2BlockHash, // Block hash in which the event was emitted
+      },
+    );
+  }
+}

package/src/events/index.ts

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

package/src/events/private_event_filter_validator.ts

@@ -0,0 +1,48 @@
+import type { PrivateEventFilter } from '@aztec/aztec.js/wallet';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+
+import { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
+import type { PrivateEventStoreFilter } from '../storage/private_event_store/private_event_store.js';
+
+export class PrivateEventFilterValidator {
+  constructor(private anchorBlockStore: AnchorBlockStore) {}
+
+  async validate(filter: PrivateEventFilter): Promise<PrivateEventStoreFilter> {
+    let { fromBlock, toBlock } = filter;
+
+    // Block range filters in Aztec Node are defined as closed-open intervals [fromBlock, toBlock), so
+    // we respect that convention here for consistency.
+    // We then default to [INITIAL_L2_BLOCK_NUM, latestKnownBlock + 1), ie: by default return events from
+    // the first block to the latest known block.
+    if (!fromBlock || !toBlock) {
+      const lastKnownBlock = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
+      fromBlock = fromBlock ?? BlockNumber(INITIAL_L2_BLOCK_NUM);
+      toBlock = toBlock ?? BlockNumber(lastKnownBlock + 1);
+    }
+
+    if (filter.scopes.length === 0) {
+      throw new Error('At least one scope is required to get private events');
+    }
+
+    if (fromBlock < 1) {
+      throw new Error('fromBlock must be greater than or equal to 1');
+    }
+
+    if (toBlock < 1) {
+      throw new Error('toBlock must be greater than or equal to 1');
+    }
+
+    if (fromBlock >= toBlock) {
+      throw new Error('toBlock must be strictly greater than fromBlock');
+    }
+
+    return {
+      contractAddress: filter.contractAddress,
+      scopes: filter.scopes,
+      txHash: filter.txHash,
+      toBlock,
+      fromBlock,
+    };
+  }
+}