@aztec/pxe 3.0.0-nightly.20260105 → 3.0.0-nightly.20260106

package/src/pxe.ts

@@ -59,7 +59,7 @@ import {
   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 { 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';
@@ -68,15 +68,15 @@ import {
   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 { AnchorBlockDataProvider } from './storage/anchor_block_data_provider/anchor_block_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 { SenderAddressBook } from './storage/tagging_data_provider/sender_address_book.js';
-import { SenderTaggingDataProvider } from './storage/tagging_data_provider/sender_tagging_data_provider.js';
-import { RecipientTaggingDataProvider } from './tagging/recipient_sync/recipient_tagging_data_provider.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[];
@@ -92,15 +92,15 @@ export class PXE {
     private node: AztecNode,
     private blockStateSynchronizer: BlockSynchronizer,
     private keyStore: KeyStore,
-    private contractDataProvider: ContractDataProvider,
-    private noteDataProvider: NoteDataProvider,
-    private capsuleDataProvider: CapsuleDataProvider,
-    private anchorBlockDataProvider: AnchorBlockDataProvider,
-    private senderTaggingDataProvider: SenderTaggingDataProvider,
-    private senderAddressBook: SenderAddressBook,
-    private recipientTaggingDataProvider: RecipientTaggingDataProvider,
-    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 proverEnabled: boolean,
     private proofCreator: PrivateKernelProver,
@@ -132,27 +132,20 @@ export class PXE {
         : loggerOrSuffix;
 
     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 anchorBlockDataProvider = new AnchorBlockDataProvider(store);
-    const senderTaggingDataProvider = new SenderTaggingDataProvider(store);
-    const senderAddressBook = new SenderAddressBook(store);
-    const recipientTaggingDataProvider = new RecipientTaggingDataProvider(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 BlockSynchronizer(
-      node,
-      anchorBlockDataProvider,
-      noteDataProvider,
-      tipsStore,
-      config,
-      loggerOrSuffix,
-    );
+    const synchronizer = new BlockSynchronizer(node, anchorBlockStore, noteStore, tipsStore, config, loggerOrSuffix);
 
-    const debugUtils = new PXEDebugUtils(contractDataProvider, noteDataProvider);
+    const debugUtils = new PXEDebugUtils(contractStore, noteStore);
 
     const jobQueue = new SerialQueue();
 
@@ -160,15 +153,15 @@ export class PXE {
       node,
       synchronizer,
       keyStore,
-      contractDataProvider,
-      noteDataProvider,
-      capsuleDataProvider,
-      anchorBlockDataProvider,
-      senderTaggingDataProvider,
-      senderAddressBook,
-      recipientTaggingDataProvider,
-      addressDataProvider,
-      privateEventDataProvider,
+      contractStore,
+      noteStore,
+      capsuleStore,
+      anchorBlockStore,
+      senderTaggingStore,
+      senderAddressBookStore,
+      recipientTaggingStore,
+      addressStore,
+      privateEventStore,
       simulator,
       proverEnabled,
       proofCreator,
@@ -191,23 +184,20 @@ export class PXE {
   // Internal methods
 
   #getSimulatorForTx(overrides?: { contracts?: ContractOverrides }) {
-    const proxyContractDataProvider = ProxiedContractDataProviderFactory.create(
-      this.contractDataProvider,
-      overrides?.contracts,
-    );
+    const proxyContractStore = ProxiedContractStoreFactory.create(this.contractStore, overrides?.contracts);
 
     return new ContractFunctionSimulator(
-      proxyContractDataProvider,
-      this.noteDataProvider,
+      proxyContractStore,
+      this.noteStore,
       this.keyStore,
-      this.addressDataProvider,
+      this.addressStore,
       this.node,
-      this.anchorBlockDataProvider,
-      this.senderTaggingDataProvider,
-      this.recipientTaggingDataProvider,
-      this.senderAddressBook,
-      this.capsuleDataProvider,
-      this.privateEventDataProvider,
+      this.anchorBlockStore,
+      this.senderTaggingStore,
+      this.recipientTaggingStore,
+      this.senderAddressBookStore,
+      this.capsuleStore,
+      this.privateEventStore,
       this.simulator,
     );
   }
@@ -248,8 +238,8 @@ export class 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);
@@ -278,7 +268,7 @@ export class PXE {
     const { origin: contractAddress, functionSelector } = txRequest;
 
     try {
-      const anchorBlockHeader = await this.anchorBlockDataProvider.getBlockHeader();
+      const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
 
       const result = await contractFunctionSimulator.run(
         txRequest,
@@ -295,7 +285,7 @@ export class 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;
     }
@@ -317,11 +307,11 @@ export class PXE {
     scopes?: AztecAddress[],
   ) {
     try {
-      const anchorBlockHeader = await this.anchorBlockDataProvider.getBlockHeader();
+      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;
     }
@@ -345,7 +335,7 @@ export class 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}`);
         }
@@ -373,7 +363,7 @@ export class PXE {
   ): Promise<PrivateKernelExecutionProofOutput<PrivateKernelTailCircuitPublicInputs>> {
     const simulationAnchorBlock = privateExecutionResult.getSimulationAnchorBlockNumber();
     const kernelOracle = new PrivateKernelOracleImpl(
-      this.contractDataProvider,
+      this.contractStore,
       this.keyStore,
       this.node,
       simulationAnchorBlock,
@@ -386,7 +376,7 @@ export class PXE {
   // Public API
 
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return this.contractDataProvider.getContractInstance(address);
+    return this.contractStore.getContractInstance(address);
   }
 
   /**
@@ -411,7 +401,7 @@ export class 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`);
     }
@@ -441,7 +431,7 @@ export class 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`);
     }
@@ -473,8 +463,8 @@ export class 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;
   }
 
@@ -495,7 +485,7 @@ export class PXE {
       return sender;
     }
 
-    const wasAdded = await this.senderAddressBook.addSender(sender);
+    const wasAdded = await this.senderAddressBookStore.addSender(sender);
 
     if (wasAdded) {
       this.log.info(`Added sender:\n ${sender.toString()}`);
@@ -511,7 +501,7 @@ export class PXE {
    * @returns Senders registered in this PXE.
    */
   public getSenders(): Promise<AztecAddress[]> {
-    return this.senderAddressBook.getSenders();
+    return this.senderAddressBookStore.getSenders();
   }
 
   /**
@@ -519,7 +509,7 @@ export class PXE {
    * @param sender - The address of the sender to remove.
    */
   public async removeSender(sender: AztecAddress): Promise<void> {
-    const wasRemoved = await this.senderAddressBook.removeSender(sender);
+    const wasRemoved = await this.senderAddressBookStore.removeSender(sender);
 
     if (wasRemoved) {
       this.log.info(`Removed sender:\n ${sender.toString()}`);
@@ -534,7 +524,7 @@ export class 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 =>
@@ -549,7 +539,7 @@ export class PXE {
    */
   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}`);
   }
 
@@ -578,7 +568,7 @@ export class 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)
@@ -586,7 +576,7 @@ export class 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}.`,
@@ -594,7 +584,7 @@ export class 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}`,
     );
@@ -613,14 +603,14 @@ export class PXE {
     // 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.blockStateSynchronizer.sync();
 
-      const header = await this.anchorBlockDataProvider.getBlockHeader();
+      const header = await this.anchorBlockStore.getBlockHeader();
 
       const currentClassId = await readCurrentClassId(
         contractAddress,
@@ -633,7 +623,7 @@ export class 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)
@@ -641,7 +631,7 @@ export class 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}`);
     });
   }
@@ -651,7 +641,7 @@ export class PXE {
    * @returns An array of contracts addresses registered on this PXE.
    */
   public getContracts(): Promise<AztecAddress[]> {
-    return this.contractDataProvider.getContractsAddresses();
+    return this.contractStore.getContractsAddresses();
   }
 
   /**
@@ -721,7 +711,7 @@ export class PXE {
           // TODO(benesjan): The following is an expensive operation. Figure out a way to avoid it.
           const txHash = (await txProvingResult.toTx()).txHash;
 
-          await this.senderTaggingDataProvider.storePendingIndexes(preTagsUsedInTheTx, txHash);
+          await this.senderTaggingStore.storePendingIndexes(preTagsUsedInTheTx, txHash);
           this.log.debug(`Stored used pre-tags as sender for the tx`, {
             preTagsUsedInTheTx,
           });
@@ -891,7 +881,7 @@ export class PXE {
           ({ publicInputs, executionSteps } = await generateSimulatedProvingResult(
             privateExecutionResult,
             nonceGenerator,
-            this.contractDataProvider,
+            this.contractStore,
           ));
         } else {
           // Kernel logic, plus proving of all private functions and kernels.
@@ -1000,6 +990,11 @@ export class PXE {
         const syncTime = syncTimer.ms();
         const functionTimer = new Timer();
         const contractFunctionSimulator = this.#getSimulatorForTx();
+
+        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();
 
@@ -1041,21 +1036,25 @@ export class PXE {
    *    Defaults to the latest known block to PXE + 1.
    * @returns - The packed events with block and tx metadata.
    */
-  public async getPrivateEvents(
-    eventSelector: EventSelector,
-    filter: PrivateEventFilter,
-  ): Promise<PackedPrivateEvent[]> {
-    // We need to manually trigger private state sync to have a guarantee that all the events are available.
-    const call = await this.contractDataProvider.getFunctionCall('sync_private_state', [], filter.contractAddress);
-    await this.simulateUtility(call);
-
-    const sanitizedFilter = await new PrivateEventFilterValidator(this.anchorBlockDataProvider).validate(filter);
-
-    this.log.debug(
-      `Getting private events for ${sanitizedFilter.contractAddress.toString()} from ${sanitizedFilter.fromBlock} to ${sanitizedFilter.toBlock}`,
-    );
+  public getPrivateEvents(eventSelector: EventSelector, filter: PrivateEventFilter): Promise<PackedPrivateEvent[]> {
+    return this.#putInJobQueue(async () => {
+      await this.blockStateSynchronizer.sync();
+      const contractFunctionSimulator = this.#getSimulatorForTx();
+
+      await this.contractStore.syncPrivateState(
+        filter.contractAddress,
+        null,
+        async privateSyncCall => await this.#simulateUtility(contractFunctionSimulator, privateSyncCall),
+      );
+
+      const sanitizedFilter = await new PrivateEventFilterValidator(this.anchorBlockStore).validate(filter);
 
-    return this.privateEventDataProvider.getPrivateEvents(eventSelector, sanitizedFilter);
+      this.log.debug(
+        `Getting private events for ${sanitizedFilter.contractAddress.toString()} from ${sanitizedFilter.fromBlock} to ${sanitizedFilter.toBlock}`,
+      );
+
+      return this.privateEventStore.getPrivateEvents(eventSelector, sanitizedFilter);
+    });
   }
 
   /**

package/src/storage/{address_data_provider/address_data_provider.ts → address_store/address_store.ts}

@@ -3,7 +3,7 @@ import type { AztecAsyncArray, AztecAsyncKVStore, AztecAsyncMap } from '@aztec/k
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { CompleteAddress } from '@aztec/stdlib/contract';
 
-export class AddressDataProvider {
+export class AddressStore {
   #store: AztecAsyncKVStore;
   #completeAddresses: AztecAsyncArray<Buffer>;
   #completeAddressIndex: AztecAsyncMap<string, number>;

package/src/storage/address_store/index.ts

@@ -0,0 +1 @@
+export { AddressStore } from './address_store.js';

package/src/storage/{anchor_block_data_provider/anchor_block_data_provider.ts → anchor_block_store/anchor_block_store.ts}

@@ -1,7 +1,7 @@
 import type { AztecAsyncKVStore, AztecAsyncSingleton } from '@aztec/kv-store';
 import { BlockHeader } from '@aztec/stdlib/tx';
 
-export class AnchorBlockDataProvider {
+export class AnchorBlockStore {
   #store: AztecAsyncKVStore;
   #synchronizedHeader: AztecAsyncSingleton<Buffer>;
 

package/src/storage/anchor_block_store/index.ts

@@ -0,0 +1 @@
+export { AnchorBlockStore } from './anchor_block_store.js';

package/src/storage/{capsule_data_provider/capsule_data_provider.ts → capsule_store/capsule_store.ts}

@@ -3,7 +3,7 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-export class CapsuleDataProvider {
+export class CapsuleStore {
   #store: AztecAsyncKVStore;
 
   // Arbitrary data stored by contracts. Key is computed as `${contractAddress}:${key}`

package/src/storage/capsule_store/index.ts

@@ -0,0 +1 @@
+export { CapsuleStore } from './capsule_store.js';

package/src/storage/{contract_data_provider/contract_data_provider.ts → contract_store/contract_store.ts}

@@ -3,6 +3,7 @@ import type { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import type { MembershipWitness } from '@aztec/foundation/trees';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { isProtocolContract } from '@aztec/protocol-contracts';
 import {
   type ContractArtifact,
   type FunctionAbi,
@@ -28,13 +29,13 @@ import {
 import { PrivateFunctionsTree } from './private_functions_tree.js';
 
 /**
- * ContractDataProvider serves as a data manager and retriever for Aztec.nr contracts.
+ * ContractStore serves as a data manager and retriever for Aztec.nr contracts.
  * It provides methods to obtain contract addresses, function ABI, bytecode, and membership witnesses
  * from a given contract address and function selector. The class maintains a cache of ContractTree instances
  * to efficiently serve the requested data. It interacts with the ContractDatabase and AztecNode to fetch
  * the required information and facilitate cryptographic proof generation.
  */
-export class ContractDataProvider {
+export class ContractStore {
   /** Map from contract class id to private function tree. */
   // TODO: Update it to be LRU cache so that it doesn't keep all the data all the time.
   #privateFunctionTrees: Map<string, PrivateFunctionsTree> = new Map();
@@ -316,4 +317,23 @@ export class ContractDataProvider {
       returnTypes: functionDao.returnTypes,
     };
   }
+
+  // Synchronize target contract data
+  public async syncPrivateState(
+    contractAddress: AztecAddress,
+    functionToInvokeAfterSync: FunctionSelector | null,
+    utilityExecutor: (privateSyncCall: FunctionCall) => Promise<any>,
+  ) {
+    // Protocol contracts don't have private state to sync
+    if (!isProtocolContract(contractAddress)) {
+      const syncPrivateStateFunctionCall = await this.getFunctionCall('sync_private_state', [], contractAddress);
+      if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncPrivateStateFunctionCall.selector)) {
+        throw new Error(
+          'Forbidden `sync_private_state` invocation. `sync_private_state` can only be invoked by PXE, manual execution can lead to inconsistencies.',
+        );
+      }
+
+      return utilityExecutor(syncPrivateStateFunctionCall);
+    }
+  }
 }

package/src/storage/contract_store/index.ts

@@ -0,0 +1 @@
+export { ContractStore } from './contract_store.js';

package/src/storage/index.ts

@@ -1,8 +1,8 @@
-export * from './address_data_provider/index.js';
-export * from './capsule_data_provider/index.js';
-export * from './contract_data_provider/index.js';
-export * from './note_data_provider/index.js';
-export * from './anchor_block_data_provider/index.js';
-export * from './tagging_data_provider/index.js';
+export * from './address_store/index.js';
+export * from './capsule_store/index.js';
+export * from './contract_store/index.js';
+export * from './note_store/index.js';
+export * from './anchor_block_store/index.js';
+export * from './tagging_store/index.js';
 export * from './metadata.js';
-export * from './private_event_data_provider/private_event_data_provider.js';
+export * from './private_event_store/private_event_store.js';

package/src/storage/note_store/index.ts

@@ -0,0 +1,2 @@
+export { NoteDao } from '@aztec/stdlib/note';
+export { NoteStore } from './note_store.js';

package/src/storage/{note_data_provider/note_data_provider.ts → note_store/note_store.ts}

@@ -8,12 +8,12 @@ import { NoteStatus, type NotesFilter } from '@aztec/stdlib/note';
 import { NoteDao } from '@aztec/stdlib/note';
 
 /**
- * NoteDataProvider manages the storage and retrieval of notes.
+ * NoteStore manages the storage and retrieval of notes.
  *
  * Notes can be active or nullified. This class processes new notes, nullifications,
  * and performs rollback handling in the case of a reorg.
  **/
-export class NoteDataProvider {
+export class NoteStore {
   #store: AztecAsyncKVStore;
   #notes: AztecAsyncMap<string, Buffer>;
   #nullifiedNotes: AztecAsyncMap<string, Buffer>;
@@ -49,16 +49,16 @@ export class NoteDataProvider {
   }
 
   /**
-   * Creates and initializes a new NoteDataProvider instance.
+   * Creates and initializes a new NoteStore instance.
    *
-   * This factory method creates a NoteDataProvider and restores any existing
+   * This factory method creates a NoteStore and restores any existing
    * scope-specific indexes from the database.
    *
    * @param store - The key-value store to use for persistence
-   * @returns Promise resolving to a fully initialized NoteDataProvider instance
+   * @returns Promise resolving to a fully initialized NoteStore instance
    */
-  public static async create(store: AztecAsyncKVStore): Promise<NoteDataProvider> {
-    const pxeDB = new NoteDataProvider(store);
+  public static async create(store: AztecAsyncKVStore): Promise<NoteStore> {
+    const pxeDB = new NoteStore(store);
     for await (const scope of pxeDB.#scopes.keysAsync()) {
       pxeDB.#notesByContractAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_contract`));
       pxeDB.#notesByStorageSlotAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_storage_slot`));

package/src/storage/{private_event_data_provider/private_event_data_provider.ts → private_event_store/private_event_store.ts}

@@ -10,7 +10,7 @@ import { type InTx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PackedPrivateEvent } from '../../pxe.js';
 
-export type PrivateEventDataProviderFilter = {
+export type PrivateEventStoreFilter = {
   contractAddress: AztecAddress;
   fromBlock: number;
   toBlock: number;
@@ -34,7 +34,7 @@ type PrivateEventMetadata = InTx & {
 /**
  * Stores decrypted private event logs.
  */
-export class PrivateEventDataProvider {
+export class PrivateEventStore {
   #store: AztecAsyncKVStore;
   /** Array storing the actual private event log entries containing the log content and block number */
   #eventLogs: AztecAsyncArray<PrivateEventEntry>;
@@ -43,7 +43,7 @@ export class PrivateEventDataProvider {
   /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */
   #seenLogs: AztecAsyncMap<number, boolean>;
 
-  logger = createLogger('private_event_data_provider');
+  logger = createLogger('private_event_store');
 
   constructor(store: AztecAsyncKVStore) {
     this.#store = store;
@@ -117,7 +117,7 @@ export class PrivateEventDataProvider {
    */
   public async getPrivateEvents(
     eventSelector: EventSelector,
-    filter: PrivateEventDataProviderFilter,
+    filter: PrivateEventStoreFilter,
   ): Promise<PackedPrivateEvent[]> {
     const events: Array<{ eventCommitmentIndex: number; event: PackedPrivateEvent }> = [];
 

package/src/storage/tagging_store/index.ts

@@ -0,0 +1,3 @@
+export { SenderTaggingStore } from './sender_tagging_store.js';
+export { SenderAddressBookStore } from './sender_address_book_store.js';
+export { RecipientTaggingStore } from './recipient_tagging_store.js';

package/src/{tagging/recipient_sync/recipient_tagging_data_provider.ts → storage/tagging_store/recipient_tagging_store.ts}

@@ -3,15 +3,15 @@ import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 
 /**
  * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class
- * is called SenderTaggingDataProvider. We have the providers separate for the sender and recipient because
+ * is called SenderTaggingStore. We have the providers separate for the sender and recipient because
  * the algorithms are completely disjoint and there is not data reuse between the two.
  *
  * @dev Chain reorgs do not need to be handled here because both the finalized and aged indexes refer to finalized
  * blocks, which by definition cannot be affected by reorgs.
  *
- * TODO(benesjan): Relocate to yarn-project/pxe/src/storage/tagging_data_provider
+ * TODO(benesjan): Relocate to yarn-project/pxe/src/storage/tagging_store
  */
-export class RecipientTaggingDataProvider {
+export class RecipientTaggingStore {
   #store: AztecAsyncKVStore;
 
   #highestAgedIndex: AztecAsyncMap<string, number>;