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

package/src/logs/log_service.ts

@@ -8,24 +8,24 @@ import { DirectionalAppTaggingSecret, PendingTaggedLog, SiloedTag, Tag, TxScoped
 
 import type { LogRetrievalRequest } from '../contract_function_simulator/noir-structs/log_retrieval_request.js';
 import { LogRetrievalResponse } from '../contract_function_simulator/noir-structs/log_retrieval_response.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 type { SenderAddressBook } from '../storage/tagging_data_provider/sender_address_book.js';
-import { loadPrivateLogsForSenderRecipientPair } from '../tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.js';
-import type { 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 type { RecipientTaggingStore } from '../storage/tagging_store/recipient_tagging_store.js';
+import type { SenderAddressBookStore } from '../storage/tagging_store/sender_address_book_store.js';
+import { loadPrivateLogsForSenderRecipientPair } from '../tagging/index.js';
 
 export class LogService {
   private log = createLogger('log_service');
 
   constructor(
     private readonly aztecNode: AztecNode,
-    private readonly anchorBlockDataProvider: AnchorBlockDataProvider,
+    private readonly anchorBlockStore: AnchorBlockStore,
     private readonly keyStore: KeyStore,
-    private readonly capsuleDataProvider: CapsuleDataProvider,
-    private readonly recipientTaggingDataProvider: RecipientTaggingDataProvider,
-    private readonly senderAddressBook: SenderAddressBook,
-    private readonly addressDataProvider: AddressDataProvider,
+    private readonly capsuleStore: CapsuleStore,
+    private readonly recipientTaggingStore: RecipientTaggingStore,
+    private readonly senderAddressBookStore: SenderAddressBookStore,
+    private readonly addressStore: AddressStore,
   ) {}
 
   public async bulkRetrieveLogs(logRetrievalRequests: LogRetrievalRequest[]): Promise<(LogRetrievalResponse | null)[]> {
@@ -101,7 +101,7 @@ export class LogService {
     this.log.verbose('Searching for tagged logs', { contract: contractAddress });
 
     // We only load logs from block up to and including the anchor block number
-    const anchorBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+    const anchorBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
 
     // Determine recipients: use scopes if provided, otherwise get all accounts
     const recipients = scopes && scopes.length > 0 ? scopes : await this.keyStore.getAccounts();
@@ -120,7 +120,7 @@ export class LogService {
               secret,
               contractAddress,
               this.aztecNode,
-              this.recipientTaggingDataProvider,
+              this.recipientTaggingStore,
               anchorBlockNumber,
             ),
           ),
@@ -146,7 +146,7 @@ export class LogService {
 
     // We implicitly add all PXE accounts as senders, this helps us decrypt tags on notes that we send to ourselves
     // (recipient = us, sender = us)
-    const allSenders = [...(await this.senderAddressBook.getSenders()), ...(await this.keyStore.getAccounts())];
+    const allSenders = [...(await this.senderAddressBookStore.getSenders()), ...(await this.keyStore.getAccounts())];
 
     // We deduplicate the senders by adding them to a set and then converting the set back to an array
     const deduplicatedSenders = Array.from(new Set(allSenders.map(sender => sender.toString()))).map(sender =>
@@ -186,11 +186,11 @@ export class LogService {
     });
 
     // TODO: This looks like it could belong more at the oracle interface level
-    return this.capsuleDataProvider.appendToCapsuleArray(contractAddress, capsuleArrayBaseSlot, pendingTaggedLogs);
+    return this.capsuleStore.appendToCapsuleArray(contractAddress, capsuleArrayBaseSlot, pendingTaggedLogs);
   }
 
   async #getCompleteAddress(account: AztecAddress): Promise<CompleteAddress> {
-    const completeAddress = await this.addressDataProvider.getCompleteAddress(account);
+    const completeAddress = await this.addressStore.getCompleteAddress(account);
     if (!completeAddress) {
       throw new Error(
         `No public key registered for address ${account}.

package/src/notes/note_service.ts

@@ -7,14 +7,14 @@ import { Note, NoteDao, NoteStatus } from '@aztec/stdlib/note';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { TxHash } from '@aztec/stdlib/tx';
 
-import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
-import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
+import type { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
+import type { NoteStore } from '../storage/note_store/note_store.js';
 
 export class NoteService {
   constructor(
-    private readonly noteDataProvider: NoteDataProvider,
+    private readonly noteStore: NoteStore,
     private readonly aztecNode: AztecNode,
-    private readonly anchorBlockDataProvider: AnchorBlockDataProvider,
+    private readonly anchorBlockStore: AnchorBlockStore,
   ) {}
 
   /**
@@ -33,7 +33,7 @@ export class NoteService {
     status: NoteStatus,
     scopes?: AztecAddress[],
   ) {
-    const noteDaos = await this.noteDataProvider.getNotes({
+    const noteDaos = await this.noteStore.getNotes({
       contractAddress,
       owner,
       storageSlot,
@@ -59,7 +59,7 @@ export class NoteService {
   /**
    * Looks for nullifiers of active contract notes and marks them as nullified if a nullifier is found.
    *
-   * Fetches notes from the NoteDataProvider and checks which nullifiers are present in the
+   * Fetches notes from the NoteStore and checks which nullifiers are present in the
    * onchain nullifier Merkle tree - up to the latest locally synced block. We use the
    * locally synced block instead of querying the chain's 'latest' block to ensure correctness:
    * notes are only marked nullified once their corresponding nullifier has been included in a
@@ -69,9 +69,9 @@ export class NoteService {
    * @param contractAddress - The contract whose notes should be checked and nullified.
    */
   public async syncNoteNullifiers(contractAddress: AztecAddress): Promise<void> {
-    const syncedBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+    const syncedBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
 
-    const contractNotes = await this.noteDataProvider.getNotes({ contractAddress });
+    const contractNotes = await this.noteStore.getNotes({ contractAddress });
 
     if (contractNotes.length === 0) {
       return;
@@ -105,7 +105,7 @@ export class NoteService {
       })
       .filter(nullifier => nullifier !== undefined) as DataInBlock<Fr>[];
 
-    await this.noteDataProvider.applyNullifiers(foundNullifiers);
+    await this.noteStore.applyNullifiers(foundNullifiers);
   }
 
   public async deliverNote(
@@ -120,7 +120,7 @@ export class NoteService {
     txHash: TxHash,
     recipient: AztecAddress,
   ): Promise<void> {
-    // We are going to store the new note in the NoteDataProvider, which will let us later return it via `getNotes`.
+    // We are going to store the new note in the NoteStore, which will let us later return it via `getNotes`.
     // There's two things we need to check before we do this however:
     //  - we must make sure the note does actually exist in the note hash tree
     //  - we need to check if the note has already been nullified
@@ -139,7 +139,7 @@ export class NoteService {
     // number which *should* be recent enough to be available, even for non-archive nodes.
     // Also note that the note should never be ahead of the synced block here since `fetchTaggedLogs` only processes
     // logs up to the synced block making this only an additional safety check.
-    const syncedBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+    const syncedBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
 
     // By computing siloed and unique note hashes ourselves we prevent contracts from interfering with the note storage
     // of other contracts, which would constitute a security breach.
@@ -190,11 +190,11 @@ export class NoteService {
     );
 
     // The note was found by `recipient`, so we use that as the scope when storing the note.
-    await this.noteDataProvider.addNotes([noteDao], recipient);
+    await this.noteStore.addNotes([noteDao], recipient);
 
     if (nullifierIndex !== undefined) {
       const { data: _, ...blockHashAndNum } = nullifierIndex;
-      await this.noteDataProvider.applyNullifiers([{ data: siloedNullifier, ...blockHashAndNum }]);
+      await this.noteStore.applyNullifiers([{ data: siloedNullifier, ...blockHashAndNum }]);
     }
   }
 }

package/src/private_kernel/private_kernel_oracle_impl.ts

@@ -18,7 +18,7 @@ import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
 import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 
-import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
 import type { PrivateKernelOracle } from './private_kernel_oracle.js';
 
 // TODO: Block number should not be "latest".
@@ -29,7 +29,7 @@ import type { PrivateKernelOracle } from './private_kernel_oracle.js';
  */
 export class PrivateKernelOracleImpl implements PrivateKernelOracle {
   constructor(
-    private contractDataProvider: ContractDataProvider,
+    private contractStore: ContractStore,
     private keyStore: KeyStore,
     private node: AztecNode,
     private blockNumber: BlockParameter = 'latest',
@@ -37,7 +37,7 @@ export class PrivateKernelOracleImpl implements PrivateKernelOracle {
   ) {}
 
   public async getContractAddressPreimage(address: AztecAddress) {
-    const instance = await this.contractDataProvider.getContractInstance(address);
+    const instance = await this.contractStore.getContractInstance(address);
     if (!instance) {
       throw new Error(`Contract instance not found when getting address preimage. Contract address: ${address}.`);
     }
@@ -48,7 +48,7 @@ export class PrivateKernelOracleImpl implements PrivateKernelOracle {
   }
 
   public async getContractClassIdPreimage(contractClassId: Fr) {
-    const contractClass = await this.contractDataProvider.getContractClass(contractClassId);
+    const contractClass = await this.contractStore.getContractClass(contractClassId);
     if (!contractClass) {
       throw new Error(`Contract class not found when getting class id preimage. Class id: ${contractClassId}.`);
     }
@@ -56,7 +56,7 @@ export class PrivateKernelOracleImpl implements PrivateKernelOracle {
   }
 
   public async getFunctionMembershipWitness(contractClassId: Fr, selector: FunctionSelector) {
-    const membershipWitness = await this.contractDataProvider.getFunctionMembershipWitness(contractClassId, selector);
+    const membershipWitness = await this.contractStore.getFunctionMembershipWitness(contractClassId, selector);
     if (!membershipWitness) {
       throw new Error(
         `Membership witness not found for contract class id ${contractClassId} and selector ${selector}.`,
@@ -96,7 +96,7 @@ export class PrivateKernelOracleImpl implements PrivateKernelOracle {
   }
 
   public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string> {
-    return this.contractDataProvider.getDebugFunctionName(contractAddress, selector);
+    return this.contractStore.getDebugFunctionName(contractAddress, selector);
   }
 
   public async getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints> {

package/src/public_storage/public_storage_service.ts

@@ -3,11 +3,11 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockParameter } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 
-import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
+import type { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
 
 export class PublicStorageService {
   constructor(
-    private readonly anchorBlockDataProvider: AnchorBlockDataProvider,
+    private readonly anchorBlockStore: AnchorBlockStore,
     private readonly aztecNode: AztecNode,
   ) {}
 
@@ -24,7 +24,7 @@ export class PublicStorageService {
    * @throws If the contract is not deployed.
    */
   public async getPublicStorageAt(blockNumber: BlockParameter, contract: AztecAddress, slot: Fr): Promise<Fr> {
-    const anchorBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+    const anchorBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
     if (blockNumber !== 'latest' && blockNumber > anchorBlockNumber) {
       throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
     }