@aztec/txe 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/dest/txe_session.js

@@ -2,32 +2,44 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
-import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { AddressStore, AnchorBlockStore, CapsuleStore, JobCoordinator, NoteService, NoteStore, PrivateEventStore, RecipientTaggingStore, SenderAddressBookStore, SenderTaggingStore } from '@aztec/pxe/server';
-import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, Oracle, PrivateExecutionOracle, UtilityExecutionOracle } from '@aztec/pxe/simulator';
+import { openEphemeralStore } from '@aztec/kv-store/lmdb-v2';
+import { AddressStore, AnchorBlockStore, AnchoredContractData, CapsuleService, CapsuleStore, FactService, FactStore, JobCoordinator, NoteService, NoteStore, PrivateEventStore, RecipientTaggingStore, SenderTaggingStore, TaggingSecretSourcesStore, composeHooks } from '@aztec/pxe/server';
+import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, LEGACY_ORACLE_REGISTRY, TransientArrayService, UtilityExecutionOracle, buildACIRCallback } from '@aztec/pxe/simulator';
 import { ExecutionError, WASMSimulator, createSimulationError, extractCallStack, resolveAssertionMessageFromError, toACVMWitness } from '@aztec/simulator/client';
+import { STANDARD_AUTH_REGISTRY_ADDRESS } from '@aztec/standard-contracts/auth-registry/constants';
 import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { GasSettings } from '@aztec/stdlib/gas';
 import { computeProtocolNullifier } from '@aztec/stdlib/hash';
 import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import { CallContext, TxContext } from '@aztec/stdlib/tx';
+import { CallContext, OFFCHAIN_MESSAGE_IDENTIFIER, TxContext } from '@aztec/stdlib/tx';
 import { z } from 'zod';
-import { DEFAULT_ADDRESS } from './constants.js';
+import { DEFAULT_ADDRESS, MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY, MAX_OFFCHAIN_EFFECT_LEN } from './constants.js';
+import { makeResolveTaggingSecretStrategyHook } from './oracle/tagging_secret_strategy.js';
 import { TXEOraclePublicContext } from './oracle/txe_oracle_public_context.js';
-import { TXEOracleTopLevelContext } from './oracle/txe_oracle_top_level_context.js';
-import { RPCTranslator } from './rpc_translator.js';
+import { callTxeLegacyHandler } from './oracle/txe_oracle_registry.js';
+import { TXEOracleTopLevelContext, authorizeAllUtilityCallsHook } from './oracle/txe_oracle_top_level_context.js';
+import { TXE_ORACLE_VERSION_MAJOR, TXE_ORACLE_VERSION_MINOR } from './oracle/txe_oracle_version.js';
+import { TXEPrivateExecutionOracle } from './oracle/txe_private_execution_oracle.js';
+import { RPCTranslator, UnavailableOracleError } from './rpc_translator.js';
 import { TXEArchiver } from './state_machine/archiver.js';
 import { TXEStateMachine } from './state_machine/index.js';
-import { TXEAccountStore } from './util/txe_account_store.js';
-import { TXEContractStore } from './util/txe_contract_store.js';
 import { getSingleTxBlockRequestHash, insertTxEffectIntoWorldTrees, makeTXEBlock } from './utils/block_creation.js';
 import { makeTxEffect } from './utils/tx_effect_creation.js';
+import { TXEAccountStore } from './utils/txe_account_store.js';
+function emptyLastCallState() {
+    return {
+        offchainEffects: [],
+        queried: false,
+        txHash: Fr.ZERO,
+        anchorBlockTimestamp: 0n
+    };
+}
 /**
  * A `TXESession` corresponds to a Noir `#[test]` function, and handles all of its oracle calls, stores test-specific
  * state, etc., independent of all other tests running in parallel.
  */ export class TXESession {
     logger;
+    sessionStore;
     stateMachine;
     oracleHandler;
     contractStore;
@@ -37,18 +49,28 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
     accountStore;
     senderTaggingStore;
     recipientTaggingStore;
-    senderAddressBookStore;
+    taggingSecretSourcesStore;
     capsuleStore;
+    factStore;
     privateEventStore;
     jobCoordinator;
     currentJobId;
     chainId;
     version;
     nextBlockTimestamp;
+    artifactResolver;
+    rootPath;
+    packageName;
     state;
     authwits;
-    constructor(logger, stateMachine, oracleHandler, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, jobCoordinator, currentJobId, chainId, version, nextBlockTimestamp){
+    taggingSecretStrategies;
+    authorizeAllUtilityCallTargets;
+    lastCallInfo;
+    txeOracleVersion;
+    disposed;
+    constructor(logger, sessionStore, stateMachine, oracleHandler, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, taggingSecretSourcesStore, capsuleStore, factStore, privateEventStore, jobCoordinator, currentJobId, chainId, version, nextBlockTimestamp, artifactResolver, rootPath, packageName){
         this.logger = logger;
+        this.sessionStore = sessionStore;
         this.stateMachine = stateMachine;
         this.oracleHandler = oracleHandler;
         this.contractStore = contractStore;
@@ -58,45 +80,71 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
         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.jobCoordinator = jobCoordinator;
         this.currentJobId = currentJobId;
         this.chainId = chainId;
         this.version = version;
         this.nextBlockTimestamp = nextBlockTimestamp;
+        this.artifactResolver = artifactResolver;
+        this.rootPath = rootPath;
+        this.packageName = packageName;
         this.state = {
             name: 'TOP_LEVEL'
         };
         this.authwits = new Map();
+        this.taggingSecretStrategies = new Map();
+        this.authorizeAllUtilityCallTargets = false;
+        this.lastCallInfo = emptyLastCallState();
+        this.disposed = false;
     }
-    static async init(protocolContracts) {
-        const store = await openTmpStore('txe-session');
+    /**
+   * Closes the per-session `txe-session` LMDB and the `NativeWorldStateService` .
+   * Called via IPC when the dispatcher detects the end of a test. Idempotent.
+   */ async dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        try {
+            await this.stateMachine.synchronizer.nativeWorldStateService.close();
+        } catch (err) {
+            this.logger.warn(`Error closing native world state during session dispose`, err);
+        }
+        try {
+            await this.sessionStore.close();
+        } catch (err) {
+            this.logger.warn(`Error closing session LMDB during dispose`, err);
+        }
+    }
+    static async init(contractStore, artifactResolver, rootPath, packageName) {
+        // Size LMDB's reader slots to the libuv pool (capped to 2 in bin/index.ts via
+        // HARDWARE_CONCURRENCY): each native LMDB read needs a libuv worker thread to run, so any
+        // slot beyond the pool size would sit idle while still consuming a semaphore + reader-table
+        // entry per session.
+        const store = await openEphemeralStore('txe-session', undefined, 2);
         const addressStore = new AddressStore(store);
         const privateEventStore = new PrivateEventStore(store);
-        const contractStore = new TXEContractStore(store);
         const noteStore = new NoteStore(store);
         const senderTaggingStore = new SenderTaggingStore(store);
         const recipientTaggingStore = new RecipientTaggingStore(store);
-        const senderAddressBookStore = new SenderAddressBookStore(store);
+        const taggingSecretSourcesStore = new TaggingSecretSourcesStore(store);
         const capsuleStore = new CapsuleStore(store);
+        const factStore = new FactStore(store);
         const keyStore = new KeyStore(store);
         const accountStore = new TXEAccountStore(store);
-        // Create job coordinator and register staged stores
         const jobCoordinator = new JobCoordinator(store);
         jobCoordinator.registerStores([
             capsuleStore,
+            factStore,
             senderTaggingStore,
             recipientTaggingStore,
             privateEventStore,
             noteStore
         ]);
-        // Register protocol contracts.
-        for (const { contractClass, instance, artifact } of protocolContracts){
-            await contractStore.addContractArtifact(contractClass.id, artifact);
-            await contractStore.addContractInstance(instance);
-        }
         const archiver = new TXEArchiver(store);
         const anchorBlockStore = new AnchorBlockStore(store);
         const stateMachine = await TXEStateMachine.create(archiver, anchorBlockStore, contractStore, noteStore);
@@ -104,9 +152,12 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
         const version = new Fr(await stateMachine.node.getVersion());
         const chainId = new Fr(await stateMachine.node.getChainId());
         const initialJobId = jobCoordinator.beginJob();
-        const topLevelOracleHandler = new TXEOracleTopLevelContext(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, initialJobId, nextBlockTimestamp, version, chainId, new Map());
-        await topLevelOracleHandler.txeAdvanceBlocksBy(1);
-        return new TXESession(createLogger('txe:session'), stateMachine, topLevelOracleHandler, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, jobCoordinator, initialJobId, version, chainId, nextBlockTimestamp);
+        const logger = createLogger('txe:session');
+        const topLevelOracleHandler = new TXEOracleTopLevelContext(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, taggingSecretSourcesStore, capsuleStore, factStore, privateEventStore, nextBlockTimestamp, version, chainId, new Map(), new Map(), false, artifactResolver, rootPath, packageName);
+        await topLevelOracleHandler.mineDeploymentNullifiers([
+            STANDARD_AUTH_REGISTRY_ADDRESS
+        ]);
+        return new TXESession(logger, store, stateMachine, topLevelOracleHandler, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, taggingSecretSourcesStore, capsuleStore, factStore, privateEventStore, jobCoordinator, initialJobId, version, chainId, nextBlockTimestamp, artifactResolver, rootPath, packageName);
     }
     /**
    * Processes an oracle function invoked by the Noir test associated to this session.
@@ -115,13 +166,28 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
    * @returns The oracle return values.
    */ processFunction(functionName, inputs) {
         try {
+            // Oracles retired into the PXE legacy registry have no translator method; dispatch them through the same
+            // buildACIRCallback legacy path that contract execution uses, keeping TXE's two oracle paths in sync.
+            // Use an own-property check: `in` would match inherited `Object.prototype` keys (e.g. `constructor`), routing
+            // them into the legacy path instead of letting them fall through to the unknown-oracle error.
+            if (Object.hasOwn(LEGACY_ORACLE_REGISTRY, functionName)) {
+                return callTxeLegacyHandler(functionName, inputs, this.oracleHandler);
+            }
             const translator = new RPCTranslator(this, this.oracleHandler);
             // We perform a runtime validation to check that the function name corresponds to a real oracle handler.
             const validatedFunctionName = z.string().refine((fn)=>typeof translator[fn] === 'function' && !fn.startsWith('handlerAs') && fn !== 'constructor').parse(functionName);
             return translator[validatedFunctionName](...inputs);
         } catch (error) {
             if (error instanceof z.ZodError) {
-                throw new Error(`${functionName} does not correspond to any oracle handler available on RPCTranslator`);
+                let versionHint;
+                if (!this.txeOracleVersion) {
+                    versionHint = ' The test appears to use an older version of Aztec.nr that does not' + ' support test environment oracle versioning. Update Aztec.nr to a compatible version.' + ' See https://docs.aztec.network/errors/12';
+                } else if (this.txeOracleVersion.minor > TXE_ORACLE_VERSION_MINOR) {
+                    versionHint = ` The test uses Aztec.nr test oracle version` + ` ${this.txeOracleVersion.major}.${this.txeOracleVersion.minor}, but this test environment` + ` only supports up to ${TXE_ORACLE_VERSION_MAJOR}.${TXE_ORACLE_VERSION_MINOR}.` + ` Upgrade the Aztec CLI to a compatible version.` + ` See https://docs.aztec.network/errors/12`;
+                } else {
+                    versionHint = ` The test's oracle version (${this.txeOracleVersion.major}.${this.txeOracleVersion.minor})` + ` is compatible with this test environment` + ` (${TXE_ORACLE_VERSION_MAJOR}.${TXE_ORACLE_VERSION_MINOR}), so this oracle should be` + ` available. This is an unexpected error, please report it.` + ` See https://docs.aztec.network/errors/13`;
+                }
+                throw new Error(`Unknown oracle '${functionName}'.${versionHint}`);
             } else if (error instanceof Error) {
                 throw new Error(`Execution error while processing function ${functionName} in state ${this.state.name}: ${error.message}`);
             } else {
@@ -129,6 +195,132 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
             }
         }
     }
+    /** Commits the current job and begins a new one. Returns the new job ID. */ async cycleJob() {
+        await this.jobCoordinator.commitJob(this.currentJobId);
+        this.currentJobId = this.jobCoordinator.beginJob();
+        return this.currentJobId;
+    }
+    resetLastCall() {
+        const notQueriedMessageCount = this.lastCallInfo.queried ? 0 : this.lastCallInfo.offchainEffects.filter((payload)=>payload[0]?.equals(OFFCHAIN_MESSAGE_IDENTIFIER)).length;
+        if (notQueriedMessageCount > 0) {
+            this.logger.warn(`Dropping ${notQueriedMessageCount} unqueried offchain message(s) from the previous top-level call. ` + `To deliver them, call \`env.offchain_messages()\` and forward the result to the recipient contract's ` + `\`offchain_receive\` utility before issuing another top-level call. To intentionally discard, assign ` + `to \`let _ = env.offchain_messages()\` to silence this warning.`);
+        }
+        this.lastCallInfo = emptyLastCallState();
+    }
+    recordOffchainEffect(data) {
+        this.lastCallInfo.offchainEffects.push(data);
+    }
+    setLastCallContext(txHash, anchorBlockTimestamp) {
+        this.lastCallInfo.txHash = txHash;
+        this.lastCallInfo.anchorBlockTimestamp = anchorBlockTimestamp;
+    }
+    async withTopLevelCallTracking(work) {
+        this.resetLastCall();
+        // Capture the anchor *before* `work` runs: private/public executor calls mine a new block as a
+        // side effect, and that block's timestamp should not be attributed to this call's anchor.
+        const anchorBlockTimestamp = (await this.stateMachine.node.getBlockData('latest')).header.globalVariables.timestamp;
+        const { result, txHash } = await work();
+        this.setLastCallContext(txHash ?? Fr.ZERO, anchorBlockTimestamp);
+        return result;
+    }
+    getLastCallOffchainEffects() {
+        this.lastCallInfo.queried = true;
+        const effects = this.lastCallInfo.offchainEffects;
+        if (effects.length > MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY) {
+            throw new Error(`${effects.length} offchain effects exceed max ${MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY}`);
+        }
+        if (effects.some((e)=>e.length > MAX_OFFCHAIN_EFFECT_LEN)) {
+            throw new Error(`Some offchain effect has length larger than max ${MAX_OFFCHAIN_EFFECT_LEN}`);
+        }
+        return {
+            effects
+        };
+    }
+    getLastCallContext() {
+        const { txHash, anchorBlockTimestamp } = this.lastCallInfo;
+        return {
+            txHash,
+            anchorBlockTimestamp
+        };
+    }
+    async executePrivateCall(from, targetContractAddress, functionSelector, args, argsHash, isStaticCall, additionalScopes, authorizedUtilityCallTargets, gasSettings) {
+        const handler = this.handlerAsTxe();
+        return await this.withTopLevelCallTracking(async ()=>{
+            const { returnValues, offchainEffects } = await handler.privateCallNewFlow(from?.value, targetContractAddress, functionSelector, args, argsHash, isStaticCall, additionalScopes, this.currentJobId, authorizedUtilityCallTargets, gasSettings);
+            // Private execution collects offchain effects inside PXE's PrivateExecutionOracle rather than round-tripping
+            // them through `aztec_utl_emitOffchainEffect`, so the session buffer is empty at this point. Drain the effects
+            // from the execution tree into the session buffer so the next `env.offchain_messages()` call in the test sees
+            // them.
+            for (const data of offchainEffects){
+                this.recordOffchainEffect(data);
+            }
+            await this.cycleJob();
+            if (isStaticCall) {
+                // Static calls revert their checkpoint and mine no block, so there is no tx hash to tag offchain effects
+                // with. Querying `getLastTxEffects()` here would return an unrelated predecessor tx.
+                return {
+                    result: returnValues
+                };
+            }
+            const { txHash } = await handler.getLastTxEffects();
+            return {
+                result: returnValues,
+                txHash: txHash.hash
+            };
+        });
+    }
+    async executeUtilityFunction(from, targetContractAddress, functionSelector, args, authorizedUtilityCallTargets) {
+        const handler = this.handlerAsTxe();
+        return await this.withTopLevelCallTracking(async ()=>{
+            const returnValues = await handler.executeUtilityFunction(from?.value, targetContractAddress, functionSelector, args, this.currentJobId, authorizedUtilityCallTargets);
+            await this.cycleJob();
+            return {
+                result: returnValues
+            };
+        });
+    }
+    async executePublicCall(from, targetContractAddress, calldata, isStaticCall, gasSettings) {
+        const handler = this.handlerAsTxe();
+        return await this.withTopLevelCallTracking(async ()=>{
+            const returnValues = await handler.publicCallNewFlow(from?.value, targetContractAddress, calldata, isStaticCall, gasSettings);
+            await this.cycleJob();
+            if (isStaticCall) {
+                // See the equivalent branch in `executePrivateCall`.
+                return {
+                    result: returnValues
+                };
+            }
+            const { txHash } = await handler.getLastTxEffects();
+            return {
+                result: returnValues,
+                txHash: txHash.hash
+            };
+        });
+    }
+    async getPrivateEvents(selector, contractAddress, scope) {
+        const handler = this.handlerAsTxe();
+        await handler.syncContractNonOracleMethod(contractAddress, scope, this.currentJobId);
+        // Cycle the job to commit the stores after the contract sync.
+        await this.cycleJob();
+        return handler.getPrivateEvents(selector, contractAddress, scope);
+    }
+    handlerAsTxe() {
+        if (!('isTxe' in this.oracleHandler)) {
+            throw new UnavailableOracleError('Txe');
+        }
+        return this.oracleHandler;
+    }
+    setTxeOracleVersion(major, minor) {
+        if (major !== TXE_ORACLE_VERSION_MAJOR) {
+            const hint = major > TXE_ORACLE_VERSION_MAJOR ? 'The test was compiled with a newer version of Aztec.nr than your test environment supports. Upgrade your test environment to a compatible version.' : 'The test was compiled with an older version of Aztec.nr than your test environment supports. Recompile the test with a compatible version of Aztec.nr.';
+            throw new Error(`Incompatible test environment version: ${hint} See https://docs.aztec.network/errors/12 (expected test oracle major version ${TXE_ORACLE_VERSION_MAJOR}, got ${major})`);
+        }
+        this.txeOracleVersion = {
+            major,
+            minor
+        };
+        this.logger.debug(`Test compiled with test oracle version ${major}.${minor}`);
+    }
     async enterTopLevelState() {
         switch(this.state.name){
             case 'PRIVATE':
@@ -156,22 +348,24 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
                 }
         }
         // Commit all staged stores from the job that was just completed, then begin a new job
-        await this.jobCoordinator.commitJob(this.currentJobId);
-        this.currentJobId = this.jobCoordinator.beginJob();
-        this.oracleHandler = new TXEOracleTopLevelContext(this.stateMachine, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.accountStore, this.senderTaggingStore, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.currentJobId, this.nextBlockTimestamp, this.version, this.chainId, this.authwits);
+        await this.cycleJob();
+        this.oracleHandler = new TXEOracleTopLevelContext(this.stateMachine, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.accountStore, this.senderTaggingStore, this.recipientTaggingStore, this.taggingSecretSourcesStore, this.capsuleStore, this.factStore, this.privateEventStore, this.nextBlockTimestamp, this.version, this.chainId, this.authwits, this.taggingSecretStrategies, this.authorizeAllUtilityCallTargets, this.artifactResolver, this.rootPath, this.packageName);
         this.state = {
             name: 'TOP_LEVEL'
         };
         this.logger.debug(`Entered state ${this.state.name}`);
     }
-    async enterPrivateState(contractAddress = DEFAULT_ADDRESS, anchorBlockNumber) {
+    async enterPrivateState(contractAddressOpt, anchorBlockNumberOpt, gasSettings) {
+        const contractAddress = contractAddressOpt?.value ?? DEFAULT_ADDRESS;
+        const anchorBlockNumber = anchorBlockNumberOpt?.value;
         this.exitTopLevelState();
+        this.resetLastCall();
         // Private execution has two associated block numbers: the anchor block (i.e. the historical block that is used to
         // build the proof), and the *next* block, i.e. the one we'll create once the execution ends, and which will contain
         // a single transaction with the effects of what was done in the test.
-        const anchorBlock = await this.stateMachine.node.getBlockHeader(anchorBlockNumber ?? 'latest');
-        await new NoteService(this.noteStore, this.stateMachine.node, anchorBlock, this.currentJobId).syncNoteNullifiers(contractAddress);
-        const latestBlock = await this.stateMachine.node.getBlockHeader('latest');
+        const anchorBlock = await this.stateMachine.node.getBlock(anchorBlockNumber ?? 'latest').then((b)=>b?.header);
+        await new NoteService(this.noteStore, this.stateMachine.node, anchorBlock, this.currentJobId).syncNoteNullifiers(contractAddress, await this.keyStore.getAccounts());
+        const latestBlock = await this.stateMachine.node.getBlock('latest').then((b)=>b?.header);
         const nextBlockGlobalVariables = makeGlobalVariables(undefined, {
             blockNumber: BlockNumber(latestBlock.globalVariables.blockNumber + 1),
             timestamp: this.nextBlockTimestamp,
@@ -183,7 +377,43 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
         const noteCache = new ExecutionNoteCache(protocolNullifier);
         const taggingIndexCache = new ExecutionTaggingIndexCache();
         const utilityExecutor = this.utilityExecutorForContractSync(anchorBlock);
-        this.oracleHandler = new PrivateExecutionOracle(Fr.ZERO, new TxContext(this.chainId, this.version, GasSettings.empty()), new CallContext(AztecAddress.ZERO, contractAddress, FunctionSelector.empty(), false), anchorBlock, utilityExecutor, [], [], new HashedValuesCache(), 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.currentJobId);
+        const transientArrayService = new TransientArrayService();
+        const anchoredContractData = new AnchoredContractData(this.contractStore, this.stateMachine.contractClassService, anchorBlock);
+        this.oracleHandler = new TXEPrivateExecutionOracle({
+            argsHash: Fr.ZERO,
+            txContext: new TxContext(this.chainId, this.version, gasSettings),
+            txRequestSalt: Fr.ZERO,
+            callContext: new CallContext(AztecAddress.ZERO, contractAddress, FunctionSelector.empty(), false),
+            anchorBlockHeader: anchorBlock,
+            utilityExecutor,
+            authWitnesses: [],
+            capsules: [],
+            executionCache: new HashedValuesCache(),
+            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, await this.keyStore.getAccounts()),
+            factService: new FactService(this.factStore, await this.keyStore.getAccounts()),
+            privateEventStore: this.privateEventStore,
+            contractSyncService: this.stateMachine.contractSyncService,
+            l2TipsStore: this.stateMachine.l2TipsProvider,
+            jobId: this.currentJobId,
+            scopes: await this.keyStore.getAccounts(),
+            txResolver: this.stateMachine.txResolver,
+            simulator: new WASMSimulator(),
+            hooks: composeHooks({
+                resolveTaggingSecretStrategy: makeResolveTaggingSecretStrategyHook(this.taggingSecretStrategies),
+                authorizeUtilityCall: this.authorizeAllUtilityCallTargets ? authorizeAllUtilityCallsHook : undefined
+            }),
+            transientArrayService
+        });
         // We store the note and tagging index caches fed into the PrivateExecutionOracle (along with some other auxiliary
         // data) in order to refer to it later, mimicking the way this object is used by the ContractFunctionSimulator. The
         // difference resides in that the simulator has all information needed in order to run the simulation, while ours
@@ -196,54 +426,100 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
             taggingIndexCache
         };
         this.logger.debug(`Entered state ${this.state.name}`);
+        // Record the *resolved* anchor's timestamp — if the caller pinned the anchor to a past block
+        // via `anchorBlockNumber`, "latest" would be the wrong anchor for offchain-message semantics.
+        this.setLastCallContext(Fr.ZERO, anchorBlock.globalVariables.timestamp);
         return this.oracleHandler.getPrivateContextInputs();
     }
-    async enterPublicState(contractAddress) {
+    async enterPublicState(contractAddressOpt) {
+        const contractAddress = contractAddressOpt?.value ?? DEFAULT_ADDRESS;
         this.exitTopLevelState();
+        this.resetLastCall();
         // The PublicContext will create a block with a single transaction in it, containing the effects of what was done in
         // the test. The block therefore gets the *next* block number and timestamp.
-        const latestBlockNumber = (await this.stateMachine.node.getBlockHeader('latest')).globalVariables.blockNumber;
+        const latestHeader = (await this.stateMachine.node.getBlockData('latest')).header;
         const globalVariables = makeGlobalVariables(undefined, {
-            blockNumber: BlockNumber(latestBlockNumber + 1),
+            blockNumber: BlockNumber(latestHeader.globalVariables.blockNumber + 1),
             timestamp: this.nextBlockTimestamp,
             version: this.version,
             chainId: this.chainId
         });
-        this.oracleHandler = new TXEOraclePublicContext(contractAddress ?? DEFAULT_ADDRESS, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), getSingleTxBlockRequestHash(globalVariables.blockNumber), globalVariables);
+        this.oracleHandler = new TXEOraclePublicContext(contractAddress, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), getSingleTxBlockRequestHash(globalVariables.blockNumber), globalVariables, this.contractStore);
         this.state = {
             name: 'PUBLIC'
         };
         this.logger.debug(`Entered state ${this.state.name}`);
+        // Public state is anchored at the latest block.
+        this.setLastCallContext(Fr.ZERO, latestHeader.globalVariables.timestamp);
     }
-    async enterUtilityState(contractAddress = DEFAULT_ADDRESS) {
+    async enterUtilityState(contractAddressOpt) {
+        const contractAddress = contractAddressOpt?.value ?? DEFAULT_ADDRESS;
         this.exitTopLevelState();
+        this.resetLastCall();
         const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
         // There is no automatic message discovery and contract-driven syncing process in inlined private or utility
         // contexts, which means that known nullifiers are also not searched for, since it is during the tagging sync that
         // we perform this. We therefore search for known nullifiers now, as otherwise notes that were nullified would not
         // be removed from the database.
         // TODO(#12553): make the synchronizer sync here instead and remove this
-        await new NoteService(this.noteStore, this.stateMachine.node, anchorBlockHeader, this.currentJobId).syncNoteNullifiers(contractAddress);
-        this.oracleHandler = new UtilityExecutionOracle(contractAddress, [], [], anchorBlockHeader, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.stateMachine.node, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.currentJobId);
+        await new NoteService(this.noteStore, this.stateMachine.node, anchorBlockHeader, this.currentJobId).syncNoteNullifiers(contractAddress, await this.keyStore.getAccounts());
+        this.oracleHandler = new UtilityExecutionOracle({
+            callContext: CallContext.from({
+                msgSender: AztecAddress.NULL_MSG_SENDER,
+                contractAddress,
+                // No specific function is being executed in this inlined utility context, hence the empty selector.
+                functionSelector: FunctionSelector.empty(),
+                isStaticCall: true
+            }),
+            authWitnesses: [],
+            capsules: [],
+            anchorBlockHeader,
+            anchoredContractData: new AnchoredContractData(this.contractStore, this.stateMachine.contractClassService, anchorBlockHeader),
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: this.stateMachine.node,
+            recipientTaggingStore: this.recipientTaggingStore,
+            taggingSecretSourcesStore: this.taggingSecretSourcesStore,
+            capsuleService: new CapsuleService(this.capsuleStore, await this.keyStore.getAccounts()),
+            factService: new FactService(this.factStore, await this.keyStore.getAccounts()),
+            privateEventStore: this.privateEventStore,
+            txResolver: this.stateMachine.txResolver,
+            contractSyncService: this.stateMachine.contractSyncService,
+            l2TipsStore: this.stateMachine.l2TipsProvider,
+            jobId: this.currentJobId,
+            scopes: await this.keyStore.getAccounts(),
+            simulator: new WASMSimulator(),
+            utilityExecutor: this.utilityExecutorForContractSync(anchorBlockHeader),
+            hooks: composeHooks({
+                authorizeUtilityCall: this.authorizeAllUtilityCallTargets ? authorizeAllUtilityCallsHook : undefined
+            }),
+            // Execution-tree root (top-level utility run): own store; nested frames inherit it.
+            transientArrayService: new TransientArrayService()
+        });
         this.state = {
             name: 'UTILITY'
         };
         this.logger.debug(`Entered state ${this.state.name}`);
+        // Utility state anchors at whatever the anchor block store is pointing to (tracked as latest).
+        this.setLastCallContext(Fr.ZERO, anchorBlockHeader.globalVariables.timestamp);
     }
     exitTopLevelState() {
         if (this.state.name != 'TOP_LEVEL') {
             throw new Error(`Expected to be in state 'TOP_LEVEL', but got '${this.state.name}' instead`);
         }
         // Note that while all public and private contexts do is build a single block that we then process when exiting
-        // those, the top level context performs a large number of actions not captured in the following 'close' call. Among
-        // others, it will create empty blocks (via `txeAdvanceBlocksBy` and `deploy`), create blocks with transactions via
-        // `txePrivateCallNewFlow` and `txePublicCallNewFlow`, add accounts to PXE via `txeAddAccount`, etc. This is a
-        // slight inconsistency in the working model of this class, but is not too bad.
-        // TODO: it's quite unfortunate that we need to capture the authwits created to later pass them again when the top
-        // level context is re-created. This is because authwits create a temporary utility context that'd otherwise reset
-        // the authwits if not persisted, so we'd not be able to pass more than one per execution.
-        // Ideally authwits would be passed alongside a contract call instead of pre-seeded.
-        [this.nextBlockTimestamp, this.authwits] = this.oracleHandler.close();
+        // them, the top level context does most of its work as it goes: it creates empty blocks (via `advanceBlocksBy`
+        // and `deploy`), creates blocks with transactions (via `privateCallNewFlow` and `publicCallNewFlow`), adds
+        // accounts to PXE (via `addAccount`), etc. This is a slight inconsistency in the working model of this class, but
+        // is not too bad. The `close` call below therefore only hands back the session-scoped values that a test
+        // sets directly at the top level, outside any contract execution (e.g. via `advanceTimestampBy`,
+        // `addAuthWitness`, `setTaggingSecretStrategies`). The oracle handler is discarded on every state transition,
+        // so the session must seed these values into the contexts it creates later.
+        // TODO: persisting authwits this way is quite unfortunate: they create a temporary utility context that would
+        // otherwise reset them, so we'd not be able to pass more than one per execution. Ideally authwits would be passed
+        // alongside a contract call instead of pre-seeded.
+        ({ nextBlockTimestamp: this.nextBlockTimestamp, authwits: this.authwits, taggingSecretStrategies: this.taggingSecretStrategies, authorizeAllUtilityCallTargets: this.authorizeAllUtilityCallTargets } = this.oracleHandler.close());
     }
     async exitPrivateState() {
         if (this.state.name != 'PRIVATE') {
@@ -281,14 +557,48 @@ import { makeTxEffect } from './utils/tx_effect_creation.js';
         }
     }
     utilityExecutorForContractSync(anchorBlock) {
-        return async (call)=>{
-            const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+        return async (call, scopes)=>{
+            const anchoredContractData = new AnchoredContractData(this.contractStore, this.stateMachine.contractClassService, anchorBlock);
+            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`);
             }
             try {
-                const oracle = new UtilityExecutionOracle(call.to, [], [], anchorBlock, this.contractStore, this.noteStore, this.keyStore, this.addressStore, this.stateMachine.node, this.recipientTaggingStore, this.senderAddressBookStore, this.capsuleStore, this.privateEventStore, this.currentJobId);
-                await new WASMSimulator().executeUserCircuit(toACVMWitness(0, call.args), entryPointArtifact, new Oracle(oracle).toACIRCallback()).catch((err)=>{
+                const simulator = new WASMSimulator();
+                const oracle = new UtilityExecutionOracle({
+                    callContext: CallContext.from({
+                        msgSender: AztecAddress.NULL_MSG_SENDER,
+                        contractAddress: call.to,
+                        functionSelector: call.selector,
+                        isStaticCall: true
+                    }),
+                    authWitnesses: [],
+                    capsules: [],
+                    anchorBlockHeader: anchorBlock,
+                    anchoredContractData,
+                    noteStore: this.noteStore,
+                    keyStore: this.keyStore,
+                    addressStore: this.addressStore,
+                    aztecNode: this.stateMachine.node,
+                    recipientTaggingStore: this.recipientTaggingStore,
+                    taggingSecretSourcesStore: this.taggingSecretSourcesStore,
+                    capsuleService: new CapsuleService(this.capsuleStore, scopes),
+                    factService: new FactService(this.factStore, scopes),
+                    privateEventStore: this.privateEventStore,
+                    txResolver: this.stateMachine.txResolver,
+                    contractSyncService: this.stateMachine.contractSyncService,
+                    l2TipsStore: this.stateMachine.l2TipsProvider,
+                    jobId: this.currentJobId,
+                    scopes,
+                    simulator,
+                    utilityExecutor: this.utilityExecutorForContractSync(anchorBlock),
+                    // Top-level utility entrypoint: gets a fresh store. Nested frames inherit it via UtilityExecutionOracle.
+                    transientArrayService: new TransientArrayService()
+                });
+                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,

package/dest/utils/block_creation.d.ts

@@ -9,7 +9,7 @@ import { BlockHeader, GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
  * @returns The transaction request hash.
  */
 export declare function getSingleTxBlockRequestHash(blockNumber: BlockNumber): Fr;
-export declare function insertTxEffectIntoWorldTrees(txEffect: TxEffect, worldTrees: MerkleTreeWriteOperations): Promise<void>;
+export declare function insertTxEffectIntoWorldTrees(txEffect: TxEffect, worldTrees: MerkleTreeWriteOperations, l1ToL2Messages?: Fr[]): Promise<void>;
 export declare function makeTXEBlockHeader(worldTrees: MerkleTreeWriteOperations, globalVariables: GlobalVariables): Promise<BlockHeader>;
 /**
  * Creates an L2Block with proper archive chaining.
@@ -25,4 +25,4 @@ export declare function makeTXEBlockHeader(worldTrees: MerkleTreeWriteOperations
  * @returns The created L2Block with proper archive chaining
  */
 export declare function makeTXEBlock(worldTrees: MerkleTreeWriteOperations, globalVariables: GlobalVariables, txEffects: TxEffect[]): Promise<L2Block>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2tfY3JlYXRpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9ibG9ja19jcmVhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxPQUFPLEVBQUUsV0FBVyxFQUEyQyxNQUFNLGlDQUFpQyxDQUFDO0FBRXZHLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQVEsT0FBTyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUF3QyxLQUFLLHlCQUF5QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDM0csT0FBTyxFQUFFLFdBQVcsRUFBRSxlQUFlLEVBQUUsUUFBUSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFMUU7Ozs7R0FJRztBQUNILHdCQUFnQiwyQkFBMkIsQ0FBQyxXQUFXLEVBQUUsV0FBVyxHQUFHLEVBQUUsQ0FFeEU7QUFFRCx3QkFBc0IsNEJBQTRCLENBQ2hELFFBQVEsRUFBRSxRQUFRLEVBQ2xCLFVBQVUsRUFBRSx5QkFBeUIsR0FDcEMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQWtCZjtBQUVELHdCQUFzQixrQkFBa0IsQ0FDdEMsVUFBVSxFQUFFLHlCQUF5QixFQUNyQyxlQUFlLEVBQUUsZUFBZSxHQUMvQixPQUFPLENBQUMsV0FBVyxDQUFDLENBWXRCO0FBRUQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLFlBQVksQ0FDaEMsVUFBVSxFQUFFLHlCQUF5QixFQUNyQyxlQUFlLEVBQUUsZUFBZSxFQUNoQyxTQUFTLEVBQUUsUUFBUSxFQUFFLEdBQ3BCLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FpQmxCIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2tfY3JlYXRpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9ibG9ja19jcmVhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxPQUFPLEVBQUUsV0FBVyxFQUEyQyxNQUFNLGlDQUFpQyxDQUFDO0FBRXZHLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQVEsT0FBTyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUF3QyxLQUFLLHlCQUF5QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDM0csT0FBTyxFQUFFLFdBQVcsRUFBRSxlQUFlLEVBQUUsUUFBUSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFMUU7Ozs7R0FJRztBQUNILHdCQUFnQiwyQkFBMkIsQ0FBQyxXQUFXLEVBQUUsV0FBVyxHQUFHLEVBQUUsQ0FFeEU7QUFFRCx3QkFBc0IsNEJBQTRCLENBQ2hELFFBQVEsRUFBRSxRQUFRLEVBQ2xCLFVBQVUsRUFBRSx5QkFBeUIsRUFDckMsY0FBYyxHQUFFLEVBQUUsRUFBTyxHQUN4QixPQUFPLENBQUMsSUFBSSxDQUFDLENBa0JmO0FBRUQsd0JBQXNCLGtCQUFrQixDQUN0QyxVQUFVLEVBQUUseUJBQXlCLEVBQ3JDLGVBQWUsRUFBRSxlQUFlLEdBQy9CLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FZdEI7QUFFRDs7Ozs7Ozs7Ozs7O0dBWUc7QUFDSCx3QkFBc0IsWUFBWSxDQUNoQyxVQUFVLEVBQUUseUJBQXlCLEVBQ3JDLGVBQWUsRUFBRSxlQUFlLEVBQ2hDLFNBQVMsRUFBRSxRQUFRLEVBQUUsR0FDcEIsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQWlCbEIifQ==

package/dest/utils/block_creation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_creation.d.ts","sourceRoot":"","sources":["../../src/utils/block_creation.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAA2C,MAAM,iCAAiC,CAAC;AAEvG,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAQ,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAwC,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC3G,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE1E;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,EAAE,CAExE;AAED,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,yBAAyB,GACpC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,WAAW,CAAC,CAYtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,QAAQ,EAAE,GACpB,OAAO,CAAC,OAAO,CAAC,CAiBlB"}
+{"version":3,"file":"block_creation.d.ts","sourceRoot":"","sources":["../../src/utils/block_creation.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAA2C,MAAM,iCAAiC,CAAC;AAEvG,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAQ,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAwC,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC3G,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE1E;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,EAAE,CAExE;AAED,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,yBAAyB,EACrC,cAAc,GAAE,EAAE,EAAO,GACxB,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,WAAW,CAAC,CAYtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,QAAQ,EAAE,GACpB,OAAO,CAAC,OAAO,CAAC,CAiBlB"}

package/dest/utils/block_creation.js

@@ -12,10 +12,10 @@ import { BlockHeader } from '@aztec/stdlib/tx';
  */ export function getSingleTxBlockRequestHash(blockNumber) {
     return new Fr(blockNumber + 9999); // Why does this need to be a high number? Why do small numbered nullifiers already exist?
 }
-export async function insertTxEffectIntoWorldTrees(txEffect, worldTrees) {
+export async function insertTxEffectIntoWorldTrees(txEffect, worldTrees, l1ToL2Messages = []) {
     await worldTrees.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
     await worldTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
-    await worldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, padArrayEnd(txEffect.l2ToL1Msgs, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+    await worldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
 // We do not need to add public data writes because we apply them as we go.
 }
 export async function makeTXEBlockHeader(worldTrees, globalVariables) {