@aztec/pxe 0.77.1 → 0.78.1

package/dest/pxe_service/pxe_service.js

@@ -1,5 +1,8 @@
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import { KeyStore } from '@aztec/key-store';
+import { L2TipsStore } from '@aztec/kv-store/stores';
 import { ProtocolContractAddress, protocolContractNames } from '@aztec/protocol-contracts';
 import { AcirSimulator, readCurrentClassId } from '@aztec/simulator/client';
 import { EventSelector, FunctionSelector, FunctionType, decodeFunctionSignature, encodeArguments } from '@aztec/stdlib/abi';
@@ -10,73 +13,125 @@ import { siloNullifier } from '@aztec/stdlib/hash';
 import { computeAddressSecret } from '@aztec/stdlib/keys';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { UniqueNote } from '@aztec/stdlib/note';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { PrivateSimulationResult, TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
 import { inspect } from 'util';
 import { getPackageInfo } from '../config/package_info.js';
-import { ContractDataProvider } from '../contract_data_provider/index.js';
 import { KernelOracle } from '../kernel_oracle/index.js';
 import { KernelProver } 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';
 /**
  * A Private eXecution Environment (PXE) implementation.
  */ export class PXEService {
-    keyStore;
     node;
-    db;
-    proofCreator;
-    protocolContractsProvider;
     synchronizer;
+    keyStore;
     contractDataProvider;
-    pxeDataProvider;
+    noteDataProvider;
+    capsuleDataProvider;
+    syncDataProvider;
+    taggingDataProvider;
+    addressDataProvider;
+    authWitnessDataProvider;
     simulator;
-    log;
     packageVersion;
     proverEnabled;
-    constructor(keyStore, node, db, tipsStore, proofCreator, simulationProvider, protocolContractsProvider, config, loggerOrSuffix){
-        this.keyStore = keyStore;
+    proofCreator;
+    protocolContractsProvider;
+    log;
+    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, authWitnessDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log){
         this.node = node;
-        this.db = db;
+        this.synchronizer = synchronizer;
+        this.keyStore = keyStore;
+        this.contractDataProvider = contractDataProvider;
+        this.noteDataProvider = noteDataProvider;
+        this.capsuleDataProvider = capsuleDataProvider;
+        this.syncDataProvider = syncDataProvider;
+        this.taggingDataProvider = taggingDataProvider;
+        this.addressDataProvider = addressDataProvider;
+        this.authWitnessDataProvider = authWitnessDataProvider;
+        this.simulator = simulator;
+        this.packageVersion = packageVersion;
+        this.proverEnabled = proverEnabled;
         this.proofCreator = proofCreator;
         this.protocolContractsProvider = protocolContractsProvider;
-        this.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, node, simulationProvider, this.contractDataProvider, this.log);
-        this.simulator = new AcirSimulator(this.pxeDataProvider, simulationProvider);
-        this.packageVersion = getPackageInfo().version;
-        this.proverEnabled = !!config.proverEnabled;
+        this.log = log;
     }
     /**
-   * Starts the PXE Service by beginning the synchronization process between the Aztec node and the database.
+   * 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 when the server has started successfully.
-   */ async init() {
-        await this.#registerProtocolContracts();
-        const info = await this.getNodeInfo();
-        this.log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
+   * @returns A promise that resolves PXE service is ready to be used.
+   */ static async create(node, store, proofCreator, simulationProvider, protocolContractsProvider, config, loggerOrSuffix) {
+        const log = !loggerOrSuffix || typeof loggerOrSuffix === 'string' ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`) : loggerOrSuffix;
+        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, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, authWitnessDataProvider, log);
+        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) {
         return this.node.isL1ToL2MessageSynced(l1ToL2Message);
     }
-    /** Returns an estimate of the db size in bytes. */ estimateDbSize() {
-        return this.db.estimateSize();
+    /** Returns an estimate of the db size in bytes. */ 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);
     }
     addAuthWitness(witness) {
-        return this.db.addAuthWitness(witness.requestHash, witness.witness);
+        return this.authWitnessDataProvider.addAuthWitness(witness.requestHash, witness.witness);
     }
     getAuthWitness(messageHash) {
-        return this.db.getAuthWitness(messageHash);
+        return this.authWitnessDataProvider.getAuthWitness(messageHash);
     }
     storeCapsule(contract, storageSlot, capsule) {
-        return this.db.storeCapsule(contract, storageSlot, capsule);
+        return this.capsuleDataProvider.storeCapsule(contract, storageSlot, capsule);
     }
     getContractInstance(address) {
-        return this.db.getContractInstance(address);
+        return this.contractDataProvider.getContractInstance(address);
     }
     async getContractClassMetadata(id, includeArtifact = false) {
-        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),
             isContractClassPubliclyRegistered: await this.#isContractClassPubliclyRegistered(id),
@@ -84,8 +139,14 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         };
     }
     async getContractMetadata(address) {
+        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)
         };
@@ -100,7 +161,8 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             this.log.info(`Registered account ${accountCompleteAddress.address.toString()}`);
             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;
     }
     async registerSender(address) {
@@ -109,7 +171,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
             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()}`);
         } else {
@@ -118,11 +180,11 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         return address;
     }
     getSenders() {
-        const senders = this.db.getSenderAddresses();
+        const senders = this.taggingDataProvider.getSenderAddresses();
         return Promise.resolve(senders);
     }
     async removeSender(address) {
-        const wasRemoved = await this.db.removeSenderAddress(address);
+        const wasRemoved = await this.taggingDataProvider.removeSenderAddress(address);
         if (wasRemoved) {
             this.log.info(`Removed sender:\n ${address.toString()}`);
         } else {
@@ -132,14 +194,14 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     }
     async getRegisteredAccounts() {
         // 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)=>accounts.find((address)=>address.equals(completeAddress.address)));
     }
     async registerContractClass(artifact) {
         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}`);
     }
     async registerContract(contract) {
@@ -156,7 +218,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             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).map((fn)=>decodeFunctionSignature(fn.name, fn.parameters));
             await this.node.registerContractFunctionSignatures(instance.address, publicFunctionSignatures);
             // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
@@ -167,27 +229,21 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             });
         } 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}`);
     }
     async updateContract(contractAddress, artifact) {
-        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 currentClassId = await readCurrentClassId(contractAddress, currentInstance, this.pxeDataProvider, header.globalVariables.blockNumber.toNumber());
+        const header = await this.syncDataProvider.getBlockHeader();
+        const currentClassId = await readCurrentClassId(contractAddress, currentInstance, 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).map((fn)=>decodeFunctionSignature(fn.name, fn.parameters));
         await this.node.registerContractFunctionSignatures(contractAddress, publicFunctionSignatures);
         // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
@@ -197,24 +253,21 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             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}`);
     }
     getContracts() {
-        return this.db.getContractsAddresses();
+        return this.contractDataProvider.getContractsAddresses();
     }
     async getPublicStorageAt(contract, slot) {
-        if (!await this.getContractInstance(contract)) {
-            throw new Error(`Contract ${contract.toString()} is not deployed`);
-        }
         return await this.node.getPublicStorageAt('latest', contract, slot);
     }
     async getNotes(filter) {
-        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));
                 const completeAddress = completeAddresses[completeAddressIndex];
                 if (completeAddress === undefined) {
@@ -360,7 +413,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         return this.node.getContractClassLogs(filter);
     }
     async #getFunctionCall(functionName, args, to) {
-        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`);
         }
@@ -412,8 +465,8 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         const registered = {};
         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);
@@ -441,7 +494,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             return result;
         } catch (err) {
             if (err instanceof SimulationError) {
-                await enrichSimulationError(err, this.db, this.log);
+                await enrichSimulationError(err, this.contractDataProvider, this.log);
             }
             throw err;
         }
@@ -463,7 +516,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             return result;
         } catch (err) {
             if (err instanceof SimulationError) {
-                await enrichSimulationError(err, this.db, this.log);
+                await enrichSimulationError(err, this.contractDataProvider, this.log);
             }
             throw err;
         }
@@ -485,7 +538,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         } 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}`);
                 }
@@ -593,7 +646,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         return decodedEvents;
     }
     async resetNoteSyncData() {
-        return await this.db.resetNoteSyncData();
+        return await this.taggingDataProvider.resetNoteSyncData();
     }
     contextualizeError(err, ...context) {
         let contextStr = '';

package/dest/storage/address_data_provider/address_data_provider.d.ts

@@ -0,0 +1,13 @@
+import type { AztecAsyncKVStore } 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 declare class AddressDataProvider implements DataProvider {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    addCompleteAddress(completeAddress: CompleteAddress): Promise<boolean>;
+    getCompleteAddress(account: AztecAddress): Promise<CompleteAddress | undefined>;
+    getCompleteAddresses(): Promise<CompleteAddress[]>;
+    getSize(): Promise<number>;
+}
+//# sourceMappingURL=address_data_provider.d.ts.map

package/dest/storage/address_data_provider/address_data_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/address_data_provider/address_data_provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,mBAAoB,YAAW,YAAY;;gBAK1C,KAAK,EAAE,iBAAiB;IAOpC,kBAAkB,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IAsCtE,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAIzE,oBAAoB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAMlD,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;CAGjC"}

package/dest/storage/address_data_provider/address_data_provider.js

@@ -0,0 +1,50 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+export class AddressDataProvider {
+    #store;
+    #completeAddresses;
+    #completeAddressIndex;
+    constructor(store){
+        this.#store = store;
+        this.#completeAddresses = this.#store.openArray('complete_addresses');
+        this.#completeAddressIndex = this.#store.openMap('complete_address_index');
+    }
+    addCompleteAddress(completeAddress) {
+        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) {
+        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) {
+        return this.#getCompleteAddress(account);
+    }
+    async getCompleteAddresses() {
+        return await Promise.all((await toArray(this.#completeAddresses.valuesAsync())).map((v)=>CompleteAddress.fromBuffer(v)));
+    }
+    async getSize() {
+        return await this.#completeAddresses.lengthAsync() * CompleteAddress.SIZE_IN_BYTES;
+    }
+}

package/dest/storage/address_data_provider/index.d.ts

@@ -0,0 +1,2 @@
+export { AddressDataProvider } from './address_data_provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/storage/address_data_provider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/address_data_provider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dest/storage/address_data_provider/index.js

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

package/dest/storage/auth_witness_data_provider/auth_witness_data_provider.d.ts

@@ -0,0 +1,11 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { DataProvider } from '../data_provider.js';
+export declare class AuthWitnessDataProvider implements DataProvider {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    addAuthWitness(messageHash: Fr, witness: Fr[]): Promise<void>;
+    getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
+    getSize(): Promise<number>;
+}
+//# sourceMappingURL=auth_witness_data_provider.d.ts.map

package/dest/storage/auth_witness_data_provider/auth_witness_data_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth_witness_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/auth_witness_data_provider/auth_witness_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AAExE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,uBAAwB,YAAW,YAAY;;gBAI9C,KAAK,EAAE,iBAAiB;IAK9B,cAAc,CAAC,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7D,cAAc,CAAC,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,EAAE,GAAG,SAAS,CAAC;IAK1D,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;CAMjC"}

package/dest/storage/auth_witness_data_provider/auth_witness_data_provider.js

@@ -0,0 +1,20 @@
+import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
+export class AuthWitnessDataProvider {
+    #store;
+    #authWitnesses;
+    constructor(store){
+        this.#store = store;
+        this.#authWitnesses = this.#store.openMap('auth_witnesses');
+    }
+    async addAuthWitness(messageHash, witness) {
+        await this.#authWitnesses.set(messageHash.toString(), witness.map((w)=>w.toBuffer()));
+    }
+    async getAuthWitness(messageHash) {
+        const witness = await this.#authWitnesses.getAsync(messageHash.toString());
+        return witness?.map((w)=>Fr.fromBuffer(w));
+    }
+    async getSize() {
+        return (await toArray(this.#authWitnesses.valuesAsync())).reduce((sum, value)=>sum + value.length * Fr.SIZE_IN_BYTES, 0);
+    }
+}

package/dest/storage/auth_witness_data_provider/index.d.ts

@@ -0,0 +1,2 @@
+export { AuthWitnessDataProvider } from './auth_witness_data_provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/storage/auth_witness_data_provider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/auth_witness_data_provider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/storage/auth_witness_data_provider/index.js

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

package/dest/storage/capsule_data_provider/capsule_data_provider.d.ts

@@ -0,0 +1,16 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type LogFn } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { DataProvider } from '../data_provider.js';
+export declare class CapsuleDataProvider implements DataProvider {
+    #private;
+    debug: LogFn;
+    constructor(store: AztecAsyncKVStore);
+    storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void>;
+    loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
+    deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void>;
+    copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
+    getSize(): Promise<number>;
+}
+//# sourceMappingURL=capsule_data_provider.d.ts.map

package/dest/storage/capsule_data_provider/capsule_data_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capsule_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/capsule_data_provider/capsule_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,KAAK,EAAyB,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,mBAAoB,YAAW,YAAY;;IAMtD,KAAK,EAAE,KAAK,CAAC;gBAED,KAAK,EAAE,iBAAiB;IAQ9B,YAAY,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAInF,WAAW,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC;IAa1E,aAAa,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrE,WAAW,CAAC,eAAe,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBhG,OAAO;CAMrB"}

package/dest/storage/capsule_data_provider/capsule_data_provider.js

@@ -0,0 +1,57 @@
+import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
+import { createDebugOnlyLogger } from '@aztec/foundation/log';
+export class CapsuleDataProvider {
+    #store;
+    // Arbitrary data stored by contracts. Key is computed as `${contractAddress}:${key}`
+    #capsules;
+    debug;
+    constructor(store){
+        this.#store = store;
+        this.#capsules = this.#store.openMap('capsules');
+        this.debug = createDebugOnlyLogger('pxe:capsule-data-provider');
+    }
+    async storeCapsule(contractAddress, slot, capsule) {
+        await this.#capsules.set(dbSlotToKey(contractAddress, slot), Buffer.concat(capsule.map((value)=>value.toBuffer())));
+    }
+    async loadCapsule(contractAddress, slot) {
+        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 = [];
+        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, slot) {
+        await this.#capsules.delete(dbSlotToKey(contractAddress, slot));
+    }
+    async copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
+        // 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);
+        }
+    }
+    async getSize() {
+        return (await toArray(this.#capsules.valuesAsync())).reduce((sum, value)=>sum + value.length * Fr.SIZE_IN_BYTES, 0);
+    }
+}
+function dbSlotToKey(contractAddress, slot) {
+    return `${contractAddress.toString()}:${slot.toString()}`;
+}

package/dest/storage/capsule_data_provider/index.d.ts

@@ -0,0 +1,2 @@
+export { CapsuleDataProvider } from './capsule_data_provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/storage/capsule_data_provider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/capsule_data_provider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dest/storage/capsule_data_provider/index.js

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