@aztec/txe 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

package/dest/oracle/txe_oracle_top_level_context.js

@@ -1,11 +1,76 @@
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
 import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, MAX_PRIVATE_LOGS_PER_TX, 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 { CapsuleService, ORACLE_VERSION_MAJOR, composeHooks, enrichPublicSimulationError } from '@aztec/pxe/server';
-import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, Oracle, PrivateExecutionOracle, UtilityExecutionOracle, executePrivateFunction, generateSimulatedProvingResult } from '@aztec/pxe/simulator';
+import { AnchoredContractData, CapsuleService, FactService, ORACLE_VERSION_MAJOR, composeHooks, enrichPublicSimulationError } from '@aztec/pxe/server';
+import { CONTRACT_INSTANCE, ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, PrivateExecutionOracle, TransientArrayService, UtilityExecutionOracle, buildACIRCallback, executePrivateFunction, generateSimulatedProvingResult } from '@aztec/pxe/simulator';
 import { ExecutionError, WASMSimulator, createSimulationError, extractCallStack, resolveAssertionMessageFromError, toACVMWitness, witnessMapToFields } from '@aztec/simulator/client';
 import { GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor, PublicTxSimulator } from '@aztec/simulator/server';
 import { FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
@@ -16,7 +81,9 @@ import { computePartialAddress } from '@aztec/stdlib/contract';
 import { Gas, GasFees } from '@aztec/stdlib/gas';
 import { computeCalldataHash, computeProtocolNullifier, siloNullifier } from '@aztec/stdlib/hash';
 import { PartialPrivateTailPublicInputsForPublic, PrivateKernelTailCircuitPublicInputs, PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
-import { hashPublicKey } from '@aztec/stdlib/keys';
+import { deriveKeys, hashPublicKey } from '@aztec/stdlib/keys';
+import { AppTaggingSecretKind } from '@aztec/stdlib/logs';
+import { L1Actor, L1ToL2Message, L2Actor } from '@aztec/stdlib/messaging';
 import { ChonkProof } from '@aztec/stdlib/proofs';
 import { makeGlobalVariables } from '@aztec/stdlib/testing';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
@@ -25,6 +92,7 @@ import { ForkCheckpoint } from '@aztec/world-state/native';
 import { DEFAULT_ADDRESS, MAX_PRIVATE_EVENTS_PER_TXE_QUERY, MAX_PRIVATE_EVENT_LEN } from '../constants.js';
 import { getSingleTxBlockRequestHash, insertTxEffectIntoWorldTrees, makeTXEBlock } from '../utils/block_creation.js';
 import { TXEPublicContractDataSource } from '../utils/txe_public_contract_data_source.js';
+import { makeResolveTaggingSecretStrategyHook } from './tagging_secret_strategy.js';
 export class TXEOracleTopLevelContext {
     stateMachine;
     contractStore;
@@ -34,20 +102,23 @@ export class TXEOracleTopLevelContext {
     accountStore;
     senderTaggingStore;
     recipientTaggingStore;
-    senderAddressBookStore;
+    taggingSecretSourcesStore;
     capsuleStore;
+    factStore;
     privateEventStore;
     nextBlockTimestamp;
     version;
     chainId;
     authwits;
+    taggingSecretStrategies;
+    authorizeAllUtilityCallTargets;
     artifactResolver;
     rootPath;
     packageName;
     isMisc;
     isTxe;
     logger;
-    constructor(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, nextBlockTimestamp, version, chainId, authwits, artifactResolver, rootPath, packageName){
+    constructor(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, taggingSecretSourcesStore, capsuleStore, factStore, privateEventStore, nextBlockTimestamp, version, chainId, authwits, taggingSecretStrategies, authorizeAllUtilityCallTargets, artifactResolver, rootPath, packageName){
         this.stateMachine = stateMachine;
         this.contractStore = contractStore;
         this.noteStore = noteStore;
@@ -56,13 +127,16 @@ export class TXEOracleTopLevelContext {
         this.accountStore = accountStore;
         this.senderTaggingStore = senderTaggingStore;
         this.recipientTaggingStore = recipientTaggingStore;
-        this.senderAddressBookStore = senderAddressBookStore;
+        this.taggingSecretSourcesStore = taggingSecretSourcesStore;
         this.capsuleStore = capsuleStore;
+        this.factStore = factStore;
         this.privateEventStore = privateEventStore;
         this.nextBlockTimestamp = nextBlockTimestamp;
         this.version = version;
         this.chainId = chainId;
         this.authwits = authwits;
+        this.taggingSecretStrategies = taggingSecretStrategies;
+        this.authorizeAllUtilityCallTargets = authorizeAllUtilityCallTargets;
         this.artifactResolver = artifactResolver;
         this.rootPath = rootPath;
         this.packageName = packageName;
@@ -142,7 +216,10 @@ export class TXEOracleTopLevelContext {
         }
         const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
         await this.stateMachine.contractSyncService.ensureContractSynced(contractAddress, null, async (call, execScopes)=>{
-            await this.executeUtilityCall(call, execScopes, jobId);
+            await this.executeUtilityCall(call, {
+                scopes: execScopes,
+                jobId
+            });
         }, blockHeader, jobId, [
             scope
         ]);
@@ -175,7 +252,7 @@ export class TXEOracleTopLevelContext {
         this.nextBlockTimestamp += duration;
     }
     deploymentNullifier(address) {
-        return siloNullifier(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), address.toField());
+        return siloNullifier(AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), address.toField());
     }
     async deploy(contractPath, initializer, args, secret, salt, deployer) {
         const { artifact, instance } = await this.artifactResolver.resolveDeployArtifact({
@@ -201,14 +278,7 @@ export class TXEOracleTopLevelContext {
             await this.contractStore.addContractArtifact(artifact);
             this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
         }
-        return [
-            instance.salt,
-            instance.deployer.toField(),
-            instance.currentContractClassId,
-            instance.initializationHash,
-            instance.immutablesHash,
-            ...instance.publicKeys.toFields()
-        ];
+        return CONTRACT_INSTANCE.serialization.fn(instance).flat();
     }
     /**
    * Mines a single block containing only the deployment nullifiers for the contracts at the given addresses.
@@ -226,15 +296,14 @@ export class TXEOracleTopLevelContext {
         this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
         await this.contractStore.addContractInstance(instance);
         await this.contractStore.addContractArtifact(artifact);
-        const completeAddress = await this.keyStore.addAccount(secret, partialAddress);
+        const completeAddress = await this.keyStore.addAccount(await deriveKeys(secret), partialAddress);
         await this.accountStore.setAccount(completeAddress.address, completeAddress);
         await this.addressStore.addCompleteAddress(completeAddress);
         this.logger.debug(`Created account ${completeAddress.address}`);
         return completeAddress;
     }
-    async createAccount(secret) {
-        // This is a foot gun !
-        const completeAddress = await this.keyStore.addAccount(secret, secret);
+    async createAccount(secret, partialAddress) {
+        const completeAddress = await this.keyStore.addAccount(await deriveKeys(secret), partialAddress);
         await this.accountStore.setAccount(completeAddress.address, completeAddress);
         await this.addressStore.addCompleteAddress(completeAddress);
         this.logger.debug(`Created account ${completeAddress.address}`);
@@ -249,6 +318,32 @@ export class TXEOracleTopLevelContext {
         const authWitness = new AuthWitness(messageHash, signature.toLimbFields());
         this.authwits.set(authWitness.requestHash.toString(), authWitness);
     }
+    setTaggingSecretStrategies(unconstrainedStrategy, constrainedStrategy) {
+        const apply = (mode, strategy)=>{
+            if (strategy.isSome()) {
+                this.taggingSecretStrategies.set(mode, strategy.value);
+            } else {
+                this.taggingSecretStrategies.delete(mode);
+            }
+        };
+        apply(AppTaggingSecretKind.UNCONSTRAINED, unconstrainedStrategy);
+        apply(AppTaggingSecretKind.CONSTRAINED, constrainedStrategy);
+    }
+    setAuthorizeAllUtilityCallTargets(authorizeAll) {
+        this.authorizeAllUtilityCallTargets = authorizeAll;
+    }
+    async sendL1ToL2Message(content, secretHash, sender, recipient) {
+        // Messages are appended to the tree, so the next free slot is simply the current tree size.
+        const { size } = await this.stateMachine.synchronizer.getCommitted().getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+        const leafIndex = new Fr(size);
+        const message = new L1ToL2Message(new L1Actor(sender, this.chainId.toNumber()), new L2Actor(recipient, this.version.toNumber()), content, secretHash, leafIndex);
+        await this.mineBlock({
+            l1ToL2Messages: [
+                message.hash()
+            ]
+        });
+        return leafIndex;
+    }
     async mineBlock(options = {}) {
         const blockNumber = await this.getNextBlockNumber();
         const txEffect = TxEffect.empty();
@@ -258,7 +353,7 @@ export class TXEOracleTopLevelContext {
         ];
         txEffect.txHash = new TxHash(new Fr(blockNumber));
         const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
-        await insertTxEffectIntoWorldTrees(txEffect, forkedWorldTrees);
+        await insertTxEffectIntoWorldTrees(txEffect, forkedWorldTrees, options.l1ToL2Messages ?? []);
         const globals = makeGlobalVariables(undefined, {
             blockNumber,
             timestamp: this.nextBlockTimestamp,
@@ -270,280 +365,319 @@ export class TXEOracleTopLevelContext {
         ]);
         await forkedWorldTrees.close();
         this.logger.info(`Created block ${blockNumber} with timestamp ${block.header.globalVariables.timestamp}`);
-        await this.stateMachine.handleL2Block(block);
+        await this.stateMachine.handleL2Block(block, options.l1ToL2Messages ?? []);
     }
     async privateCallNewFlow(from, targetContractAddress = AztecAddress.zero(), functionSelector = FunctionSelector.empty(), args, argsHash = Fr.zero(), isStaticCall = false, additionalScopes = [], jobId, authorizedUtilityCallTargets, gasSettings) {
-        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);
-        }
-        const scopes = from === undefined ? additionalScopes : [
-            from,
-            ...additionalScopes
-        ];
-        // Sync notes before executing private function to discover notes from previous transactions
-        const utilityExecutor = async (call, execScopes)=>{
-            await this.executeUtilityCall(call, execScopes, jobId);
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
         };
-        const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
-        await this.stateMachine.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, utilityExecutor, blockHeader, jobId, scopes);
-        const blockNumber = await this.getNextBlockNumber();
-        const msgSender = from ?? AztecAddress.NULL_MSG_SENDER;
-        const callContext = new CallContext(msgSender, targetContractAddress, functionSelector, isStaticCall);
-        const txContext = new TxContext(this.chainId, this.version, gasSettings);
-        const protocolNullifier = await computeProtocolNullifier(getSingleTxBlockRequestHash(blockNumber));
-        const noteCache = new ExecutionNoteCache(protocolNullifier);
-        // In production, the account contract sets the min revertible counter before calling the app function.
-        // Since TXE bypasses the account contract, we simulate this by setting minRevertibleSideEffectCounter to 1,
-        // marking all side effects as revertible.
-        const minRevertibleSideEffectCounter = 1;
-        await noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
-        const taggingIndexCache = new ExecutionTaggingIndexCache();
-        const simulator = new WASMSimulator();
-        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, scopes),
-            privateEventStore: this.privateEventStore,
-            contractSyncService: this.stateMachine.contractSyncService,
-            jobId,
-            totalPublicCalldataCount: 0,
-            sideEffectCounter: minRevertibleSideEffectCounter,
-            scopes,
-            // 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.l2TipsProvider,
-            hooks: composeHooks({
-                authorizeUtilityCall: this.buildAuthorizeUtilityCallHook(isStaticCall ? 'private view' : 'private', authorizedUtilityCallTargets)
-            })
-        });
-        // 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;
         try {
-            executionResult = await executePrivateFunction(simulator, privateExecutionOracle, artifact, targetContractAddress, functionSelector);
-            const publicCallRequests = collectNested([
+            const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+            const anchoredContractData = new AnchoredContractData(this.contractStore, this.stateMachine.contractClassService, blockHeader);
+            this.logger.verbose(`Executing external function ${await anchoredContractData.getDebugFunctionName(targetContractAddress, functionSelector)}@${targetContractAddress} isStaticCall=${isStaticCall}`);
+            const artifact = await anchoredContractData.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);
+            }
+            const scopes = from === undefined ? additionalScopes : [
+                from,
+                ...additionalScopes
+            ];
+            // Sync notes before executing private function to discover notes from previous transactions
+            const utilityExecutor = async (call, execScopes)=>{
+                await this.executeUtilityCall(call, {
+                    scopes: execScopes,
+                    jobId
+                });
+            };
+            await this.stateMachine.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, utilityExecutor, blockHeader, jobId, scopes);
+            const blockNumber = await this.getNextBlockNumber();
+            const msgSender = from ?? AztecAddress.NULL_MSG_SENDER;
+            const callContext = new CallContext(msgSender, targetContractAddress, functionSelector, isStaticCall);
+            const txContext = new TxContext(this.chainId, this.version, gasSettings);
+            const protocolNullifier = await computeProtocolNullifier(getSingleTxBlockRequestHash(blockNumber));
+            const noteCache = new ExecutionNoteCache(protocolNullifier);
+            // In production, the account contract sets the min revertible counter before calling the app function.
+            // Since TXE bypasses the account contract, we simulate this by setting minRevertibleSideEffectCounter to 1,
+            // marking all side effects as revertible.
+            const minRevertibleSideEffectCounter = 1;
+            await noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
+            const taggingIndexCache = new ExecutionTaggingIndexCache();
+            const simulator = new WASMSimulator();
+            const transientArrayService = new TransientArrayService();
+            const privateExecutionOracle = new PrivateExecutionOracle({
+                argsHash,
+                txContext,
+                txRequestSalt: Fr.ZERO,
+                callContext,
+                anchorBlockHeader: blockHeader,
+                utilityExecutor,
+                authWitnesses: Array.from(this.authwits.values()),
+                capsules: [],
+                executionCache: HashedValuesCache.create([
+                    new HashedValues(args, argsHash)
+                ]),
+                noteCache,
+                taggingIndexCache,
+                anchoredContractData,
+                noteStore: this.noteStore,
+                keyStore: this.keyStore,
+                addressStore: this.addressStore,
+                aztecNode: this.stateMachine.node,
+                senderTaggingStore: this.senderTaggingStore,
+                recipientTaggingStore: this.recipientTaggingStore,
+                taggingSecretSourcesStore: this.taggingSecretSourcesStore,
+                capsuleService: new CapsuleService(this.capsuleStore, scopes),
+                factService: new FactService(this.factStore, scopes),
+                privateEventStore: this.privateEventStore,
+                contractSyncService: this.stateMachine.contractSyncService,
+                jobId,
+                totalPublicCalldataCount: 0,
+                sideEffectCounter: minRevertibleSideEffectCounter,
+                scopes,
+                // 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,
+                txResolver: this.stateMachine.txResolver,
+                l2TipsStore: this.stateMachine.l2TipsProvider,
+                hooks: composeHooks({
+                    authorizeUtilityCall: this.buildAuthorizeUtilityCallHook(isStaticCall ? 'private view' : 'private', authorizedUtilityCallTargets),
+                    resolveTaggingSecretStrategy: makeResolveTaggingSecretStrategyHook(this.taggingSecretStrategies)
+                }),
+                transientArrayService
+            });
+            // 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;
+            try {
+                executionResult = await executePrivateFunction(simulator, privateExecutionOracle, artifact, targetContractAddress, functionSelector);
+                const publicCallRequests = collectNested([
+                    executionResult
+                ], (r)=>r.publicInputs.publicCallRequests.getActiveItems().map((r)=>r.inner).concat(r.publicInputs.publicTeardownCallRequest.isEmpty() ? [] : [
+                        r.publicInputs.publicTeardownCallRequest
+                    ]));
+                const publicFunctionsCalldata = await Promise.all(publicCallRequests.map(async (r)=>{
+                    const calldata = await privateExecutionOracle.getHashPreimage(r.calldataHash);
+                    return new HashedValues(calldata, r.calldataHash);
+                }));
+                const nonceGenerator = noteCache.getNonceGenerator();
+                result = new PrivateExecutionResult(executionResult, nonceGenerator, publicFunctionsCalldata);
+            } catch (err) {
+                throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
+            }
+            // 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, (addr, sel)=>anchoredContractData.getDebugFunctionName(addr, sel), this.stateMachine.node, minRevertibleSideEffectCounter);
+            const globals = makeGlobalVariables();
+            globals.blockNumber = blockNumber;
+            globals.timestamp = this.nextBlockTimestamp;
+            globals.chainId = this.chainId;
+            globals.version = this.version;
+            globals.gasFees = GasFees.empty();
+            const forkedWorldTrees = _ts_add_disposable_resource(env, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), true);
+            const bindings = this.logger.getBindings();
+            const contractsDB = new PublicContractsDB(new TXEPublicContractDataSource(blockNumber, this.contractStore), bindings);
+            const guardedMerkleTrees = new GuardedMerkleTreeOperations(forkedWorldTrees);
+            const config = PublicSimulatorConfig.from({
+                skipFeeEnforcement: true,
+                collectDebugLogs: true,
+                collectHints: false,
+                collectStatistics: false,
+                collectCallMetadata: true
+            });
+            // The AVM simulator reads this fork's contracts DB, scoped by fork id, for each simulation.
+            const forkId = forkedWorldTrees.getRevision().forkId;
+            const processor = new PublicProcessor(globals, guardedMerkleTrees, contractsDB, new PublicTxSimulator(this.stateMachine.synchronizer.avmSimulator, globals, contractsDB, forkId, config, bindings), new TestDateProvider(), undefined, createLogger('simulator:public-processor', bindings));
+            const tx = await Tx.create({
+                data: publicInputs,
+                chonkProof: ChonkProof.empty(),
+                contractClassLogFields: [],
+                publicFunctionCalldata: result.publicFunctionCalldata
+            });
+            let checkpoint;
+            if (isStaticCall) {
+                checkpoint = await ForkCheckpoint.new(forkedWorldTrees);
+            }
+            const results = await processor.process([
+                tx
+            ]);
+            const [processedTx] = results[0];
+            const failedTxs = results[1];
+            if (failedTxs.length !== 0) {
+                throw new Error(`Public execution has failed: ${failedTxs[0].error}`);
+            } else if (!processedTx.revertCode.isOK()) {
+                if (processedTx.revertReason) {
+                    try {
+                        await enrichPublicSimulationError(processedTx.revertReason, this.contractStore, this.stateMachine.contractClassService, await this.stateMachine.anchorBlockStore.getBlockHeader(), this.logger);
+                    // eslint-disable-next-line no-empty
+                    } catch  {}
+                    throw new Error(`Contract execution has reverted: ${processedTx.revertReason.getMessage()}`);
+                } else {
+                    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.publicInputs.publicCallRequests.getActiveItems().map((r)=>r.inner).concat(r.publicInputs.publicTeardownCallRequest.isEmpty() ? [] : [
-                    r.publicInputs.publicTeardownCallRequest
-                ]));
-            const publicFunctionsCalldata = await Promise.all(publicCallRequests.map(async (r)=>{
-                const calldata = await privateExecutionOracle.getHashPreimage(r.calldataHash);
-                return new HashedValues(calldata, r.calldataHash);
-            }));
-            noteCache.finish();
-            const nonceGenerator = noteCache.getNonceGenerator();
-            result = new PrivateExecutionResult(executionResult, nonceGenerator, publicFunctionsCalldata);
-        } catch (err) {
-            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
-        }
-        // 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, (addr, sel)=>this.contractStore.getDebugFunctionName(addr, sel), this.stateMachine.node, minRevertibleSideEffectCounter);
-        const globals = makeGlobalVariables();
-        globals.blockNumber = blockNumber;
-        globals.timestamp = this.nextBlockTimestamp;
-        globals.chainId = this.chainId;
-        globals.version = this.version;
-        globals.gasFees = GasFees.empty();
-        const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
-        const bindings = this.logger.getBindings();
-        const contractsDB = new PublicContractsDB(new TXEPublicContractDataSource(blockNumber, this.contractStore), bindings);
-        const guardedMerkleTrees = new GuardedMerkleTreeOperations(forkedWorldTrees);
-        const config = PublicSimulatorConfig.from({
-            skipFeeEnforcement: true,
-            collectDebugLogs: true,
-            collectHints: false,
-            collectStatistics: false,
-            collectCallMetadata: true
-        });
-        const processor = new PublicProcessor(globals, guardedMerkleTrees, contractsDB, new PublicTxSimulator(guardedMerkleTrees, contractsDB, globals, config, bindings), new TestDateProvider(), undefined, createLogger('simulator:public-processor', bindings));
-        const tx = await Tx.create({
-            data: publicInputs,
-            chonkProof: ChonkProof.empty(),
-            contractClassLogFields: [],
-            publicFunctionCalldata: result.publicFunctionCalldata
-        });
-        let checkpoint;
-        if (isStaticCall) {
-            checkpoint = await ForkCheckpoint.new(forkedWorldTrees);
-        }
-        const results = await processor.process([
-            tx
-        ]);
-        const [processedTx] = results[0];
-        const failedTxs = results[1];
-        if (failedTxs.length !== 0) {
-            throw new Error(`Public execution has failed: ${failedTxs[0].error}`);
-        } else if (!processedTx.revertCode.isOK()) {
-            if (processedTx.revertReason) {
-                try {
-                    await enrichPublicSimulationError(processedTx.revertReason, this.contractStore, this.logger);
-                // eslint-disable-next-line no-empty
-                } catch  {}
-                throw new Error(`Contract execution has reverted: ${processedTx.revertReason.getMessage()}`);
-            } else {
-                throw new Error('Contract execution has reverted');
+            ], (r)=>r.offchainEffects.map((e)=>e.data));
+            if (isStaticCall) {
+                await checkpoint.revert();
+                return {
+                    returnValues: executionResult.returnValues ?? [],
+                    offchainEffects
+                };
             }
-        }
-        // 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();
+            const txEffect = TxEffect.empty();
+            txEffect.noteHashes = processedTx.txEffect.noteHashes;
+            txEffect.nullifiers = processedTx.txEffect.nullifiers;
+            txEffect.privateLogs = processedTx.txEffect.privateLogs;
+            txEffect.publicLogs = processedTx.txEffect.publicLogs;
+            txEffect.publicDataWrites = processedTx.txEffect.publicDataWrites;
+            txEffect.txHash = new TxHash(new Fr(blockNumber));
+            const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
+            await forkedWorldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
+            const l2Block = await makeTXEBlock(forkedWorldTrees, globals, [
+                txEffect
+            ]);
+            await this.stateMachine.handleL2Block(l2Block);
             return {
                 returnValues: executionResult.returnValues ?? [],
                 offchainEffects
             };
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
         }
-        const txEffect = TxEffect.empty();
-        txEffect.noteHashes = processedTx.txEffect.noteHashes;
-        txEffect.nullifiers = processedTx.txEffect.nullifiers;
-        txEffect.privateLogs = processedTx.txEffect.privateLogs;
-        txEffect.publicLogs = processedTx.txEffect.publicLogs;
-        txEffect.publicDataWrites = processedTx.txEffect.publicDataWrites;
-        txEffect.txHash = new TxHash(new Fr(blockNumber));
-        const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
-        await forkedWorldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
-        const l2Block = await makeTXEBlock(forkedWorldTrees, globals, [
-            txEffect
-        ]);
-        await this.stateMachine.handleL2Block(l2Block);
-        await forkedWorldTrees.close();
-        return {
-            returnValues: executionResult.returnValues ?? [],
-            offchainEffects
-        };
     }
     async publicCallNewFlow(from, targetContractAddress, calldata, isStaticCall, gasSettings) {
-        this.logger.verbose(`Executing public function ${await this.contractStore.getDebugFunctionName(targetContractAddress, FunctionSelector.fromField(calldata[0]))}@${targetContractAddress} isStaticCall=${isStaticCall}`);
-        const blockNumber = await this.getNextBlockNumber();
-        const txContext = new TxContext(this.chainId, this.version, gasSettings);
-        const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
-        const calldataHash = await computeCalldataHash(calldata);
-        const calldataHashedValues = new HashedValues(calldata, calldataHash);
-        const globals = makeGlobalVariables();
-        globals.blockNumber = blockNumber;
-        globals.timestamp = this.nextBlockTimestamp;
-        globals.chainId = this.chainId;
-        globals.version = this.version;
-        globals.gasFees = GasFees.empty();
-        const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
-        const bindings2 = this.logger.getBindings();
-        const contractsDB = new PublicContractsDB(new TXEPublicContractDataSource(blockNumber, this.contractStore), bindings2);
-        const guardedMerkleTrees = new GuardedMerkleTreeOperations(forkedWorldTrees);
-        const config = PublicSimulatorConfig.from({
-            skipFeeEnforcement: true,
-            collectDebugLogs: true,
-            collectHints: false,
-            collectStatistics: false,
-            collectCallMetadata: true
-        });
-        const simulator = new PublicTxSimulator(guardedMerkleTrees, contractsDB, globals, config, bindings2);
-        const processor = new PublicProcessor(globals, guardedMerkleTrees, contractsDB, simulator, new TestDateProvider(), undefined, createLogger('simulator:public-processor', bindings2));
-        // We're simulating a scenario in which private execution immediately enqueues a public call and halts. The private
-        // kernel init would in this case inject a nullifier with the transaction request hash as a non-revertible
-        // side-effect, which the AVM then expects to exist in order to use it as the nonce generator when siloing notes as
-        // unique.
-        const nonRevertibleAccumulatedData = PrivateToPublicAccumulatedData.empty();
-        nonRevertibleAccumulatedData.nullifiers[0] = getSingleTxBlockRequestHash(blockNumber);
-        // The enqueued public call itself we make be revertible so that the public execution is itself revertible, as tests
-        // may require producing reverts.
-        const revertibleAccumulatedData = PrivateToPublicAccumulatedData.empty();
-        revertibleAccumulatedData.publicCallRequests[0] = new PublicCallRequest(from ?? AztecAddress.NULL_MSG_SENDER, 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(), /*expirationTimestamp=*/ 0n, inputsForPublic, undefined);
-        const tx = await Tx.create({
-            data: txData,
-            chonkProof: ChonkProof.empty(),
-            contractClassLogFields: [],
-            publicFunctionCalldata: [
-                calldataHashedValues
-            ]
-        });
-        let checkpoint;
-        if (isStaticCall) {
-            checkpoint = await ForkCheckpoint.new(forkedWorldTrees);
-        }
-        const results = await processor.process([
-            tx
-        ]);
-        const [processedTx] = results[0];
-        const failedTxs = results[1];
-        if (failedTxs.length !== 0) {
-            throw new Error(`Public execution has failed: ${failedTxs[0].error}`);
-        } else if (!processedTx.revertCode.isOK()) {
-            if (processedTx.revertReason) {
-                try {
-                    await enrichPublicSimulationError(processedTx.revertReason, this.contractStore, this.logger);
-                // eslint-disable-next-line no-empty
-                } catch  {}
-                throw new Error(`Contract execution has reverted: ${processedTx.revertReason.getMessage()}`);
-            } else {
-                throw new Error('Contract execution has reverted');
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
+        try {
+            const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+            const anchoredContractData = new AnchoredContractData(this.contractStore, this.stateMachine.contractClassService, anchorBlockHeader);
+            this.logger.verbose(`Executing public function ${await anchoredContractData.getDebugFunctionName(targetContractAddress, FunctionSelector.fromField(calldata[0]))}@${targetContractAddress} isStaticCall=${isStaticCall}`);
+            const blockNumber = await this.getNextBlockNumber();
+            const txContext = new TxContext(this.chainId, this.version, gasSettings);
+            const calldataHash = await computeCalldataHash(calldata);
+            const calldataHashedValues = new HashedValues(calldata, calldataHash);
+            const globals = makeGlobalVariables();
+            globals.blockNumber = blockNumber;
+            globals.timestamp = this.nextBlockTimestamp;
+            globals.chainId = this.chainId;
+            globals.version = this.version;
+            globals.gasFees = GasFees.empty();
+            const forkedWorldTrees = _ts_add_disposable_resource(env, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), true);
+            const bindings2 = this.logger.getBindings();
+            const contractsDB = new PublicContractsDB(new TXEPublicContractDataSource(blockNumber, this.contractStore), bindings2);
+            const guardedMerkleTrees = new GuardedMerkleTreeOperations(forkedWorldTrees);
+            const config = PublicSimulatorConfig.from({
+                skipFeeEnforcement: true,
+                collectDebugLogs: true,
+                collectHints: false,
+                collectStatistics: false,
+                collectCallMetadata: true
+            });
+            // The AVM simulator reads this fork's contracts DB, scoped by fork id, for each simulation.
+            const forkId2 = forkedWorldTrees.getRevision().forkId;
+            const simulator = new PublicTxSimulator(this.stateMachine.synchronizer.avmSimulator, globals, contractsDB, forkId2, config, bindings2);
+            const processor = new PublicProcessor(globals, guardedMerkleTrees, contractsDB, simulator, new TestDateProvider(), undefined, createLogger('simulator:public-processor', bindings2));
+            // We're simulating a scenario in which private execution immediately enqueues a public call and halts. The private
+            // kernel init would in this case inject a nullifier with the transaction request hash as a non-revertible
+            // side-effect, which the AVM then expects to exist in order to use it as the nonce generator when siloing notes as
+            // unique.
+            const nonRevertibleAccumulatedData = PrivateToPublicAccumulatedData.empty();
+            nonRevertibleAccumulatedData.nullifiers[0] = getSingleTxBlockRequestHash(blockNumber);
+            // The enqueued public call itself we make be revertible so that the public execution is itself revertible, as tests
+            // may require producing reverts.
+            const revertibleAccumulatedData = PrivateToPublicAccumulatedData.empty();
+            revertibleAccumulatedData.publicCallRequests[0] = new PublicCallRequest(from ?? AztecAddress.NULL_MSG_SENDER, 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(), /*expirationTimestamp=*/ 0n, inputsForPublic, undefined);
+            const tx = await Tx.create({
+                data: txData,
+                chonkProof: ChonkProof.empty(),
+                contractClassLogFields: [],
+                publicFunctionCalldata: [
+                    calldataHashedValues
+                ]
+            });
+            let checkpoint;
+            if (isStaticCall) {
+                checkpoint = await ForkCheckpoint.new(forkedWorldTrees);
             }
-        }
-        const returnValues = results[3][0].values;
-        if (isStaticCall) {
-            await checkpoint.revert();
-            await forkedWorldTrees.close();
+            const results = await processor.process([
+                tx
+            ]);
+            const [processedTx] = results[0];
+            const failedTxs = results[1];
+            if (failedTxs.length !== 0) {
+                throw new Error(`Public execution has failed: ${failedTxs[0].error}`);
+            } else if (!processedTx.revertCode.isOK()) {
+                if (processedTx.revertReason) {
+                    try {
+                        await enrichPublicSimulationError(processedTx.revertReason, this.contractStore, this.stateMachine.contractClassService, anchorBlockHeader, this.logger);
+                    // eslint-disable-next-line no-empty
+                    } catch  {}
+                    throw new Error(`Contract execution has reverted: ${processedTx.revertReason.getMessage()}`);
+                } else {
+                    throw new Error('Contract execution has reverted');
+                }
+            }
+            const returnValues = results[3][0].values;
+            if (isStaticCall) {
+                await checkpoint.revert();
+                return returnValues ?? [];
+            }
+            const txEffect = TxEffect.empty();
+            txEffect.noteHashes = processedTx.txEffect.noteHashes;
+            txEffect.nullifiers = processedTx.txEffect.nullifiers;
+            txEffect.privateLogs = processedTx.txEffect.privateLogs;
+            txEffect.publicLogs = processedTx.txEffect.publicLogs;
+            txEffect.publicDataWrites = processedTx.txEffect.publicDataWrites;
+            txEffect.txHash = new TxHash(new Fr(blockNumber));
+            const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
+            await forkedWorldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
+            const l2Block = await makeTXEBlock(forkedWorldTrees, globals, [
+                txEffect
+            ]);
+            await this.stateMachine.handleL2Block(l2Block);
             return returnValues ?? [];
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
         }
-        const txEffect = TxEffect.empty();
-        txEffect.noteHashes = processedTx.txEffect.noteHashes;
-        txEffect.nullifiers = processedTx.txEffect.nullifiers;
-        txEffect.privateLogs = processedTx.txEffect.privateLogs;
-        txEffect.publicLogs = processedTx.txEffect.publicLogs;
-        txEffect.publicDataWrites = processedTx.txEffect.publicDataWrites;
-        txEffect.txHash = new TxHash(new Fr(blockNumber));
-        const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
-        await forkedWorldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
-        const l2Block = await makeTXEBlock(forkedWorldTrees, globals, [
-            txEffect
-        ]);
-        await this.stateMachine.handleL2Block(l2Block);
-        await forkedWorldTrees.close();
-        return returnValues ?? [];
     }
-    async executeUtilityFunction(targetContractAddress, functionSelector, args, jobId, authorizedUtilityCallTargets) {
-        const artifact = await this.contractStore.getFunctionArtifact(targetContractAddress, functionSelector);
+    async executeUtilityFunction(from, targetContractAddress, functionSelector, args, jobId, authorizedUtilityCallTargets) {
+        const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        const anchoredContractData = new AnchoredContractData(this.contractStore, this.stateMachine.contractClassService, blockHeader);
+        const artifact = await anchoredContractData.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, execScopes)=>{
-            await this.executeUtilityCall(call, execScopes, jobId);
+            await this.executeUtilityCall(call, {
+                scopes: execScopes,
+                jobId
+            });
         }, blockHeader, jobId, await this.keyStore.getAccounts());
         const call = FunctionCall.from({
             name: artifact.name,
@@ -555,10 +689,20 @@ export class TXEOracleTopLevelContext {
             args,
             returnTypes: []
         });
-        return this.executeUtilityCall(call, await this.keyStore.getAccounts(), jobId, authorizedUtilityCallTargets);
+        return this.executeUtilityCall(call, {
+            from,
+            scopes: await this.keyStore.getAccounts(),
+            jobId,
+            authorizedUtilityCallTargets
+        });
     }
-    async executeUtilityCall(call, scopes, jobId, authorizedUtilityCallTargets = []) {
-        const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+    async executeUtilityCall(call, { from = AztecAddress.NULL_MSG_SENDER, scopes, jobId, authorizedUtilityCallTargets = [] }) {
+        const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        const anchoredContractData = new AnchoredContractData(this.contractStore, this.stateMachine.contractClassService, anchorBlockHeader);
+        const entryPointArtifact = await anchoredContractData.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+        if (!entryPointArtifact) {
+            throw new Error(`Cannot run function ${call.selector} on ${call.to}: the contract is not registered.`);
+        }
         if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
             throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
         }
@@ -567,26 +711,34 @@ export class TXEOracleTopLevelContext {
             selector: call.selector
         });
         try {
-            const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
             const simulator = new WASMSimulator();
             const utilityExecutor = async (syncCall, execScopes)=>{
-                await this.executeUtilityCall(syncCall, execScopes, jobId);
+                await this.executeUtilityCall(syncCall, {
+                    scopes: execScopes,
+                    jobId
+                });
             };
             const oracle = new UtilityExecutionOracle({
-                contractAddress: call.to,
+                callContext: CallContext.from({
+                    msgSender: from,
+                    contractAddress: call.to,
+                    functionSelector: call.selector,
+                    isStaticCall: true
+                }),
                 authWitnesses: [],
                 capsules: [],
                 anchorBlockHeader,
-                contractStore: this.contractStore,
+                anchoredContractData,
                 noteStore: this.noteStore,
                 keyStore: this.keyStore,
                 addressStore: this.addressStore,
                 aztecNode: this.stateMachine.node,
                 recipientTaggingStore: this.recipientTaggingStore,
-                senderAddressBookStore: this.senderAddressBookStore,
+                taggingSecretSourcesStore: this.taggingSecretSourcesStore,
                 capsuleService: new CapsuleService(this.capsuleStore, scopes),
+                factService: new FactService(this.factStore, scopes),
                 privateEventStore: this.privateEventStore,
-                messageContextService: this.stateMachine.messageContextService,
+                txResolver: this.stateMachine.txResolver,
                 contractSyncService: this.stateMachine.contractSyncService,
                 l2TipsStore: this.stateMachine.l2TipsProvider,
                 jobId,
@@ -595,9 +747,11 @@ export class TXEOracleTopLevelContext {
                 hooks: composeHooks({
                     authorizeUtilityCall: this.buildAuthorizeUtilityCallHook('utility', authorizedUtilityCallTargets)
                 }),
-                utilityExecutor
+                utilityExecutor,
+                // Execution-tree root (top-level utility run or contract sync): own store; nested frames inherit it.
+                transientArrayService: new TransientArrayService()
             });
-            const acirExecutionResult = await simulator.executeUserCircuit(toACVMWitness(0, call.args), entryPointArtifact, new Oracle(oracle).toACIRCallback()).catch((err)=>{
+            const acirExecutionResult = await simulator.executeUserCircuit(toACVMWitness(0, call.args), entryPointArtifact, buildACIRCallback(oracle)).catch((err)=>{
                 err.message = resolveAssertionMessageFromError(err, entryPointArtifact);
                 throw new ExecutionError(err.message, {
                     contractAddress: call.to,
@@ -614,16 +768,21 @@ export class TXEOracleTopLevelContext {
     }
     close() {
         this.logger.debug('Exiting Top Level Context');
-        return [
-            this.nextBlockTimestamp,
-            this.authwits
-        ];
+        return {
+            nextBlockTimestamp: this.nextBlockTimestamp,
+            authwits: this.authwits,
+            taggingSecretStrategies: this.taggingSecretStrategies,
+            authorizeAllUtilityCallTargets: this.authorizeAllUtilityCallTargets
+        };
     }
     async getLastBlockNumber() {
         const block = await this.stateMachine.node.getBlock('latest');
         return block ? block.header.globalVariables.blockNumber : BlockNumber.ZERO;
     }
     buildAuthorizeUtilityCallHook(callerContext, authorizedTargets) {
+        if (this.authorizeAllUtilityCallTargets) {
+            return authorizeAllUtilityCallsHook;
+        }
         if (authorizedTargets.length === 0) {
             return undefined;
         }
@@ -632,3 +791,10 @@ export class TXEOracleTopLevelContext {
             });
     }
 }
+/**
+ * An `authorizeUtilityCall` hook that authorizes every cross-contract utility call.
+ *
+ * Backs the `aztec_txe_setAuthorizeAllUtilityCallTargets` oracle.
+ */ export const authorizeAllUtilityCallsHook = ()=>Promise.resolve({
+        authorized: true
+    });