@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/pxe_service/pxe_service.js

@@ -1,664 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { KeyStore } from '@aztec/key-store';
-import { L2TipsStore } from '@aztec/kv-store/stores';
-import { ProtocolContractAddress, protocolContractNames } from '@aztec/protocol-contracts';
-import { AcirSimulator, readCurrentClassId } from '@aztec/simulator/client';
-import { EventSelector, FunctionSelector, FunctionType, decodeFunctionSignature, encodeArguments } from '@aztec/stdlib/abi';
-import { computeContractAddressFromInstance, getContractClassFromArtifact } from '@aztec/stdlib/contract';
-import { SimulationError } from '@aztec/stdlib/errors';
-import { EventMetadata, L1EventPayload } from '@aztec/stdlib/event';
-import { siloNullifier } from '@aztec/stdlib/hash';
-import { computeAddressSecret } from '@aztec/stdlib/keys';
-import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
-import { UniqueNote } from '@aztec/stdlib/note';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { PrivateSimulationResult, TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
-import { inspect } from 'util';
-import { getPackageInfo } from '../config/package_info.js';
-import { KernelOracle } from '../kernel_oracle/index.js';
-import { KernelProver } from '../kernel_prover/kernel_prover.js';
-import { PXEOracleInterface } from '../pxe_oracle_interface/index.js';
-import { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
-import { AuthWitnessDataProvider } from '../storage/auth_witness_data_provider/auth_witness_data_provider.js';
-import { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
-import { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
-import { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
-import { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
-import { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
-import { Synchronizer } from '../synchronizer/index.js';
-import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
-/**
- * A Private eXecution Environment (PXE) implementation.
- */ export class PXEService {
-    node;
-    synchronizer;
-    keyStore;
-    contractDataProvider;
-    noteDataProvider;
-    capsuleDataProvider;
-    syncDataProvider;
-    taggingDataProvider;
-    addressDataProvider;
-    authWitnessDataProvider;
-    simulator;
-    packageVersion;
-    proverEnabled;
-    proofCreator;
-    protocolContractsProvider;
-    log;
-    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, authWitnessDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log){
-        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.authWitnessDataProvider = authWitnessDataProvider;
-        this.simulator = simulator;
-        this.packageVersion = packageVersion;
-        this.proverEnabled = proverEnabled;
-        this.proofCreator = proofCreator;
-        this.protocolContractsProvider = protocolContractsProvider;
-        this.log = log;
-    }
-    /**
-   * 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, simulationProvider, protocolContractsProvider, config, loggerOrSuffix) {
-        const log = !loggerOrSuffix || typeof loggerOrSuffix === 'string' ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`) : loggerOrSuffix;
-        const packageVersion = getPackageInfo().version;
-        const proverEnabled = !!config.proverEnabled;
-        const addressDataProvider = new AddressDataProvider(store);
-        const authWitnessDataProvider = new AuthWitnessDataProvider(store);
-        const contractDataProvider = new ContractDataProvider(store);
-        const noteDataProvider = await NoteDataProvider.create(store);
-        const syncDataProvider = new SyncDataProvider(store);
-        const taggingDataProvider = new TaggingDataProvider(store);
-        const capsuleDataProvider = new CapsuleDataProvider(store);
-        const keyStore = new KeyStore(store);
-        const tipsStore = new L2TipsStore(store, 'pxe');
-        const synchronizer = new Synchronizer(node, syncDataProvider, noteDataProvider, taggingDataProvider, tipsStore, config, loggerOrSuffix);
-        const pxeOracleInterface = new PXEOracleInterface(node, keyStore, simulationProvider, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, authWitnessDataProvider, log);
-        const simulator = new AcirSimulator(pxeOracleInterface, simulationProvider);
-        const pxeService = new PXEService(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, authWitnessDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log);
-        await pxeService.#registerProtocolContracts();
-        const info = await pxeService.getNodeInfo();
-        log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
-        return pxeService;
-    }
-    isL1ToL2MessageSynced(l1ToL2Message) {
-        return this.node.isL1ToL2MessageSynced(l1ToL2Message);
-    }
-    /** Returns an estimate of the db size in bytes. */ async estimateDbSize() {
-        const treeRootsSize = Object.keys(MerkleTreeId).length * Fr.SIZE_IN_BYTES;
-        const dbSizes = await Promise.all([
-            this.addressDataProvider.getSize(),
-            this.authWitnessDataProvider.getSize(),
-            this.capsuleDataProvider.getSize(),
-            this.contractDataProvider.getSize(),
-            this.noteDataProvider.getSize(),
-            this.syncDataProvider.getSize(),
-            this.taggingDataProvider.getSize()
-        ]);
-        return [
-            ...dbSizes,
-            treeRootsSize
-        ].reduce((sum, size)=>sum + size, 0);
-    }
-    addAuthWitness(witness) {
-        return this.authWitnessDataProvider.addAuthWitness(witness.requestHash, witness.witness);
-    }
-    getAuthWitness(messageHash) {
-        return this.authWitnessDataProvider.getAuthWitness(messageHash);
-    }
-    storeCapsule(contract, storageSlot, capsule) {
-        return this.capsuleDataProvider.storeCapsule(contract, storageSlot, capsule);
-    }
-    getContractInstance(address) {
-        return this.contractDataProvider.getContractInstance(address);
-    }
-    async getContractClassMetadata(id, includeArtifact = false) {
-        let artifact;
-        try {
-            artifact = await this.contractDataProvider.getContractArtifact(id);
-        } catch  {
-            this.log.warn(`No artifact found for contract class ${id.toString()} when looking for its metadata`);
-        }
-        return {
-            contractClass: artifact && await getContractClassFromArtifact(artifact),
-            isContractClassPubliclyRegistered: await this.#isContractClassPubliclyRegistered(id),
-            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),
-            isContractPubliclyDeployed: await this.#isContractPubliclyDeployed(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() {
-        const senders = this.taggingDataProvider.getSenderAddresses();
-        return Promise.resolve(senders);
-    }
-    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.`);
-        }
-        return Promise.resolve();
-    }
-    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(instance.address, publicFunctionSignatures);
-            // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
-            await this.node.addContractClass({
-                ...contractClass,
-                privateFunctions: [],
-                unconstrainedFunctions: []
-            });
-        } else {
-            // Otherwise, make sure there is an artifact already registered for that class id
-            artifact = await this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
-        }
-        await this.contractDataProvider.addContractInstance(instance);
-        this.log.info(`Added contract ${artifact.name} at ${instance.address.toString()} with class ${instance.currentContractClassId}`);
-    }
-    async updateContract(contractAddress, artifact) {
-        const currentInstance = await this.contractDataProvider.getContractInstance(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.toNumber());
-        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(contractAddress, publicFunctionSignatures);
-        // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
-        await this.node.addContractClass({
-            ...contractClass,
-            privateFunctions: [],
-            unconstrainedFunctions: []
-        });
-        currentInstance.currentContractClassId = contractClass.id;
-        await this.contractDataProvider.addContractInstance(currentInstance);
-        this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
-    }
-    getContracts() {
-        return this.contractDataProvider.getContractsAddresses();
-    }
-    async getPublicStorageAt(contract, slot) {
-        return await this.node.getPublicStorageAt('latest', contract, slot);
-    }
-    async getNotes(filter) {
-        const noteDaos = await this.noteDataProvider.getNotes(filter);
-        const extendedNotes = noteDaos.map(async (dao)=>{
-            let owner = filter.owner;
-            if (owner === undefined) {
-                const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
-                const completeAddressIndex = (await Promise.all(completeAddresses.map((completeAddresses)=>completeAddresses.address.toAddressPoint()))).findIndex((addressPoint)=>addressPoint.equals(dao.addressPoint));
-                const completeAddress = completeAddresses[completeAddressIndex];
-                if (completeAddress === undefined) {
-                    throw new Error(`Cannot find complete address for addressPoint ${dao.addressPoint.toString()}`);
-                }
-                owner = completeAddress.address;
-            }
-            return new UniqueNote(dao.note, owner, dao.contractAddress, dao.storageSlot, dao.noteTypeId, dao.txHash, dao.nonce);
-        });
-        return Promise.all(extendedNotes);
-    }
-    async getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
-        return await getNonNullifiedL1ToL2MessageWitness(this.node, contractAddress, messageHash, secret);
-    }
-    getL2ToL1MembershipWitness(blockNumber, l2Tol1Message) {
-        return this.node.getL2ToL1MessageMembershipWitness(blockNumber, l2Tol1Message);
-    }
-    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();
-    }
-    async proveTx(txRequest, privateExecutionResult) {
-        try {
-            const { publicInputs, clientIvcProof } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
-                simulate: false,
-                skipFeeEnforcement: false,
-                profile: false
-            });
-            return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof);
-        } catch (err) {
-            throw this.contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
-        }
-    }
-    // TODO(#7456) Prevent msgSender being defined here for the first call
-    async simulateTx(txRequest, simulatePublic, msgSender = undefined, skipTxValidation = false, skipFeeEnforcement = false, profile = false, scopes) {
-        try {
-            const txInfo = {
-                origin: txRequest.origin,
-                functionSelector: txRequest.functionSelector,
-                simulatePublic,
-                msgSender,
-                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 timer = new Timer();
-            await this.synchronizer.sync();
-            const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
-            const { publicInputs, profileResult } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
-                simulate: !profile,
-                skipFeeEnforcement,
-                profile
-            });
-            const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
-            const simulatedTx = privateSimulationResult.toSimulatedTx();
-            let publicOutput;
-            if (simulatePublic && publicInputs.forPublic) {
-                publicOutput = await this.#simulatePublicCalls(simulatedTx, skipFeeEnforcement);
-            }
-            if (!skipTxValidation) {
-                const validationResult = await this.node.isValidTx(simulatedTx, {
-                    isSimulation: true,
-                    skipFeeEnforcement
-                });
-                if (validationResult.result === 'invalid') {
-                    throw new Error('The simulated transaction is unable to be added to state and is invalid.');
-                }
-            }
-            const txHash = await simulatedTx.getTxHash();
-            this.log.info(`Simulation completed for ${txHash.toString()} in ${timer.ms()}ms`, {
-                txHash,
-                ...txInfo,
-                ...profileResult ? {
-                    gateCounts: profileResult.gateCounts
-                } : {},
-                ...publicOutput ? {
-                    gasUsed: publicOutput.gasUsed,
-                    revertCode: publicOutput.txEffect.revertCode.getCode(),
-                    revertReason: publicOutput.revertReason
-                } : {}
-            });
-            return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput, profileResult);
-        } catch (err) {
-            throw this.contextualizeError(err, inspect(txRequest), `simulatePublic=${simulatePublic}`, `msgSender=${msgSender?.toString() ?? 'undefined'}`, `skipTxValidation=${skipTxValidation}`, `profile=${profile}`, `scopes=${scopes?.map((s)=>s.toString()).join(', ') ?? 'undefined'}`);
-        }
-    }
-    async sendTx(tx) {
-        const txHash = await 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;
-    }
-    async simulateUnconstrained(functionName, args, to, _from, scopes) {
-        try {
-            await this.synchronizer.sync();
-            // TODO - Should check if `from` has the permission to call the view function.
-            const functionCall = await this.#getFunctionCall(functionName, args, to);
-            const executionResult = await this.#simulateUnconstrained(functionCall, scopes);
-            // TODO - Return typed result based on the function artifact.
-            return executionResult;
-        } catch (err) {
-            const stringifiedArgs = args.map((arg)=>arg.toString()).join(', ');
-            throw this.contextualizeError(err, `simulateUnconstrained ${to}:${functionName}(${stringifiedArgs})`, `scopes=${scopes?.map((s)=>s.toString()).join(', ') ?? 'undefined'}`);
-        }
-    }
-    getTxReceipt(txHash) {
-        return this.node.getTxReceipt(txHash);
-    }
-    getTxEffect(txHash) {
-        return this.node.getTxEffect(txHash);
-    }
-    async getBlockNumber() {
-        return await this.node.getBlockNumber();
-    }
-    async getProvenBlockNumber() {
-        return await this.node.getProvenBlockNumber();
-    }
-    /**
-   * Gets public logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */ getPublicLogs(filter) {
-        return this.node.getPublicLogs(filter);
-    }
-    /**
-   * Gets contract class logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */ getContractClassLogs(filter) {
-        return this.node.getContractClassLogs(filter);
-    }
-    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
-        };
-    }
-    async getNodeInfo() {
-        const [nodeVersion, protocolVersion, 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()
-        ]);
-        const nodeInfo = {
-            nodeVersion,
-            l1ChainId: chainId,
-            protocolVersion,
-            enr,
-            l1ContractAddresses: contractAddresses,
-            protocolContractAddresses: protocolContractAddresses
-        };
-        return nodeInfo;
-    }
-    getPXEInfo() {
-        return Promise.resolve({
-            pxeVersion: this.packageVersion,
-            protocolContractAddresses: {
-                classRegisterer: ProtocolContractAddress.ContractClassRegisterer,
-                feeJuice: ProtocolContractAddress.FeeJuice,
-                instanceDeployer: ProtocolContractAddress.ContractInstanceDeployer,
-                multiCallEntrypoint: ProtocolContractAddress.MultiCallEntrypoint
-            }
-        });
-    }
-    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);
-    }
-    /**
-   * Retrieves the simulation parameters required to run an ACIR simulation.
-   * This includes the contract address, function artifact, and historical tree roots.
-   *
-   * @param execRequest - The transaction request object containing details of the contract call.
-   * @returns An object containing the contract address, function artifact, and historical tree roots.
-   */ #getSimulationParameters(execRequest) {
-        const contractAddress = execRequest.to ?? execRequest.origin;
-        const functionSelector = execRequest.selector ?? execRequest.functionSelector;
-        return {
-            contractAddress,
-            functionSelector
-        };
-    }
-    async #executePrivate(txRequest, msgSender, scopes) {
-        // TODO - Pause syncing while simulating.
-        const { contractAddress, functionSelector } = this.#getSimulationParameters(txRequest);
-        try {
-            const result = await this.simulator.run(txRequest, contractAddress, functionSelector, msgSender, 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 an unconstrained transaction on the given contract, without considering constraints set by ACIR.
-   * The simulation parameters are fetched using ContractDataProvider and executed using AcirSimulator.
-   * Returns the simulation result containing the outputs of the unconstrained function.
-   *
-   * @param execRequest - The transaction request object containing the target contract and function data.
-   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
-   * @returns The simulation result containing the outputs of the unconstrained function.
-   */ async #simulateUnconstrained(execRequest, scopes) {
-        const { contractAddress, functionSelector } = this.#getSimulationParameters(execRequest);
-        this.log.debug('Executing unconstrained simulator...');
-        try {
-            const result = await this.simulator.runUnconstrained(execRequest, contractAddress, functionSelector, scopes);
-            this.log.verbose(`Unconstrained simulation for ${contractAddress}.${functionSelector} completed`);
-            return result;
-        } 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
-   * @returns An object that contains the output of the kernel execution, including the ClientIvcProof if proving is enabled.
-   */ async #prove(txExecutionRequest, proofCreator, privateExecutionResult, { simulate, skipFeeEnforcement, profile }) {
-        // use the block the tx was simulated against
-        const block = privateExecutionResult.entrypoint.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
-        const kernelOracle = new KernelOracle(this.contractDataProvider, this.keyStore, this.node, block);
-        const kernelProver = new KernelProver(kernelOracle, proofCreator, !this.proverEnabled);
-        this.log.debug(`Executing kernel prover (simulate: ${simulate}, profile: ${profile})...`);
-        return await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult, {
-            simulate,
-            skipFeeEnforcement,
-            profile
-        });
-    }
-    async #isContractClassPubliclyRegistered(id) {
-        return !!await this.node.getContractClass(id);
-    }
-    async #isContractPubliclyDeployed(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 getPrivateEvents(eventMetadataDef, from, limit, // TODO (#9272): Make this better, we should be able to only pass an address now
-    vpks) {
-        const eventMetadata = new EventMetadata(eventMetadataDef);
-        if (vpks.length === 0) {
-            throw new Error('Tried to get encrypted events without supplying any viewing public keys');
-        }
-        const blocks = await this.node.getBlocks(from, limit);
-        const txEffects = blocks.flatMap((block)=>block.body.txEffects);
-        const privateLogs = txEffects.flatMap((txEffect)=>txEffect.privateLogs);
-        const vsks = await Promise.all(vpks.map(async (vpk)=>{
-            const [keyPrefix, account] = await this.keyStore.getKeyPrefixAndAccount(vpk);
-            let secretKey = await this.keyStore.getMasterSecretKey(vpk);
-            if (keyPrefix === 'iv') {
-                const registeredAccount = (await this.getRegisteredAccounts()).find((completeAddress)=>completeAddress.address.equals(account));
-                if (!registeredAccount) {
-                    throw new Error('No registered account');
-                }
-                const preaddress = await registeredAccount.getPreaddress();
-                secretKey = await computeAddressSecret(preaddress, secretKey);
-            }
-            return secretKey;
-        }));
-        const visibleEvents = (await Promise.all(privateLogs.map(async (log)=>{
-            for (const sk of vsks){
-                // TODO: Verify that the first field of the log is the tag siloed with contract address.
-                // Or use tags to query logs, like we do with notes.
-                const decryptedEvent = await L1EventPayload.decryptAsIncoming(log, sk);
-                if (decryptedEvent !== undefined) {
-                    return [
-                        decryptedEvent
-                    ];
-                }
-            }
-            return [];
-        }))).flat();
-        const decodedEvents = visibleEvents.map((visibleEvent)=>{
-            if (visibleEvent === undefined) {
-                return undefined;
-            }
-            if (!visibleEvent.eventTypeId.equals(eventMetadata.eventSelector)) {
-                return undefined;
-            }
-            return eventMetadata.decode(visibleEvent);
-        }).filter((visibleEvent)=>visibleEvent !== undefined);
-        return decodedEvents;
-    }
-    async getPublicEvents(eventMetadataDef, from, limit) {
-        const eventMetadata = new EventMetadata(eventMetadataDef);
-        const { logs } = await this.node.getPublicLogs({
-            fromBlock: from,
-            toBlock: from + limit
-        });
-        const decodedEvents = logs.map((log)=>{
-            // +1 for the event selector
-            const expectedLength = eventMetadata.fieldNames.length + 1;
-            const logFields = log.log.log.slice(0, expectedLength);
-            // 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(eventMetadata.eventSelector)) {
-                return undefined;
-            }
-            // If any of the remaining fields, are non-zero, the payload does match expected:
-            if (log.log.log.slice(expectedLength + 1).find((f)=>!f.isZero())) {
-                throw new Error('Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length');
-            }
-            return eventMetadata.decode(log.log);
-        }).filter((log)=>log !== undefined);
-        return decodedEvents;
-    }
-    async resetNoteSyncData() {
-        return await this.taggingDataProvider.resetNoteSyncData();
-    }
-    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;
-    }
-}

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

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