@aztec/pxe 0.77.1 → 0.78.1

package/src/pxe_service/pxe_service.ts

@@ -3,8 +3,9 @@ import { Fr, type Point } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { SiblingPath } from '@aztec/foundation/trees';
-import type { KeyStore } from '@aztec/key-store';
-import type { L2TipsStore } from '@aztec/kv-store/stores';
+import { KeyStore } from '@aztec/key-store';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { L2TipsStore } from '@aztec/kv-store/stores';
 import {
   ProtocolContractAddress,
   type ProtocolContractsProvider,
@@ -24,12 +25,12 @@ import {
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { InBlock, L2Block } from '@aztec/stdlib/block';
-import type {
+import {
   CompleteAddress,
-  ContractClassWithId,
-  ContractInstanceWithAddress,
-  NodeInfo,
-  PartialAddress,
+  type ContractClassWithId,
+  type ContractInstanceWithAddress,
+  type NodeInfo,
+  type PartialAddress,
 } from '@aztec/stdlib/contract';
 import { computeContractAddressFromInstance, getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
@@ -50,6 +51,7 @@ import { computeAddressSecret } from '@aztec/stdlib/keys';
 import type { LogFilter } from '@aztec/stdlib/logs';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { type NotesFilter, UniqueNote } from '@aztec/stdlib/note';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   PrivateExecutionResult,
   PrivateSimulationResult,
@@ -67,11 +69,16 @@ import { inspect } from 'util';
 
 import type { PXEServiceConfig } from '../config/index.js';
 import { getPackageInfo } from '../config/package_info.js';
-import { ContractDataProvider } from '../contract_data_provider/index.js';
-import type { PxeDatabase } from '../database/index.js';
 import { KernelOracle } from '../kernel_oracle/index.js';
 import { KernelProver, type ProvingConfig } from '../kernel_prover/kernel_prover.js';
-import { PXEDataProvider } from '../pxe_data_provider/index.js';
+import { PXEOracleInterface } from '../pxe_oracle_interface/index.js';
+import { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
+import { AuthWitnessDataProvider } from '../storage/auth_witness_data_provider/auth_witness_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 { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
+import { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
 import { Synchronizer } from '../synchronizer/index.js';
 import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
 
@@ -79,53 +86,102 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
  * A Private eXecution Environment (PXE) implementation.
  */
 export class PXEService implements PXE {
-  private synchronizer: Synchronizer;
-  private contractDataProvider: ContractDataProvider;
-  private pxeDataProvider: PXEDataProvider;
-  private simulator: AcirSimulator;
-  private log: Logger;
-  private packageVersion: string;
-  private proverEnabled: boolean;
-
-  constructor(
-    private keyStore: KeyStore,
+  private constructor(
     private node: AztecNode,
-    private db: PxeDatabase,
-    tipsStore: L2TipsStore,
+    private synchronizer: Synchronizer,
+    private keyStore: KeyStore,
+    private contractDataProvider: ContractDataProvider,
+    private noteDataProvider: NoteDataProvider,
+    private capsuleDataProvider: CapsuleDataProvider,
+    private syncDataProvider: SyncDataProvider,
+    private taggingDataProvider: TaggingDataProvider,
+    private addressDataProvider: AddressDataProvider,
+    private authWitnessDataProvider: AuthWitnessDataProvider,
+    private simulator: AcirSimulator,
+    private packageVersion: string,
+    private proverEnabled: boolean,
     private proofCreator: PrivateKernelProver,
-    simulationProvider: SimulationProvider,
     private protocolContractsProvider: ProtocolContractsProvider,
+    private log: Logger,
+  ) {}
+
+  /**
+   * Creates an instance of a PXE Service by instantiating all the necessary data providers and services.
+   * Also triggers the registration of the protocol contracts and makes sure the provided node
+   * can be contacted.
+   *
+   * @returns A promise that resolves PXE service is ready to be used.
+   */
+  public static async create(
+    node: AztecNode,
+    store: AztecAsyncKVStore,
+    proofCreator: PrivateKernelProver,
+    simulationProvider: SimulationProvider,
+    protocolContractsProvider: ProtocolContractsProvider,
     config: PXEServiceConfig,
     loggerOrSuffix?: string | Logger,
   ) {
-    this.log =
+    const log =
       !loggerOrSuffix || typeof loggerOrSuffix === 'string'
         ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`)
         : loggerOrSuffix;
-    this.synchronizer = new Synchronizer(node, db, tipsStore, config, loggerOrSuffix);
-    this.contractDataProvider = new ContractDataProvider(db);
-    this.pxeDataProvider = new PXEDataProvider(
-      db,
-      keyStore,
+
+    const packageVersion = getPackageInfo().version;
+    const proverEnabled = !!config.proverEnabled;
+    const addressDataProvider = new AddressDataProvider(store);
+    const authWitnessDataProvider = new AuthWitnessDataProvider(store);
+    const contractDataProvider = new ContractDataProvider(store);
+    const noteDataProvider = await NoteDataProvider.create(store);
+    const syncDataProvider = new SyncDataProvider(store);
+    const taggingDataProvider = new TaggingDataProvider(store);
+    const capsuleDataProvider = new CapsuleDataProvider(store);
+    const keyStore = new KeyStore(store);
+    const tipsStore = new L2TipsStore(store, 'pxe');
+    const synchronizer = new Synchronizer(
       node,
+      syncDataProvider,
+      noteDataProvider,
+      taggingDataProvider,
+      tipsStore,
+      config,
+      loggerOrSuffix,
+    );
+    const pxeOracleInterface = new PXEOracleInterface(
+      node,
+      keyStore,
       simulationProvider,
-      this.contractDataProvider,
-      this.log,
+      contractDataProvider,
+      noteDataProvider,
+      capsuleDataProvider,
+      syncDataProvider,
+      taggingDataProvider,
+      addressDataProvider,
+      authWitnessDataProvider,
+      log,
     );
-    this.simulator = new AcirSimulator(this.pxeDataProvider, simulationProvider);
-    this.packageVersion = getPackageInfo().version;
-    this.proverEnabled = !!config.proverEnabled;
-  }
-
-  /**
-   * Starts the PXE Service by beginning the synchronization process between the Aztec node and the database.
-   *
-   * @returns A promise that resolves when the server has started successfully.
-   */
-  public async init() {
-    await this.#registerProtocolContracts();
-    const info = await this.getNodeInfo();
-    this.log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
+    const simulator = new AcirSimulator(pxeOracleInterface, simulationProvider);
+    const pxeService = new PXEService(
+      node,
+      synchronizer,
+      keyStore,
+      contractDataProvider,
+      noteDataProvider,
+      capsuleDataProvider,
+      syncDataProvider,
+      taggingDataProvider,
+      addressDataProvider,
+      authWitnessDataProvider,
+      simulator,
+      packageVersion,
+      proverEnabled,
+      proofCreator,
+      protocolContractsProvider,
+      log,
+    );
+    await pxeService.#registerProtocolContracts();
+    const info = await pxeService.getNodeInfo();
+    log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
+    return pxeService;
   }
 
   isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
@@ -133,24 +189,34 @@ export class PXEService implements PXE {
   }
 
   /** Returns an estimate of the db size in bytes. */
-  public estimateDbSize() {
-    return this.db.estimateSize();
+  public async estimateDbSize() {
+    const treeRootsSize = Object.keys(MerkleTreeId).length * Fr.SIZE_IN_BYTES;
+    const dbSizes = await Promise.all([
+      this.addressDataProvider.getSize(),
+      this.authWitnessDataProvider.getSize(),
+      this.capsuleDataProvider.getSize(),
+      this.contractDataProvider.getSize(),
+      this.noteDataProvider.getSize(),
+      this.syncDataProvider.getSize(),
+      this.taggingDataProvider.getSize(),
+    ]);
+    return [...dbSizes, treeRootsSize].reduce((sum, size) => sum + size, 0);
   }
 
   public addAuthWitness(witness: AuthWitness) {
-    return this.db.addAuthWitness(witness.requestHash, witness.witness);
+    return this.authWitnessDataProvider.addAuthWitness(witness.requestHash, witness.witness);
   }
 
   public getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
-    return this.db.getAuthWitness(messageHash);
+    return this.authWitnessDataProvider.getAuthWitness(messageHash);
   }
 
   public storeCapsule(contract: AztecAddress, storageSlot: Fr, capsule: Fr[]) {
-    return this.db.storeCapsule(contract, storageSlot, capsule);
+    return this.capsuleDataProvider.storeCapsule(contract, storageSlot, capsule);
   }
 
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return this.db.getContractInstance(address);
+    return this.contractDataProvider.getContractInstance(address);
   }
 
   public async getContractClassMetadata(
@@ -161,7 +227,12 @@ export class PXEService implements PXE {
     isContractClassPubliclyRegistered: boolean;
     artifact: ContractArtifact | undefined;
   }> {
-    const artifact = await this.db.getContractArtifact(id);
+    let artifact;
+    try {
+      artifact = await this.contractDataProvider.getContractArtifact(id);
+    } catch {
+      this.log.warn(`No artifact found for contract class ${id.toString()} when looking for its metadata`);
+    }
 
     return {
       contractClass: artifact && (await getContractClassFromArtifact(artifact)),
@@ -175,8 +246,14 @@ export class PXEService implements PXE {
     isContractInitialized: boolean;
     isContractPubliclyDeployed: boolean;
   }> {
+    let instance;
+    try {
+      instance = await this.contractDataProvider.getContractInstance(address);
+    } catch {
+      this.log.warn(`No instance found for contract ${address.toString()} when looking for its metadata`);
+    }
     return {
-      contractInstance: await this.db.getContractInstance(address),
+      contractInstance: instance,
       isContractInitialized: await this.#isContractInitialized(address),
       isContractPubliclyDeployed: await this.#isContractPubliclyDeployed(address),
     };
@@ -193,7 +270,8 @@ export class PXEService implements PXE {
       this.log.debug(`Registered account\n ${accountCompleteAddress.toReadableString()}`);
     }
 
-    await this.db.addCompleteAddress(accountCompleteAddress);
+    await this.addressDataProvider.addCompleteAddress(accountCompleteAddress);
+    await this.noteDataProvider.addScope(accountCompleteAddress.address);
     return accountCompleteAddress;
   }
 
@@ -204,7 +282,7 @@ export class PXEService implements PXE {
       return address;
     }
 
-    const wasAdded = await this.db.addSenderAddress(address);
+    const wasAdded = await this.taggingDataProvider.addSenderAddress(address);
 
     if (wasAdded) {
       this.log.info(`Added sender:\n ${address.toString()}`);
@@ -216,13 +294,13 @@ export class PXEService implements PXE {
   }
 
   public getSenders(): Promise<AztecAddress[]> {
-    const senders = this.db.getSenderAddresses();
+    const senders = this.taggingDataProvider.getSenderAddresses();
 
     return Promise.resolve(senders);
   }
 
   public async removeSender(address: AztecAddress): Promise<void> {
-    const wasRemoved = await this.db.removeSenderAddress(address);
+    const wasRemoved = await this.taggingDataProvider.removeSenderAddress(address);
 
     if (wasRemoved) {
       this.log.info(`Removed sender:\n ${address.toString()}`);
@@ -235,7 +313,7 @@ export class PXEService implements PXE {
 
   public async getRegisteredAccounts(): Promise<CompleteAddress[]> {
     // Get complete addresses of both the recipients and the accounts
-    const completeAddresses = await this.db.getCompleteAddresses();
+    const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
     // Filter out the addresses not corresponding to accounts
     const accounts = await this.keyStore.getAccounts();
     return completeAddresses.filter(completeAddress =>
@@ -245,7 +323,7 @@ export class PXEService implements PXE {
 
   public async registerContractClass(artifact: ContractArtifact): Promise<void> {
     const { id: contractClassId } = await getContractClassFromArtifact(artifact);
-    await this.db.addContractArtifact(contractClassId, artifact);
+    await this.contractDataProvider.addContractArtifact(contractClassId, artifact);
     this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
   }
 
@@ -266,8 +344,7 @@ export class PXEService implements PXE {
       if (!computedAddress.equals(instance.address)) {
         throw new Error('Added a contract in which the address does not match the contract instance.');
       }
-
-      await this.db.addContractArtifact(contractClass.id, artifact);
+      await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
 
       const publicFunctionSignatures = artifact.functions
         .filter(fn => fn.functionType === FunctionType.PUBLIC)
@@ -278,41 +355,33 @@ export class PXEService implements PXE {
       await this.node.addContractClass({ ...contractClass, privateFunctions: [], unconstrainedFunctions: [] });
     } else {
       // Otherwise, make sure there is an artifact already registered for that class id
-      artifact = await this.db.getContractArtifact(instance.currentContractClassId);
-      if (!artifact) {
-        throw new Error(
-          `Missing contract artifact for class id ${instance.currentContractClassId} for contract ${instance.address}`,
-        );
-      }
+      artifact = await this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
     }
 
-    await this.db.addContractInstance(instance);
+    await this.contractDataProvider.addContractInstance(instance);
     this.log.info(
       `Added contract ${artifact.name} at ${instance.address.toString()} with class ${instance.currentContractClassId}`,
     );
   }
 
   public async updateContract(contractAddress: AztecAddress, artifact: ContractArtifact): Promise<void> {
-    const currentInstance = await this.db.getContractInstance(contractAddress);
-    if (!currentInstance) {
-      throw new Error(`Contract ${contractAddress.toString()} is not registered.`);
-    }
+    const currentInstance = await this.contractDataProvider.getContractInstance(contractAddress);
     const contractClass = await getContractClassFromArtifact(artifact);
     await this.synchronizer.sync();
 
-    const header = await this.db.getBlockHeader();
+    const header = await this.syncDataProvider.getBlockHeader();
 
     const currentClassId = await readCurrentClassId(
       contractAddress,
       currentInstance,
-      this.pxeDataProvider,
+      this.node,
       header.globalVariables.blockNumber.toNumber(),
     );
     if (!contractClass.id.equals(currentClassId)) {
       throw new Error('Could not update contract to a class different from the current one.');
     }
 
-    await this.db.addContractArtifact(contractClass.id, artifact);
+    await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
 
     const publicFunctionSignatures = artifact.functions
       .filter(fn => fn.functionType === FunctionType.PUBLIC)
@@ -322,28 +391,25 @@ export class PXEService implements PXE {
     // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
     await this.node.addContractClass({ ...contractClass, privateFunctions: [], unconstrainedFunctions: [] });
     currentInstance.currentContractClassId = contractClass.id;
-    await this.db.addContractInstance(currentInstance);
+    await this.contractDataProvider.addContractInstance(currentInstance);
     this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
   }
 
   public getContracts(): Promise<AztecAddress[]> {
-    return this.db.getContractsAddresses();
+    return this.contractDataProvider.getContractsAddresses();
   }
 
   public async getPublicStorageAt(contract: AztecAddress, slot: Fr) {
-    if (!(await this.getContractInstance(contract))) {
-      throw new Error(`Contract ${contract.toString()} is not deployed`);
-    }
     return await this.node.getPublicStorageAt('latest', contract, slot);
   }
 
   public async getNotes(filter: NotesFilter): Promise<UniqueNote[]> {
-    const noteDaos = await this.db.getNotes(filter);
+    const noteDaos = await this.noteDataProvider.getNotes(filter);
 
     const extendedNotes = noteDaos.map(async dao => {
       let owner = filter.owner;
       if (owner === undefined) {
-        const completeAddresses = await this.db.getCompleteAddresses();
+        const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
         const completeAddressIndex = (
           await Promise.all(completeAddresses.map(completeAddresses => completeAddresses.address.toAddressPoint()))
         ).findIndex(addressPoint => addressPoint.equals(dao.addressPoint));
@@ -559,7 +625,7 @@ export class PXEService implements PXE {
   }
 
   async #getFunctionCall(functionName: string, args: any[], to: AztecAddress): Promise<FunctionCall> {
-    const contract = await this.db.getContract(to);
+    const contract = await this.contractDataProvider.getContract(to);
     if (!contract) {
       throw new Error(
         `Unknown contract ${to}: add it to PXE Service by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/reference/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`,
@@ -622,8 +688,8 @@ export class PXEService implements PXE {
     for (const name of protocolContractNames) {
       const { address, contractClass, instance, artifact } =
         await this.protocolContractsProvider.getProtocolContractArtifact(name);
-      await this.db.addContractArtifact(contractClass.id, artifact);
-      await this.db.addContractInstance(instance);
+      await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
+      await this.contractDataProvider.addContractInstance(instance);
       registered[name] = address.toString();
     }
     this.log.verbose(`Registered protocol contracts in pxe`, registered);
@@ -661,7 +727,7 @@ export class PXEService implements PXE {
       return result;
     } catch (err) {
       if (err instanceof SimulationError) {
-        await enrichSimulationError(err, this.db, this.log);
+        await enrichSimulationError(err, this.contractDataProvider, this.log);
       }
       throw err;
     }
@@ -687,7 +753,7 @@ export class PXEService implements PXE {
       return result;
     } catch (err) {
       if (err instanceof SimulationError) {
-        await enrichSimulationError(err, this.db, this.log);
+        await enrichSimulationError(err, this.contractDataProvider, this.log);
       }
       throw err;
     }
@@ -711,7 +777,7 @@ export class PXEService implements PXE {
     } catch (err) {
       if (err instanceof SimulationError) {
         try {
-          await enrichPublicSimulationError(err, this.contractDataProvider, this.db, this.log);
+          await enrichPublicSimulationError(err, this.contractDataProvider, this.log);
         } catch (enrichErr) {
           this.log.error(`Failed to enrich public simulation error: ${enrichErr}`);
         }
@@ -864,7 +930,7 @@ export class PXEService implements PXE {
   }
 
   async resetNoteSyncData() {
-    return await this.db.resetNoteSyncData();
+    return await this.taggingDataProvider.resetNoteSyncData();
   }
 
   private contextualizeError(err: Error, ...context: string[]): Error {

package/src/storage/address_data_provider/address_data_provider.ts

@@ -0,0 +1,71 @@
+import { toArray } from '@aztec/foundation/iterable';
+import type { AztecAsyncArray, AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+
+import type { DataProvider } from '../data_provider.js';
+
+export class AddressDataProvider implements DataProvider {
+  #store: AztecAsyncKVStore;
+  #completeAddresses: AztecAsyncArray<Buffer>;
+  #completeAddressIndex: AztecAsyncMap<string, number>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+
+    this.#completeAddresses = this.#store.openArray('complete_addresses');
+    this.#completeAddressIndex = this.#store.openMap('complete_address_index');
+  }
+
+  addCompleteAddress(completeAddress: CompleteAddress): Promise<boolean> {
+    return this.#store.transactionAsync(async () => {
+      // TODO readd this
+      // await this.#addScope(completeAddress.address);
+
+      const addressString = completeAddress.address.toString();
+      const buffer = completeAddress.toBuffer();
+      const existing = await this.#completeAddressIndex.getAsync(addressString);
+      if (existing === undefined) {
+        const index = await this.#completeAddresses.lengthAsync();
+        await this.#completeAddresses.push(buffer);
+        await this.#completeAddressIndex.set(addressString, index);
+
+        return true;
+      } else {
+        const existingBuffer = await this.#completeAddresses.atAsync(existing);
+
+        if (existingBuffer && Buffer.from(existingBuffer).equals(buffer)) {
+          return false;
+        }
+
+        throw new Error(
+          `Complete address with aztec address ${addressString} but different public key or partial key already exists in memory database`,
+        );
+      }
+    });
+  }
+
+  async #getCompleteAddress(address: AztecAddress): Promise<CompleteAddress | undefined> {
+    const index = await this.#completeAddressIndex.getAsync(address.toString());
+    if (index === undefined) {
+      return undefined;
+    }
+
+    const value = await this.#completeAddresses.atAsync(index);
+    return value ? await CompleteAddress.fromBuffer(value) : undefined;
+  }
+
+  getCompleteAddress(account: AztecAddress): Promise<CompleteAddress | undefined> {
+    return this.#getCompleteAddress(account);
+  }
+
+  async getCompleteAddresses(): Promise<CompleteAddress[]> {
+    return await Promise.all(
+      (await toArray(this.#completeAddresses.valuesAsync())).map(v => CompleteAddress.fromBuffer(v)),
+    );
+  }
+
+  async getSize(): Promise<number> {
+    return (await this.#completeAddresses.lengthAsync()) * CompleteAddress.SIZE_IN_BYTES;
+  }
+}

package/src/storage/address_data_provider/index.ts

@@ -0,0 +1 @@
+export { AddressDataProvider } from './address_data_provider.js';

package/src/storage/auth_witness_data_provider/auth_witness_data_provider.ts

@@ -0,0 +1,34 @@
+import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+
+import type { DataProvider } from '../data_provider.js';
+
+export class AuthWitnessDataProvider implements DataProvider {
+  #store: AztecAsyncKVStore;
+  #authWitnesses: AztecAsyncMap<string, Buffer[]>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+    this.#authWitnesses = this.#store.openMap('auth_witnesses');
+  }
+
+  async addAuthWitness(messageHash: Fr, witness: Fr[]): Promise<void> {
+    await this.#authWitnesses.set(
+      messageHash.toString(),
+      witness.map(w => w.toBuffer()),
+    );
+  }
+
+  async getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
+    const witness = await this.#authWitnesses.getAsync(messageHash.toString());
+    return witness?.map(w => Fr.fromBuffer(w));
+  }
+
+  async getSize(): Promise<number> {
+    return (await toArray(this.#authWitnesses.valuesAsync())).reduce(
+      (sum, value) => sum + value.length * Fr.SIZE_IN_BYTES,
+      0,
+    );
+  }
+}

package/src/storage/auth_witness_data_provider/index.ts

@@ -0,0 +1 @@
+export { AuthWitnessDataProvider } from './auth_witness_data_provider.js';

package/src/storage/capsule_data_provider/capsule_data_provider.ts

@@ -0,0 +1,80 @@
+import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
+import { type LogFn, createDebugOnlyLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import type { DataProvider } from '../data_provider.js';
+
+export class CapsuleDataProvider implements DataProvider {
+  #store: AztecAsyncKVStore;
+
+  // Arbitrary data stored by contracts. Key is computed as `${contractAddress}:${key}`
+  #capsules: AztecAsyncMap<string, Buffer>;
+
+  debug: LogFn;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+
+    this.#capsules = this.#store.openMap('capsules');
+
+    this.debug = createDebugOnlyLogger('pxe:capsule-data-provider');
+  }
+
+  async storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
+    await this.#capsules.set(dbSlotToKey(contractAddress, slot), Buffer.concat(capsule.map(value => value.toBuffer())));
+  }
+
+  async loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+    const dataBuffer = await this.#capsules.getAsync(dbSlotToKey(contractAddress, slot));
+    if (!dataBuffer) {
+      this.debug(`Data not found for contract ${contractAddress.toString()} and slot ${slot.toString()}`);
+      return null;
+    }
+    const capsule: Fr[] = [];
+    for (let i = 0; i < dataBuffer.length; i += Fr.SIZE_IN_BYTES) {
+      capsule.push(Fr.fromBuffer(dataBuffer.subarray(i, i + Fr.SIZE_IN_BYTES)));
+    }
+    return capsule;
+  }
+
+  async deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+    await this.#capsules.delete(dbSlotToKey(contractAddress, slot));
+  }
+
+  async copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
+    // In order to support overlapping source and destination regions, we need to check the relative positions of source
+    // and destination. If destination is ahead of source, then by the time we overwrite source elements using forward
+    // indexes we'll have already read those. On the contrary, if source is ahead of destination we need to use backward
+    // indexes to avoid reading elements that've been overwritten.
+
+    const indexes = Array.from(Array(numEntries).keys());
+    if (srcSlot.lt(dstSlot)) {
+      indexes.reverse();
+    }
+
+    for (const i of indexes) {
+      const currentSrcSlot = dbSlotToKey(contractAddress, srcSlot.add(new Fr(i)));
+      const currentDstSlot = dbSlotToKey(contractAddress, dstSlot.add(new Fr(i)));
+
+      const toCopy = await this.#capsules.getAsync(currentSrcSlot);
+      if (!toCopy) {
+        throw new Error(`Attempted to copy empty slot ${currentSrcSlot} for contract ${contractAddress.toString()}`);
+      }
+
+      await this.#capsules.set(currentDstSlot, toCopy);
+    }
+  }
+
+  public async getSize() {
+    return (await toArray(this.#capsules.valuesAsync())).reduce(
+      (sum, value) => sum + value.length * Fr.SIZE_IN_BYTES,
+      0,
+    );
+  }
+}
+
+function dbSlotToKey(contractAddress: AztecAddress, slot: Fr): string {
+  return `${contractAddress.toString()}:${slot.toString()}`;
+}

package/src/storage/capsule_data_provider/index.ts

@@ -0,0 +1 @@
+export { CapsuleDataProvider } from './capsule_data_provider.js';