@aztec/pxe 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/dest/pxe.js

@@ -1,69 +1,79 @@
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { Timer } from '@aztec/foundation/timer';
 import { KeyStore } from '@aztec/key-store';
 import { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { protocolContractNames } from '@aztec/protocol-contracts';
-import { FunctionSelector, FunctionType, decodeFunctionSignature, encodeArguments } from '@aztec/stdlib/abi';
+import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
 import { computeContractAddressFromInstance, getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
-import { computeProtocolNullifier, siloNullifier } from '@aztec/stdlib/hash';
 import { PrivateSimulationResult, TxProfileResult, TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
 import { inspect } from 'util';
+import { BlockSynchronizer } from './block_synchronizer/index.js';
+import { BenchmarkedNodeFactory } from './contract_function_simulator/benchmarked_node.js';
 import { ContractFunctionSimulator, generateSimulatedProvingResult } from './contract_function_simulator/contract_function_simulator.js';
-import { readCurrentClassId } from './contract_function_simulator/oracle/private_execution.js';
-import { ProxiedContractDataProviderFactory } from './contract_function_simulator/proxied_contract_data_source.js';
-import { ProxiedNodeFactory } from './contract_function_simulator/proxied_node.js';
-import { PXEOracleInterface } from './contract_function_simulator/pxe_oracle_interface.js';
+import { ProxiedContractStoreFactory } from './contract_function_simulator/proxied_contract_data_source.js';
+import { ensureContractSynced, readCurrentClassId } from './contract_sync/index.js';
+import { PXEDebugUtils } from './debug/pxe_debug_utils.js';
 import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
+import { PrivateEventFilterValidator } from './events/private_event_filter_validator.js';
+import { JobCoordinator } from './job_coordinator/job_coordinator.js';
 import { PrivateKernelExecutionProver } from './private_kernel/private_kernel_execution_prover.js';
-import { PrivateKernelOracleImpl } from './private_kernel/private_kernel_oracle_impl.js';
-import { AddressDataProvider } from './storage/address_data_provider/address_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 { PrivateEventDataProvider } from './storage/private_event_data_provider/private_event_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 { PrivateKernelOracle } from './private_kernel/private_kernel_oracle.js';
+import { AddressStore } from './storage/address_store/address_store.js';
+import { AnchorBlockStore } from './storage/anchor_block_store/anchor_block_store.js';
+import { CapsuleStore } from './storage/capsule_store/capsule_store.js';
+import { ContractStore } from './storage/contract_store/contract_store.js';
+import { NoteStore } from './storage/note_store/note_store.js';
+import { PrivateEventStore } from './storage/private_event_store/private_event_store.js';
+import { RecipientTaggingStore } from './storage/tagging_store/recipient_tagging_store.js';
+import { SenderAddressBookStore } from './storage/tagging_store/sender_address_book_store.js';
+import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store.js';
 /**
  * Private eXecution Environment (PXE) is a library used by wallets to simulate private phase of transactions and to
  * manage private state of users.
  */ export class PXE {
     node;
-    synchronizer;
+    blockStateSynchronizer;
     keyStore;
-    contractDataProvider;
-    noteDataProvider;
-    capsuleDataProvider;
-    syncDataProvider;
-    taggingDataProvider;
-    addressDataProvider;
-    privateEventDataProvider;
+    contractStore;
+    noteStore;
+    capsuleStore;
+    anchorBlockStore;
+    senderTaggingStore;
+    senderAddressBookStore;
+    recipientTaggingStore;
+    addressStore;
+    privateEventStore;
     simulator;
     proverEnabled;
     proofCreator;
     protocolContractsProvider;
     log;
     jobQueue;
-    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue){
+    jobCoordinator;
+    debug;
+    constructor(node, blockStateSynchronizer, keyStore, contractStore, noteStore, capsuleStore, anchorBlockStore, senderTaggingStore, senderAddressBookStore, recipientTaggingStore, addressStore, privateEventStore, simulator, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue, jobCoordinator, debug){
         this.node = node;
-        this.synchronizer = synchronizer;
+        this.blockStateSynchronizer = blockStateSynchronizer;
         this.keyStore = keyStore;
-        this.contractDataProvider = contractDataProvider;
-        this.noteDataProvider = noteDataProvider;
-        this.capsuleDataProvider = capsuleDataProvider;
-        this.syncDataProvider = syncDataProvider;
-        this.taggingDataProvider = taggingDataProvider;
-        this.addressDataProvider = addressDataProvider;
-        this.privateEventDataProvider = privateEventDataProvider;
+        this.contractStore = contractStore;
+        this.noteStore = noteStore;
+        this.capsuleStore = capsuleStore;
+        this.anchorBlockStore = anchorBlockStore;
+        this.senderTaggingStore = senderTaggingStore;
+        this.senderAddressBookStore = senderAddressBookStore;
+        this.recipientTaggingStore = recipientTaggingStore;
+        this.addressStore = addressStore;
+        this.privateEventStore = privateEventStore;
         this.simulator = simulator;
         this.proverEnabled = proverEnabled;
         this.proofCreator = proofCreator;
         this.protocolContractsProvider = protocolContractsProvider;
         this.log = log;
         this.jobQueue = jobQueue;
+        this.jobCoordinator = jobCoordinator;
+        this.debug = debug;
     }
     /**
    * Creates an instance of a PXE by instantiating all the necessary data providers and services.
@@ -74,18 +84,30 @@ import { Synchronizer } from './synchronizer/index.js';
    */ static async create(node, store, proofCreator, simulator, protocolContractsProvider, config, loggerOrSuffix) {
         const log = !loggerOrSuffix || typeof loggerOrSuffix === 'string' ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`) : loggerOrSuffix;
         const proverEnabled = !!config.proverEnabled;
-        const addressDataProvider = new AddressDataProvider(store);
-        const privateEventDataProvider = new PrivateEventDataProvider(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 addressStore = new AddressStore(store);
+        const privateEventStore = new PrivateEventStore(store);
+        const contractStore = new ContractStore(store);
+        const noteStore = new NoteStore(store);
+        const anchorBlockStore = new AnchorBlockStore(store);
+        const senderTaggingStore = new SenderTaggingStore(store);
+        const senderAddressBookStore = new SenderAddressBookStore(store);
+        const recipientTaggingStore = new RecipientTaggingStore(store);
+        const capsuleStore = new CapsuleStore(store);
         const keyStore = new KeyStore(store);
         const tipsStore = new L2TipsKVStore(store, 'pxe');
-        const synchronizer = new Synchronizer(node, syncDataProvider, noteDataProvider, taggingDataProvider, tipsStore, config, loggerOrSuffix);
+        const synchronizer = new BlockSynchronizer(node, store, anchorBlockStore, noteStore, privateEventStore, tipsStore, config, loggerOrSuffix);
+        const jobCoordinator = new JobCoordinator(store);
+        jobCoordinator.registerStores([
+            capsuleStore,
+            senderTaggingStore,
+            recipientTaggingStore,
+            privateEventStore,
+            noteStore
+        ]);
+        const debugUtils = new PXEDebugUtils(contractStore, noteStore);
         const jobQueue = new SerialQueue();
-        const pxe = new PXE(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue);
+        const pxe = new PXE(node, synchronizer, keyStore, contractStore, noteStore, capsuleStore, anchorBlockStore, senderTaggingStore, senderAddressBookStore, recipientTaggingStore, addressStore, privateEventStore, simulator, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue, jobCoordinator, debugUtils);
+        debugUtils.setPXE(pxe);
         pxe.jobQueue.start();
         await pxe.#registerProtocolContracts();
         const info = await node.getNodeInfo();
@@ -94,8 +116,8 @@ import { Synchronizer } from './synchronizer/index.js';
     }
     // Internal methods
     #getSimulatorForTx(overrides) {
-        const pxeOracleInterface = new PXEOracleInterface(ProxiedNodeFactory.create(this.node), this.keyStore, ProxiedContractDataProviderFactory.create(this.contractDataProvider, overrides?.contracts), this.noteDataProvider, this.capsuleDataProvider, this.syncDataProvider, this.taggingDataProvider, this.addressDataProvider, this.privateEventDataProvider, this.log);
-        return new ContractFunctionSimulator(pxeOracleInterface, this.simulator);
+        const proxyContractStore = ProxiedContractStoreFactory.create(this.contractStore, overrides?.contracts);
+        return new ContractFunctionSimulator(proxyContractStore, this.noteStore, this.keyStore, this.addressStore, BenchmarkedNodeFactory.create(this.node), this.anchorBlockStore, this.senderTaggingStore, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.simulator);
     }
     #contextualizeError(err, ...context) {
         let contextStr = '';
@@ -120,61 +142,46 @@ import { Synchronizer } from './synchronizer/index.js';
         if (this.jobQueue.length() != 0) {
             this.log.warn(`PXE is already processing ${this.jobQueue.length()} jobs, concurrent execution is not supported. Will run once those are complete.`);
         }
-        return this.jobQueue.put(fn);
+        return this.jobQueue.put(async ()=>{
+            const jobId = this.jobCoordinator.beginJob();
+            this.log.verbose(`Beginning job ${jobId}`);
+            try {
+                const result = await fn(jobId);
+                this.log.verbose(`Committing job ${jobId}`);
+                await this.jobCoordinator.commitJob(jobId);
+                return result;
+            } catch (err) {
+                this.log.verbose(`Aborting job ${jobId}`);
+                await this.jobCoordinator.abortJob(jobId);
+                throw err;
+            }
+        });
     }
     async #registerProtocolContracts() {
         const registered = {};
         for (const name of protocolContractNames){
             const { address, contractClass, instance, artifact } = await this.protocolContractsProvider.getProtocolContractArtifact(name);
-            await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
-            await this.contractDataProvider.addContractInstance(instance);
+            await this.contractStore.addContractArtifact(contractClass.id, artifact);
+            await this.contractStore.addContractInstance(instance);
             registered[name] = address.toString();
         }
         this.log.verbose(`Registered protocol contracts in pxe`, registered);
     }
-    async #isContractClassPubliclyRegistered(id) {
-        return !!await this.node.getContractClass(id);
-    }
-    async #isContractPublished(address) {
-        return !!await this.node.getContract(address);
-    }
-    async #isContractInitialized(address) {
-        const initNullifier = await siloNullifier(address, address.toField());
-        return !!await this.node.getNullifierMembershipWitness('latest', initNullifier);
-    }
-    async #getFunctionCall(functionName, args, to) {
-        const contract = await this.contractDataProvider.getContract(to);
-        if (!contract) {
-            throw new Error(`Unknown contract ${to}: add it to PXE by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/resources/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`);
-        }
-        const functionDao = contract.functions.find((f)=>f.name === functionName);
-        if (!functionDao) {
-            throw new Error(`Unknown function ${functionName} in contract ${contract.name}.`);
-        }
-        return {
-            name: functionDao.name,
-            args: encodeArguments(functionDao, args),
-            selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
-            type: functionDao.functionType,
-            to,
-            hideMsgSender: false,
-            isStatic: functionDao.isStatic,
-            returnTypes: functionDao.returnTypes
-        };
-    }
     // Executes the entrypoint private function, as well as all nested private
     // functions that might arise.
-    async #executePrivate(contractFunctionSimulator, txRequest, scopes) {
+    async #executePrivate(contractFunctionSimulator, txRequest, scopes, jobId) {
         const { origin: contractAddress, functionSelector } = txRequest;
         try {
-            const result = await contractFunctionSimulator.run(txRequest, contractAddress, functionSelector, undefined, // The sender for tags is set by contracts, typically by an account
+            const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+            await ensureContractSynced(contractAddress, functionSelector, (privateSyncCall)=>this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId), this.node, this.contractStore, anchorBlockHeader);
+            const result = await contractFunctionSimulator.run(txRequest, contractAddress, functionSelector, undefined, anchorBlockHeader, // The sender for tags is set by contracts, typically by an account
             // contract entrypoint
-            undefined, scopes);
+            undefined, scopes, jobId);
             this.log.debug(`Private simulation completed for ${contractAddress.toString()}:${functionSelector}`);
             return result;
         } catch (err) {
             if (err instanceof SimulationError) {
-                await enrichSimulationError(err, this.contractDataProvider, this.log);
+                await enrichSimulationError(err, this.contractStore, this.log);
             }
             throw err;
         }
@@ -186,13 +193,15 @@ import { Synchronizer } from './synchronizer/index.js';
    * @param authWitnesses - Authentication witnesses required for the function call.
    * @param scopes - Optional array of account addresses whose notes can be accessed in this call. Defaults to all
    * accounts if not specified.
+   * @param jobId - The job ID for staged writes.
    * @returns The simulation result containing the outputs of the utility function.
-   */ async #simulateUtility(contractFunctionSimulator, call, authWitnesses, scopes) {
+   */ async #simulateUtility(contractFunctionSimulator, call, authWitnesses, scopes, jobId) {
         try {
-            return contractFunctionSimulator.runUtility(call, authWitnesses ?? [], scopes);
+            const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+            return contractFunctionSimulator.runUtility(call, authWitnesses ?? [], anchorBlockHeader, scopes, jobId);
         } catch (err) {
             if (err instanceof SimulationError) {
-                await enrichSimulationError(err, this.contractDataProvider, this.log);
+                await enrichSimulationError(err, this.contractStore, this.log);
             }
             throw err;
         }
@@ -214,7 +223,7 @@ import { Synchronizer } from './synchronizer/index.js';
         } catch (err) {
             if (err instanceof SimulationError) {
                 try {
-                    await enrichPublicSimulationError(err, this.contractDataProvider, this.log);
+                    await enrichPublicSimulationError(err, this.contractStore, this.log);
                 } catch (enrichErr) {
                     this.log.error(`Failed to enrich public simulation error: ${enrichErr}`);
                 }
@@ -233,62 +242,23 @@ import { Synchronizer } from './synchronizer/index.js';
    * @param config - The configuration for the kernel execution prover.
    * @returns An object that contains the output of the kernel execution, including the ChonkProof if proving is enabled.
    */ async #prove(txExecutionRequest, proofCreator, privateExecutionResult, config) {
-        const simulationAnchorBlock = privateExecutionResult.getSimulationAnchorBlockNumber();
-        const kernelOracle = new PrivateKernelOracleImpl(this.contractDataProvider, this.keyStore, this.node, simulationAnchorBlock);
+        const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+        const anchorBlockHash = await anchorBlockHeader.hash();
+        const kernelOracle = new PrivateKernelOracle(this.contractStore, this.keyStore, this.node, anchorBlockHash);
         const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled);
         this.log.debug(`Executing kernel trace prover (${JSON.stringify(config)})...`);
         return await kernelTraceProver.proveWithKernels(txExecutionRequest.toTxRequest(), privateExecutionResult, config);
     }
     // Public API
     getContractInstance(address) {
-        return this.contractDataProvider.getContractInstance(address);
+        return this.contractStore.getContractInstance(address);
     }
     /**
-   * Returns the contract class metadata given a contract class id.
-   * The metadata consists of its contract class, whether it has been publicly registered, and its artifact.
-   * @remark - it queries the node to check whether the contract class with the given id has been publicly registered.
-   * @param id - Identifier of the class.
-   * @param includeArtifact - Identifier of the class.
-   * @returns - It returns the contract class metadata, with the artifact field being optional, and will only be returned if true is passed in
-   * for `includeArtifact`
-   * TODO(@spalladino): The PXE actually holds artifacts and not classes, what should we return? Also,
-   * should the pxe query the node for contract public info, and merge it with its own definitions?
-   * TODO(@spalladino): This method is strictly needed to decide whether to publicly register a class or not
-   * during a public deployment. We probably want a nicer and more general API for this, but it'll have to
-   * do for the time being.
-   */ async getContractClassMetadata(id, includeArtifact = false) {
-        const artifact = await this.contractDataProvider.getContractArtifact(id);
-        if (!artifact) {
-            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),
-            artifact: includeArtifact ? artifact : undefined
-        };
-    }
-    /**
-   * Returns the contract metadata given an address.
-   * The metadata consists of its contract instance, which includes the contract class identifier,
-   * initialization hash, deployment salt, and public keys hash; whether the contract instance has been initialized;
-   * and whether the contract instance with the given address has been publicly deployed.
-   * @remark - it queries the node to check whether the contract instance has been initialized / publicly deployed through a node.
-   * This query is not dependent on the PXE.
-   * @param address - The address that the contract instance resides at.
-   * @returns - It returns the contract metadata
-   * TODO(@spalladino): Should we return the public keys in plain as well here?
-   */ 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: instance,
-            isContractInitialized: await this.#isContractInitialized(address),
-            isContractPublished: await this.#isContractPublished(address)
-        };
+   * Returns the contract artifact for a given contract class id, if it's registered in the PXE.
+   * @param id - Identifier of the contract class.
+   * @returns The contract artifact if found, undefined otherwise.
+   */ async getContractArtifact(id) {
+        return await this.contractStore.getContractArtifact(id);
     }
     /**
    * Registers a user account in PXE given its master encryption private key.
@@ -309,46 +279,47 @@ import { Synchronizer } from './synchronizer/index.js';
             this.log.info(`Registered account ${accountCompleteAddress.address.toString()}`);
             this.log.debug(`Registered account\n ${accountCompleteAddress.toReadableString()}`);
         }
-        await this.addressDataProvider.addCompleteAddress(accountCompleteAddress);
-        await this.noteDataProvider.addScope(accountCompleteAddress.address);
+        await this.addressStore.addCompleteAddress(accountCompleteAddress);
         return accountCompleteAddress;
     }
     /**
-   * Registers a user contact in PXE.
+   * Registers a sender in this PXE.
    *
-   * Once a new contact is registered, the PXE will be able to receive notes tagged from this contact.
-   * Will do nothing if the account is already registered.
+   * After registering a new sender, the PXE will sync private logs that are tagged with this sender's address.
+   * Will do nothing if the address is already registered.
    *
-   * @param address - Address of the user to add to the address book
-   * @returns The address address of the account.
-   */ async registerSender(address) {
+   * @param sender - Address of the sender to register.
+   * @returns The address of the sender.
+   * TODO: It's strange that we return the address here and I (benesjan) think we should drop the return value.
+   */ async registerSender(sender) {
         const accounts = await this.keyStore.getAccounts();
-        if (accounts.includes(address)) {
-            this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
-            return address;
+        if (accounts.includes(sender)) {
+            this.log.info(`Sender:\n "${sender.toString()}"\n already registered.`);
+            return sender;
         }
-        const wasAdded = await this.taggingDataProvider.addSenderAddress(address);
+        const wasAdded = await this.senderAddressBookStore.addSender(sender);
         if (wasAdded) {
-            this.log.info(`Added sender:\n ${address.toString()}`);
+            this.log.info(`Added sender:\n ${sender.toString()}`);
         } else {
-            this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
+            this.log.info(`Sender:\n "${sender.toString()}"\n already registered.`);
         }
-        return address;
+        return sender;
     }
     /**
-   * Retrieves the addresses stored as senders on this PXE.
-   * @returns An array of the senders on this PXE.
+   * Retrieves senders registered in this PXE.
+   * @returns Senders registered in this PXE.
    */ getSenders() {
-        return this.taggingDataProvider.getSenderAddresses();
+        return this.senderAddressBookStore.getSenders();
     }
     /**
-   * Removes a sender in the address book.
-   */ async removeSender(address) {
-        const wasRemoved = await this.taggingDataProvider.removeSenderAddress(address);
+   * Removes a sender registered in this PXE.
+   * @param sender - The address of the sender to remove.
+   */ async removeSender(sender) {
+        const wasRemoved = await this.senderAddressBookStore.removeSender(sender);
         if (wasRemoved) {
-            this.log.info(`Removed sender:\n ${address.toString()}`);
+            this.log.info(`Removed sender:\n ${sender.toString()}`);
         } else {
-            this.log.info(`Sender:\n "${address.toString()}"\n not in address book.`);
+            this.log.info(`Sender:\n "${sender.toString()}"\n not registered in PXE.`);
         }
     }
     /**
@@ -356,7 +327,7 @@ import { Synchronizer } from './synchronizer/index.js';
    * @returns An array of the accounts registered on this PXE.
    */ async getRegisteredAccounts() {
         // Get complete addresses of both the recipients and the accounts
-        const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
+        const completeAddresses = await this.addressStore.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)));
@@ -367,7 +338,7 @@ import { Synchronizer } from './synchronizer/index.js';
    * @param artifact - The build artifact for the contract class.
    */ async registerContractClass(artifact) {
         const { id: contractClassId } = await getContractClassFromArtifact(artifact);
-        await this.contractDataProvider.addContractArtifact(contractClassId, artifact);
+        await this.contractStore.addContractArtifact(contractClassId, artifact);
         this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
     }
     /**
@@ -391,17 +362,17 @@ import { Synchronizer } from './synchronizer/index.js';
             if (!computedAddress.equals(instance.address)) {
                 throw new Error('Added a contract in which the address does not match the contract instance.');
             }
-            await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
+            await this.contractStore.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(publicFunctionSignatures);
         } else {
             // Otherwise, make sure there is an artifact already registered for that class id
-            artifact = await this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
+            artifact = await this.contractStore.getContractArtifact(instance.currentContractClassId);
             if (!artifact) {
                 throw new Error(`Artifact not found when registering an instance. Contract class: ${instance.currentContractClassId}.`);
             }
         }
-        await this.contractDataProvider.addContractInstance(instance);
+        await this.contractStore.addContractInstance(instance);
         this.log.info(`Added contract ${artifact.name} at ${instance.address.toString()} with class ${instance.currentContractClassId}`);
     }
     /**
@@ -416,22 +387,22 @@ import { Synchronizer } from './synchronizer/index.js';
         // We disable concurrently updating contracts to avoid concurrently syncing with the node, or changing a contract's
         // class while we're simulating it.
         return this.#putInJobQueue(async ()=>{
-            const currentInstance = await this.contractDataProvider.getContractInstance(contractAddress);
+            const currentInstance = await this.contractStore.getContractInstance(contractAddress);
             if (!currentInstance) {
                 throw new Error(`Instance not found when updating a contract. Contract address: ${contractAddress}.`);
             }
             const contractClass = await getContractClassFromArtifact(artifact);
-            await this.synchronizer.sync();
-            const header = await this.syncDataProvider.getBlockHeader();
-            const currentClassId = await readCurrentClassId(contractAddress, currentInstance, this.node, header.globalVariables.blockNumber, header.globalVariables.timestamp);
+            await this.blockStateSynchronizer.sync();
+            const header = await this.anchorBlockStore.getBlockHeader();
+            const currentClassId = await readCurrentClassId(contractAddress, currentInstance, this.node, header);
             if (!contractClass.id.equals(currentClassId)) {
                 throw new Error('Could not update contract to a class different from the current one.');
             }
-            await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
+            await this.contractStore.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(publicFunctionSignatures);
             currentInstance.currentContractClassId = contractClass.id;
-            await this.contractDataProvider.addContractInstance(currentInstance);
+            await this.contractStore.addContractInstance(currentInstance);
             this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
         });
     }
@@ -439,23 +410,7 @@ import { Synchronizer } from './synchronizer/index.js';
    * Retrieves the addresses of contracts added to this PXE.
    * @returns An array of contracts addresses registered on this PXE.
    */ getContracts() {
-        return this.contractDataProvider.getContractsAddresses();
-    }
-    /**
-   * A debugging utility to get notes based on the provided filter.
-   *
-   * Note that this should not be used in production code because the structure of notes is considered to be
-   * an implementation detail of contracts. This is only meant to be used for debugging purposes. If you need to obtain
-   * note-related information in production code, please implement a custom utility function on your contract and call
-   * that function instead (e.g. `get_balance(owner: AztecAddress) -> u128` utility function on a Token contract).
-   *
-   * @param filter - The filter to apply to the notes.
-   * @returns The requested notes.
-   */ async getNotes(filter) {
-        // We need to manually trigger private state sync to have a guarantee that all the notes are available.
-        const call = await this.#getFunctionCall('sync_private_state', [], filter.contractAddress);
-        await this.simulateUtility(call);
-        return this.noteDataProvider.getNotes(filter);
+        return this.contractStore.getContractsAddresses();
     }
     /**
    * Proves the private portion of a simulated transaction, ready to send to the network
@@ -469,14 +424,14 @@ import { Synchronizer } from './synchronizer/index.js';
         let privateExecutionResult;
         // We disable proving concurrently mostly out of caution, since it accesses some of our stores. Proving is so
         // computationally demanding that it'd be rare for someone to try to do it concurrently regardless.
-        return this.#putInJobQueue(async ()=>{
+        return this.#putInJobQueue(async (jobId)=>{
             const totalTimer = new Timer();
             try {
                 const syncTimer = new Timer();
-                await this.synchronizer.sync();
+                await this.blockStateSynchronizer.sync();
                 const syncTime = syncTimer.ms();
                 const contractFunctionSimulator = this.#getSimulatorForTx();
-                privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
+                privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, undefined, jobId);
                 const { publicInputs, chonkProof, executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
                     simulate: false,
                     skipFeeEnforcement: false,
@@ -502,14 +457,21 @@ import { Synchronizer } from './synchronizer/index.js';
                     timings,
                     nodeRPCCalls: contractFunctionSimulator?.getStats().nodeRPCCalls
                 });
+                // While not strictly necessary to store tagging cache contents in the DB since we sync tagging indexes from
+                // chain before sending new logs, the sync can only see logs already included in blocks. If we send another
+                // transaction before this one is included in a block from this PXE, and that transaction contains a log with
+                // a tag derived from the same secret, we would reuse the tag and the transactions would be linked. Hence
+                // storing the tags here prevents linkage of txs sent from the same PXE.
                 const preTagsUsedInTheTx = privateExecutionResult.entrypoint.preTags;
                 if (preTagsUsedInTheTx.length > 0) {
-                    await this.taggingDataProvider.setLastUsedIndexesAsSender(preTagsUsedInTheTx);
-                    this.log.debug(`Stored used pre tags as sender for the tx`, {
+                    // TODO(benesjan): The following is an expensive operation. Figure out a way to avoid it.
+                    const txHash = (await txProvingResult.toTx()).txHash;
+                    await this.senderTaggingStore.storePendingIndexes(preTagsUsedInTheTx, txHash, jobId);
+                    this.log.debug(`Stored used pre-tags as sender for the tx`, {
                         preTagsUsedInTheTx
                     });
                 } else {
-                    this.log.debug(`No pre tags used in the tx`);
+                    this.log.debug(`No pre-tags used in the tx`);
                 }
                 return txProvingResult;
             } catch (err) {
@@ -527,7 +489,7 @@ import { Synchronizer } from './synchronizer/index.js';
    * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
    */ profileTx(txRequest, profileMode, skipProofGeneration = true) {
         // We disable concurrent profiles for consistency with simulateTx.
-        return this.#putInJobQueue(async ()=>{
+        return this.#putInJobQueue(async (jobId)=>{
             const totalTimer = new Timer();
             try {
                 const txInfo = {
@@ -540,10 +502,10 @@ import { Synchronizer } from './synchronizer/index.js';
                 };
                 this.log.info(`Profiling transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`, txInfo);
                 const syncTimer = new Timer();
-                await this.synchronizer.sync();
+                await this.blockStateSynchronizer.sync();
                 const syncTime = syncTimer.ms();
                 const contractFunctionSimulator = this.#getSimulatorForTx();
-                const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
+                const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, undefined, jobId);
                 const { executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
                     simulate: skipProofGeneration,
                     skipFeeEnforcement: false,
@@ -603,7 +565,7 @@ import { Synchronizer } from './synchronizer/index.js';
         // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
         // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
         // delete the same read value, or reading values that another simulation is currently modifying).
-        return this.#putInJobQueue(async ()=>{
+        return this.#putInJobQueue(async (jobId)=>{
             try {
                 const totalTimer = new Timer();
                 const txInfo = {
@@ -616,7 +578,7 @@ import { Synchronizer } from './synchronizer/index.js';
                 };
                 this.log.info(`Simulating transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`, txInfo);
                 const syncTimer = new Timer();
-                await this.synchronizer.sync();
+                await this.blockStateSynchronizer.sync();
                 const syncTime = syncTimer.ms();
                 const contractFunctionSimulator = this.#getSimulatorForTx(overrides);
                 // Temporary: in case there are overrides, we have to skip the kernels or validations
@@ -624,14 +586,11 @@ import { Synchronizer } from './synchronizer/index.js';
                 // or not.
                 const skipKernels = overrides?.contracts !== undefined && Object.keys(overrides.contracts ?? {}).length > 0;
                 // Execution of private functions only; no proving, and no kernel logic.
-                const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, scopes);
+                const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, scopes, jobId);
                 let publicInputs;
                 let executionSteps = [];
                 if (skipKernels) {
-                    // According to the protocol rules, the nonce generator for the note hashes
-                    // can either be the first nullifier in the tx or the protocol nullifier if there are none.
-                    const nonceGenerator = privateExecutionResult.firstNullifier.equals(Fr.ZERO) ? await computeProtocolNullifier(await txRequest.toTxRequest().hash()) : privateExecutionResult.firstNullifier;
-                    ({ publicInputs, executionSteps } = await generateSimulatedProvingResult(privateExecutionResult, nonceGenerator, this.contractDataProvider));
+                    ({ publicInputs, executionSteps } = await generateSimulatedProvingResult(privateExecutionResult, this.contractStore));
                 } else {
                     // Kernel logic, plus proving of all private functions and kernels.
                     ({ publicInputs, executionSteps } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
@@ -707,15 +666,17 @@ import { Synchronizer } from './synchronizer/index.js';
         // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
         // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
         // delete the same read value, or reading values that another simulation is currently modifying).
-        return this.#putInJobQueue(async ()=>{
+        return this.#putInJobQueue(async (jobId)=>{
             try {
                 const totalTimer = new Timer();
                 const syncTimer = new Timer();
-                await this.synchronizer.sync();
+                await this.blockStateSynchronizer.sync();
                 const syncTime = syncTimer.ms();
                 const functionTimer = new Timer();
                 const contractFunctionSimulator = this.#getSimulatorForTx();
-                const executionResult = await this.#simulateUtility(contractFunctionSimulator, call, authwits ?? [], scopes);
+                const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+                await ensureContractSynced(call.to, call.selector, (privateSyncCall)=>this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId), this.node, this.contractStore, anchorBlockHeader);
+                const executionResult = await this.#simulateUtility(contractFunctionSimulator, call, authwits ?? [], scopes, jobId);
                 const functionTime = functionTimer.ms();
                 const totalTime = totalTimer.ms();
                 const perFunction = [
@@ -747,21 +708,29 @@ import { Synchronizer } from './synchronizer/index.js';
     }
     /**
    * Returns the private events given search parameters.
-   * @param contractAddress - The address of the contract to get events from.
    * @param eventSelector - Event selector to search for.
-   * @param from - The block number to search from.
-   * @param numBlocks - The amount of blocks to search.
-   * @param recipients - The addresses that decrypted the logs.
+   * @param filter
+   *  contractAddress - The address of the contract to get events from. Required.
+   *  scopes - One or more event scope addresses to filter by. Required.
+   *  fromBlock - The block number to search from (inclusive). Optional. If provided, it must be >= 0.
+   *    Defaults to 0.
+   *    If toBlock is defined but fromBlock is not, fromBlock defaults to toBlock - 1.
+   *  toBlock - The block number to search up to (exclusive). Optional. If provided, it must be > 0.
+   *    Defaults to the latest known block to PXE + 1.
    * @returns - The packed events with block and tx metadata.
-   */ async getPrivateEvents(contractAddress, eventSelector, from, numBlocks, recipients) {
-        if (recipients.length === 0) {
-            throw new Error('Recipients are required to get private events');
-        }
-        this.log.verbose(`Getting private events for ${contractAddress.toString()} from ${from} to ${from + numBlocks}`);
-        // We need to manually trigger private state sync to have a guarantee that all the events are available.
-        const call = await this.#getFunctionCall('sync_private_state', [], contractAddress);
-        await this.simulateUtility(call);
-        return this.privateEventDataProvider.getPrivateEvents(contractAddress, from, numBlocks, recipients, eventSelector);
+   */ async getPrivateEvents(eventSelector, filter) {
+        let anchorBlockNumber;
+        await this.#putInJobQueue(async (jobId)=>{
+            await this.blockStateSynchronizer.sync();
+            const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+            anchorBlockNumber = anchorBlockHeader.getBlockNumber();
+            const contractFunctionSimulator = this.#getSimulatorForTx();
+            await ensureContractSynced(filter.contractAddress, null, async (privateSyncCall)=>await this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId), this.node, this.contractStore, anchorBlockHeader);
+        });
+        // anchorBlockNumber is set during the job and fixed to whatever it is after a block sync
+        const sanitizedFilter = new PrivateEventFilterValidator(anchorBlockNumber).validate(filter);
+        this.log.debug(`Getting private events for ${sanitizedFilter.contractAddress.toString()} from ${sanitizedFilter.fromBlock} to ${sanitizedFilter.toBlock}`);
+        return this.privateEventStore.getPrivateEvents(eventSelector, sanitizedFilter);
     }
     /**
    * Stops the PXE's job queue.