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

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

@@ -1,64 +1,41 @@
-import { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import type { PrivateEventFilter } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { Timer } from '@aztec/foundation/timer';
-import type { SiblingPath } from '@aztec/foundation/trees';
 import { KeyStore } from '@aztec/key-store';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import { L2TipsKVStore } from '@aztec/kv-store/stores';
-import {
-  ProtocolContractAddress,
-  type ProtocolContractsProvider,
-  protocolContractNames,
-} from '@aztec/protocol-contracts';
+import { type ProtocolContractsProvider, protocolContractNames } from '@aztec/protocol-contracts';
 import type { CircuitSimulator } from '@aztec/simulator/client';
 import {
   type ContractArtifact,
   EventSelector,
   FunctionCall,
-  FunctionSelector,
   FunctionType,
-  decodeFromAbi,
   decodeFunctionSignature,
-  encodeArguments,
 } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2Block } from '@aztec/stdlib/block';
 import {
   CompleteAddress,
   type ContractClassWithId,
   type ContractInstanceWithAddress,
-  type NodeInfo,
   type PartialAddress,
   computeContractAddressFromInstance,
   getContractClassFromArtifact,
 } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
-import type { GasFees } from '@aztec/stdlib/gas';
-import { siloNullifier } from '@aztec/stdlib/hash';
-import type {
-  AztecNode,
-  EventMetadataDefinition,
-  GetContractClassLogsResponse,
-  GetPublicLogsResponse,
-  PXE,
-  PXEInfo,
-  PrivateKernelProver,
-} from '@aztec/stdlib/interfaces/client';
+import { computeProtocolNullifier, siloNullifier } from '@aztec/stdlib/hash';
+import type { AztecNode, PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 import type {
   PrivateExecutionStep,
   PrivateKernelExecutionProofOutput,
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
-import type { LogFilter } from '@aztec/stdlib/logs';
-import { computeL2ToL1MembershipWitness, getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
-import { type NotesFilter, UniqueNote } from '@aztec/stdlib/note';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type ContractOverrides,
-  type IndexedTxEffect,
+  type InTx,
   PrivateExecutionResult,
   PrivateSimulationResult,
   type ProvingTimings,
@@ -67,73 +44,78 @@ import {
   type SimulationTimings,
   Tx,
   TxExecutionRequest,
-  type TxHash,
   TxProfileResult,
   TxProvingResult,
-  type TxReceipt,
   TxSimulationResult,
   UtilitySimulationResult,
 } from '@aztec/stdlib/tx';
 
 import { inspect } from 'util';
 
-import type { PXEServiceConfig } from '../config/index.js';
-import { getPackageInfo } from '../config/package_info.js';
+import { BlockSynchronizer } from './block_synchronizer/index.js';
+import type { PXEConfig } from './config/index.js';
 import {
   ContractFunctionSimulator,
   generateSimulatedProvingResult,
-} from '../contract_function_simulator/contract_function_simulator.js';
-import { readCurrentClassId } from '../contract_function_simulator/oracle/private_execution.js';
-import { ProxiedContractDataProviderFactory } from '../contract_function_simulator/proxied_contract_data_source.js';
-import { ProxiedNodeFactory } from '../contract_function_simulator/proxied_node.js';
-import { PXEOracleInterface } from '../contract_function_simulator/pxe_oracle_interface.js';
+} from './contract_function_simulator/contract_function_simulator.js';
+import { readCurrentClassId } from './contract_function_simulator/oracle/private_execution.js';
+import { ProxiedContractStoreFactory } from './contract_function_simulator/proxied_contract_data_source.js';
+import { PXEDebugUtils } from './debug/pxe_debug_utils.js';
+import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
+import { PrivateEventFilterValidator } from './events/private_event_filter_validator.js';
 import {
   PrivateKernelExecutionProver,
   type PrivateKernelExecutionProverConfig,
-} from '../private_kernel/private_kernel_execution_prover.js';
-import { PrivateKernelOracleImpl } from '../private_kernel/private_kernel_oracle_impl.js';
-import { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
-import { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
-import { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
-import { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
-import { PrivateEventDataProvider } from '../storage/private_event_data_provider/private_event_data_provider.js';
-import { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
-import { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
-import { Synchronizer } from '../synchronizer/index.js';
-import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
+} from './private_kernel/private_kernel_execution_prover.js';
+import { PrivateKernelOracleImpl } from './private_kernel/private_kernel_oracle_impl.js';
+import { AddressStore } from './storage/address_store/address_store.js';
+import { AnchorBlockStore } from './storage/anchor_block_store/anchor_block_store.js';
+import { CapsuleStore } from './storage/capsule_store/capsule_store.js';
+import { ContractStore } from './storage/contract_store/contract_store.js';
+import { NoteStore } from './storage/note_store/note_store.js';
+import { PrivateEventStore } from './storage/private_event_store/private_event_store.js';
+import { RecipientTaggingStore } from './storage/tagging_store/recipient_tagging_store.js';
+import { SenderAddressBookStore } from './storage/tagging_store/sender_address_book_store.js';
+import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store.js';
+
+export type PackedPrivateEvent = InTx & {
+  packedEvent: Fr[];
+  eventSelector: EventSelector;
+};
 
 /**
- * A Private eXecution Environment (PXE) implementation.
+ * Private eXecution Environment (PXE) is a library used by wallets to simulate private phase of transactions and to
+ * manage private state of users.
  */
-export class PXEService implements PXE {
-  #nodeInfo?: NodeInfo;
-
+export class PXE {
   private constructor(
     private node: AztecNode,
-    private synchronizer: Synchronizer,
+    private blockStateSynchronizer: BlockSynchronizer,
     private keyStore: KeyStore,
-    private contractDataProvider: ContractDataProvider,
-    private noteDataProvider: NoteDataProvider,
-    private capsuleDataProvider: CapsuleDataProvider,
-    private syncDataProvider: SyncDataProvider,
-    private taggingDataProvider: TaggingDataProvider,
-    private addressDataProvider: AddressDataProvider,
-    private privateEventDataProvider: PrivateEventDataProvider,
+    private contractStore: ContractStore,
+    private noteStore: NoteStore,
+    private capsuleStore: CapsuleStore,
+    private anchorBlockStore: AnchorBlockStore,
+    private senderTaggingStore: SenderTaggingStore,
+    private senderAddressBookStore: SenderAddressBookStore,
+    private recipientTaggingStore: RecipientTaggingStore,
+    private addressStore: AddressStore,
+    private privateEventStore: PrivateEventStore,
     private simulator: CircuitSimulator,
-    private packageVersion: string,
     private proverEnabled: boolean,
     private proofCreator: PrivateKernelProver,
     private protocolContractsProvider: ProtocolContractsProvider,
     private log: Logger,
     private jobQueue: SerialQueue,
+    public debug: PXEDebugUtils,
   ) {}
 
   /**
-   * Creates an instance of a PXE Service by instantiating all the necessary data providers and services.
+   * Creates an instance of a PXE by instantiating all the necessary data providers and services.
    * Also triggers the registration of the protocol contracts and makes sure the provided node
    * can be contacted.
    *
-   * @returns A promise that resolves PXE service is ready to be used.
+   * @returns A promise that resolves PXE is ready to be used.
    */
   public static async create(
     node: AztecNode,
@@ -141,7 +123,7 @@ export class PXEService implements PXE {
     proofCreator: PrivateKernelProver,
     simulator: CircuitSimulator,
     protocolContractsProvider: ProtocolContractsProvider,
-    config: PXEServiceConfig,
+    config: PXEConfig,
     loggerOrSuffix?: string | Logger,
   ) {
     const log =
@@ -149,126 +131,83 @@ export class PXEService implements PXE {
         ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`)
         : loggerOrSuffix;
 
-    const packageVersion = getPackageInfo().version;
     const proverEnabled = !!config.proverEnabled;
-    const addressDataProvider = new AddressDataProvider(store);
-    const privateEventDataProvider = new PrivateEventDataProvider(store);
-    const contractDataProvider = new ContractDataProvider(store);
-    const noteDataProvider = await NoteDataProvider.create(store);
-    const syncDataProvider = new SyncDataProvider(store);
-    const taggingDataProvider = new TaggingDataProvider(store);
-    const capsuleDataProvider = new CapsuleDataProvider(store);
+    const addressStore = new AddressStore(store);
+    const privateEventStore = new PrivateEventStore(store);
+    const contractStore = new ContractStore(store);
+    const noteStore = await NoteStore.create(store);
+    const anchorBlockStore = new AnchorBlockStore(store);
+    const senderTaggingStore = new SenderTaggingStore(store);
+    const senderAddressBookStore = new SenderAddressBookStore(store);
+    const recipientTaggingStore = new RecipientTaggingStore(store);
+    const capsuleStore = new CapsuleStore(store);
     const keyStore = new KeyStore(store);
     const tipsStore = new L2TipsKVStore(store, 'pxe');
-    const synchronizer = new Synchronizer(
+    const synchronizer = new BlockSynchronizer(
       node,
-      syncDataProvider,
-      noteDataProvider,
-      taggingDataProvider,
+      anchorBlockStore,
+      noteStore,
+      privateEventStore,
       tipsStore,
       config,
       loggerOrSuffix,
     );
 
+    const debugUtils = new PXEDebugUtils(contractStore, noteStore);
+
     const jobQueue = new SerialQueue();
 
-    const pxeService = new PXEService(
+    const pxe = new PXE(
       node,
       synchronizer,
       keyStore,
-      contractDataProvider,
-      noteDataProvider,
-      capsuleDataProvider,
-      syncDataProvider,
-      taggingDataProvider,
-      addressDataProvider,
-      privateEventDataProvider,
+      contractStore,
+      noteStore,
+      capsuleStore,
+      anchorBlockStore,
+      senderTaggingStore,
+      senderAddressBookStore,
+      recipientTaggingStore,
+      addressStore,
+      privateEventStore,
       simulator,
-      packageVersion,
       proverEnabled,
       proofCreator,
       protocolContractsProvider,
       log,
       jobQueue,
+      debugUtils,
     );
 
-    pxeService.jobQueue.start();
+    debugUtils.setPXE(pxe);
 
-    await pxeService.#registerProtocolContracts();
-    const info = await pxeService.getNodeInfo();
-    log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.rollupVersion}`);
-    return pxeService;
-  }
+    pxe.jobQueue.start();
 
-  // Aztec node proxy methods
-
-  public isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
-    return this.node.isL1ToL2MessageSynced(l1ToL2Message);
-  }
-
-  public async getL2ToL1MembershipWitness(
-    blockNumber: number,
-    l2Tol1Message: Fr,
-  ): Promise<[bigint, SiblingPath<number>]> {
-    const result = await computeL2ToL1MembershipWitness(this.node, blockNumber, l2Tol1Message);
-    if (!result) {
-      throw new Error(`L2 to L1 message not found in block ${blockNumber}`);
-    }
-    return [result.leafIndex, result.siblingPath];
-  }
-
-  public getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.node.getTxReceipt(txHash);
-  }
-
-  public getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined> {
-    return this.node.getTxEffect(txHash);
-  }
-
-  public getBlockNumber(): Promise<number> {
-    return this.node.getBlockNumber();
-  }
-
-  public getProvenBlockNumber(): Promise<number> {
-    return this.node.getProvenBlockNumber();
-  }
-
-  public getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
-    return this.node.getPublicLogs(filter);
-  }
-
-  public getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
-    return this.node.getContractClassLogs(filter);
-  }
-
-  public getPublicStorageAt(contract: AztecAddress, slot: Fr) {
-    return this.node.getPublicStorageAt('latest', contract, slot);
-  }
-
-  public async getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
-    return await getNonNullifiedL1ToL2MessageWitness(this.node, contractAddress, messageHash, secret);
+    await pxe.#registerProtocolContracts();
+    const info = await node.getNodeInfo();
+    log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.rollupVersion}`);
+    return pxe;
   }
 
   // Internal methods
 
   #getSimulatorForTx(overrides?: { contracts?: ContractOverrides }) {
-    const pxeOracleInterface = new PXEOracleInterface(
-      ProxiedNodeFactory.create(this.node),
+    const proxyContractStore = ProxiedContractStoreFactory.create(this.contractStore, overrides?.contracts);
+
+    return new ContractFunctionSimulator(
+      proxyContractStore,
+      this.noteStore,
       this.keyStore,
-      ProxiedContractDataProviderFactory.create(this.contractDataProvider, overrides?.contracts),
-      this.noteDataProvider,
-      this.capsuleDataProvider,
-      this.syncDataProvider,
-      this.taggingDataProvider,
-      this.addressDataProvider,
-      this.privateEventDataProvider,
-      this.log,
+      this.addressStore,
+      this.node,
+      this.anchorBlockStore,
+      this.senderTaggingStore,
+      this.recipientTaggingStore,
+      this.senderAddressBookStore,
+      this.capsuleStore,
+      this.privateEventStore,
+      this.simulator,
     );
-    return new ContractFunctionSimulator(pxeOracleInterface, this.simulator);
   }
 
   #contextualizeError(err: Error, ...context: string[]): Error {
@@ -307,8 +246,8 @@ export class PXEService implements PXE {
     for (const name of protocolContractNames) {
       const { address, contractClass, instance, artifact } =
         await this.protocolContractsProvider.getProtocolContractArtifact(name);
-      await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
-      await this.contractDataProvider.addContractInstance(instance);
+      await this.contractStore.addContractArtifact(contractClass.id, artifact);
+      await this.contractStore.addContractInstance(instance);
       registered[name] = address.toString();
     }
     this.log.verbose(`Registered protocol contracts in pxe`, registered);
@@ -327,30 +266,6 @@ export class PXEService implements PXE {
     return !!(await this.node.getNullifierMembershipWitness('latest', initNullifier));
   }
 
-  async #getFunctionCall(functionName: string, args: any[], to: AztecAddress): Promise<FunctionCall> {
-    const contract = await this.contractDataProvider.getContract(to);
-    if (!contract) {
-      throw new Error(
-        `Unknown contract ${to}: add it to PXE Service by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/reference/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`,
-      );
-    }
-
-    const functionDao = contract.functions.find(f => f.name === functionName);
-    if (!functionDao) {
-      throw new Error(`Unknown function ${functionName} in contract ${contract.name}.`);
-    }
-
-    return {
-      name: functionDao.name,
-      args: encodeArguments(functionDao, args),
-      selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
-      type: functionDao.functionType,
-      to,
-      isStatic: functionDao.isStatic,
-      returnTypes: functionDao.returnTypes,
-    };
-  }
-
   // Executes the entrypoint private function, as well as all nested private
   // functions that might arise.
   async #executePrivate(
@@ -361,11 +276,14 @@ export class PXEService implements PXE {
     const { origin: contractAddress, functionSelector } = txRequest;
 
     try {
+      const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+
       const result = await contractFunctionSimulator.run(
         txRequest,
         contractAddress,
         functionSelector,
         undefined,
+        anchorBlockHeader,
         // The sender for tags is set by contracts, typically by an account
         // contract entrypoint
         undefined, // senderForTags
@@ -375,7 +293,7 @@ export class PXEService implements PXE {
       return result;
     } catch (err) {
       if (err instanceof SimulationError) {
-        await enrichSimulationError(err, this.contractDataProvider, this.log);
+        await enrichSimulationError(err, this.contractStore, this.log);
       }
       throw err;
     }
@@ -397,10 +315,11 @@ export class PXEService implements PXE {
     scopes?: AztecAddress[],
   ) {
     try {
-      return contractFunctionSimulator.runUtility(call, authWitnesses ?? [], scopes);
+      const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+      return contractFunctionSimulator.runUtility(call, authWitnesses ?? [], anchorBlockHeader, scopes);
     } catch (err) {
       if (err instanceof SimulationError) {
-        await enrichSimulationError(err, this.contractDataProvider, this.log);
+        await enrichSimulationError(err, this.contractStore, this.log);
       }
       throw err;
     }
@@ -424,7 +343,7 @@ export class PXEService implements PXE {
     } catch (err) {
       if (err instanceof SimulationError) {
         try {
-          await enrichPublicSimulationError(err, this.contractDataProvider, this.log);
+          await enrichPublicSimulationError(err, this.contractStore, this.log);
         } catch (enrichErr) {
           this.log.error(`Failed to enrich public simulation error: ${enrichErr}`);
         }
@@ -442,7 +361,7 @@ export class PXEService implements PXE {
    * @param proofCreator - The proof creator to use for proving the execution.
    * @param privateExecutionResult - The result of the private execution
    * @param config - The configuration for the kernel execution prover.
-   * @returns An object that contains the output of the kernel execution, including the ClientIvcProof if proving is enabled.
+   * @returns An object that contains the output of the kernel execution, including the ChonkProof if proving is enabled.
    */
   async #prove(
     txExecutionRequest: TxExecutionRequest,
@@ -450,8 +369,13 @@ export class PXEService implements PXE {
     privateExecutionResult: PrivateExecutionResult,
     config: PrivateKernelExecutionProverConfig,
   ): Promise<PrivateKernelExecutionProofOutput<PrivateKernelTailCircuitPublicInputs>> {
-    const block = privateExecutionResult.getSimulationBlockNumber();
-    const kernelOracle = new PrivateKernelOracleImpl(this.contractDataProvider, this.keyStore, this.node, block);
+    const simulationAnchorBlock = privateExecutionResult.getSimulationAnchorBlockNumber();
+    const kernelOracle = new PrivateKernelOracleImpl(
+      this.contractStore,
+      this.keyStore,
+      this.node,
+      simulationAnchorBlock,
+    );
     const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled);
     this.log.debug(`Executing kernel trace prover (${JSON.stringify(config)})...`);
     return await kernelTraceProver.proveWithKernels(txExecutionRequest.toTxRequest(), privateExecutionResult, config);
@@ -459,24 +383,24 @@ export class PXEService implements PXE {
 
   // Public API
 
-  /** Returns an estimate of the db size in bytes. */
-  public async estimateDbSize() {
-    const treeRootsSize = Object.keys(MerkleTreeId).length * Fr.SIZE_IN_BYTES;
-    const dbSizes = await Promise.all([
-      this.addressDataProvider.getSize(),
-      this.capsuleDataProvider.getSize(),
-      this.contractDataProvider.getSize(),
-      this.noteDataProvider.getSize(),
-      this.syncDataProvider.getSize(),
-      this.taggingDataProvider.getSize(),
-    ]);
-    return [...dbSizes, treeRootsSize].reduce((sum, size) => sum + size, 0);
-  }
-
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return this.contractDataProvider.getContractInstance(address);
+    return this.contractStore.getContractInstance(address);
   }
 
+  /**
+   * Returns the contract class metadata given a contract class id.
+   * The metadata consists of its contract class, whether it has been publicly registered, and its artifact.
+   * @remark - it queries the node to check whether the contract class with the given id has been publicly registered.
+   * @param id - Identifier of the class.
+   * @param includeArtifact - Identifier of the class.
+   * @returns - It returns the contract class metadata, with the artifact field being optional, and will only be returned if true is passed in
+   * for `includeArtifact`
+   * TODO(@spalladino): The PXE actually holds artifacts and not classes, what should we return? Also,
+   * should the pxe query the node for contract public info, and merge it with its own definitions?
+   * TODO(@spalladino): This method is strictly needed to decide whether to publicly register a class or not
+   * during a public deployment. We probably want a nicer and more general API for this, but it'll have to
+   * do for the time being.
+   */
   public async getContractClassMetadata(
     id: Fr,
     includeArtifact: boolean = false,
@@ -485,7 +409,7 @@ export class PXEService implements PXE {
     isContractClassPubliclyRegistered: boolean;
     artifact: ContractArtifact | undefined;
   }> {
-    const artifact = await this.contractDataProvider.getContractArtifact(id);
+    const artifact = await this.contractStore.getContractArtifact(id);
     if (!artifact) {
       this.log.warn(`No artifact found for contract class ${id.toString()} when looking for its metadata`);
     }
@@ -497,6 +421,17 @@ export class PXEService implements PXE {
     };
   }
 
+  /**
+   * Returns the contract metadata given an address.
+   * The metadata consists of its contract instance, which includes the contract class identifier,
+   * initialization hash, deployment salt, and public keys hash; whether the contract instance has been initialized;
+   * and whether the contract instance with the given address has been publicly deployed.
+   * @remark - it queries the node to check whether the contract instance has been initialized / publicly deployed through a node.
+   * This query is not dependent on the PXE.
+   * @param address - The address that the contract instance resides at.
+   * @returns - It returns the contract metadata
+   * TODO(@spalladino): Should we return the public keys in plain as well here?
+   */
   public async getContractMetadata(address: AztecAddress): Promise<{
     contractInstance: ContractInstanceWithAddress | undefined;
     isContractInitialized: boolean;
@@ -504,7 +439,7 @@ export class PXEService implements PXE {
   }> {
     let instance;
     try {
-      instance = await this.contractDataProvider.getContractInstance(address);
+      instance = await this.contractStore.getContractInstance(address);
     } catch {
       this.log.warn(`No instance found for contract ${address.toString()} when looking for its metadata`);
     }
@@ -515,6 +450,16 @@ export class PXEService implements PXE {
     };
   }
 
+  /**
+   * Registers a user account in PXE given its master encryption private key.
+   * Once a new account is registered, the PXE will trial-decrypt all published notes on
+   * the chain and store those that correspond to the registered account. Will do nothing if the
+   * account is already registered.
+   *
+   * @param secretKey - Secret key of the corresponding user master public key.
+   * @param partialAddress - The partial address of the account contract corresponding to the account being registered.
+   * @returns The complete address of the account.
+   */
   public async registerAccount(secretKey: Fr, partialAddress: PartialAddress): Promise<CompleteAddress> {
     const accounts = await this.keyStore.getAccounts();
     const accountCompleteAddress = await this.keyStore.addAccount(secretKey, partialAddress);
@@ -526,46 +471,68 @@ export class PXEService implements PXE {
       this.log.debug(`Registered account\n ${accountCompleteAddress.toReadableString()}`);
     }
 
-    await this.addressDataProvider.addCompleteAddress(accountCompleteAddress);
-    await this.noteDataProvider.addScope(accountCompleteAddress.address);
+    await this.addressStore.addCompleteAddress(accountCompleteAddress);
+    await this.noteStore.addScope(accountCompleteAddress.address);
     return accountCompleteAddress;
   }
 
-  public async registerSender(address: AztecAddress): Promise<AztecAddress> {
+  /**
+   * Registers a sender in this PXE.
+   *
+   * After registering a new sender, the PXE will sync private logs that are tagged with this sender's address.
+   * Will do nothing if the address is already registered.
+   *
+   * @param sender - Address of the sender to register.
+   * @returns The address of the sender.
+   * TODO: It's strange that we return the address here and I (benesjan) think we should drop the return value.
+   */
+  public async registerSender(sender: AztecAddress): Promise<AztecAddress> {
     const accounts = await this.keyStore.getAccounts();
-    if (accounts.includes(address)) {
-      this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
-      return address;
+    if (accounts.includes(sender)) {
+      this.log.info(`Sender:\n "${sender.toString()}"\n already registered.`);
+      return sender;
     }
 
-    const wasAdded = await this.taggingDataProvider.addSenderAddress(address);
+    const wasAdded = await this.senderAddressBookStore.addSender(sender);
 
     if (wasAdded) {
-      this.log.info(`Added sender:\n ${address.toString()}`);
+      this.log.info(`Added sender:\n ${sender.toString()}`);
     } else {
-      this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
+      this.log.info(`Sender:\n "${sender.toString()}"\n already registered.`);
     }
 
-    return address;
+    return sender;
   }
 
+  /**
+   * Retrieves senders registered in this PXE.
+   * @returns Senders registered in this PXE.
+   */
   public getSenders(): Promise<AztecAddress[]> {
-    return this.taggingDataProvider.getSenderAddresses();
+    return this.senderAddressBookStore.getSenders();
   }
 
-  public async removeSender(address: AztecAddress): Promise<void> {
-    const wasRemoved = await this.taggingDataProvider.removeSenderAddress(address);
+  /**
+   * Removes a sender registered in this PXE.
+   * @param sender - The address of the sender to remove.
+   */
+  public async removeSender(sender: AztecAddress): Promise<void> {
+    const wasRemoved = await this.senderAddressBookStore.removeSender(sender);
 
     if (wasRemoved) {
-      this.log.info(`Removed sender:\n ${address.toString()}`);
+      this.log.info(`Removed sender:\n ${sender.toString()}`);
     } else {
-      this.log.info(`Sender:\n "${address.toString()}"\n not in address book.`);
+      this.log.info(`Sender:\n "${sender.toString()}"\n not registered in PXE.`);
     }
   }
 
+  /**
+   * Retrieves the user accounts registered on this PXE.
+   * @returns An array of the accounts registered on this PXE.
+   */
   public async getRegisteredAccounts(): Promise<CompleteAddress[]> {
     // Get complete addresses of both the recipients and the accounts
-    const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
+    const completeAddresses = await this.addressStore.getCompleteAddresses();
     // Filter out the addresses not corresponding to accounts
     const accounts = await this.keyStore.getAccounts();
     return completeAddresses.filter(completeAddress =>
@@ -573,12 +540,25 @@ export class PXEService implements PXE {
     );
   }
 
+  /**
+   * Registers a contract class in the PXE without registering any associated contract instance with it.
+   *
+   * @param artifact - The build artifact for the contract class.
+   */
   public async registerContractClass(artifact: ContractArtifact): Promise<void> {
     const { id: contractClassId } = await getContractClassFromArtifact(artifact);
-    await this.contractDataProvider.addContractArtifact(contractClassId, artifact);
+    await this.contractStore.addContractArtifact(contractClassId, artifact);
     this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
   }
 
+  /**
+   * Adds deployed contracts to the PXE. Deployed contract information is used to access the
+   * contract code when simulating local transactions. This is automatically called by aztec.js when
+   * deploying a contract. Dapps that wish to interact with contracts already deployed should register
+   * these contracts in their users' PXE through this method.
+   *
+   * @param contract - A contract instance to register, with an optional artifact which can be omitted if the contract class has already been registered.
+   */
   public async registerContract(contract: { instance: ContractInstanceWithAddress; artifact?: ContractArtifact }) {
     const { instance } = contract;
     let { artifact } = contract;
@@ -596,7 +576,7 @@ export class PXEService implements PXE {
       if (!computedAddress.equals(instance.address)) {
         throw new Error('Added a contract in which the address does not match the contract instance.');
       }
-      await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
+      await this.contractStore.addContractArtifact(contractClass.id, artifact);
 
       const publicFunctionSignatures = artifact.functions
         .filter(fn => fn.functionType === FunctionType.PUBLIC)
@@ -604,7 +584,7 @@ export class PXEService implements PXE {
       await this.node.registerContractFunctionSignatures(publicFunctionSignatures);
     } else {
       // Otherwise, make sure there is an artifact already registered for that class id
-      artifact = await this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
+      artifact = await this.contractStore.getContractArtifact(instance.currentContractClassId);
       if (!artifact) {
         throw new Error(
           `Artifact not found when registering an instance. Contract class: ${instance.currentContractClassId}.`,
@@ -612,24 +592,33 @@ export class PXEService implements PXE {
       }
     }
 
-    await this.contractDataProvider.addContractInstance(instance);
+    await this.contractStore.addContractInstance(instance);
     this.log.info(
       `Added contract ${artifact.name} at ${instance.address.toString()} with class ${instance.currentContractClassId}`,
     );
   }
 
+  /**
+   * Updates a deployed contract in the PXE. This is used to update the contract artifact when
+   * an update has happened, so the new code can be used in the simulation of local transactions.
+   * This is called by aztec.js when instantiating a contract in a given address with a mismatching artifact.
+   * @param contractAddress - The address of the contract to update.
+   * @param artifact - The updated artifact for the contract.
+   * @throws If the artifact's contract class is not found in the PXE or if the contract class is different from
+   * the current one (current one from the point of view of the node to which the PXE is connected).
+   */
   public updateContract(contractAddress: AztecAddress, artifact: ContractArtifact): Promise<void> {
     // We disable concurrently updating contracts to avoid concurrently syncing with the node, or changing a contract's
     // class while we're simulating it.
     return this.#putInJobQueue(async () => {
-      const currentInstance = await this.contractDataProvider.getContractInstance(contractAddress);
+      const currentInstance = await this.contractStore.getContractInstance(contractAddress);
       if (!currentInstance) {
         throw new Error(`Instance not found when updating a contract. Contract address: ${contractAddress}.`);
       }
       const contractClass = await getContractClassFromArtifact(artifact);
-      await this.synchronizer.sync();
+      await this.blockStateSynchronizer.sync();
 
-      const header = await this.syncDataProvider.getBlockHeader();
+      const header = await this.anchorBlockStore.getBlockHeader();
 
       const currentClassId = await readCurrentClassId(
         contractAddress,
@@ -642,7 +631,7 @@ export class PXEService implements PXE {
         throw new Error('Could not update contract to a class different from the current one.');
       }
 
-      await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
+      await this.contractStore.addContractArtifact(contractClass.id, artifact);
 
       const publicFunctionSignatures = artifact.functions
         .filter(fn => fn.functionType === FunctionType.PUBLIC)
@@ -650,72 +639,44 @@ export class PXEService implements PXE {
       await this.node.registerContractFunctionSignatures(publicFunctionSignatures);
 
       currentInstance.currentContractClassId = contractClass.id;
-      await this.contractDataProvider.addContractInstance(currentInstance);
+      await this.contractStore.addContractInstance(currentInstance);
       this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
     });
   }
 
+  /**
+   * Retrieves the addresses of contracts added to this PXE.
+   * @returns An array of contracts addresses registered on this PXE.
+   */
   public getContracts(): Promise<AztecAddress[]> {
-    return this.contractDataProvider.getContractsAddresses();
+    return this.contractStore.getContractsAddresses();
   }
 
-  public async getNotes(filter: NotesFilter): Promise<UniqueNote[]> {
-    // We need to manually trigger private state sync to have a guarantee that all the events are available.
-    await this.simulateUtility('sync_private_state', [], filter.contractAddress);
-
-    const noteDaos = await this.noteDataProvider.getNotes(filter);
-
-    const extendedNotes = noteDaos.map(async dao => {
-      let recipient = filter.recipient;
-      if (recipient === undefined) {
-        const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
-        const completeAddressIndex = completeAddresses.findIndex(completeAddress =>
-          completeAddress.address.equals(dao.recipient),
-        );
-        const completeAddress = completeAddresses[completeAddressIndex];
-        if (completeAddress === undefined) {
-          throw new Error(`Cannot find complete address for recipient ${dao.recipient.toString()}`);
-        }
-        recipient = completeAddress.address;
-      }
-      return new UniqueNote(dao.note, recipient, dao.contractAddress, dao.storageSlot, dao.txHash, dao.noteNonce);
-    });
-    return Promise.all(extendedNotes);
-  }
-
-  public async getBlock(blockNumber: number): Promise<L2Block | undefined> {
-    // If a negative block number is provided the current block number is fetched.
-    if (blockNumber < 0) {
-      blockNumber = await this.node.getBlockNumber();
-    }
-    return await this.node.getBlock(blockNumber);
-  }
-
-  public async getCurrentBaseFees(): Promise<GasFees> {
-    return await this.node.getCurrentBaseFees();
-  }
-
-  public proveTx(
-    txRequest: TxExecutionRequest,
-    privateExecutionResult?: PrivateExecutionResult,
-  ): Promise<TxProvingResult> {
+  /**
+   * Proves the private portion of a simulated transaction, ready to send to the network
+   * (where validators prove the public portion).
+   *
+   * @param txRequest - An authenticated tx request ready for proving
+   * @returns A result containing the proof and public inputs of the tail circuit.
+   * @throws If contract code not found, or public simulation reverts.
+   * Also throws if simulatePublic is true and public simulation reverts.
+   */
+  public proveTx(txRequest: TxExecutionRequest): Promise<TxProvingResult> {
+    let privateExecutionResult: PrivateExecutionResult;
     // We disable proving concurrently mostly out of caution, since it accesses some of our stores. Proving is so
     // computationally demanding that it'd be rare for someone to try to do it concurrently regardless.
     return this.#putInJobQueue(async () => {
       const totalTimer = new Timer();
       try {
-        let syncTime: number | undefined;
-        let contractFunctionSimulator: ContractFunctionSimulator | undefined;
-        if (!privateExecutionResult) {
-          const syncTimer = new Timer();
-          await this.synchronizer.sync();
-          syncTime = syncTimer.ms();
-          contractFunctionSimulator = this.#getSimulatorForTx();
-          privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
-        }
+        const syncTimer = new Timer();
+        await this.blockStateSynchronizer.sync();
+        const syncTime = syncTimer.ms();
+        const contractFunctionSimulator = this.#getSimulatorForTx();
+        privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
+
         const {
           publicInputs,
-          clientIvcProof,
+          chonkProof,
           executionSteps,
           timings: { proving } = {},
         } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
@@ -742,16 +703,46 @@ export class PXEService implements PXE {
         };
 
         this.log.debug(`Proving completed in ${totalTime}ms`, { timings });
-        return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!, {
+
+        const txProvingResult = new TxProvingResult(privateExecutionResult, publicInputs, chonkProof!, {
           timings,
           nodeRPCCalls: contractFunctionSimulator?.getStats().nodeRPCCalls,
         });
+
+        // While not strictly necessary to store tagging cache contents in the DB since we sync tagging indexes from
+        // chain before sending new logs, the sync can only see logs already included in blocks. If we send another
+        // transaction before this one is included in a block from this PXE, and that transaction contains a log with
+        // a tag derived from the same secret, we would reuse the tag and the transactions would be linked. Hence
+        // storing the tags here prevents linkage of txs sent from the same PXE.
+        const preTagsUsedInTheTx = privateExecutionResult.entrypoint.preTags;
+        if (preTagsUsedInTheTx.length > 0) {
+          // TODO(benesjan): The following is an expensive operation. Figure out a way to avoid it.
+          const txHash = (await txProvingResult.toTx()).txHash;
+
+          await this.senderTaggingStore.storePendingIndexes(preTagsUsedInTheTx, txHash);
+          this.log.debug(`Stored used pre-tags as sender for the tx`, {
+            preTagsUsedInTheTx,
+          });
+        } else {
+          this.log.debug(`No pre-tags used in the tx`);
+        }
+
+        return txProvingResult;
       } catch (err: any) {
         throw this.#contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
       }
     });
   }
 
+  /**
+   * Profiles a transaction, reporting gate counts (unless disabled) and returns an execution trace.
+   *
+   * @param txRequest - An authenticated tx request ready for simulation
+   * @param msgSender - (Optional) The message sender to use for the simulation.
+   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
+   * @returns A trace of the program execution with gate counts.
+   * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
+   */
   public profileTx(
     txRequest: TxExecutionRequest,
     profileMode: 'full' | 'execution-steps' | 'gates',
@@ -774,7 +765,7 @@ export class PXEService implements PXE {
           txInfo,
         );
         const syncTimer = new Timer();
-        await this.synchronizer.sync();
+        await this.blockStateSynchronizer.sync();
         const syncTime = syncTimer.ms();
 
         const contractFunctionSimulator = this.#getSimulatorForTx();
@@ -824,7 +815,29 @@ export class PXEService implements PXE {
     });
   }
 
-  // TODO(#7456) Prevent msgSender being defined here for the first call
+  /**
+   * Simulates a transaction based on the provided preauthenticated execution request.
+   * This will run a local simulation of private execution (and optionally of public as well), run the
+   * kernel circuits to ensure adherence to protocol rules (without generating a proof), and return the
+   * simulation results .
+   *
+   *
+   * Note that this is used with `ContractFunctionInteraction::simulateTx` to bypass certain checks.
+   * In that case, the transaction returned is only potentially ready to be sent to the network for execution.
+   *
+   *
+   * @param txRequest - An authenticated tx request ready for simulation
+   * @param simulatePublic - Whether to simulate the public part of the transaction.
+   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
+   * @param skipFeeEnforcement - (Optional) If false, fees are enforced.
+   * @param overrides - (Optional) State overrides for the simulation, such as msgSender, contract instances and artifacts.
+   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will default to all.
+   * @returns A simulated transaction result object that includes public and private return values.
+   * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
+   * Also throws if simulatePublic is true and public simulation reverts.
+   *
+   * TODO(#7456) Prevent msgSender being defined here for the first call
+   */
   public simulateTx(
     txRequest: TxExecutionRequest,
     simulatePublic: boolean,
@@ -852,7 +865,7 @@ export class PXEService implements PXE {
           txInfo,
         );
         const syncTimer = new Timer();
-        await this.synchronizer.sync();
+        await this.blockStateSynchronizer.sync();
         const syncTime = syncTimer.ms();
 
         const contractFunctionSimulator = this.#getSimulatorForTx(overrides);
@@ -869,15 +882,14 @@ export class PXEService implements PXE {
 
         if (skipKernels) {
           // According to the protocol rules, the nonce generator for the note hashes
-          // can either be the first nullifier in the tx or the hash of the initial tx request
-          // if there are none.
+          // can either be the first nullifier in the tx or the protocol nullifier if there are none.
           const nonceGenerator = privateExecutionResult.firstNullifier.equals(Fr.ZERO)
-            ? await txRequest.toTxRequest().hash()
+            ? await computeProtocolNullifier(await txRequest.toTxRequest().hash())
             : privateExecutionResult.firstNullifier;
           ({ publicInputs, executionSteps } = await generateSimulatedProvingResult(
             privateExecutionResult,
             nonceGenerator,
-            this.contractDataProvider,
+            this.contractStore,
           ));
         } else {
           // Kernel logic, plus proving of all private functions and kernels.
@@ -961,25 +973,18 @@ export class PXEService implements PXE {
     });
   }
 
-  public async sendTx(tx: Tx): Promise<TxHash> {
-    const txHash = tx.getTxHash();
-    if (await this.node.getTxEffect(txHash)) {
-      throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
-    }
-    this.log.debug(`Sending transaction ${txHash}`);
-    await this.node.sendTx(tx).catch(err => {
-      throw this.#contextualizeError(err, inspect(tx));
-    });
-    this.log.info(`Sent transaction ${txHash}`);
-    return txHash;
-  }
-
+  /**
+   * Simulate the execution of a contract utility function.
+   *
+   * @param call - The function call containing the function details, arguments, and target contract address.
+   * @param authwits - (Optional) The authentication witnesses required for the function call.
+   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will
+   * default to all.
+   * @returns The result of the utility function call, structured based on the function ABI.
+   */
   public simulateUtility(
-    functionName: string,
-    args: any[],
-    to: AztecAddress,
+    call: FunctionCall,
     authwits?: AuthWitness[],
-    _from?: AztecAddress,
     scopes?: AztecAddress[],
   ): Promise<UtilitySimulationResult> {
     // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
@@ -989,23 +994,21 @@ export class PXEService implements PXE {
       try {
         const totalTimer = new Timer();
         const syncTimer = new Timer();
-        await this.synchronizer.sync();
+        await this.blockStateSynchronizer.sync();
         const syncTime = syncTimer.ms();
-        // TODO - Should check if `from` has the permission to call the view function.
-        const functionCall = await this.#getFunctionCall(functionName, args, to);
         const functionTimer = new Timer();
         const contractFunctionSimulator = this.#getSimulatorForTx();
-        const executionResult = await this.#simulateUtility(
-          contractFunctionSimulator,
-          functionCall,
-          authwits ?? [],
-          scopes,
+
+        await this.contractStore.syncPrivateState(call.to, call.selector, privateSyncCall =>
+          this.#simulateUtility(contractFunctionSimulator, privateSyncCall),
         );
+
+        const executionResult = await this.#simulateUtility(contractFunctionSimulator, call, authwits ?? [], scopes);
         const functionTime = functionTimer.ms();
 
         const totalTime = totalTimer.ms();
 
-        const perFunction = [{ functionName, time: functionTime }];
+        const perFunction = [{ functionName: call.name, time: functionTime }];
 
         const timings: SimulationTimings = {
           total: totalTime,
@@ -1017,118 +1020,54 @@ export class PXEService implements PXE {
         const simulationStats = contractFunctionSimulator.getStats();
         return { result: executionResult, stats: { timings, nodeRPCCalls: simulationStats.nodeRPCCalls } };
       } catch (err: any) {
+        const { to, name, args } = call;
         const stringifiedArgs = args.map(arg => arg.toString()).join(', ');
         throw this.#contextualizeError(
           err,
-          `simulateUtility ${to}:${functionName}(${stringifiedArgs})`,
+          `simulateUtility ${to}:${name}(${stringifiedArgs})`,
           `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
         );
       }
     });
   }
 
-  public async getNodeInfo(): Promise<NodeInfo> {
-    // This assumes we're connected to a single node, so we cache the info to avoid repeated calls.
-    // Load balancers and a myriad other configurations can break this assumption, so review this!
-    // Temporary measure to avoid hammering full nodes with requests on testnet.
-    if (!this.#nodeInfo) {
-      const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses] =
-        await Promise.all([
-          this.node.getNodeVersion(),
-          this.node.getVersion(),
-          this.node.getChainId(),
-          this.node.getEncodedEnr(),
-          this.node.getL1ContractAddresses(),
-          this.node.getProtocolContractAddresses(),
-        ]);
-
-      this.#nodeInfo = {
-        nodeVersion,
-        l1ChainId: chainId,
-        rollupVersion,
-        enr,
-        l1ContractAddresses: contractAddresses,
-        protocolContractAddresses: protocolContractAddresses,
-      };
-    }
-
-    return this.#nodeInfo;
-  }
-
-  public getPXEInfo(): Promise<PXEInfo> {
-    return Promise.resolve({
-      pxeVersion: this.packageVersion,
-      protocolContractAddresses: {
-        classRegistry: ProtocolContractAddress.ContractClassRegistry,
-        feeJuice: ProtocolContractAddress.FeeJuice,
-        instanceRegistry: ProtocolContractAddress.ContractInstanceRegistry,
-        multiCallEntrypoint: ProtocolContractAddress.MultiCallEntrypoint,
-      },
-    });
-  }
-
-  public async getPrivateEvents<T>(
-    contractAddress: AztecAddress,
-    eventMetadataDef: EventMetadataDefinition,
-    from: number,
-    numBlocks: number,
-    recipients: AztecAddress[],
-  ): Promise<T[]> {
-    if (recipients.length === 0) {
-      throw new Error('Recipients are required to get private events');
-    }
-
-    this.log.verbose(`Getting private events for ${contractAddress.toString()} from ${from} to ${from + numBlocks}`);
-
-    // We need to manually trigger private state sync to have a guarantee that all the events are available.
-    await this.simulateUtility('sync_private_state', [], contractAddress);
+  /**
+   * Returns the private events given search parameters.
+   * @param eventSelector - Event selector to search for.
+   * @param filter
+   *  contractAddress - The address of the contract to get events from. Required.
+   *  scopes - One or more event scope addresses to filter by. Required.
+   *  fromBlock - The block number to search from (inclusive). Optional. If provided, it must be >= 0.
+   *    Defaults to 0.
+   *    If toBlock is defined but fromBlock is not, fromBlock defaults to toBlock - 1.
+   *  toBlock - The block number to search up to (exclusive). Optional. If provided, it must be > 0.
+   *    Defaults to the latest known block to PXE + 1.
+   * @returns - The packed events with block and tx metadata.
+   */
+  public getPrivateEvents(eventSelector: EventSelector, filter: PrivateEventFilter): Promise<PackedPrivateEvent[]> {
+    return this.#putInJobQueue(async () => {
+      await this.blockStateSynchronizer.sync();
+      const contractFunctionSimulator = this.#getSimulatorForTx();
 
-    const events = await this.privateEventDataProvider.getPrivateEvents(
-      contractAddress,
-      from,
-      numBlocks,
-      recipients,
-      eventMetadataDef.eventSelector,
-    );
+      await this.contractStore.syncPrivateState(
+        filter.contractAddress,
+        null,
+        async privateSyncCall => await this.#simulateUtility(contractFunctionSimulator, privateSyncCall),
+      );
 
-    const decodedEvents = events.map((event: Fr[]): T => decodeFromAbi([eventMetadataDef.abiType], event) as T);
+      const sanitizedFilter = await new PrivateEventFilterValidator(this.anchorBlockStore).validate(filter);
 
-    return decodedEvents;
-  }
+      this.log.debug(
+        `Getting private events for ${sanitizedFilter.contractAddress.toString()} from ${sanitizedFilter.fromBlock} to ${sanitizedFilter.toBlock}`,
+      );
 
-  async getPublicEvents<T>(eventMetadataDef: EventMetadataDefinition, from: number, limit: number): Promise<T[]> {
-    const { logs } = await this.node.getPublicLogs({
-      fromBlock: from,
-      toBlock: from + limit,
+      return this.privateEventStore.getPrivateEvents(eventSelector, sanitizedFilter);
     });
-
-    const decodedEvents = logs
-      .map(log => {
-        // +1 for the event selector
-        const expectedLength = eventMetadataDef.fieldNames.length + 1;
-        if (log.log.emittedLength !== expectedLength) {
-          throw new Error(
-            `Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length. Expected ${expectedLength}. Got ${log.log.emittedLength}.`,
-          );
-        }
-
-        const logFields = log.log.getEmittedFields();
-        // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
-        if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
-          return undefined;
-        }
-
-        return decodeFromAbi([eventMetadataDef.abiType], log.log.fields) as T;
-      })
-      .filter(log => log !== undefined) as T[];
-
-    return decodedEvents;
-  }
-
-  async resetNoteSyncData() {
-    return await this.taggingDataProvider.resetNoteSyncData();
   }
 
+  /**
+   * Stops the PXE's job queue.
+   */
   public stop(): Promise<void> {
     return this.jobQueue.end();
   }