@aztec/pxe 0.80.0 → 0.82.0

package/dest/pxe_service/pxe_service.js

@@ -15,14 +15,13 @@ 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 { PrivateSimulationResult, TxProfileResult, 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 { PrivateKernelExecutionProver } from '../private_kernel/private_kernel_execution_prover.js';
+import { PrivateKernelOracleImpl } from '../private_kernel/private_kernel_oracle_impl.js';
 import { PXEOracleInterface } from '../pxe_oracle_interface/pxe_oracle_interface.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';
@@ -42,7 +41,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     syncDataProvider;
     taggingDataProvider;
     addressDataProvider;
-    authWitnessDataProvider;
     simulator;
     packageVersion;
     proverEnabled;
@@ -50,7 +48,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     protocolContractsProvider;
     log;
     jobQueue;
-    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, authWitnessDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue){
+    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue){
         this.node = node;
         this.synchronizer = synchronizer;
         this.keyStore = keyStore;
@@ -60,7 +58,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         this.syncDataProvider = syncDataProvider;
         this.taggingDataProvider = taggingDataProvider;
         this.addressDataProvider = addressDataProvider;
-        this.authWitnessDataProvider = authWitnessDataProvider;
         this.simulator = simulator;
         this.packageVersion = packageVersion;
         this.proverEnabled = proverEnabled;
@@ -80,7 +77,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         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);
@@ -89,16 +85,61 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         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 pxeOracleInterface = new PXEOracleInterface(node, keyStore, simulationProvider, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, log);
         const simulator = new AcirSimulator(pxeOracleInterface, simulationProvider);
         const jobQueue = new SerialQueue();
-        const pxeService = new PXEService(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, authWitnessDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue);
+        const pxeService = new PXEService(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, 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.protocolVersion}`);
         return pxeService;
     }
+    // Aztec node proxy methods
+    isL1ToL2MessageSynced(l1ToL2Message) {
+        return this.node.isL1ToL2MessageSynced(l1ToL2Message);
+    }
+    getL2ToL1MembershipWitness(blockNumber, l2Tol1Message) {
+        return this.node.getL2ToL1MessageMembershipWitness(blockNumber, l2Tol1Message);
+    }
+    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
+    #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.
@@ -111,14 +152,127 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         }
         return this.jobQueue.put(fn);
     }
-    isL1ToL2MessageSynced(l1ToL2Message) {
-        return this.node.isL1ToL2MessageSynced(l1ToL2Message);
+    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 #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 #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 #executePrivate(txRequest, msgSender, scopes) {
+        const { origin: contractAddress, functionSelector } = 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, authWitnesses, scopes) {
+        const { to: contractAddress, selector: functionSelector } = execRequest;
+        this.log.debug('Executing unconstrained simulator...');
+        try {
+            const result = await this.simulator.runUnconstrained(execRequest, contractAddress, functionSelector, authWitnesses ?? [], 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
+   * @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.authWitnessDataProvider.getSize(),
             this.capsuleDataProvider.getSize(),
             this.contractDataProvider.getSize(),
             this.noteDataProvider.getSize(),
@@ -130,15 +284,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             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);
     }
@@ -197,8 +342,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         return address;
     }
     getSenders() {
-        const senders = this.taggingDataProvider.getSenderAddresses();
-        return Promise.resolve(senders);
+        return this.taggingDataProvider.getSenderAddresses();
     }
     async removeSender(address) {
         const wasRemoved = await this.taggingDataProvider.removeSenderAddress(address);
@@ -207,7 +351,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         } 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
@@ -238,12 +381,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             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);
@@ -266,12 +403,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             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}`);
@@ -280,32 +411,23 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     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) {
+            let recipient = filter.recipient;
+            if (recipient === 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 completeAddressIndex = completeAddresses.findIndex((completeAddress)=>completeAddress.address.equals(dao.recipient));
                 const completeAddress = completeAddresses[completeAddressIndex];
                 if (completeAddress === undefined) {
-                    throw new Error(`Cannot find complete address for addressPoint ${dao.addressPoint.toString()}`);
+                    throw new Error(`Cannot find complete address for recipient ${dao.recipient.toString()}`);
                 }
-                owner = completeAddress.address;
+                recipient = completeAddress.address;
             }
-            return new UniqueNote(dao.note, owner, dao.contractAddress, dao.storageSlot, dao.noteTypeId, dao.txHash, dao.nonce);
+            return new UniqueNote(dao.note, recipient, dao.contractAddress, dao.storageSlot, 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) {
@@ -324,16 +446,43 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
                 const { publicInputs, clientIvcProof } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
                     simulate: false,
                     skipFeeEnforcement: false,
-                    profile: false
+                    profileMode: 'none'
                 });
                 return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof);
             } catch (err) {
-                throw this.contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
+                throw this.#contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
+            }
+        });
+    }
+    profileTx(txRequest, profileMode, msgSender) {
+        // We disable concurrent profiles for consistency with simulateTx.
+        return this.#putInJobQueue(async ()=>{
+            try {
+                const txInfo = {
+                    origin: txRequest.origin,
+                    functionSelector: txRequest.functionSelector,
+                    simulatePublic: false,
+                    msgSender,
+                    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);
+                await this.synchronizer.sync();
+                const privateExecutionResult = await this.#executePrivate(txRequest, msgSender);
+                const { executionSteps } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+                    simulate: true,
+                    skipFeeEnforcement: false,
+                    profileMode
+                });
+                return new TxProfileResult(executionSteps);
+            } catch (err) {
+                throw this.#contextualizeError(err, inspect(txRequest), `profileMode=${profileMode}`, `msgSender=${msgSender?.toString() ?? 'undefined'}`);
             }
         });
     }
     // TODO(#7456) Prevent msgSender being defined here for the first call
-    simulateTx(txRequest, simulatePublic, msgSender = undefined, skipTxValidation = false, skipFeeEnforcement = false, profile = false, scopes) {
+    simulateTx(txRequest, simulatePublic, msgSender = undefined, skipTxValidation = false, skipFeeEnforcement = false, 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).
@@ -352,10 +501,10 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
                 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,
+                const { publicInputs } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+                    simulate: true,
                     skipFeeEnforcement,
-                    profile
+                    profileMode: 'none'
                 });
                 const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
                 const simulatedTx = privateSimulationResult.toSimulatedTx();
@@ -376,18 +525,15 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
                 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);
+                return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput);
             } 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'}`);
+                throw this.#contextualizeError(err, inspect(txRequest), `simulatePublic=${simulatePublic}`, `msgSender=${msgSender?.toString() ?? 'undefined'}`, `skipTxValidation=${skipTxValidation}`, `scopes=${scopes?.map((s)=>s.toString()).join(', ') ?? 'undefined'}`);
             }
         });
     }
@@ -398,12 +544,12 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         }
         this.log.debug(`Sending transaction ${txHash}`);
         await this.node.sendTx(tx).catch((err)=>{
-            throw this.contextualizeError(err, inspect(tx));
+            throw this.#contextualizeError(err, inspect(tx));
         });
         this.log.info(`Sent transaction ${txHash}`);
         return txHash;
     }
-    simulateUnconstrained(functionName, args, to, _from, scopes) {
+    simulateUnconstrained(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).
@@ -412,60 +558,15 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
                 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);
+                const executionResult = await this.#simulateUnconstrained(functionCall, authwits ?? [], 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'}`);
+                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(),
@@ -496,122 +597,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             }
         });
     }
-    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);
@@ -683,17 +668,4 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     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/contract_data_provider/contract_data_provider.d.ts

@@ -3,7 +3,7 @@
 import type { Fr } from '@aztec/foundation/fields';
 import type { MembershipWitness } from '@aztec/foundation/trees';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { type ContractArtifact, type FunctionArtifact, type FunctionDebugMetadata, FunctionSelector } from '@aztec/stdlib/abi';
+import { type ContractArtifact, type FunctionArtifact, type FunctionArtifactWithContractName, type FunctionDebugMetadata, FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type ContractClass, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { DataProvider } from '../data_provider.js';
@@ -59,7 +59,7 @@ export declare class ContractDataProvider implements DataProvider {
      * @param selector - The function selector.
      * @returns The corresponding function's artifact as an object.
      */
-    getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifact>;
+    getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifactWithContractName>;
     /**
      * Retrieves the artifact of a specified function within a given contract.
      * The function is identified by its name, which is unique within a contract.