@aztec/pxe 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/dest/pxe_service/pxe_service.js

@@ -1,791 +0,0 @@
-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 { ProtocolContractAddress, protocolContractNames } from '@aztec/protocol-contracts';
-import { EventSelector, FunctionSelector, FunctionType, decodeFromAbi, decodeFunctionSignature, encodeArguments } from '@aztec/stdlib/abi';
-import { computeContractAddressFromInstance, getContractClassFromArtifact } from '@aztec/stdlib/contract';
-import { SimulationError } from '@aztec/stdlib/errors';
-import { siloNullifier } from '@aztec/stdlib/hash';
-import { computeL2ToL1MembershipWitness, getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
-import { UniqueNote } from '@aztec/stdlib/note';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { PrivateSimulationResult, TxProfileResult, TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
-import { inspect } from 'util';
-import { getPackageInfo } from '../config/package_info.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 { 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 { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
-/**
- * A Private eXecution Environment (PXE) implementation.
- */ export class PXEService {
-    node;
-    synchronizer;
-    keyStore;
-    contractDataProvider;
-    noteDataProvider;
-    capsuleDataProvider;
-    syncDataProvider;
-    taggingDataProvider;
-    addressDataProvider;
-    privateEventDataProvider;
-    simulator;
-    packageVersion;
-    proverEnabled;
-    proofCreator;
-    protocolContractsProvider;
-    log;
-    jobQueue;
-    #nodeInfo;
-    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue){
-        this.node = node;
-        this.synchronizer = synchronizer;
-        this.keyStore = keyStore;
-        this.contractDataProvider = contractDataProvider;
-        this.noteDataProvider = noteDataProvider;
-        this.capsuleDataProvider = capsuleDataProvider;
-        this.syncDataProvider = syncDataProvider;
-        this.taggingDataProvider = taggingDataProvider;
-        this.addressDataProvider = addressDataProvider;
-        this.privateEventDataProvider = privateEventDataProvider;
-        this.simulator = simulator;
-        this.packageVersion = packageVersion;
-        this.proverEnabled = proverEnabled;
-        this.proofCreator = proofCreator;
-        this.protocolContractsProvider = protocolContractsProvider;
-        this.log = log;
-        this.jobQueue = jobQueue;
-    }
-    /**
-   * Creates an instance of a PXE Service by instantiating all the necessary data providers and services.
-   * Also triggers the registration of the protocol contracts and makes sure the provided node
-   * can be contacted.
-   *
-   * @returns A promise that resolves PXE service is ready to be used.
-   */ 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 packageVersion = getPackageInfo().version;
-        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 keyStore = new KeyStore(store);
-        const tipsStore = new L2TipsKVStore(store, 'pxe');
-        const synchronizer = new Synchronizer(node, syncDataProvider, noteDataProvider, taggingDataProvider, tipsStore, config, loggerOrSuffix);
-        const jobQueue = new SerialQueue();
-        const pxeService = new PXEService(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue);
-        pxeService.jobQueue.start();
-        await pxeService.#registerProtocolContracts();
-        const info = await pxeService.getNodeInfo();
-        log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.rollupVersion}`);
-        return pxeService;
-    }
-    getL1ToL2MessageBlock(l1ToL2Message) {
-        return this.node.getL1ToL2MessageBlock(l1ToL2Message);
-    }
-    // Aztec node proxy methods
-    isL1ToL2MessageSynced(l1ToL2Message) {
-        return this.node.isL1ToL2MessageSynced(l1ToL2Message);
-    }
-    async getL2ToL1MembershipWitness(blockNumber, l2Tol1Message) {
-        const result = await computeL2ToL1MembershipWitness(this.node, blockNumber, l2Tol1Message);
-        if (!result) {
-            throw new Error(`L2 to L1 message not found in block ${blockNumber}`);
-        }
-        return [
-            result.leafIndex,
-            result.siblingPath
-        ];
-    }
-    getTxReceipt(txHash) {
-        return this.node.getTxReceipt(txHash);
-    }
-    getTxEffect(txHash) {
-        return this.node.getTxEffect(txHash);
-    }
-    getBlockNumber() {
-        return this.node.getBlockNumber();
-    }
-    getProvenBlockNumber() {
-        return this.node.getProvenBlockNumber();
-    }
-    getPublicLogs(filter) {
-        return this.node.getPublicLogs(filter);
-    }
-    getContractClassLogs(filter) {
-        return this.node.getContractClassLogs(filter);
-    }
-    getPublicStorageAt(contract, slot) {
-        return this.node.getPublicStorageAt('latest', contract, slot);
-    }
-    async getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
-        return await getNonNullifiedL1ToL2MessageWitness(this.node, contractAddress, messageHash, secret);
-    }
-    // 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);
-    }
-    #contextualizeError(err, ...context) {
-        let contextStr = '';
-        if (context.length > 0) {
-            contextStr = `\nContext:\n${context.join('\n')}`;
-        }
-        if (err instanceof SimulationError) {
-            err.setAztecContext(contextStr);
-        } else {
-            this.log.error(err.name, err);
-            this.log.debug(contextStr);
-        }
-        return err;
-    }
-    /**
-   * Enqueues a job for execution once no other jobs are running. Returns a promise that will resolve once the job is
-   * complete.
-   *
-   * Useful for tasks that cannot run concurrently, such as contract function simulation.
-   */ #putInJobQueue(fn) {
-        // TODO(#12636): relax the conditions under which we forbid concurrency.
-        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);
-    }
-    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);
-            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 Service by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/reference/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`);
-        }
-        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,
-            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) {
-        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
-            // contract entrypoint
-            undefined, scopes);
-            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);
-            }
-            throw err;
-        }
-    }
-    /**
-   * Simulate 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.
-   * @returns The simulation result containing the outputs of the utility function.
-   */ async #simulateUtility(contractFunctionSimulator, call, authWitnesses, scopes) {
-        try {
-            return contractFunctionSimulator.runUtility(call, authWitnesses ?? [], scopes);
-        } catch (err) {
-            if (err instanceof SimulationError) {
-                await enrichSimulationError(err, this.contractDataProvider, this.log);
-            }
-            throw err;
-        }
-    }
-    /**
-   * Simulate the public part of a transaction.
-   * 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) {
-        // 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);
-            if (result.revertReason) {
-                throw result.revertReason;
-            }
-            return result;
-        } catch (err) {
-            if (err instanceof SimulationError) {
-                try {
-                    await enrichPublicSimulationError(err, this.contractDataProvider, this.log);
-                } catch (enrichErr) {
-                    this.log.error(`Failed to enrich public simulation error: ${enrichErr}`);
-                }
-            }
-            throw err;
-        }
-    }
-    /**
-   * Generate a kernel proof, and create a private kernel output.
-   * The function takes in a transaction execution request, and the result of private execution
-   * and then generates a kernel proof.
-   *
-   * @param txExecutionRequest - The transaction request to be simulated and proved.
-   * @param proofCreator - The proof creator to use for proving the execution.
-   * @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 ClientIvcProof if proving is enabled.
-   */ async #prove(txExecutionRequest, proofCreator, privateExecutionResult, config) {
-        const block = privateExecutionResult.getSimulationBlockNumber();
-        const kernelOracle = new PrivateKernelOracleImpl(this.contractDataProvider, this.keyStore, this.node, block);
-        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
-    /** Returns an estimate of the db size in bytes. */ async estimateDbSize() {
-        const treeRootsSize = Object.keys(MerkleTreeId).length * Fr.SIZE_IN_BYTES;
-        const dbSizes = await Promise.all([
-            this.addressDataProvider.getSize(),
-            this.capsuleDataProvider.getSize(),
-            this.contractDataProvider.getSize(),
-            this.noteDataProvider.getSize(),
-            this.syncDataProvider.getSize(),
-            this.taggingDataProvider.getSize()
-        ]);
-        return [
-            ...dbSizes,
-            treeRootsSize
-        ].reduce((sum, size)=>sum + size, 0);
-    }
-    getContractInstance(address) {
-        return this.contractDataProvider.getContractInstance(address);
-    }
-    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
-        };
-    }
-    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)
-        };
-    }
-    async registerAccount(secretKey, partialAddress) {
-        const accounts = await this.keyStore.getAccounts();
-        const accountCompleteAddress = await this.keyStore.addAccount(secretKey, partialAddress);
-        if (accounts.includes(accountCompleteAddress.address)) {
-            this.log.info(`Account:\n "${accountCompleteAddress.address.toString()}"\n already registered.`);
-            return accountCompleteAddress;
-        } else {
-            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);
-        return accountCompleteAddress;
-    }
-    async registerSender(address) {
-        const accounts = await this.keyStore.getAccounts();
-        if (accounts.includes(address)) {
-            this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
-            return address;
-        }
-        const wasAdded = await this.taggingDataProvider.addSenderAddress(address);
-        if (wasAdded) {
-            this.log.info(`Added sender:\n ${address.toString()}`);
-        } else {
-            this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
-        }
-        return address;
-    }
-    getSenders() {
-        return this.taggingDataProvider.getSenderAddresses();
-    }
-    async removeSender(address) {
-        const wasRemoved = await this.taggingDataProvider.removeSenderAddress(address);
-        if (wasRemoved) {
-            this.log.info(`Removed sender:\n ${address.toString()}`);
-        } else {
-            this.log.info(`Sender:\n "${address.toString()}"\n not in address book.`);
-        }
-    }
-    async getRegisteredAccounts() {
-        // Get complete addresses of both the recipients and the accounts
-        const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
-        // Filter out the addresses not corresponding to accounts
-        const accounts = await this.keyStore.getAccounts();
-        return completeAddresses.filter((completeAddress)=>accounts.find((address)=>address.equals(completeAddress.address)));
-    }
-    async registerContractClass(artifact) {
-        const { id: contractClassId } = await getContractClassFromArtifact(artifact);
-        await this.contractDataProvider.addContractArtifact(contractClassId, artifact);
-        this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
-    }
-    async registerContract(contract) {
-        const { instance } = contract;
-        let { artifact } = contract;
-        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})`);
-            }
-            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.contractDataProvider.addContractArtifact(contractClass.id, artifact);
-            const publicFunctionSignatures = artifact.functions.filter((fn)=>fn.functionType === FunctionType.PUBLIC).map((fn)=>decodeFunctionSignature(fn.name, fn.parameters));
-            await this.node.registerContractFunctionSignatures(publicFunctionSignatures);
-        } else {
-            // Otherwise, make sure there is an artifact already registered for that class id
-            artifact = await this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
-            if (!artifact) {
-                throw new Error(`Artifact not found when registering an instance. Contract class: ${instance.currentContractClassId}.`);
-            }
-        }
-        await this.contractDataProvider.addContractInstance(instance);
-        this.log.info(`Added contract ${artifact.name} at ${instance.address.toString()} with class ${instance.currentContractClassId}`);
-    }
-    updateContract(contractAddress, artifact) {
-        // 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);
-            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);
-            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);
-            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);
-            this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
-        });
-    }
-    getContracts() {
-        return this.contractDataProvider.getContractsAddresses();
-    }
-    async getNotes(filter) {
-        // We need to manually trigger private state sync to have a guarantee that all the events are available.
-        await this.simulateUtility('sync_private_state', [], filter.contractAddress);
-        const noteDaos = await this.noteDataProvider.getNotes(filter);
-        const extendedNotes = noteDaos.map(async (dao)=>{
-            let recipient = filter.recipient;
-            if (recipient === undefined) {
-                const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
-                const completeAddressIndex = completeAddresses.findIndex((completeAddress)=>completeAddress.address.equals(dao.recipient));
-                const completeAddress = completeAddresses[completeAddressIndex];
-                if (completeAddress === undefined) {
-                    throw new Error(`Cannot find complete address for recipient ${dao.recipient.toString()}`);
-                }
-                recipient = completeAddress.address;
-            }
-            return new UniqueNote(dao.note, recipient, dao.contractAddress, dao.storageSlot, dao.txHash, dao.noteNonce);
-        });
-        return Promise.all(extendedNotes);
-    }
-    async getBlock(blockNumber) {
-        // If a negative block number is provided the current block number is fetched.
-        if (blockNumber < 0) {
-            blockNumber = await this.node.getBlockNumber();
-        }
-        return await this.node.getBlock(blockNumber);
-    }
-    async getCurrentBaseFees() {
-        return await this.node.getCurrentBaseFees();
-    }
-    proveTx(txRequest, 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 ()=>{
-            const totalTimer = new Timer();
-            try {
-                let syncTime;
-                let contractFunctionSimulator;
-                if (!privateExecutionResult) {
-                    const syncTimer = new Timer();
-                    await this.synchronizer.sync();
-                    syncTime = syncTimer.ms();
-                    contractFunctionSimulator = this.#getSimulatorForTx();
-                    privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
-                }
-                const { publicInputs, clientIvcProof, executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
-                    simulate: false,
-                    skipFeeEnforcement: false,
-                    profileMode: 'none'
-                });
-                const totalTime = totalTimer.ms();
-                const perFunction = executionSteps.map(({ functionName, timings: { witgen, oracles } })=>({
-                        functionName,
-                        time: witgen,
-                        oracles
-                    }));
-                const timings = {
-                    total: totalTime,
-                    sync: syncTime,
-                    proving,
-                    perFunction,
-                    unaccounted: totalTime - ((syncTime ?? 0) + (proving ?? 0) + perFunction.reduce((acc, { time })=>acc + time, 0))
-                };
-                this.log.debug(`Proving completed in ${totalTime}ms`, {
-                    timings
-                });
-                return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof, {
-                    timings,
-                    nodeRPCCalls: contractFunctionSimulator?.getStats().nodeRPCCalls
-                });
-            } catch (err) {
-                throw this.#contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
-            }
-        });
-    }
-    profileTx(txRequest, profileMode, skipProofGeneration = true) {
-        // We disable concurrent profiles for consistency with simulateTx.
-        return this.#putInJobQueue(async ()=>{
-            const totalTimer = new Timer();
-            try {
-                const txInfo = {
-                    origin: txRequest.origin,
-                    functionSelector: txRequest.functionSelector,
-                    simulatePublic: false,
-                    chainId: txRequest.txContext.chainId,
-                    version: txRequest.txContext.version,
-                    authWitnesses: txRequest.authWitnesses.map((w)=>w.requestHash)
-                };
-                this.log.info(`Profiling transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`, txInfo);
-                const syncTimer = new Timer();
-                await this.synchronizer.sync();
-                const syncTime = syncTimer.ms();
-                const contractFunctionSimulator = this.#getSimulatorForTx();
-                const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
-                const { executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
-                    simulate: skipProofGeneration,
-                    skipFeeEnforcement: false,
-                    profileMode
-                });
-                const totalTime = totalTimer.ms();
-                const perFunction = executionSteps.map(({ functionName, timings: { witgen, oracles } })=>{
-                    return {
-                        functionName,
-                        time: witgen,
-                        oracles
-                    };
-                });
-                // Gate computation is time is not relevant for profiling, so we subtract it from the total time.
-                const gateCountComputationTime = executionSteps.reduce((acc, { timings })=>acc + (timings.gateCount ?? 0), 0) ?? 0;
-                const total = totalTime - gateCountComputationTime;
-                const timings = {
-                    total,
-                    sync: syncTime,
-                    proving,
-                    perFunction,
-                    unaccounted: total - ((syncTime ?? 0) + (proving ?? 0) + perFunction.reduce((acc, { time })=>acc + time, 0))
-                };
-                const simulatorStats = contractFunctionSimulator.getStats();
-                return new TxProfileResult(executionSteps, {
-                    timings,
-                    nodeRPCCalls: simulatorStats.nodeRPCCalls
-                });
-            } catch (err) {
-                throw this.#contextualizeError(err, inspect(txRequest), `profileMode=${profileMode}`);
-            }
-        });
-    }
-    // TODO(#7456) Prevent msgSender being defined here for the first call
-    simulateTx(txRequest, simulatePublic, skipTxValidation = false, skipFeeEnforcement = false, overrides, scopes) {
-        // 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 ()=>{
-            try {
-                const totalTimer = new Timer();
-                const txInfo = {
-                    origin: txRequest.origin,
-                    functionSelector: txRequest.functionSelector,
-                    simulatePublic,
-                    chainId: txRequest.txContext.chainId,
-                    version: txRequest.txContext.version,
-                    authWitnesses: txRequest.authWitnesses.map((w)=>w.requestHash)
-                };
-                this.log.info(`Simulating transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`, txInfo);
-                const syncTimer = new Timer();
-                await this.synchronizer.sync();
-                const syncTime = syncTimer.ms();
-                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);
-                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 hash of the initial tx request
-                    // if there are none.
-                    const nonceGenerator = privateExecutionResult.firstNullifier.equals(Fr.ZERO) ? await txRequest.toTxRequest().hash() : privateExecutionResult.firstNullifier;
-                    ({ publicInputs, executionSteps } = await generateSimulatedProvingResult(privateExecutionResult, nonceGenerator, this.contractDataProvider));
-                } else {
-                    // Kernel logic, plus proving of all private functions and kernels.
-                    ({ publicInputs, executionSteps } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
-                        simulate: true,
-                        skipFeeEnforcement,
-                        profileMode: 'none'
-                    }));
-                }
-                const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
-                const simulatedTx = await privateSimulationResult.toSimulatedTx();
-                let publicSimulationTime;
-                let publicOutput;
-                if (simulatePublic && publicInputs.forPublic) {
-                    const publicSimulationTimer = new Timer();
-                    publicOutput = await this.#simulatePublicCalls(simulatedTx, skipFeeEnforcement);
-                    publicSimulationTime = publicSimulationTimer.ms();
-                }
-                let validationTime;
-                if (!skipTxValidation) {
-                    const validationTimer = new Timer();
-                    const validationResult = await this.node.isValidTx(simulatedTx, {
-                        isSimulation: true,
-                        skipFeeEnforcement
-                    });
-                    validationTime = validationTimer.ms();
-                    if (validationResult.result === 'invalid') {
-                        throw new Error('The simulated transaction is unable to be added to state and is invalid.');
-                    }
-                }
-                const txHash = simulatedTx.getTxHash();
-                const totalTime = totalTimer.ms();
-                const perFunction = executionSteps.map(({ functionName, timings: { witgen, oracles } })=>({
-                        functionName,
-                        time: witgen,
-                        oracles
-                    }));
-                const timings = {
-                    total: totalTime,
-                    sync: syncTime,
-                    publicSimulation: publicSimulationTime,
-                    validation: validationTime,
-                    perFunction,
-                    unaccounted: totalTime - (syncTime + (publicSimulationTime ?? 0) + (validationTime ?? 0) + perFunction.reduce((acc, { time })=>acc + time, 0))
-                };
-                this.log.info(`Simulation completed for ${txHash.toString()} in ${totalTime}ms`, {
-                    txHash,
-                    ...txInfo,
-                    ...publicOutput ? {
-                        gasUsed: publicOutput.gasUsed,
-                        revertCode: publicOutput.txEffect.revertCode.getCode(),
-                        revertReason: publicOutput.revertReason
-                    } : {}
-                });
-                const simulatorStats = contractFunctionSimulator.getStats();
-                return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput, {
-                    timings,
-                    nodeRPCCalls: simulatorStats.nodeRPCCalls
-                });
-            } catch (err) {
-                throw this.#contextualizeError(err, inspect(txRequest), `simulatePublic=${simulatePublic}`, `skipTxValidation=${skipTxValidation}`, `scopes=${scopes?.map((s)=>s.toString()).join(', ') ?? 'undefined'}`);
-            }
-        });
-    }
-    async sendTx(tx) {
-        const txHash = tx.getTxHash();
-        if (await this.node.getTxEffect(txHash)) {
-            throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
-        }
-        this.log.debug(`Sending transaction ${txHash}`);
-        await this.node.sendTx(tx).catch((err)=>{
-            throw this.#contextualizeError(err, inspect(tx));
-        });
-        this.log.info(`Sent transaction ${txHash}`);
-        return txHash;
-    }
-    simulateUtility(functionName, args, to, authwits, _from, scopes) {
-        // 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 ()=>{
-            try {
-                const totalTimer = new Timer();
-                const syncTimer = new Timer();
-                await this.synchronizer.sync();
-                const syncTime = syncTimer.ms();
-                // TODO - Should check if `from` has the permission to call the view function.
-                const functionCall = await this.#getFunctionCall(functionName, args, to);
-                const functionTimer = new Timer();
-                const contractFunctionSimulator = this.#getSimulatorForTx();
-                const executionResult = await this.#simulateUtility(contractFunctionSimulator, functionCall, authwits ?? [], scopes);
-                const functionTime = functionTimer.ms();
-                const totalTime = totalTimer.ms();
-                const perFunction = [
-                    {
-                        functionName,
-                        time: functionTime
-                    }
-                ];
-                const timings = {
-                    total: totalTime,
-                    sync: syncTime,
-                    perFunction,
-                    unaccounted: totalTime - (syncTime + perFunction.reduce((acc, { time })=>acc + time, 0))
-                };
-                const simulationStats = contractFunctionSimulator.getStats();
-                return {
-                    result: executionResult,
-                    stats: {
-                        timings,
-                        nodeRPCCalls: simulationStats.nodeRPCCalls
-                    }
-                };
-            } catch (err) {
-                const stringifiedArgs = args.map((arg)=>arg.toString()).join(', ');
-                throw this.#contextualizeError(err, `simulateUtility ${to}:${functionName}(${stringifiedArgs})`, `scopes=${scopes?.map((s)=>s.toString()).join(', ') ?? 'undefined'}`);
-            }
-        });
-    }
-    async getNodeInfo() {
-        // This assumes we're connected to a single node, so we cache the info to avoid repeated calls.
-        // Load balancers and a myriad other configurations can break this assumption, so review this!
-        // Temporary measure to avoid hammering full nodes with requests on testnet.
-        if (!this.#nodeInfo) {
-            const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses] = await Promise.all([
-                this.node.getNodeVersion(),
-                this.node.getVersion(),
-                this.node.getChainId(),
-                this.node.getEncodedEnr(),
-                this.node.getL1ContractAddresses(),
-                this.node.getProtocolContractAddresses()
-            ]);
-            this.#nodeInfo = {
-                nodeVersion,
-                l1ChainId: chainId,
-                rollupVersion,
-                enr,
-                l1ContractAddresses: contractAddresses,
-                protocolContractAddresses: protocolContractAddresses
-            };
-        }
-        return this.#nodeInfo;
-    }
-    getPXEInfo() {
-        return Promise.resolve({
-            pxeVersion: this.packageVersion,
-            protocolContractAddresses: {
-                classRegistry: ProtocolContractAddress.ContractClassRegistry,
-                feeJuice: ProtocolContractAddress.FeeJuice,
-                instanceRegistry: ProtocolContractAddress.ContractInstanceRegistry,
-                multiCallEntrypoint: ProtocolContractAddress.MultiCallEntrypoint
-            }
-        });
-    }
-    async getPrivateEvents(contractAddress, eventMetadataDef, 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.
-        await this.simulateUtility('sync_private_state', [], contractAddress);
-        const events = await this.privateEventDataProvider.getPrivateEvents(contractAddress, from, numBlocks, recipients, eventMetadataDef.eventSelector);
-        const decodedEvents = events.map((event)=>decodeFromAbi([
-                eventMetadataDef.abiType
-            ], event));
-        return decodedEvents;
-    }
-    async getPublicEvents(eventMetadataDef, from, limit) {
-        const { logs } = await this.node.getPublicLogs({
-            fromBlock: from,
-            toBlock: from + limit
-        });
-        const decodedEvents = logs.map((log)=>{
-            // +1 for the event selector
-            const expectedLength = eventMetadataDef.fieldNames.length + 1;
-            if (log.log.emittedLength !== expectedLength) {
-                throw new Error(`Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length. Expected ${expectedLength}. Got ${log.log.emittedLength}.`);
-            }
-            const logFields = log.log.getEmittedFields();
-            // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
-            if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
-                return undefined;
-            }
-            return decodeFromAbi([
-                eventMetadataDef.abiType
-            ], log.log.fields);
-        }).filter((log)=>log !== undefined);
-        return decodedEvents;
-    }
-    async resetNoteSyncData() {
-        return await this.taggingDataProvider.resetNoteSyncData();
-    }
-    stop() {
-        return this.jobQueue.end();
-    }
-}