@aztec/pxe 0.77.0 → 0.78.0

package/src/kernel_prover/kernel_prover.ts

@@ -21,9 +21,7 @@ import {
   PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
   PrivateVerificationKeyHints,
-  type ScopedPrivateLogData,
 } from '@aztec/stdlib/kernel';
-import type { PrivateLog } from '@aztec/stdlib/logs';
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import {
   type PrivateCallExecutionResult,
@@ -38,48 +36,10 @@ import {
 import { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 
 import type { WitnessMap } from '@noir-lang/types';
-import { strict as assert } from 'assert';
 
 import { PrivateKernelResetPrivateInputsBuilder } from './hints/build_private_kernel_reset_private_inputs.js';
 import type { ProvingDataOracle } from './proving_data_oracle.js';
 
-// TODO(#10592): Temporary workaround to check that the private logs are correctly split into non-revertible set and revertible set.
-// This should be done in TailToPublicOutputValidator in private kernel tail.
-function checkPrivateLogs(
-  privateLogs: ScopedPrivateLogData[],
-  nonRevertiblePrivateLogs: PrivateLog[],
-  revertiblePrivateLogs: PrivateLog[],
-  splitCounter: number,
-) {
-  let numNonRevertible = 0;
-  let numRevertible = 0;
-  privateLogs
-    .filter(privateLog => privateLog.inner.counter !== 0)
-    .forEach(privateLog => {
-      if (privateLog.inner.counter < splitCounter) {
-        assert(
-          privateLog.inner.log.toBuffer().equals(nonRevertiblePrivateLogs[numNonRevertible].toBuffer()),
-          `mismatch non-revertible private logs at index ${numNonRevertible}`,
-        );
-        numNonRevertible++;
-      } else {
-        assert(
-          privateLog.inner.log.toBuffer().equals(revertiblePrivateLogs[numRevertible].toBuffer()),
-          `mismatch revertible private logs at index ${numRevertible}`,
-        );
-        numRevertible++;
-      }
-    });
-  assert(
-    nonRevertiblePrivateLogs.slice(numNonRevertible).every(l => l.isEmpty()),
-    'Unexpected non-empty private log in non-revertible set.',
-  );
-  assert(
-    revertiblePrivateLogs.slice(numRevertible).every(l => l.isEmpty()),
-    'Unexpected non-empty private log in revertible set.',
-  );
-}
-
 const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs> = {
   publicInputs: PrivateKernelCircuitPublicInputs.empty(),
   verificationKey: VerificationKeyAsFields.makeEmpty(CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS),
@@ -309,12 +269,6 @@ export class KernelProver {
     const tailOutput = generateWitnesses
       ? await this.proofCreator.generateTailOutput(privateInputs)
       : await this.proofCreator.simulateTail(privateInputs);
-    if (tailOutput.publicInputs.forPublic) {
-      const privateLogs = privateInputs.previousKernel.publicInputs.end.privateLogs;
-      const nonRevertiblePrivateLogs = tailOutput.publicInputs.forPublic.nonRevertibleAccumulatedData.privateLogs;
-      const revertiblePrivateLogs = tailOutput.publicInputs.forPublic.revertibleAccumulatedData.privateLogs;
-      checkPrivateLogs(privateLogs, nonRevertiblePrivateLogs, revertiblePrivateLogs, validationRequestsSplitCounter);
-    }
 
     acirs.push(tailOutput.bytecode);
     witnessStack.push(tailOutput.outputWitness);

package/src/note_decryption_utils/add_public_values_to_payload.ts

@@ -2,7 +2,7 @@ import { ContractNotFoundError } from '@aztec/simulator/client';
 import type { L1NotePayload } from '@aztec/stdlib/logs';
 import { Note } from '@aztec/stdlib/note';
 
-import type { PxeDatabase } from '../database/interfaces/pxe_database.js';
+import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
 
 /**
  * Merges privately and publicly delivered note values.
@@ -11,21 +11,21 @@ import type { PxeDatabase } from '../database/interfaces/pxe_database.js';
  * @returns Note payload with public fields added.
  */
 export async function getOrderedNoteItems(
-  db: PxeDatabase,
+  contractDataProvider: ContractDataProvider,
   { contractAddress, noteTypeId, privateNoteValues, publicNoteValues }: L1NotePayload,
 ): Promise<Note> {
   if (publicNoteValues.length === 0) {
     return new Note(privateNoteValues);
   }
 
-  const instance = await db.getContractInstance(contractAddress);
+  const instance = await contractDataProvider.getContractInstance(contractAddress);
   if (!instance) {
     throw new ContractNotFoundError(
       `Could not find instance for ${contractAddress.toString()}. This should never happen here as the partial notes flow should be triggered only for non-deferred notes.`,
     );
   }
 
-  const artifact = await db.getContractArtifact(instance.currentContractClassId);
+  const artifact = await contractDataProvider.getContractArtifact(instance.currentContractClassId);
   if (!artifact) {
     throw new Error(
       `Could not find artifact for contract class ${instance.currentContractClassId.toString()}. This should never happen here as the partial notes flow should be triggered only for non-deferred notes.`,

package/src/{pxe_data_provider → pxe_oracle_interface}/index.ts

@@ -42,23 +42,33 @@ import { MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import { TxHash } from '@aztec/stdlib/tx';
 
-import { ContractDataProvider } from '../contract_data_provider/index.js';
-import type { PxeDatabase } from '../database/index.js';
-import { NoteDao } from '../database/note_dao.js';
 import { getOrderedNoteItems } from '../note_decryption_utils/add_public_values_to_payload.js';
+import type { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
+import type { AuthWitnessDataProvider } from '../storage/auth_witness_data_provider/auth_witness_data_provider.js';
+import type { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
+import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
+import { NoteDao } from '../storage/note_data_provider/note_dao.js';
+import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
+import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
+import type { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
 import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
 
 /**
  * A data layer that provides and stores information needed for simulating/proving a transaction.
  */
-export class PXEDataProvider implements ExecutionDataProvider {
+export class PXEOracleInterface implements ExecutionDataProvider {
   constructor(
-    private db: PxeDatabase,
-    private keyStore: KeyStore,
     private aztecNode: AztecNode,
+    private keyStore: KeyStore,
     private simulationProvider: SimulationProvider,
     private contractDataProvider: ContractDataProvider,
-    private log = createLogger('pxe:pxe_data_provider'),
+    private noteDataProvider: NoteDataProvider,
+    private capsuleDataProvider: CapsuleDataProvider,
+    private syncDataProvider: SyncDataProvider,
+    private taggingDataProvider: TaggingDataProvider,
+    private addressDataProvider: AddressDataProvider,
+    private authWitnessDataProvider: AuthWitnessDataProvider,
+    private log = createLogger('pxe:pxe_data_manager'),
   ) {}
 
   getKeyValidationRequest(pkMHash: Fr, contractAddress: AztecAddress): Promise<KeyValidationRequest> {
@@ -66,7 +76,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
   }
 
   async getCompleteAddress(account: AztecAddress): Promise<CompleteAddress> {
-    const completeAddress = await this.db.getCompleteAddress(account);
+    const completeAddress = await this.addressDataProvider.getCompleteAddress(account);
     if (!completeAddress) {
       throw new Error(
         `No public key registered for address ${account}.
@@ -77,23 +87,20 @@ export class PXEDataProvider implements ExecutionDataProvider {
   }
 
   async getContractInstance(address: AztecAddress): Promise<ContractInstance> {
-    const instance = await this.db.getContractInstance(address);
+    const instance = await this.contractDataProvider.getContractInstance(address);
     if (!instance) {
       throw new Error(`No contract instance found for address ${address.toString()}`);
     }
     return instance;
   }
 
-  async getAuthWitness(messageHash: Fr): Promise<Fr[]> {
-    const witness = await this.db.getAuthWitness(messageHash);
-    if (!witness) {
-      throw new Error(`Unknown auth witness for message hash ${messageHash.toString()}`);
-    }
+  async getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
+    const witness = await this.authWitnessDataProvider.getAuthWitness(messageHash);
     return witness;
   }
 
   async getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus, scopes?: AztecAddress[]) {
-    const noteDaos = await this.db.getNotes({
+    const noteDaos = await this.noteDataProvider.getNotes({
       contractAddress,
       storageSlot,
       status,
@@ -244,7 +251,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
    * @returns A Promise that resolves to a BlockHeader object.
    */
   getBlockHeader(): Promise<BlockHeader> {
-    return this.db.getBlockHeader();
+    return this.syncDataProvider.getBlockHeader();
   }
 
   /**
@@ -282,7 +289,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
    * @returns The full list of the users contact addresses.
    */
   public getSenders(): Promise<AztecAddress[]> {
-    return this.db.getSenderAddresses();
+    return this.taggingDataProvider.getSenderAddresses();
   }
 
   /**
@@ -301,7 +308,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
     await this.syncTaggedLogsAsSender(contractAddress, sender, recipient);
 
     const appTaggingSecret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
-    const [index] = await this.db.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
+    const [index] = await this.taggingDataProvider.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
 
     return new IndexedTaggingSecret(appTaggingSecret, index);
   }
@@ -327,8 +334,8 @@ export class PXEDataProvider implements ExecutionDataProvider {
       contractAddress,
     });
 
-    const [index] = await this.db.getTaggingSecretsIndexesAsSender([secret]);
-    await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(secret, index + 1)]);
+    const [index] = await this.taggingDataProvider.getTaggingSecretsIndexesAsSender([secret]);
+    await this.taggingDataProvider.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(secret, index + 1)]);
   }
 
   async #calculateAppTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress) {
@@ -358,16 +365,17 @@ export class PXEDataProvider implements ExecutionDataProvider {
 
     // 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 senders = [...(await this.db.getSenderAddresses()), ...(await this.keyStore.getAccounts())].filter(
-      (address, index, self) => index === self.findIndex(otherAddress => otherAddress.equals(address)),
-    );
+    const senders = [
+      ...(await this.taggingDataProvider.getSenderAddresses()),
+      ...(await this.keyStore.getAccounts()),
+    ].filter((address, index, self) => index === self.findIndex(otherAddress => otherAddress.equals(address)));
     const appTaggingSecrets = await Promise.all(
       senders.map(async contact => {
         const sharedSecret = await computeTaggingSecretPoint(recipientCompleteAddress, recipientIvsk, contact);
         return poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
       }),
     );
-    const indexes = await this.db.getTaggingSecretsIndexesAsRecipient(appTaggingSecrets);
+    const indexes = await this.taggingDataProvider.getTaggingSecretsIndexesAsRecipient(appTaggingSecrets);
     return appTaggingSecrets.map((secret, i) => new IndexedTaggingSecret(secret, indexes[i]));
   }
 
@@ -384,7 +392,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
     recipient: AztecAddress,
   ): Promise<void> {
     const appTaggingSecret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
-    const [oldIndex] = await this.db.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
+    const [oldIndex] = await this.taggingDataProvider.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
 
     // This algorithm works such that:
     // 1. If we find minimum consecutive empty logs in a window of logs we set the index to the index of the last log
@@ -422,7 +430,9 @@ export class PXEDataProvider implements ExecutionDataProvider {
 
     const contractName = await this.contractDataProvider.getDebugContractName(contractAddress);
     if (currentIndex !== oldIndex) {
-      await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(appTaggingSecret, currentIndex)]);
+      await this.taggingDataProvider.setTaggingSecretsIndexesAsSender([
+        new IndexedTaggingSecret(appTaggingSecret, currentIndex),
+      ]);
 
       this.log.debug(`Syncing logs for sender ${sender} at contract ${contractName}(${contractAddress})`, {
         sender,
@@ -591,7 +601,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
       );
 
       // At this point we have processed all the logs for the recipient so we store the new largest indexes in the db.
-      await this.db.setTaggingSecretsIndexesAsRecipient(
+      await this.taggingDataProvider.setTaggingSecretsIndexesAsRecipient(
         Object.entries(newLargestIndexMapToStore).map(
           ([appTaggingSecret, index]) => new IndexedTaggingSecret(Fr.fromHexString(appTaggingSecret), index),
         ),
@@ -632,7 +642,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
         excludedIndices.set(scopedLog.txHash.toString(), new Set());
       }
 
-      const note = await getOrderedNoteItems(this.db, payload);
+      const note = await getOrderedNoteItems(this.contractDataProvider, payload);
       const plaintext = [payload.storageSlot, payload.noteTypeId.toField(), ...note.items];
 
       decrypted.push({ plaintext, txHash: scopedLog.txHash, contractAddress: payload.contractAddress });
@@ -680,7 +690,6 @@ export class PXEDataProvider implements ExecutionDataProvider {
     return;
   }
 
-  // Called when notes are delivered, usually as a result to a call to the process_log contract function
   public async deliverNote(
     contractAddress: AztecAddress,
     storageSlot: Fr,
@@ -691,23 +700,96 @@ export class PXEDataProvider implements ExecutionDataProvider {
     txHash: Fr,
     recipient: AztecAddress,
   ): Promise<void> {
-    const noteDao = await this.produceNoteDao(
+    // We are going to store the new note in the NoteDataProvider, 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
+    //
+    // Failing to do either of the above would result in circuits getting either non-existent notes and failing to
+    // produce inclusion proofs for them, or getting nullified notes and producing duplicate nullifiers, both of which
+    // are catastrophic failure modes.
+    //
+    // Note that adding a note and removing it is *not* equivalent to never adding it in the first place. A nullifier
+    // emitted in a block that comes after note creation might result in the note being de-nullified by a chain reorg,
+    // so we must store both the note hash and nullifier block information.
+
+    // We avoid making node queries at 'latest' since we don't want to process notes or nullifiers that only exist ahead
+    // in time of the locally synced state.
+    // Note that while this technically results in historical queries, we perform it at the latest locally synced block
+    // number which *should* be recent enough to be available, even for non-archive nodes.
+    const syncedBlockNumber = (await this.syncDataProvider.getBlockNumber())!;
+    // TODO (#12559): handle undefined syncedBlockNumber
+    // if (syncedBlockNumber === undefined) {
+    //  throw new Error(`Attempted to deliver a note with an unsynchronized PXE - this should never happen`);
+    //}
+
+    // 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.
+    const uniqueNoteHash = await computeUniqueNoteHash(nonce, await siloNoteHash(contractAddress, noteHash));
+    const siloedNullifier = await siloNullifier(contractAddress, nullifier);
+
+    // We store notes by their index in the global note hash tree, which has the convenient side effect of validating
+    // note existence in said tree.
+    const [uniqueNoteHashTreeIndex] = await this.aztecNode.findLeavesIndexes(
+      syncedBlockNumber,
+      MerkleTreeId.NOTE_HASH_TREE,
+      [uniqueNoteHash],
+    );
+    if (uniqueNoteHashTreeIndex === undefined) {
+      throw new Error(
+        `Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present on the tree at block ${syncedBlockNumber} (from tx ${txHash})`,
+      );
+    }
+
+    // TODO (#12550): findLeavesIndexes should probably return an InBlock, same as findNullifiersIndexesWithBlock. This
+    // would save us from having to then query the tx receipt in order to get the block hash and number. Note regardless
+    // that we're not validating that the note was indeed created in this tx (which would require inspecting the tx
+    // effects), so maybe what we really want is an InTx.
+    const txReceipt = await this.aztecNode.getTxReceipt(new TxHash(txHash));
+    if (txReceipt === undefined) {
+      throw new Error(`Failed to fetch tx receipt for tx hash ${txHash} when searching for note hashes`);
+    }
+
+    // TODO(#12549): does it make sense to store the recipient's address point instead of just its address?
+    const recipientAddressPoint = await recipient.toAddressPoint();
+    const noteDao = new NoteDao(
+      new Note(content),
       contractAddress,
       storageSlot,
       nonce,
-      content,
       noteHash,
-      nullifier,
-      txHash,
-      recipient,
+      siloedNullifier,
+      new TxHash(txHash),
+      txReceipt.blockNumber!,
+      txReceipt.blockHash!.toString(),
+      uniqueNoteHashTreeIndex,
+      recipientAddressPoint,
+      NoteSelector.empty(), // TODO(#12013): remove
     );
 
-    await this.db.addNotes([noteDao], recipient);
+    await this.noteDataProvider.addNotes([noteDao], recipient);
     this.log.verbose('Added note', {
       contract: noteDao.contractAddress,
       slot: noteDao.storageSlot,
-      nullifier: noteDao.siloedNullifier.toString,
+      noteHash: noteDao.noteHash,
+      nullifier: noteDao.siloedNullifier.toString(),
     });
+
+    const [nullifierIndex] = await this.aztecNode.findNullifiersIndexesWithBlock(syncedBlockNumber, [siloedNullifier]);
+    if (nullifierIndex !== undefined) {
+      const { data: _, ...blockHashAndNum } = nullifierIndex;
+      await this.noteDataProvider.removeNullifiedNotes(
+        [{ data: siloedNullifier, ...blockHashAndNum }],
+        recipientAddressPoint,
+      );
+
+      this.log.verbose(`Removed just-added note`, {
+        contract: contractAddress,
+        slot: storageSlot,
+        noteHash: noteHash,
+        nullifier: siloedNullifier.toString(),
+      });
+    }
   }
 
   public async getLogByTag(tag: Fr): Promise<LogWithTxData | null> {
@@ -751,7 +833,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
     this.log.verbose('Searching for nullifiers of known notes', { contract: contractAddress });
 
     for (const recipient of await this.keyStore.getAccounts()) {
-      const currentNotesForRecipient = await this.db.getNotes({ contractAddress, owner: recipient });
+      const currentNotesForRecipient = await this.noteDataProvider.getNotes({ contractAddress, owner: recipient });
       const nullifiersToCheck = currentNotesForRecipient.map(note => note.siloedNullifier);
       const nullifierIndexes = await this.aztecNode.findNullifiersIndexesWithBlock('latest', nullifiersToCheck);
 
@@ -763,7 +845,10 @@ export class PXEDataProvider implements ExecutionDataProvider {
         })
         .filter(nullifier => nullifier !== undefined) as InBlock<Fr>[];
 
-      const nullifiedNotes = await this.db.removeNullifiedNotes(foundNullifiers, await recipient.toAddressPoint());
+      const nullifiedNotes = await this.noteDataProvider.removeNullifiedNotes(
+        foundNullifiers,
+        await recipient.toAddressPoint(),
+      );
       nullifiedNotes.forEach(noteDao => {
         this.log.verbose(`Removed note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
           contract: noteDao.contractAddress,
@@ -774,59 +859,6 @@ export class PXEDataProvider implements ExecutionDataProvider {
     }
   }
 
-  async produceNoteDao(
-    contractAddress: AztecAddress,
-    storageSlot: Fr,
-    nonce: Fr,
-    content: Fr[],
-    noteHash: Fr,
-    nullifier: Fr,
-    txHash: Fr,
-    recipient: AztecAddress,
-  ): Promise<NoteDao> {
-    // We need to validate that the note does indeed exist in the world state to avoid adding notes that are then
-    // impossible to prove.
-
-    const receipt = await this.aztecNode.getTxReceipt(new TxHash(txHash));
-    if (receipt === undefined) {
-      throw new Error(`Failed to fetch tx receipt for tx hash ${txHash} when searching for note hashes`);
-    }
-
-    // Siloed and unique hashes are computed by us instead of relying on values sent by the contract to make sure
-    // we're not e.g. storing notes that belong to some other contract, which would constitute a security breach.
-    const uniqueNoteHash = await computeUniqueNoteHash(nonce, await siloNoteHash(contractAddress, noteHash));
-    const siloedNullifier = await siloNullifier(contractAddress, nullifier);
-
-    // We store notes by their index in the global note hash tree, which has the convenient side effect of validating
-    // note existence in said tree. Note that while this is technically a historical query, we perform it at the latest
-    // locally synced block number which *should* be recent enough to be available. We avoid querying at 'latest' since
-    // we want to avoid accidentally processing notes that only exist ahead in time of the locally synced state.
-    const syncedBlockNumber = await this.db.getBlockNumber();
-    const uniqueNoteHashTreeIndex = (
-      await this.aztecNode.findLeavesIndexes(syncedBlockNumber!, MerkleTreeId.NOTE_HASH_TREE, [uniqueNoteHash])
-    )[0];
-    if (uniqueNoteHashTreeIndex === undefined) {
-      throw new Error(
-        `Note hash ${noteHash} (uniqued as ${uniqueNoteHash}) is not present on the tree at block ${syncedBlockNumber} (from tx ${txHash})`,
-      );
-    }
-
-    return new NoteDao(
-      new Note(content),
-      contractAddress,
-      storageSlot,
-      nonce,
-      noteHash,
-      siloedNullifier,
-      new TxHash(txHash),
-      receipt.blockNumber!,
-      receipt.blockHash!.toString(),
-      uniqueNoteHashTreeIndex,
-      await recipient.toAddressPoint(),
-      NoteSelector.empty(), // TODO(#12013): remove
-    );
-  }
-
   async callProcessLog(
     contractAddress: AztecAddress,
     logPlaintext: Fr[],
@@ -836,7 +868,7 @@ export class PXEDataProvider implements ExecutionDataProvider {
     recipient: AztecAddress,
     simulator?: AcirSimulator,
   ) {
-    const artifact: FunctionArtifact | undefined = await new ContractDataProvider(this.db).getFunctionArtifactByName(
+    const artifact: FunctionArtifact | undefined = await this.contractDataProvider.getFunctionArtifactByName(
       contractAddress,
       'process_log',
     );
@@ -872,19 +904,19 @@ export class PXEDataProvider implements ExecutionDataProvider {
   }
 
   storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
-    return this.db.storeCapsule(contractAddress, slot, capsule);
+    return this.capsuleDataProvider.storeCapsule(contractAddress, slot, capsule);
   }
 
   loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
-    return this.db.loadCapsule(contractAddress, slot);
+    return this.capsuleDataProvider.loadCapsule(contractAddress, slot);
   }
 
   deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
-    return this.db.deleteCapsule(contractAddress, slot);
+    return this.capsuleDataProvider.deleteCapsule(contractAddress, slot);
   }
 
   copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
-    return this.db.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
+    return this.capsuleDataProvider.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
   }
 }
 

package/src/pxe_service/error_enriching.ts

@@ -6,15 +6,18 @@ import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type SimulationError, isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
 
-import { ContractDataProvider } from '../contract_data_provider/index.js';
-import type { PxeDatabase } from '../database/interfaces/pxe_database.js';
+import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
 
 /**
  * Adds contract and function names to a simulation error, if they
  * can be found in the PXE database
  * @param err - The error to enrich.
  */
-export async function enrichSimulationError(err: SimulationError, db: PxeDatabase, logger: Logger) {
+export async function enrichSimulationError(
+  err: SimulationError,
+  contractDataProvider: ContractDataProvider,
+  logger: Logger,
+) {
   // Maps contract addresses to the set of function names that were in error.
   // Map and Set do reference equality for their keys instead of value equality, so we store the string
   // representation to get e.g. different contract address objects with the same address value to match.
@@ -30,7 +33,7 @@ export async function enrichSimulationError(err: SimulationError, db: PxeDatabas
   await Promise.all(
     [...mentionedFunctions.entries()].map(async ([contractAddress, fnNames]) => {
       const parsedContractAddress = AztecAddress.fromString(contractAddress);
-      const contract = await db.getContract(parsedContractAddress);
+      const contract = await contractDataProvider.getContract(parsedContractAddress);
       if (contract) {
         err.enrichWithContractName(parsedContractAddress, contract.name);
         for (const fnName of fnNames) {
@@ -59,7 +62,6 @@ export async function enrichSimulationError(err: SimulationError, db: PxeDatabas
 export async function enrichPublicSimulationError(
   err: SimulationError,
   contractDataProvider: ContractDataProvider,
-  db: PxeDatabase,
   logger: Logger,
 ) {
   const callStack = err.getCallStack();
@@ -99,6 +101,6 @@ export async function enrichPublicSimulationError(
         );
       }
     }
-    await enrichSimulationError(err, db, logger);
+    await enrichSimulationError(err, contractDataProvider, logger);
   }
 }