@aztec/pxe 0.77.1 → 0.78.1

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

@@ -1,18 +1,26 @@
 import type { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
 import type { MembershipWitness } from '@aztec/foundation/trees';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import { ContractClassNotFoundError, ContractNotFoundError } from '@aztec/simulator/client';
 import {
   type ContractArtifact,
   type FunctionArtifact,
   type FunctionDebugMetadata,
-  type FunctionSelector,
+  FunctionSelector,
+  FunctionType,
+  contractArtifactFromBuffer,
+  contractArtifactToBuffer,
   getFunctionDebugMetadata,
 } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractClass, ContractInstance } from '@aztec/stdlib/contract';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type ContractClass,
+  type ContractInstanceWithAddress,
+  SerializableContractInstance,
+} from '@aztec/stdlib/contract';
 
-import type { ContractArtifactDatabase } from '../database/interfaces/contract_artifact_db.js';
-import type { ContractInstanceDatabase } from '../database/interfaces/contract_instance_db.js';
+import type { DataProvider } from '../data_provider.js';
 import { PrivateFunctionsTree } from './private_functions_tree.js';
 
 /**
@@ -22,30 +30,133 @@ import { PrivateFunctionsTree } from './private_functions_tree.js';
  * 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 ContractDataProvider implements DataProvider {
   /** Map from contract class id to private function tree. */
-  private contractClasses: Map<string, PrivateFunctionsTree> = new Map();
+  private contractClassesCache: Map<string, PrivateFunctionsTree> = new Map();
+
+  #contractArtifacts: AztecAsyncMap<string, Buffer>;
+  #contractInstances: AztecAsyncMap<string, Buffer>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#contractArtifacts = store.openMap('contract_artifacts');
+    this.#contractInstances = store.openMap('contracts_instances');
+  }
+
+  // Setters
+
+  public async addContractArtifact(id: Fr, contract: ContractArtifact): Promise<void> {
+    const privateFunctions = contract.functions.filter(
+      functionArtifact => functionArtifact.functionType === FunctionType.PRIVATE,
+    );
+
+    const privateSelectors = await Promise.all(
+      privateFunctions.map(async privateFunctionArtifact =>
+        (
+          await FunctionSelector.fromNameAndParameters(privateFunctionArtifact.name, privateFunctionArtifact.parameters)
+        ).toString(),
+      ),
+    );
+
+    if (privateSelectors.length !== new Set(privateSelectors).size) {
+      throw new Error('Repeated function selectors of private functions');
+    }
+
+    await this.#contractArtifacts.set(id.toString(), contractArtifactToBuffer(contract));
+  }
+
+  async addContractInstance(contract: ContractInstanceWithAddress): Promise<void> {
+    await this.#contractInstances.set(
+      contract.address.toString(),
+      new SerializableContractInstance(contract).toBuffer(),
+    );
+  }
+
+  // Private getters
+
+  async #getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    const contract = await this.#contractInstances.getAsync(address.toString());
+    return contract && SerializableContractInstance.fromBuffer(contract).withAddress(address);
+  }
 
-  constructor(private db: ContractArtifactDatabase & ContractInstanceDatabase) {}
+  async #getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
+    const contract = await this.#contractArtifacts.getAsync(id.toString());
+    // TODO(@spalladino): AztecAsyncMap lies and returns Uint8Arrays instead of Buffers, hence the extra Buffer.from.
+    return contract && contractArtifactFromBuffer(Buffer.from(contract));
+  }
+
+  /**
+   * Retrieve or create a ContractTree instance based on the provided class id.
+   * If an existing tree with the same class id is found in the cache, it will be returned.
+   * Otherwise, a new ContractTree instance will be created using the contract data from the database
+   * and added to the cache before returning.
+   *
+   * @param classId - The class id of the contract for which the ContractTree is required.
+   * @returns A ContractTree instance associated with the specified contract address.
+   * @throws An Error if the contract is not found in the ContractDatabase.
+   */
+  private async getTreeForClassId(classId: Fr): Promise<PrivateFunctionsTree> {
+    if (!this.contractClassesCache.has(classId.toString())) {
+      const artifact = await this.#getContractArtifact(classId);
+      if (!artifact) {
+        throw new ContractClassNotFoundError(classId.toString());
+      }
+      const tree = await PrivateFunctionsTree.create(artifact);
+      this.contractClassesCache.set(classId.toString(), tree);
+    }
+    return this.contractClassesCache.get(classId.toString())!;
+  }
+
+  /**
+   * Retrieve or create a ContractTree instance based on the provided AztecAddress.
+   * If an existing tree with the same contract address is found in the cache, it will be returned.
+   * Otherwise, a new ContractTree instance will be created using the contract data from the database
+   * and added to the cache before returning.
+   *
+   * @param contractAddress - The AztecAddress of the contract for which the ContractTree is required.
+   * @returns A ContractTree instance associated with the specified contract address.
+   * @throws An Error if the contract is not found in the ContractDatabase.
+   */
+  private async getTreeForAddress(contractAddress: AztecAddress): Promise<PrivateFunctionsTree> {
+    const instance = await this.getContractInstance(contractAddress);
+    return this.getTreeForClassId(instance.currentContractClassId);
+  }
+
+  // Public getters
+
+  async getContractsAddresses(): Promise<AztecAddress[]> {
+    const keys = await toArray(this.#contractInstances.keysAsync());
+    return keys.map(AztecAddress.fromString);
+  }
 
   /** Returns a contract instance for a given address. Throws if not found. */
-  public async getContractInstance(contractAddress: AztecAddress): Promise<ContractInstance> {
-    const instance = await this.db.getContractInstance(contractAddress);
+  public async getContractInstance(contractAddress: AztecAddress): Promise<ContractInstanceWithAddress> {
+    const instance = await this.#getContractInstance(contractAddress);
     if (!instance) {
       throw new ContractNotFoundError(contractAddress.toString());
     }
     return instance;
   }
 
+  public async getContractArtifact(contractClassId: Fr): Promise<ContractArtifact> {
+    const tree = await this.getTreeForClassId(contractClassId);
+    return tree.getArtifact();
+  }
+
   /** Returns a contract class for a given class id. Throws if not found. */
   public async getContractClass(contractClassId: Fr): Promise<ContractClass> {
     const tree = await this.getTreeForClassId(contractClassId);
     return tree.getContractClass();
   }
 
-  public async getContractArtifact(contractClassId: Fr): Promise<ContractArtifact> {
-    const tree = await this.getTreeForClassId(contractClassId);
-    return tree.getArtifact();
+  public async getContract(
+    address: AztecAddress,
+  ): Promise<(ContractInstanceWithAddress & ContractArtifact) | undefined> {
+    const instance = await this.getContractInstance(address);
+    const artifact = instance && (await this.getContractArtifact(instance?.currentContractClassId));
+    if (!instance || !artifact) {
+      return undefined;
+    }
+    return { ...instance, ...artifact };
   }
 
   /**
@@ -142,40 +253,9 @@ export class ContractDataProvider {
     return `${contractName}:${functionName}`;
   }
 
-  /**
-   * Retrieve or create a ContractTree instance based on the provided class id.
-   * If an existing tree with the same class id is found in the cache, it will be returned.
-   * Otherwise, a new ContractTree instance will be created using the contract data from the database
-   * and added to the cache before returning.
-   *
-   * @param classId - The class id of the contract for which the ContractTree is required.
-   * @returns A ContractTree instance associated with the specified contract address.
-   * @throws An Error if the contract is not found in the ContractDatabase.
-   */
-  private async getTreeForClassId(classId: Fr): Promise<PrivateFunctionsTree> {
-    if (!this.contractClasses.has(classId.toString())) {
-      const artifact = await this.db.getContractArtifact(classId);
-      if (!artifact) {
-        throw new ContractClassNotFoundError(classId.toString());
-      }
-      const tree = await PrivateFunctionsTree.create(artifact);
-      this.contractClasses.set(classId.toString(), tree);
-    }
-    return this.contractClasses.get(classId.toString())!;
-  }
-
-  /**
-   * Retrieve or create a ContractTree instance based on the provided AztecAddress.
-   * If an existing tree with the same contract address is found in the cache, it will be returned.
-   * Otherwise, a new ContractTree instance will be created using the contract data from the database
-   * and added to the cache before returning.
-   *
-   * @param contractAddress - The AztecAddress of the contract for which the ContractTree is required.
-   * @returns A ContractTree instance associated with the specified contract address.
-   * @throws An Error if the contract is not found in the ContractDatabase.
-   */
-  private async getTreeForAddress(contractAddress: AztecAddress): Promise<PrivateFunctionsTree> {
-    const instance = await this.getContractInstance(contractAddress);
-    return this.getTreeForClassId(instance.currentContractClassId);
+  public async getSize() {
+    return (await toArray(this.#contractInstances.valuesAsync()))
+      .concat(await toArray(this.#contractArtifacts.valuesAsync()))
+      .reduce((sum, value) => sum + value.length, 0);
   }
 }

package/src/storage/data_provider.ts

@@ -0,0 +1,3 @@
+export interface DataProvider {
+  getSize(): Promise<number>;
+}

package/src/storage/index.ts

@@ -0,0 +1,10 @@
+export * from './address_data_provider/index.js';
+export * from './auth_witness_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 './sync_data_provider/index.js';
+export * from './tagging_data_provider/index.js';
+export * from './data_provider.js';
+
+export const PXE_DATA_SCHEMA_VERSION = 2;

package/src/storage/note_data_provider/index.ts

@@ -0,0 +1,2 @@
+export { NoteDao } from './note_dao.js';
+export { NoteDataProvider } from './note_data_provider.js';

package/src/storage/note_data_provider/note_data_provider.ts

@@ -0,0 +1,345 @@
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import type { Fr, Point } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { InBlock } from '@aztec/stdlib/block';
+import type { PublicKey } from '@aztec/stdlib/keys';
+import { NoteStatus, type NotesFilter } from '@aztec/stdlib/note';
+
+import type { DataProvider } from '../data_provider.js';
+import { NoteDao } from './note_dao.js';
+
+export class NoteDataProvider implements DataProvider {
+  #store: AztecAsyncKVStore;
+
+  #notes: AztecAsyncMap<string, Buffer>;
+  #nullifiedNotes: AztecAsyncMap<string, Buffer>;
+  #nullifierToNoteId: AztecAsyncMap<string, string>;
+  #nullifiersByBlockNumber: AztecAsyncMultiMap<number, string>;
+
+  #nullifiedNotesToScope: AztecAsyncMultiMap<string, string>;
+  #nullifiedNotesByContract: AztecAsyncMultiMap<string, string>;
+  #nullifiedNotesByStorageSlot: AztecAsyncMultiMap<string, string>;
+  #nullifiedNotesByTxHash: AztecAsyncMultiMap<string, string>;
+  #nullifiedNotesByAddressPoint: AztecAsyncMultiMap<string, string>;
+  #nullifiedNotesByNullifier: AztecAsyncMap<string, string>;
+
+  #scopes: AztecAsyncMap<string, true>;
+  #notesToScope: AztecAsyncMultiMap<string, string>;
+  #notesByContractAndScope: Map<string, AztecAsyncMultiMap<string, string>>;
+  #notesByStorageSlotAndScope: Map<string, AztecAsyncMultiMap<string, string>>;
+  #notesByTxHashAndScope: Map<string, AztecAsyncMultiMap<string, string>>;
+  #notesByAddressPointAndScope: Map<string, AztecAsyncMultiMap<string, string>>;
+
+  private constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+    this.#notes = store.openMap('notes');
+    this.#nullifiedNotes = store.openMap('nullified_notes');
+    this.#nullifierToNoteId = store.openMap('nullifier_to_note');
+    this.#nullifiersByBlockNumber = store.openMultiMap('nullifier_to_block_number');
+
+    this.#nullifiedNotesToScope = store.openMultiMap('nullified_notes_to_scope');
+    this.#nullifiedNotesByContract = store.openMultiMap('nullified_notes_by_contract');
+    this.#nullifiedNotesByStorageSlot = store.openMultiMap('nullified_notes_by_storage_slot');
+    this.#nullifiedNotesByTxHash = store.openMultiMap('nullified_notes_by_tx_hash');
+    this.#nullifiedNotesByAddressPoint = store.openMultiMap('nullified_notes_by_address_point');
+    this.#nullifiedNotesByNullifier = store.openMap('nullified_notes_by_nullifier');
+
+    this.#scopes = store.openMap('scopes');
+    this.#notesToScope = store.openMultiMap('notes_to_scope');
+    this.#notesByContractAndScope = new Map<string, AztecAsyncMultiMap<string, string>>();
+    this.#notesByStorageSlotAndScope = new Map<string, AztecAsyncMultiMap<string, string>>();
+    this.#notesByTxHashAndScope = new Map<string, AztecAsyncMultiMap<string, string>>();
+    this.#notesByAddressPointAndScope = new Map<string, AztecAsyncMultiMap<string, string>>();
+  }
+
+  public static async create(store: AztecAsyncKVStore): Promise<NoteDataProvider> {
+    const pxeDB = new NoteDataProvider(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`));
+      pxeDB.#notesByTxHashAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_tx_hash`));
+      pxeDB.#notesByAddressPointAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_address_point`));
+    }
+    return pxeDB;
+  }
+
+  public async addScope(scope: AztecAddress): Promise<boolean> {
+    const scopeString = scope.toString();
+
+    if (await this.#scopes.hasAsync(scopeString)) {
+      return false;
+    }
+
+    await this.#scopes.set(scopeString, true);
+    this.#notesByContractAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_contract`));
+    this.#notesByStorageSlotAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_storage_slot`));
+    this.#notesByTxHashAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_tx_hash`));
+    this.#notesByAddressPointAndScope.set(
+      scopeString,
+      this.#store.openMultiMap(`${scopeString}:notes_by_address_point`),
+    );
+
+    return true;
+  }
+
+  async addNotes(notes: NoteDao[], scope: AztecAddress = AztecAddress.ZERO): Promise<void> {
+    if (!(await this.#scopes.hasAsync(scope.toString()))) {
+      await this.addScope(scope);
+    }
+
+    return this.#store.transactionAsync(async () => {
+      for (const dao of notes) {
+        // store notes by their index in the notes hash tree
+        // this provides the uniqueness we need to store individual notes
+        // and should also return notes in the order that they were created.
+        // Had we stored them by their nullifier, they would be returned in random order
+        const noteIndex = toBufferBE(dao.index, 32).toString('hex');
+        await this.#notes.set(noteIndex, dao.toBuffer());
+        await this.#notesToScope.set(noteIndex, scope.toString());
+        await this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
+
+        await this.#notesByContractAndScope.get(scope.toString())!.set(dao.contractAddress.toString(), noteIndex);
+        await this.#notesByStorageSlotAndScope.get(scope.toString())!.set(dao.storageSlot.toString(), noteIndex);
+        await this.#notesByTxHashAndScope.get(scope.toString())!.set(dao.txHash.toString(), noteIndex);
+        await this.#notesByAddressPointAndScope.get(scope.toString())!.set(dao.addressPoint.toString(), noteIndex);
+      }
+    });
+  }
+
+  public removeNotesAfter(blockNumber: number): Promise<void> {
+    return this.#store.transactionAsync(async () => {
+      const notes = await toArray(this.#notes.valuesAsync());
+      for (const note of notes) {
+        const noteDao = NoteDao.fromBuffer(note);
+        if (noteDao.l2BlockNumber > blockNumber) {
+          const noteIndex = toBufferBE(noteDao.index, 32).toString('hex');
+          await this.#notes.delete(noteIndex);
+          await this.#notesToScope.delete(noteIndex);
+          await this.#nullifierToNoteId.delete(noteDao.siloedNullifier.toString());
+          const scopes = await toArray(this.#scopes.keysAsync());
+          for (const scope of scopes) {
+            await this.#notesByAddressPointAndScope.get(scope)!.deleteValue(noteDao.addressPoint.toString(), noteIndex);
+            await this.#notesByTxHashAndScope.get(scope)!.deleteValue(noteDao.txHash.toString(), noteIndex);
+            await this.#notesByContractAndScope.get(scope)!.deleteValue(noteDao.contractAddress.toString(), noteIndex);
+            await this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(noteDao.storageSlot.toString(), noteIndex);
+          }
+        }
+      }
+    });
+  }
+
+  public async unnullifyNotesAfter(blockNumber: number, synchedBlockNumber?: number): Promise<void> {
+    const nullifiersToUndo: string[] = [];
+    const currentBlockNumber = blockNumber + 1;
+    const maxBlockNumber = synchedBlockNumber ?? currentBlockNumber;
+    for (let i = currentBlockNumber; i <= maxBlockNumber; i++) {
+      nullifiersToUndo.push(...(await toArray(this.#nullifiersByBlockNumber.getValuesAsync(i))));
+    }
+    const notesIndexesToReinsert = await Promise.all(
+      nullifiersToUndo.map(nullifier => this.#nullifiedNotesByNullifier.getAsync(nullifier)),
+    );
+    const notNullNoteIndexes = notesIndexesToReinsert.filter(noteIndex => noteIndex != undefined);
+    const nullifiedNoteBuffers = await Promise.all(
+      notNullNoteIndexes.map(noteIndex => this.#nullifiedNotes.getAsync(noteIndex!)),
+    );
+    const noteDaos = nullifiedNoteBuffers
+      .filter(buffer => buffer != undefined)
+      .map(buffer => NoteDao.fromBuffer(buffer!));
+
+    await this.#store.transactionAsync(async () => {
+      for (const dao of noteDaos) {
+        const noteIndex = toBufferBE(dao.index, 32).toString('hex');
+        await this.#notes.set(noteIndex, dao.toBuffer());
+        await this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
+
+        let scopes = (await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteIndex))) ?? [];
+
+        if (scopes.length === 0) {
+          scopes = [new AztecAddress(dao.addressPoint.x).toString()];
+        }
+
+        for (const scope of scopes) {
+          await this.#notesByContractAndScope.get(scope.toString())!.set(dao.contractAddress.toString(), noteIndex);
+          await this.#notesByStorageSlotAndScope.get(scope.toString())!.set(dao.storageSlot.toString(), noteIndex);
+          await this.#notesByTxHashAndScope.get(scope.toString())!.set(dao.txHash.toString(), noteIndex);
+          await this.#notesByAddressPointAndScope.get(scope.toString())!.set(dao.addressPoint.toString(), noteIndex);
+          await this.#notesToScope.set(noteIndex, scope);
+        }
+
+        await this.#nullifiedNotes.delete(noteIndex);
+        await this.#nullifiedNotesToScope.delete(noteIndex);
+        await this.#nullifiersByBlockNumber.deleteValue(dao.l2BlockNumber, dao.siloedNullifier.toString());
+        await this.#nullifiedNotesByContract.deleteValue(dao.contractAddress.toString(), noteIndex);
+        await this.#nullifiedNotesByStorageSlot.deleteValue(dao.storageSlot.toString(), noteIndex);
+        await this.#nullifiedNotesByTxHash.deleteValue(dao.txHash.toString(), noteIndex);
+        await this.#nullifiedNotesByAddressPoint.deleteValue(dao.addressPoint.toString(), noteIndex);
+        await this.#nullifiedNotesByNullifier.delete(dao.siloedNullifier.toString());
+      }
+    });
+  }
+
+  async getNotes(filter: NotesFilter): Promise<NoteDao[]> {
+    const publicKey: PublicKey | undefined = filter.owner ? await filter.owner.toAddressPoint() : undefined;
+
+    filter.status = filter.status ?? NoteStatus.ACTIVE;
+
+    const candidateNoteSources = [];
+
+    filter.scopes ??= (await toArray(this.#scopes.keysAsync())).map(addressString =>
+      AztecAddress.fromString(addressString),
+    );
+
+    const activeNoteIdsPerScope: string[][] = [];
+
+    for (const scope of new Set(filter.scopes)) {
+      const formattedScopeString = scope.toString();
+      if (!(await this.#scopes.hasAsync(formattedScopeString))) {
+        throw new Error('Trying to get incoming notes of an scope that is not in the PXE database');
+      }
+
+      activeNoteIdsPerScope.push(
+        publicKey
+          ? await toArray(
+              this.#notesByAddressPointAndScope.get(formattedScopeString)!.getValuesAsync(publicKey.toString()),
+            )
+          : filter.txHash
+          ? await toArray(
+              this.#notesByTxHashAndScope.get(formattedScopeString)!.getValuesAsync(filter.txHash.toString()),
+            )
+          : filter.contractAddress
+          ? await toArray(
+              this.#notesByContractAndScope
+                .get(formattedScopeString)!
+                .getValuesAsync(filter.contractAddress.toString()),
+            )
+          : filter.storageSlot
+          ? await toArray(
+              this.#notesByStorageSlotAndScope.get(formattedScopeString)!.getValuesAsync(filter.storageSlot.toString()),
+            )
+          : await toArray(this.#notesByAddressPointAndScope.get(formattedScopeString)!.valuesAsync()),
+      );
+    }
+
+    candidateNoteSources.push({
+      ids: new Set(activeNoteIdsPerScope.flat()),
+      notes: this.#notes,
+    });
+
+    if (filter.status == NoteStatus.ACTIVE_OR_NULLIFIED) {
+      candidateNoteSources.push({
+        ids: publicKey
+          ? await toArray(this.#nullifiedNotesByAddressPoint.getValuesAsync(publicKey.toString()))
+          : filter.txHash
+          ? await toArray(this.#nullifiedNotesByTxHash.getValuesAsync(filter.txHash.toString()))
+          : filter.contractAddress
+          ? await toArray(this.#nullifiedNotesByContract.getValuesAsync(filter.contractAddress.toString()))
+          : filter.storageSlot
+          ? await toArray(this.#nullifiedNotesByStorageSlot.getValuesAsync(filter.storageSlot.toString()))
+          : await toArray(this.#nullifiedNotes.keysAsync()),
+        notes: this.#nullifiedNotes,
+      });
+    }
+
+    const result: NoteDao[] = [];
+    for (const { ids, notes } of candidateNoteSources) {
+      for (const id of ids) {
+        const serializedNote = await notes.getAsync(id);
+        if (!serializedNote) {
+          continue;
+        }
+
+        const note = NoteDao.fromBuffer(serializedNote);
+        if (filter.contractAddress && !note.contractAddress.equals(filter.contractAddress)) {
+          continue;
+        }
+
+        if (filter.txHash && !note.txHash.equals(filter.txHash)) {
+          continue;
+        }
+
+        if (filter.storageSlot && !note.storageSlot.equals(filter.storageSlot!)) {
+          continue;
+        }
+
+        if (publicKey && !note.addressPoint.equals(publicKey)) {
+          continue;
+        }
+
+        if (filter.siloedNullifier && !note.siloedNullifier.equals(filter.siloedNullifier)) {
+          continue;
+        }
+
+        result.push(note);
+      }
+    }
+
+    return result;
+  }
+
+  removeNullifiedNotes(nullifiers: InBlock<Fr>[], accountAddressPoint: Point): Promise<NoteDao[]> {
+    if (nullifiers.length === 0) {
+      return Promise.resolve([]);
+    }
+
+    return this.#store.transactionAsync(async () => {
+      const nullifiedNotes: NoteDao[] = [];
+
+      for (const blockScopedNullifier of nullifiers) {
+        const { data: nullifier, l2BlockNumber: blockNumber } = blockScopedNullifier;
+        const noteIndex = await this.#nullifierToNoteId.getAsync(nullifier.toString());
+        if (!noteIndex) {
+          continue;
+        }
+
+        const noteBuffer = noteIndex ? await this.#notes.getAsync(noteIndex) : undefined;
+
+        if (!noteBuffer) {
+          // note doesn't exist. Maybe it got nullified already
+          continue;
+        }
+        const noteScopes = (await toArray(this.#notesToScope.getValuesAsync(noteIndex))) ?? [];
+        const note = NoteDao.fromBuffer(noteBuffer);
+        if (!note.addressPoint.equals(accountAddressPoint)) {
+          // tried to nullify someone else's note
+          continue;
+        }
+
+        nullifiedNotes.push(note);
+
+        await this.#notes.delete(noteIndex);
+        await this.#notesToScope.delete(noteIndex);
+
+        const scopes = await toArray(this.#scopes.keysAsync());
+
+        for (const scope of scopes) {
+          await this.#notesByAddressPointAndScope.get(scope)!.deleteValue(accountAddressPoint.toString(), noteIndex);
+          await this.#notesByTxHashAndScope.get(scope)!.deleteValue(note.txHash.toString(), noteIndex);
+          await this.#notesByContractAndScope.get(scope)!.deleteValue(note.contractAddress.toString(), noteIndex);
+          await this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(note.storageSlot.toString(), noteIndex);
+        }
+
+        if (noteScopes !== undefined) {
+          for (const scope of noteScopes) {
+            await this.#nullifiedNotesToScope.set(noteIndex, scope);
+          }
+        }
+        await this.#nullifiedNotes.set(noteIndex, note.toBuffer());
+        await this.#nullifiersByBlockNumber.set(blockNumber, nullifier.toString());
+        await this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteIndex);
+        await this.#nullifiedNotesByStorageSlot.set(note.storageSlot.toString(), noteIndex);
+        await this.#nullifiedNotesByTxHash.set(note.txHash.toString(), noteIndex);
+        await this.#nullifiedNotesByAddressPoint.set(note.addressPoint.toString(), noteIndex);
+        await this.#nullifiedNotesByNullifier.set(nullifier.toString(), noteIndex);
+
+        await this.#nullifierToNoteId.delete(nullifier.toString());
+      }
+      return nullifiedNotes;
+    });
+  }
+
+  async getSize() {
+    return (await this.getNotes({})).reduce((sum, note) => sum + note.getSize(), 0);
+  }
+}

package/src/storage/sync_data_provider/index.ts

@@ -0,0 +1 @@
+export { SyncDataProvider } from './sync_data_provider.js';

package/src/storage/sync_data_provider/sync_data_provider.ts

@@ -0,0 +1,40 @@
+import type { AztecAsyncKVStore, AztecAsyncSingleton } from '@aztec/kv-store';
+import { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { DataProvider } from '../data_provider.js';
+
+export class SyncDataProvider implements DataProvider {
+  #store: AztecAsyncKVStore;
+  #synchronizedHeader: AztecAsyncSingleton<Buffer>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+    this.#synchronizedHeader = this.#store.openSingleton('header');
+  }
+
+  async setHeader(header: BlockHeader): Promise<void> {
+    await this.#synchronizedHeader.set(header.toBuffer());
+  }
+
+  async getBlockNumber(): Promise<number | undefined> {
+    const headerBuffer = await this.#synchronizedHeader.getAsync();
+    if (!headerBuffer) {
+      return undefined;
+    }
+
+    return Number(BlockHeader.fromBuffer(headerBuffer).globalVariables.blockNumber.toBigInt());
+  }
+
+  async getBlockHeader(): Promise<BlockHeader> {
+    const headerBuffer = await this.#synchronizedHeader.getAsync();
+    if (!headerBuffer) {
+      throw new Error(`Header not set`);
+    }
+
+    return BlockHeader.fromBuffer(headerBuffer);
+  }
+
+  async getSize(): Promise<number> {
+    return (await this.#synchronizedHeader.getAsync())?.length ?? 0;
+  }
+}

package/src/storage/tagging_data_provider/index.ts

@@ -0,0 +1 @@
+export { TaggingDataProvider } from './tagging_data_provider.js';