@aztec/pxe 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

package/dest/pxe.js

@@ -1,41 +1,36 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 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 { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/stdlib/block';
 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 { ProxiedContractStoreFactory } from './contract_function_simulator/proxied_contract_data_source.js';
-import { ProxiedNodeFactory } from './contract_function_simulator/proxied_node.js';
+import { displayDebugLogs } from './contract_logging.js';
+import { ContractSyncService } from './contract_sync/contract_sync_service.js';
+import { readCurrentClassId } from './contract_sync/helpers.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 { MessageContextService } from './messages/message_context_service.js';
 import { PrivateKernelExecutionProver } from './private_kernel/private_kernel_execution_prover.js';
-import { PrivateKernelOracleImpl } from './private_kernel/private_kernel_oracle_impl.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';
+import { PrivateKernelOracle } from './private_kernel/private_kernel_oracle.js';
+import { openPxeStores } from './storage/open_pxe_stores.js';
+import { persistSenderTaggingIndexRangesForTx } from './tagging/index.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;
+    db;
     blockStateSynchronizer;
     keyStore;
     contractStore;
@@ -47,16 +42,23 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
     recipientTaggingStore;
     addressStore;
     privateEventStore;
+    contractSyncService;
+    messageContextService;
+    l2TipsStore;
     simulator;
     proverEnabled;
+    autoSync;
     proofCreator;
     protocolContractsProvider;
+    preloadedContractsProvider;
     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){
+    hooks;
+    constructor(node, db, blockStateSynchronizer, keyStore, contractStore, noteStore, capsuleStore, anchorBlockStore, senderTaggingStore, senderAddressBookStore, recipientTaggingStore, addressStore, privateEventStore, contractSyncService, messageContextService, l2TipsStore, simulator, proverEnabled, autoSync, proofCreator, protocolContractsProvider, preloadedContractsProvider, log, jobQueue, jobCoordinator, debug, hooks){
         this.node = node;
+        this.db = db;
         this.blockStateSynchronizer = blockStateSynchronizer;
         this.keyStore = keyStore;
         this.contractStore = contractStore;
@@ -68,14 +70,20 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
         this.recipientTaggingStore = recipientTaggingStore;
         this.addressStore = addressStore;
         this.privateEventStore = privateEventStore;
+        this.contractSyncService = contractSyncService;
+        this.messageContextService = messageContextService;
+        this.l2TipsStore = l2TipsStore;
         this.simulator = simulator;
         this.proverEnabled = proverEnabled;
+        this.autoSync = autoSync;
         this.proofCreator = proofCreator;
         this.protocolContractsProvider = protocolContractsProvider;
+        this.preloadedContractsProvider = preloadedContractsProvider;
         this.log = log;
         this.jobQueue = jobQueue;
         this.jobCoordinator = jobCoordinator;
         this.debug = debug;
+        this.hooks = hooks;
     }
     /**
    * Creates an instance of a PXE by instantiating all the necessary data providers and services.
@@ -83,36 +91,64 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    * can be contacted.
    *
    * @returns A promise that resolves PXE is ready to be used.
-   */ static async create(node, store, proofCreator, simulator, protocolContractsProvider, config, loggerOrSuffix) {
+   */ static async create({ node, store, proofCreator, simulator, protocolContractsProvider, preloadedContractsProvider, config, loggerOrSuffix, hooks }) {
+        // Extract bindings from the logger, or use empty bindings if a string suffix is provided.
+        const bindings = loggerOrSuffix && typeof loggerOrSuffix !== 'string' ? loggerOrSuffix.getBindings() : undefined;
         const log = !loggerOrSuffix || typeof loggerOrSuffix === 'string' ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`) : loggerOrSuffix;
-        const proverEnabled = !!config.proverEnabled;
-        const addressStore = new AddressStore(store);
-        const privateEventStore = new PrivateEventStore(store);
-        const contractStore = new ContractStore(store);
-        const noteStore = await NoteStore.create(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 BlockSynchronizer(node, anchorBlockStore, noteStore, privateEventStore, tipsStore, config, loggerOrSuffix);
-        const jobCoordinator = new JobCoordinator(store);
-        const debugUtils = new PXEDebugUtils(contractStore, noteStore);
+        const info = await node.getNodeInfo();
+        // Source the genesis block hash from the node so PXE's L2BlockStream agrees with the node's
+        // archiver on the dynamic initial header hash. Without this the tip store would fall back to
+        // the static `GENESIS_BLOCK_HEADER_HASH` constant, which only matches deployments with the
+        // default empty genesis (timestamp 0, no prefilled public data) and diverges otherwise — the
+        // sync at block 0 would then get stuck in `areBlockHashesEqualAt` and abort. If the node does
+        // not return a genesis block (older node or test fixture) we fall back to the static constant.
+        const initialBlockHash = (await node.getBlock(BlockNumber.ZERO))?.hash ?? GENESIS_BLOCK_HEADER_HASH;
+        const proverEnabled = config.proverEnabled !== undefined ? config.proverEnabled : info.realProofs;
+        const { addressStore, privateEventStore, contractStore, noteStore, anchorBlockStore, senderTaggingStore, senderAddressBookStore, recipientTaggingStore, capsuleStore, keyStore, l2TipsStore } = openPxeStores(store, initialBlockHash);
+        const contractSyncService = new ContractSyncService(node, contractStore, noteStore, createLogger('pxe:contract_sync', bindings));
+        const messageContextService = new MessageContextService(node);
+        const synchronizer = new BlockSynchronizer(node, store, anchorBlockStore, noteStore, privateEventStore, l2TipsStore, contractSyncService, config, bindings);
+        const jobCoordinator = new JobCoordinator(store, bindings);
+        jobCoordinator.registerStores([
+            capsuleStore,
+            senderTaggingStore,
+            recipientTaggingStore,
+            privateEventStore,
+            noteStore,
+            contractSyncService
+        ]);
+        const debugUtils = new PXEDebugUtils(contractSyncService, noteStore, synchronizer, anchorBlockStore);
         const jobQueue = new SerialQueue();
-        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);
+        const pxe = new PXE(node, store, synchronizer, keyStore, contractStore, noteStore, capsuleStore, anchorBlockStore, senderTaggingStore, senderAddressBookStore, recipientTaggingStore, addressStore, privateEventStore, contractSyncService, messageContextService, l2TipsStore, simulator, proverEnabled, config.autoSync, proofCreator, protocolContractsProvider, preloadedContractsProvider, log, jobQueue, jobCoordinator, debugUtils, hooks);
+        debugUtils.setPXEHelpers(pxe.#putInJobQueue.bind(pxe), pxe.#getSimulatorForTx.bind(pxe), pxe.#executeUtility.bind(pxe));
         pxe.jobQueue.start();
-        await pxe.#registerProtocolContracts();
-        const info = await node.getNodeInfo();
+        await Promise.all([
+            pxe.#registerProtocolContracts(),
+            pxe.#registerPreloadedContracts()
+        ]);
         log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.rollupVersion}`);
         return pxe;
     }
     // Internal methods
     #getSimulatorForTx(overrides) {
         const proxyContractStore = ProxiedContractStoreFactory.create(this.contractStore, overrides?.contracts);
-        return new ContractFunctionSimulator(proxyContractStore, this.noteStore, this.keyStore, this.addressStore, ProxiedNodeFactory.create(this.node), this.anchorBlockStore, this.senderTaggingStore, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.simulator);
+        return new ContractFunctionSimulator({
+            contractStore: proxyContractStore,
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: BenchmarkedNodeFactory.create(this.node),
+            l2TipsStore: this.l2TipsStore,
+            senderTaggingStore: this.senderTaggingStore,
+            recipientTaggingStore: this.recipientTaggingStore,
+            senderAddressBookStore: this.senderAddressBookStore,
+            capsuleStore: this.capsuleStore,
+            privateEventStore: this.privateEventStore,
+            simulator: this.simulator,
+            contractSyncService: this.contractSyncService,
+            messageContextService: this.messageContextService,
+            hooks: this.hooks
+        });
     }
     #contextualizeError(err, ...context) {
         let contextStr = '';
@@ -153,34 +189,41 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
         });
     }
     async #registerProtocolContracts() {
-        const registered = {};
-        for (const name of protocolContractNames){
-            const { address, contractClass, instance, artifact } = await this.protocolContractsProvider.getProtocolContractArtifact(name);
-            await this.contractStore.addContractArtifact(contractClass.id, artifact);
+        const registered = Object.fromEntries(await Promise.all(protocolContractNames.map(async (name)=>{
+            const { address, instance, artifact } = await this.protocolContractsProvider.getProtocolContractArtifact(name);
+            await this.contractStore.addContractArtifact(artifact);
             await this.contractStore.addContractInstance(instance);
-            registered[name] = address.toString();
-        }
+            return [
+                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 #registerPreloadedContracts() {
+        const contracts = await this.preloadedContractsProvider.getPreloadedContracts();
+        await Promise.all(contracts.map(({ instance, artifact })=>this.registerContract({
+                instance,
+                artifact
+            })));
+        this.log.verbose(`Registered preloaded contracts in pxe`, {
+            contracts: contracts.map(({ instance })=>instance.address.toString())
+        });
     }
     // Executes the entrypoint private function, as well as all nested private
     // functions that might arise.
-    async #executePrivate(contractFunctionSimulator, txRequest, scopes, jobId) {
+    async #executePrivate({ contractFunctionSimulator, txRequest, anchorBlockHeader, scopes, jobId, senderForTags }) {
         const { origin: contractAddress, functionSelector } = txRequest;
         try {
-            const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
-            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, jobId);
+            await this.contractSyncService.ensureContractSynced(contractAddress, functionSelector, (privateSyncCall, execScopes)=>this.#executeUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId), anchorBlockHeader, jobId, scopes);
+            const result = await contractFunctionSimulator.run(txRequest, {
+                contractAddress,
+                selector: functionSelector,
+                anchorBlockHeader,
+                scopes,
+                jobId,
+                senderForTags
+            });
             this.log.debug(`Private simulation completed for ${contractAddress.toString()}:${functionSelector}`);
             return result;
         } catch (err) {
@@ -191,18 +234,22 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
         }
     }
     /**
-   * Simulate a utility function call on the given contract.
+   * Execute a utility function call on the given contract.
    * @param contractFunctionSimulator - The simulator to use for the function call.
    * @param call - The function call to execute.
    * @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, jobId) {
+   * @returns The execution result containing the outputs of the utility function.
+   */ async #executeUtility(contractFunctionSimulator, call, authWitnesses, scopes, jobId) {
         try {
             const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
-            return contractFunctionSimulator.runUtility(call, authWitnesses ?? [], anchorBlockHeader, scopes, jobId);
+            const { result, offchainEffects } = await contractFunctionSimulator.runUtility(call, authWitnesses ?? [], anchorBlockHeader, scopes, jobId);
+            return {
+                result,
+                offchainEffects
+            };
         } catch (err) {
             if (err instanceof SimulationError) {
                 await enrichSimulationError(err, this.contractStore, this.log);
@@ -215,11 +262,11 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    * This allows to catch public execution errors before submitting the transaction.
    * It can also be used for estimating gas in the future.
    * @param tx - The transaction to be simulated.
-   */ async #simulatePublicCalls(tx, skipFeeEnforcement) {
+   */ async #simulatePublicCalls(tx, skipFeeEnforcement, overrides) {
         // Simulating public calls can throw if the TX fails in a phase that doesn't allow reverts (setup)
         // Or return as reverted if it fails in a phase that allows reverts (app logic, teardown)
         try {
-            const result = await this.node.simulatePublicCalls(tx, skipFeeEnforcement);
+            const result = await this.node.simulatePublicCalls(tx, skipFeeEnforcement, overrides);
             if (result.revertReason) {
                 throw result.revertReason;
             }
@@ -245,63 +292,50 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    * @param privateExecutionResult - The result of the private execution
    * @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.contractStore, this.keyStore, this.node, simulationAnchorBlock);
-        const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled);
+   */ async #prove(txExecutionRequest, proofCreator, privateExecutionResult, anchorBlockHeader, config) {
+        const kernelOracle = new PrivateKernelOracle(this.contractStore, this.keyStore, this.node, anchorBlockHeader);
+        const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled, this.log.getBindings());
         this.log.debug(`Executing kernel trace prover (${JSON.stringify(config)})...`);
         return await kernelTraceProver.proveWithKernels(txExecutionRequest.toTxRequest(), privateExecutionResult, config);
     }
+    /**
+   * Syncs with the node only when `autoSync` is enabled.
+   * When `autoSync` is disabled, callers (typically a wallet) are
+   * responsible for invoking `pxe.sync()` at the right granularity.
+   */ async #maybeSync() {
+        if (this.autoSync) {
+            await this.blockStateSynchronizer.sync();
+        }
+    }
     // Public API
-    getContractInstance(address) {
-        return this.contractStore.getContractInstance(address);
+    /**
+   * Triggers a sync of PXE state with the node, regardless of the `autoSync` config flag. Use this to
+   * batch syncs across composite flows when `autoSync` is disabled (e.g. one sync per simulate+send
+   * instead of one per inner PXE call). Serialized through the job queue.
+   */ sync() {
+        return this.#putInJobQueue(()=>this.blockStateSynchronizer.sync());
     }
     /**
-   * 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.contractStore.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 block header up to which the PXE has synced.
+   * @returns The synced block header
+   */ getSyncedBlockHeader() {
+        return this.#putInJobQueue(()=>{
+            return this.anchorBlockStore.getBlockHeader();
+        });
     }
     /**
-   * 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.contractStore.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 instance for a given address, if it's registered in the PXE.
+   * @param address - The contract address.
+   * @returns The contract instance if found, undefined otherwise.
+   */ getContractInstance(address) {
+        return this.contractStore.getContractInstance(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.
@@ -315,7 +349,7 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    */ async registerAccount(secretKey, partialAddress) {
         const accounts = await this.keyStore.getAccounts();
         const accountCompleteAddress = await this.keyStore.addAccount(secretKey, partialAddress);
-        if (accounts.includes(accountCompleteAddress.address)) {
+        if (accounts.some((a)=>a.equals(accountCompleteAddress.address))) {
             this.log.info(`Account:\n "${accountCompleteAddress.address.toString()}"\n already registered.`);
             return accountCompleteAddress;
         } else {
@@ -323,7 +357,6 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
             this.log.debug(`Registered account\n ${accountCompleteAddress.toReadableString()}`);
         }
         await this.addressStore.addCompleteAddress(accountCompleteAddress);
-        await this.noteStore.addScope(accountCompleteAddress.address);
         return accountCompleteAddress;
     }
     /**
@@ -336,14 +369,20 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    * @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) {
+        if (!await sender.isValid()) {
+            throw new Error(`Address ${sender} is not valid: it does not correspond to a point on the Grumpkin curve. Cannot register it as a sender.`);
+        }
         const accounts = await this.keyStore.getAccounts();
-        if (accounts.includes(sender)) {
+        if (accounts.some((a)=>a.equals(sender))) {
             this.log.info(`Sender:\n "${sender.toString()}"\n already registered.`);
             return sender;
         }
         const wasAdded = await this.senderAddressBookStore.addSender(sender);
         if (wasAdded) {
             this.log.info(`Added sender:\n ${sender.toString()}`);
+            // Wipe the entire sync cache: the new sender's tagged logs could contain notes/events for any contract, so
+            // all contracts must re-sync to discover them. Queued to avoid wiping while a job is in flight.
+            await this.#putInJobQueue(()=>Promise.resolve(this.contractSyncService.wipe()));
         } else {
             this.log.info(`Sender:\n "${sender.toString()}"\n already registered.`);
         }
@@ -381,8 +420,7 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    *
    * @param artifact - The build artifact for the contract class.
    */ async registerContractClass(artifact) {
-        const { id: contractClassId } = await getContractClassFromArtifact(artifact);
-        await this.contractStore.addContractArtifact(contractClassId, artifact);
+        const contractClassId = await this.contractStore.addContractArtifact(artifact);
         this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
     }
     /**
@@ -398,17 +436,18 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
         if (artifact) {
             // If the user provides an artifact, validate it against the expected class id and register it
             const contractClass = await getContractClassFromArtifact(artifact);
-            const contractClassId = contractClass.id;
-            if (!contractClassId.equals(instance.currentContractClassId)) {
-                throw new Error(`Artifact does not match expected class id (computed ${contractClassId} but instance refers to ${instance.currentContractClassId})`);
+            if (!contractClass.id.equals(instance.currentContractClassId)) {
+                throw new Error(`Artifact does not match expected class id (computed ${contractClass.id} but instance refers to ${instance.currentContractClassId})`);
             }
             const computedAddress = await computeContractAddressFromInstance(instance);
             if (!computedAddress.equals(instance.address)) {
                 throw new Error('Added a contract in which the address does not match the contract instance.');
             }
-            await this.contractStore.addContractArtifact(contractClass.id, artifact);
+            await this.contractStore.addContractArtifact(artifact, contractClass);
             const publicFunctionSignatures = artifact.functions.filter((fn)=>fn.functionType === FunctionType.PUBLIC).map((fn)=>decodeFunctionSignature(fn.name, fn.parameters));
-            await this.node.registerContractFunctionSignatures(publicFunctionSignatures);
+            if (publicFunctionSignatures.length > 0) {
+                await this.node.registerContractFunctionSignatures(publicFunctionSignatures);
+            }
         } else {
             // Otherwise, make sure there is an artifact already registered for that class id
             artifact = await this.contractStore.getContractArtifact(instance.currentContractClassId);
@@ -436,17 +475,21 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
                 throw new Error(`Instance not found when updating a contract. Contract address: ${contractAddress}.`);
             }
             const contractClass = await getContractClassFromArtifact(artifact);
-            await this.blockStateSynchronizer.sync();
+            await this.#maybeSync();
             const header = await this.anchorBlockStore.getBlockHeader();
-            const currentClassId = await readCurrentClassId(contractAddress, currentInstance, this.node, header.globalVariables.blockNumber, header.globalVariables.timestamp);
+            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.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);
+            if (publicFunctionSignatures.length > 0) {
+                await this.node.registerContractFunctionSignatures(publicFunctionSignatures);
+            }
             currentInstance.currentContractClassId = contractClass.id;
-            await this.contractStore.addContractInstance(currentInstance);
+            await Promise.all([
+                this.contractStore.addContractArtifact(artifact, contractClass),
+                this.contractStore.addContractInstance(currentInstance)
+            ]);
             this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
         });
     }
@@ -461,10 +504,11 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    * (where validators prove the public portion).
    *
    * @param txRequest - An authenticated tx request ready for proving
+   * @param scopes - Addresses whose private state and keys are accessible during private execution.
    * @returns A result containing the proof and public inputs of the tail circuit.
    * @throws If contract code not found, or public simulation reverts.
    * Also throws if simulatePublic is true and public simulation reverts.
-   */ proveTx(txRequest) {
+   */ proveTx(txRequest, { scopes, senderForTags }) {
         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.
@@ -472,11 +516,19 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
             const totalTimer = new Timer();
             try {
                 const syncTimer = new Timer();
-                await this.blockStateSynchronizer.sync();
+                await this.#maybeSync();
+                const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
                 const syncTime = syncTimer.ms();
                 const contractFunctionSimulator = this.#getSimulatorForTx();
-                privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, undefined, jobId);
-                const { publicInputs, chonkProof, executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+                privateExecutionResult = await this.#executePrivate({
+                    contractFunctionSimulator,
+                    txRequest,
+                    anchorBlockHeader,
+                    scopes,
+                    jobId,
+                    senderForTags
+                });
+                const { publicInputs, chonkProof, executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, anchorBlockHeader, {
                     simulate: false,
                     skipFeeEnforcement: false,
                     profileMode: 'none'
@@ -501,22 +553,13 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
                     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) {
-                    // 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);
-                    this.log.debug(`Stored used pre-tags as sender for the tx`, {
-                        preTagsUsedInTheTx
-                    });
-                } else {
-                    this.log.debug(`No pre-tags used in the tx`);
-                }
+                // We keep track of which tagging indices we've used in this tx so that we don't repeat them in future txs
+                // (which would link them) without having to rely on this tx being mined (and us seeing the indices being used
+                // onchain).
+                // Note that this must happen _after_ proving as it requires the proof's public inputs, from which the kernels
+                // may have removed some logs due to note-nullifier squashing - this may lead to range of tagging indices we've
+                // actually used to being reduced.
+                await persistSenderTaggingIndexRangesForTx(this.senderTaggingStore, privateExecutionResult.entrypoint.taggingIndexRanges, publicInputs, ()=>txProvingResult.getTxHash(), jobId, this.log);
                 return txProvingResult;
             } catch (err) {
                 throw this.#contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
@@ -525,13 +568,10 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
     }
     /**
    * Profiles a transaction, reporting gate counts (unless disabled) and returns an execution trace.
-   *
-   * @param txRequest - An authenticated tx request ready for simulation
-   * @param msgSender - (Optional) The message sender to use for the simulation.
-   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
+   * @param txRequest - An authenticated tx request ready for simulation.
    * @returns A trace of the program execution with gate counts.
    * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
-   */ profileTx(txRequest, profileMode, skipProofGeneration = true) {
+   */ profileTx(txRequest, { profileMode, skipProofGeneration = true, scopes, senderForTags }) {
         // We disable concurrent profiles for consistency with simulateTx.
         return this.#putInJobQueue(async (jobId)=>{
             const totalTimer = new Timer();
@@ -546,11 +586,19 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
                 };
                 this.log.info(`Profiling transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`, txInfo);
                 const syncTimer = new Timer();
-                await this.blockStateSynchronizer.sync();
+                await this.#maybeSync();
+                const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
                 const syncTime = syncTimer.ms();
                 const contractFunctionSimulator = this.#getSimulatorForTx();
-                const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, undefined, jobId);
-                const { executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+                const privateExecutionResult = await this.#executePrivate({
+                    contractFunctionSimulator,
+                    txRequest,
+                    anchorBlockHeader,
+                    scopes,
+                    jobId,
+                    senderForTags
+                });
+                const { executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, anchorBlockHeader, {
                     simulate: skipProofGeneration,
                     skipFeeEnforcement: false,
                     profileMode
@@ -594,18 +642,13 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    * In that case, the transaction returned is only potentially ready to be sent to the network for execution.
    *
    *
-   * @param txRequest - An authenticated tx request ready for simulation
-   * @param simulatePublic - Whether to simulate the public part of the transaction.
-   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
-   * @param skipFeeEnforcement - (Optional) If false, fees are enforced.
-   * @param overrides - (Optional) State overrides for the simulation, such as msgSender, contract instances and artifacts.
-   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will default to all.
+   * @param txRequest - An authenticated tx request ready for simulation.
    * @returns A simulated transaction result object that includes public and private return values.
    * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
    * Also throws if simulatePublic is true and public simulation reverts.
    *
    * TODO(#7456) Prevent msgSender being defined here for the first call
-   */ simulateTx(txRequest, simulatePublic, skipTxValidation = false, skipFeeEnforcement = false, overrides, scopes) {
+   */ simulateTx(txRequest, { simulatePublic, skipTxValidation = false, skipFeeEnforcement = false, skipKernels = true, overrides, scopes, senderForTags }) {
         // 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).
@@ -622,25 +665,29 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
                 };
                 this.log.info(`Simulating transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`, txInfo);
                 const syncTimer = new Timer();
-                await this.blockStateSynchronizer.sync();
+                await this.#maybeSync();
+                const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
                 const syncTime = syncTimer.ms();
+                if (overrides?.contracts && Object.keys(overrides.contracts).length > 0 && !skipKernels) {
+                    throw new Error('Simulating with overridden contracts is not compatible with kernel execution. Please set skipKernels to true when simulating with overridden contracts.');
+                }
                 const contractFunctionSimulator = this.#getSimulatorForTx(overrides);
-                // Temporary: in case there are overrides, we have to skip the kernels or validations
-                // will fail. Consider handing control to the user/wallet on whether they want to run them
-                // 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, jobId);
+                const privateExecutionResult = await this.#executePrivate({
+                    contractFunctionSimulator,
+                    txRequest,
+                    anchorBlockHeader,
+                    scopes,
+                    jobId,
+                    senderForTags
+                });
                 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.contractStore));
+                    ({ publicInputs, executionSteps } = await generateSimulatedProvingResult(privateExecutionResult, (addr, sel)=>this.contractStore.getDebugFunctionName(addr, sel), this.node));
                 } else {
                     // Kernel logic, plus proving of all private functions and kernels.
-                    ({ publicInputs, executionSteps } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+                    ({ publicInputs, executionSteps } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, anchorBlockHeader, {
                         simulate: true,
                         skipFeeEnforcement,
                         profileMode: 'none'
@@ -652,8 +699,11 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
                 let publicOutput;
                 if (simulatePublic && publicInputs.forPublic) {
                     const publicSimulationTimer = new Timer();
-                    publicOutput = await this.#simulatePublicCalls(simulatedTx, skipFeeEnforcement);
+                    publicOutput = await this.#simulatePublicCalls(simulatedTx, skipFeeEnforcement, overrides);
                     publicSimulationTime = publicSimulationTimer.ms();
+                    if (publicOutput?.debugLogs?.length) {
+                        await displayDebugLogs(publicOutput.debugLogs, (addr)=>this.contractStore.getDebugContractName(addr));
+                    }
                 }
                 let validationTime;
                 if (!skipTxValidation) {
@@ -664,7 +714,8 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
                     });
                     validationTime = validationTimer.ms();
                     if (validationResult.result === 'invalid') {
-                        throw new Error('The simulated transaction is unable to be added to state and is invalid.');
+                        const reason = validationResult.reason.length > 0 ? ` Reason: ${validationResult.reason.join(', ')}` : '';
+                        throw new Error(`The simulated transaction is unable to be added to state and is invalid.${reason}`);
                     }
                 }
                 const txHash = simulatedTx.getTxHash();
@@ -697,32 +748,30 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
                     nodeRPCCalls: simulatorStats.nodeRPCCalls
                 });
             } catch (err) {
-                throw this.#contextualizeError(err, inspect(txRequest), `simulatePublic=${simulatePublic}`, `skipTxValidation=${skipTxValidation}`, `scopes=${scopes?.map((s)=>s.toString()).join(', ') ?? 'undefined'}`);
+                throw this.#contextualizeError(err, inspect(txRequest), `simulatePublic=${simulatePublic}`, `skipTxValidation=${skipTxValidation}`, `scopes=${scopes.map((s)=>s.toString()).join(', ')}`);
             }
         });
     }
     /**
-   * Simulate the execution of a contract utility function.
-   *
+   * Executes a contract utility function.
    * @param call - The function call containing the function details, arguments, and target contract address.
-   * @param authwits - (Optional) The authentication witnesses required for the function call.
-   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will
-   * default to all.
-   * @returns The result of the utility function call, structured based on the function ABI.
-   */ simulateUtility(call, authwits, scopes) {
-        // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
+   */ executeUtility(call, { authwits, scopes } = {
+        scopes: []
+    }) {
+        // We disable concurrent executions 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).
+        // delete the same read value, or reading values that another execution is currently modifying).
         return this.#putInJobQueue(async (jobId)=>{
             try {
                 const totalTimer = new Timer();
                 const syncTimer = new Timer();
-                await this.blockStateSynchronizer.sync();
+                await this.#maybeSync();
                 const syncTime = syncTimer.ms();
                 const functionTimer = new Timer();
                 const contractFunctionSimulator = this.#getSimulatorForTx();
-                await this.contractStore.syncPrivateState(call.to, call.selector, (privateSyncCall)=>this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId));
-                const executionResult = await this.#simulateUtility(contractFunctionSimulator, call, authwits ?? [], scopes, jobId);
+                const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+                await this.contractSyncService.ensureContractSynced(call.to, call.selector, (privateSyncCall, execScopes)=>this.#executeUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId), anchorBlockHeader, jobId, scopes);
+                const { result: executionResult, offchainEffects } = await this.#executeUtility(contractFunctionSimulator, call, authwits ?? [], scopes, jobId);
                 const functionTime = functionTimer.ms();
                 const totalTime = totalTimer.ms();
                 const perFunction = [
@@ -740,6 +789,8 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
                 const simulationStats = contractFunctionSimulator.getStats();
                 return {
                     result: executionResult,
+                    offchainEffects,
+                    anchorBlockTimestamp: anchorBlockHeader.globalVariables.timestamp,
                     stats: {
                         timings,
                         nodeRPCCalls: simulationStats.nodeRPCCalls
@@ -748,7 +799,7 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
             } catch (err) {
                 const { to, name, args } = call;
                 const stringifiedArgs = args.map((arg)=>arg.toString()).join(', ');
-                throw this.#contextualizeError(err, `simulateUtility ${to}:${name}(${stringifiedArgs})`, `scopes=${scopes?.map((s)=>s.toString()).join(', ') ?? 'undefined'}`);
+                throw this.#contextualizeError(err, `executeUtility ${to}:${name}(${stringifiedArgs})`, `scopes=${scopes.map((s)=>s.toString()).join(', ')}`);
             }
         });
     }
@@ -764,19 +815,25 @@ import { SenderTaggingStore } from './storage/tagging_store/sender_tagging_store
    *  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.
-   */ getPrivateEvents(eventSelector, filter) {
-        return this.#putInJobQueue(async (jobId)=>{
-            await this.blockStateSynchronizer.sync();
+   */ async getPrivateEvents(eventSelector, filter) {
+        let anchorBlockNumber;
+        await this.#putInJobQueue(async (jobId)=>{
+            await this.#maybeSync();
+            const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+            anchorBlockNumber = anchorBlockHeader.getBlockNumber();
             const contractFunctionSimulator = this.#getSimulatorForTx();
-            await this.contractStore.syncPrivateState(filter.contractAddress, null, async (privateSyncCall)=>await this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId));
-            const sanitizedFilter = await new PrivateEventFilterValidator(this.anchorBlockStore).validate(filter);
-            this.log.debug(`Getting private events for ${sanitizedFilter.contractAddress.toString()} from ${sanitizedFilter.fromBlock} to ${sanitizedFilter.toBlock}`);
-            return this.privateEventStore.getPrivateEvents(eventSelector, sanitizedFilter);
+            await this.contractSyncService.ensureContractSynced(filter.contractAddress, null, async (privateSyncCall, execScopes)=>await this.#executeUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId), anchorBlockHeader, jobId, filter.scopes);
         });
+        // 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.
-   */ stop() {
-        return this.jobQueue.end();
+   * Stops the PXE's job queue and closes the backing store.
+   */ async stop() {
+        await this.jobQueue.end();
+        await this.blockStateSynchronizer.stop();
+        await this.db.close();
     }
 }