@aztec/txe 0.0.1-commit.e558bd1c → 0.0.1-commit.e5a3663dd

package/dest/oracle/txe_oracle_top_level_context.js

@@ -1,10 +1,10 @@
-import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT, DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Schnorr } from '@aztec/foundation/crypto/schnorr';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { LogLevels, applyStringFormatting, createLogger } from '@aztec/foundation/log';
 import { TestDateProvider } from '@aztec/foundation/timer';
-import { ORACLE_VERSION, enrichPublicSimulationError } from '@aztec/pxe/server';
+import { CapsuleService, ORACLE_VERSION_MAJOR, enrichPublicSimulationError } from '@aztec/pxe/server';
 import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, Oracle, PrivateExecutionOracle, UtilityExecutionOracle, executePrivateFunction, generateSimulatedProvingResult } from '@aztec/pxe/simulator';
 import { ExecutionError, WASMSimulator, createSimulationError, extractCallStack, resolveAssertionMessageFromError, toACVMWitness, witnessMapToFields } from '@aztec/simulator/client';
 import { CppPublicTxSimulator, GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor } from '@aztec/simulator/server';
@@ -13,7 +13,7 @@ import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computePartialAddress } from '@aztec/stdlib/contract';
-import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
+import { FALLBACK_TEARDOWN_DA_GAS_LIMIT, FALLBACK_TEARDOWN_L2_GAS_LIMIT, Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
 import { computeCalldataHash, computeProtocolNullifier, siloNullifier } from '@aztec/stdlib/hash';
 import { PartialPrivateTailPublicInputsForPublic, PrivateKernelTailCircuitPublicInputs, PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
 import { ChonkProof } from '@aztec/stdlib/proofs';
@@ -36,7 +36,6 @@ export class TXEOracleTopLevelContext {
     senderAddressBookStore;
     capsuleStore;
     privateEventStore;
-    jobId;
     nextBlockTimestamp;
     version;
     chainId;
@@ -44,7 +43,7 @@ export class TXEOracleTopLevelContext {
     isMisc;
     isTxe;
     logger;
-    constructor(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, jobId, nextBlockTimestamp, version, chainId, authwits){
+    constructor(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, nextBlockTimestamp, version, chainId, authwits){
         this.stateMachine = stateMachine;
         this.contractStore = contractStore;
         this.noteStore = noteStore;
@@ -56,7 +55,6 @@ export class TXEOracleTopLevelContext {
         this.senderAddressBookStore = senderAddressBookStore;
         this.capsuleStore = capsuleStore;
         this.privateEventStore = privateEventStore;
-        this.jobId = jobId;
         this.nextBlockTimestamp = nextBlockTimestamp;
         this.version = version;
         this.chainId = chainId;
@@ -66,39 +64,50 @@ export class TXEOracleTopLevelContext {
         this.logger = createLogger('txe:top_level_context');
         this.logger.debug('Entering Top Level Context');
     }
-    utilityAssertCompatibleOracleVersion(version) {
-        if (version !== ORACLE_VERSION) {
-            throw new Error(`Incompatible oracle version. TXE is using version '${ORACLE_VERSION}', but got a request for '${version}'.`);
+    contractOracleVersion;
+    assertCompatibleOracleVersion(major, minor) {
+        if (major !== ORACLE_VERSION_MAJOR) {
+            const hint = major > ORACLE_VERSION_MAJOR ? 'The contract was compiled with a newer version of Aztec.nr than this aztec cli version supports. Upgrade your aztec cli version to a compatible version.' : 'The contract was compiled with an older version of Aztec.nr than this aztec cli version supports. Recompile the contract with a compatible version of Aztec.nr.';
+            throw new Error(`Incompatible aztec cli version: ${hint} See https://docs.aztec.network/errors/8 (expected oracle major version ${ORACLE_VERSION_MAJOR}, got ${major})`);
         }
+        this.contractOracleVersion = {
+            major,
+            minor
+        };
+    }
+    // Prefixed with "nonOracleFunction" as it is not used as an oracle handler.
+    nonOracleFunctionGetContractOracleVersion() {
+        return this.contractOracleVersion;
     }
     // This is typically only invoked in private contexts, but it is convenient to also have it in top-level for testing
     // setup.
-    utilityGetRandomField() {
+    getRandomField() {
         return Fr.random();
     }
     // We instruct users to debug contracts via this oracle, so it makes sense that they'd expect it to also work in tests
-    utilityDebugLog(level, message, fields) {
+    log(level, message, fields) {
         if (!LogLevels[level]) {
-            throw new Error(`Invalid debug log level: ${level}`);
+            throw new Error(`Invalid log level: ${level}`);
         }
         const levelName = LogLevels[level];
         this.logger[levelName](`${applyStringFormatting(message, fields)}`, {
             module: `${this.logger.module}:debug_log`
         });
+        return Promise.resolve();
     }
-    txeGetDefaultAddress() {
+    getDefaultAddress() {
         return DEFAULT_ADDRESS;
     }
-    async txeGetNextBlockNumber() {
+    async getNextBlockNumber() {
         return BlockNumber(await this.getLastBlockNumber() + 1);
     }
-    txeGetNextBlockTimestamp() {
+    getNextBlockTimestamp() {
         return Promise.resolve(this.nextBlockTimestamp);
     }
-    async txeGetLastBlockTimestamp() {
+    async getLastBlockTimestamp() {
         return (await this.stateMachine.node.getBlockHeader('latest')).globalVariables.timestamp;
     }
-    async txeGetLastTxEffects() {
+    async getLastTxEffects() {
         const latestBlockNumber = await this.stateMachine.archiver.getBlockNumber();
         const block = await this.stateMachine.archiver.getBlock(latestBlockNumber);
         if (block.body.txEffects.length != 1) {
@@ -109,10 +118,23 @@ export class TXEOracleTopLevelContext {
         return {
             txHash: txEffects.txHash,
             noteHashes: txEffects.noteHashes,
-            nullifiers: txEffects.nullifiers
+            nullifiers: txEffects.nullifiers,
+            privateLogs: txEffects.privateLogs
         };
     }
-    async txeGetPrivateEvents(selector, contractAddress, scope) {
+    async syncContractNonOracleMethod(contractAddress, scope, jobId) {
+        if (contractAddress.equals(DEFAULT_ADDRESS)) {
+            this.logger.debug(`Skipping sync in getPrivateEvents because the events correspond to the default address.`);
+            return;
+        }
+        const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        await this.stateMachine.contractSyncService.ensureContractSynced(contractAddress, null, async (call, execScopes)=>{
+            await this.executeUtilityCall(call, execScopes, jobId);
+        }, blockHeader, jobId, [
+            scope
+        ]);
+    }
+    async getPrivateEvents(selector, contractAddress, scope) {
         return (await this.privateEventStore.getPrivateEvents(selector, {
             contractAddress,
             scopes: [
@@ -122,17 +144,17 @@ export class TXEOracleTopLevelContext {
             toBlock: await this.getLastBlockNumber() + 1
         })).map((e)=>e.packedEvent);
     }
-    async txeAdvanceBlocksBy(blocks) {
+    async advanceBlocksBy(blocks) {
         this.logger.debug(`time traveling ${blocks} blocks`);
         for(let i = 0; i < blocks; i++){
             await this.mineBlock();
         }
     }
-    txeAdvanceTimestampBy(duration) {
+    advanceTimestampBy(duration) {
         this.logger.debug(`time traveling ${duration} seconds`);
         this.nextBlockTimestamp += duration;
     }
-    async txeDeploy(artifact, instance, secret) {
+    async deploy(artifact, instance, secret) {
         // Emit deployment nullifier
         await this.mineBlock({
             nullifiers: [
@@ -140,25 +162,25 @@ export class TXEOracleTopLevelContext {
             ]
         });
         if (!secret.equals(Fr.ZERO)) {
-            await this.txeAddAccount(artifact, instance, secret);
+            await this.addAccount(artifact, instance, secret);
         } else {
             await this.contractStore.addContractInstance(instance);
-            await this.contractStore.addContractArtifact(instance.currentContractClassId, artifact);
+            await this.contractStore.addContractArtifact(artifact);
             this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
         }
     }
-    async txeAddAccount(artifact, instance, secret) {
+    async addAccount(artifact, instance, secret) {
         const partialAddress = await computePartialAddress(instance);
         this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
         await this.contractStore.addContractInstance(instance);
-        await this.contractStore.addContractArtifact(instance.currentContractClassId, artifact);
+        await this.contractStore.addContractArtifact(artifact);
         const completeAddress = await this.keyStore.addAccount(secret, partialAddress);
         await this.accountStore.setAccount(completeAddress.address, completeAddress);
         await this.addressStore.addCompleteAddress(completeAddress);
         this.logger.debug(`Created account ${completeAddress.address}`);
         return completeAddress;
     }
-    async txeCreateAccount(secret) {
+    async createAccount(secret) {
         // This is a foot gun !
         const completeAddress = await this.keyStore.addAccount(secret, secret);
         await this.accountStore.setAccount(completeAddress.address, completeAddress);
@@ -166,7 +188,7 @@ export class TXEOracleTopLevelContext {
         this.logger.debug(`Created account ${completeAddress.address}`);
         return completeAddress;
     }
-    async txeAddAuthWitness(address, messageHash) {
+    async addAuthWitness(address, messageHash) {
         const account = await this.accountStore.getAccount(address);
         const privateKey = await this.keyStore.getMasterSecretKey(account.publicKeys.masterIncomingViewingPublicKey);
         const schnorr = new Schnorr();
@@ -177,7 +199,7 @@ export class TXEOracleTopLevelContext {
         this.authwits.set(authWitness.requestHash.toString(), authWitness);
     }
     async mineBlock(options = {}) {
-        const blockNumber = await this.txeGetNextBlockNumber();
+        const blockNumber = await this.getNextBlockNumber();
         const txEffect = TxEffect.empty();
         txEffect.nullifiers = [
             getSingleTxBlockRequestHash(blockNumber),
@@ -199,29 +221,28 @@ export class TXEOracleTopLevelContext {
         this.logger.info(`Created block ${blockNumber} with timestamp ${block.header.globalVariables.timestamp}`);
         await this.stateMachine.handleL2Block(block);
     }
-    async txePrivateCallNewFlow(from, targetContractAddress = AztecAddress.zero(), functionSelector = FunctionSelector.empty(), args, argsHash = Fr.zero(), isStaticCall = false) {
+    async privateCallNewFlow(from, targetContractAddress = AztecAddress.zero(), functionSelector = FunctionSelector.empty(), args, argsHash = Fr.zero(), isStaticCall = false, jobId) {
         this.logger.verbose(`Executing external function ${await this.contractStore.getDebugFunctionName(targetContractAddress, functionSelector)}@${targetContractAddress} isStaticCall=${isStaticCall}`);
         const artifact = await this.contractStore.getFunctionArtifact(targetContractAddress, functionSelector);
         if (!artifact) {
             const message = functionSelector.equals(await FunctionSelector.fromSignature('verify_private_authwit(Field)')) ? 'Found no account contract artifact for a private authwit check - use `create_contract_account` instead of `create_light_account` for authwit support.' : 'Function Artifact does not exist';
             throw new Error(message);
         }
-        // When `from` is the zero address (used when creating a new contract account for example),
-        // we disable scope filtering by setting effectiveScopes to undefined. This allows these operations
-        // to proceed without requiring keys registered for the zero address.
-        const effectiveScopes = from.isZero() ? undefined : [
+        // When `from` is the zero address (e.g. when deploying a new account contract), we return an
+        // empty scope list which acts as deny-all: no notes are visible and no keys are accessible.
+        const effectiveScopes = from.isZero() ? [] : [
             from
         ];
         // Sync notes before executing private function to discover notes from previous transactions
-        const utilityExecutor = async (call)=>{
-            await this.executeUtilityCall(call, effectiveScopes);
+        const utilityExecutor = async (call, execScopes)=>{
+            await this.executeUtilityCall(call, execScopes, jobId);
         };
         const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
-        await this.stateMachine.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, utilityExecutor, blockHeader, this.jobId);
-        const blockNumber = await this.txeGetNextBlockNumber();
+        await this.stateMachine.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, utilityExecutor, blockHeader, jobId, effectiveScopes);
+        const blockNumber = await this.getNextBlockNumber();
         const callContext = new CallContext(from, targetContractAddress, functionSelector, isStaticCall);
-        const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
-        const teardownGasLimits = new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT);
+        const gasLimits = new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
+        const teardownGasLimits = new Gas(FALLBACK_TEARDOWN_DA_GAS_LIMIT, FALLBACK_TEARDOWN_L2_GAS_LIMIT);
         const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
         const txContext = new TxContext(this.chainId, this.version, gasSettings);
         const protocolNullifier = await computeProtocolNullifier(getSingleTxBlockRequestHash(blockNumber));
@@ -233,12 +254,41 @@ export class TXEOracleTopLevelContext {
         await noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
         const taggingIndexCache = new ExecutionTaggingIndexCache();
         const simulator = new WASMSimulator();
-        const privateExecutionOracle = new PrivateExecutionOracle(argsHash, txContext, callContext, /** Header of a block whose state is used during private execution (not the block the transaction is included in). */ blockHeader, utilityExecutor, /** List of transient auth witnesses to be used during this simulation */ Array.from(this.authwits.values()), /** List of transient auth witnesses to be used during this simulation */ [], HashedValuesCache.create([
-            new HashedValues(args, argsHash)
-        ]), noteCache, taggingIndexCache, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.stateMachine.node, this.senderTaggingStore, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.stateMachine.contractSyncService, this.jobId, 0, minRevertibleSideEffectCounter, undefined, effectiveScopes, /**
-       * In TXE, the typical transaction entrypoint is skipped, so we need to simulate the actions that such a
-       * contract would perform, including setting senderForTags.
-       */ from, simulator);
+        const privateExecutionOracle = new PrivateExecutionOracle({
+            argsHash,
+            txContext,
+            callContext,
+            anchorBlockHeader: blockHeader,
+            utilityExecutor,
+            authWitnesses: Array.from(this.authwits.values()),
+            capsules: [],
+            executionCache: HashedValuesCache.create([
+                new HashedValues(args, argsHash)
+            ]),
+            noteCache,
+            taggingIndexCache,
+            contractStore: this.contractStore,
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: this.stateMachine.node,
+            senderTaggingStore: this.senderTaggingStore,
+            recipientTaggingStore: this.recipientTaggingStore,
+            senderAddressBookStore: this.senderAddressBookStore,
+            capsuleService: new CapsuleService(this.capsuleStore, effectiveScopes),
+            privateEventStore: this.privateEventStore,
+            contractSyncService: this.stateMachine.contractSyncService,
+            jobId,
+            totalPublicCalldataCount: 0,
+            sideEffectCounter: minRevertibleSideEffectCounter,
+            scopes: effectiveScopes,
+            // In TXE, the typical transaction entrypoint is skipped, so we need to simulate the actions that such a
+            // contract would perform, including setting senderForTags.
+            senderForTags: from,
+            simulator,
+            messageContextService: this.stateMachine.messageContextService,
+            l2TipsStore: this.stateMachine.node
+        });
         // Note: This is a slight modification of simulator.run without any of the checks. Maybe we should modify simulator.run with a boolean value to skip checks.
         let result;
         let executionResult;
@@ -250,7 +300,7 @@ export class TXEOracleTopLevelContext {
                     r.publicInputs.publicTeardownCallRequest
                 ]));
             const publicFunctionsCalldata = await Promise.all(publicCallRequests.map(async (r)=>{
-                const calldata = await privateExecutionOracle.privateLoadFromExecutionCache(r.calldataHash);
+                const calldata = await privateExecutionOracle.getHashPreimage(r.calldataHash);
                 return new HashedValues(calldata, r.calldataHash);
             }));
             noteCache.finish();
@@ -262,7 +312,7 @@ export class TXEOracleTopLevelContext {
         // According to the protocol rules, there must be at least one nullifier in the tx. The first nullifier is used as
         // the nonce generator for the note hashes.
         // We pass the non-zero minRevertibleSideEffectCounter to make sure the side effects are split correctly.
-        const { publicInputs } = await generateSimulatedProvingResult(result, this.contractStore, minRevertibleSideEffectCounter);
+        const { publicInputs } = await generateSimulatedProvingResult(result, (addr, sel)=>this.contractStore.getDebugFunctionName(addr, sel), this.stateMachine.node, minRevertibleSideEffectCounter);
         const globals = makeGlobalVariables();
         globals.blockNumber = blockNumber;
         globals.timestamp = this.nextBlockTimestamp;
@@ -309,10 +359,20 @@ export class TXEOracleTopLevelContext {
                 throw new Error('Contract execution has reverted');
             }
         }
+        // Walk the nested private-call tree and collect every offchain effect the transaction emitted.
+        // PXE stores these on each `PrivateCallExecutionResult` and they never reach TXE via the
+        // `aztec_utl_emitOffchainEffect` foreign-call path (that path only fires at the top-level), so
+        // we pull them out here and the RPC wrapper will hand them to `TXESession` for buffering.
+        const offchainEffects = collectNested([
+            executionResult
+        ], (r)=>r.offchainEffects.map((e)=>e.data));
         if (isStaticCall) {
             await checkpoint.revert();
             await forkedWorldTrees.close();
-            return executionResult.returnValues ?? [];
+            return {
+                returnValues: executionResult.returnValues ?? [],
+                offchainEffects
+            };
         }
         const txEffect = TxEffect.empty();
         txEffect.noteHashes = processedTx.txEffect.noteHashes;
@@ -328,13 +388,16 @@ export class TXEOracleTopLevelContext {
         ]);
         await this.stateMachine.handleL2Block(l2Block);
         await forkedWorldTrees.close();
-        return executionResult.returnValues ?? [];
+        return {
+            returnValues: executionResult.returnValues ?? [],
+            offchainEffects
+        };
     }
-    async txePublicCallNewFlow(from, targetContractAddress, calldata, isStaticCall) {
+    async publicCallNewFlow(from, targetContractAddress, calldata, isStaticCall) {
         this.logger.verbose(`Executing public function ${await this.contractStore.getDebugFunctionName(targetContractAddress, FunctionSelector.fromField(calldata[0]))}@${targetContractAddress} isStaticCall=${isStaticCall}`);
-        const blockNumber = await this.txeGetNextBlockNumber();
-        const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
-        const teardownGasLimits = new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT);
+        const blockNumber = await this.getNextBlockNumber();
+        const gasLimits = new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
+        const teardownGasLimits = new Gas(FALLBACK_TEARDOWN_DA_GAS_LIMIT, FALLBACK_TEARDOWN_L2_GAS_LIMIT);
         const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
         const txContext = new TxContext(this.chainId, this.version, gasSettings);
         const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
@@ -371,7 +434,7 @@ export class TXEOracleTopLevelContext {
         revertibleAccumulatedData.publicCallRequests[0] = new PublicCallRequest(from, targetContractAddress, isStaticCall, calldataHash);
         const inputsForPublic = new PartialPrivateTailPublicInputsForPublic(nonRevertibleAccumulatedData, revertibleAccumulatedData, PublicCallRequest.empty());
         const constantData = new TxConstantData(anchorBlockHeader, txContext, Fr.zero(), Fr.zero());
-        const txData = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ new Gas(0, 0), /*feePayer=*/ AztecAddress.zero(), /*includeByTimestamp=*/ 0n, inputsForPublic, undefined);
+        const txData = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ new Gas(0, 0), /*feePayer=*/ AztecAddress.zero(), /*expirationTimestamp=*/ 0n, inputsForPublic, undefined);
         const tx = await Tx.create({
             data: txData,
             chonkProof: ChonkProof.empty(),
@@ -424,20 +487,29 @@ export class TXEOracleTopLevelContext {
         await forkedWorldTrees.close();
         return returnValues ?? [];
     }
-    async txeSimulateUtilityFunction(targetContractAddress, functionSelector, args) {
+    async executeUtilityFunction(targetContractAddress, functionSelector, args, jobId) {
         const artifact = await this.contractStore.getFunctionArtifact(targetContractAddress, functionSelector);
         if (!artifact) {
             throw new Error(`Cannot call ${functionSelector} as there is no artifact found at ${targetContractAddress}.`);
         }
         // Sync notes before executing utility function to discover notes from previous transactions
         const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
-        await this.stateMachine.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, async (call)=>{
-            await this.executeUtilityCall(call);
-        }, blockHeader, this.jobId);
-        const call = new FunctionCall(artifact.name, targetContractAddress, functionSelector, FunctionType.UTILITY, false, false, args, []);
-        return this.executeUtilityCall(call);
+        await this.stateMachine.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, async (call, execScopes)=>{
+            await this.executeUtilityCall(call, execScopes, jobId);
+        }, blockHeader, jobId, await this.keyStore.getAccounts());
+        const call = FunctionCall.from({
+            name: artifact.name,
+            to: targetContractAddress,
+            selector: functionSelector,
+            type: FunctionType.UTILITY,
+            hideMsgSender: false,
+            isStatic: false,
+            args,
+            returnTypes: []
+        });
+        return this.executeUtilityCall(call, await this.keyStore.getAccounts(), jobId);
     }
-    async executeUtilityCall(call, scopes) {
+    async executeUtilityCall(call, scopes, jobId) {
         const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
         if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
             throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
@@ -448,8 +520,29 @@ export class TXEOracleTopLevelContext {
         });
         try {
             const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
-            const oracle = new UtilityExecutionOracle(call.to, [], [], anchorBlockHeader, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.stateMachine.node, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.jobId, undefined, scopes);
-            const acirExecutionResult = await new WASMSimulator().executeUserCircuit(toACVMWitness(0, call.args), entryPointArtifact, new Oracle(oracle).toACIRCallback()).catch((err)=>{
+            const simulator = new WASMSimulator();
+            const oracle = new UtilityExecutionOracle({
+                contractAddress: call.to,
+                authWitnesses: [],
+                capsules: [],
+                anchorBlockHeader,
+                contractStore: this.contractStore,
+                noteStore: this.noteStore,
+                keyStore: this.keyStore,
+                addressStore: this.addressStore,
+                aztecNode: this.stateMachine.node,
+                recipientTaggingStore: this.recipientTaggingStore,
+                senderAddressBookStore: this.senderAddressBookStore,
+                capsuleService: new CapsuleService(this.capsuleStore, scopes),
+                privateEventStore: this.privateEventStore,
+                messageContextService: this.stateMachine.messageContextService,
+                contractSyncService: this.stateMachine.contractSyncService,
+                l2TipsStore: this.stateMachine.node,
+                jobId,
+                scopes,
+                simulator
+            });
+            const acirExecutionResult = await simulator.executeUserCircuit(toACVMWitness(0, call.args), entryPointArtifact, new Oracle(oracle).toACIRCallback()).catch((err)=>{
                 err.message = resolveAssertionMessageFromError(err, entryPointArtifact);
                 throw new ExecutionError(err.message, {
                     contractAddress: call.to,
@@ -458,10 +551,10 @@ export class TXEOracleTopLevelContext {
                     cause: err
                 });
             });
-            this.logger.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
+            this.logger.verbose(`Utility execution for ${call.to}.${call.selector} completed`);
             return witnessMapToFields(acirExecutionResult.returnWitness);
         } catch (err) {
-            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during utility simulation'));
+            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during utility execution'));
         }
     }
     close() {