@aztec/txe 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/txe_session.js

@@ -0,0 +1,499 @@
+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 { openEphemeralStore } from '@aztec/kv-store/lmdb-v2';
+import { AddressStore, AnchorBlockStore, CapsuleService, CapsuleStore, JobCoordinator, NoteService, NoteStore, PrivateEventStore, RecipientTaggingStore, SenderAddressBookStore, SenderTaggingStore } from '@aztec/pxe/server';
+import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, Oracle, UtilityExecutionOracle } 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 { computeProtocolNullifier } from '@aztec/stdlib/hash';
+import { makeGlobalVariables } from '@aztec/stdlib/testing';
+import { CallContext, OFFCHAIN_MESSAGE_IDENTIFIER, TxContext } from '@aztec/stdlib/tx';
+import { z } from 'zod';
+import { DEFAULT_ADDRESS, MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY, MAX_OFFCHAIN_EFFECT_LEN } from './constants.js';
+import { TXEOraclePublicContext } from './oracle/txe_oracle_public_context.js';
+import { TXEOracleTopLevelContext } 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 } from './rpc_translator.js';
+import { TXEArchiver } from './state_machine/archiver.js';
+import { TXEStateMachine } from './state_machine/index.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;
+    noteStore;
+    keyStore;
+    addressStore;
+    accountStore;
+    senderTaggingStore;
+    recipientTaggingStore;
+    senderAddressBookStore;
+    capsuleStore;
+    privateEventStore;
+    jobCoordinator;
+    currentJobId;
+    chainId;
+    version;
+    nextBlockTimestamp;
+    artifactResolver;
+    rootPath;
+    packageName;
+    state;
+    authwits;
+    lastCallInfo;
+    txeOracleVersion;
+    disposed;
+    constructor(logger, sessionStore, stateMachine, oracleHandler, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, jobCoordinator, currentJobId, chainId, version, nextBlockTimestamp, artifactResolver, rootPath, packageName){
+        this.logger = logger;
+        this.sessionStore = sessionStore;
+        this.stateMachine = stateMachine;
+        this.oracleHandler = oracleHandler;
+        this.contractStore = contractStore;
+        this.noteStore = noteStore;
+        this.keyStore = keyStore;
+        this.addressStore = addressStore;
+        this.accountStore = accountStore;
+        this.senderTaggingStore = senderTaggingStore;
+        this.recipientTaggingStore = recipientTaggingStore;
+        this.senderAddressBookStore = senderAddressBookStore;
+        this.capsuleStore = capsuleStore;
+        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.lastCallInfo = emptyLastCallState();
+        this.disposed = false;
+    }
+    /**
+   * 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 noteStore = new NoteStore(store);
+        const senderTaggingStore = new SenderTaggingStore(store);
+        const recipientTaggingStore = new RecipientTaggingStore(store);
+        const senderAddressBookStore = new SenderAddressBookStore(store);
+        const capsuleStore = new CapsuleStore(store);
+        const keyStore = new KeyStore(store);
+        const accountStore = new TXEAccountStore(store);
+        const jobCoordinator = new JobCoordinator(store);
+        jobCoordinator.registerStores([
+            capsuleStore,
+            senderTaggingStore,
+            recipientTaggingStore,
+            privateEventStore,
+            noteStore
+        ]);
+        const archiver = new TXEArchiver(store);
+        const anchorBlockStore = new AnchorBlockStore(store);
+        const stateMachine = await TXEStateMachine.create(archiver, anchorBlockStore, contractStore, noteStore);
+        const nextBlockTimestamp = BigInt(Math.floor(new Date().getTime() / 1000));
+        const version = new Fr(await stateMachine.node.getVersion());
+        const chainId = new Fr(await stateMachine.node.getChainId());
+        const initialJobId = jobCoordinator.beginJob();
+        const logger = createLogger('txe:session');
+        const topLevelOracleHandler = new TXEOracleTopLevelContext(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, nextBlockTimestamp, version, chainId, new Map(), artifactResolver, rootPath, packageName);
+        await topLevelOracleHandler.mineDeploymentNullifiers([
+            STANDARD_AUTH_REGISTRY_ADDRESS
+        ]);
+        return new TXESession(logger, store, stateMachine, topLevelOracleHandler, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, jobCoordinator, initialJobId, version, chainId, nextBlockTimestamp, artifactResolver, rootPath, packageName);
+    }
+    /**
+   * Processes an oracle function invoked by the Noir test associated to this session.
+   * @param functionName The name of the oracle.
+   * @param inputs The inputs of the oracle.
+   * @returns The oracle return values.
+   */ processFunction(functionName, inputs) {
+        try {
+            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) {
+                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 {
+                throw new Error(`Unknown execution error while processing function ${functionName} in state ${this.state.name}`);
+            }
+        }
+    }
+    getCurrentJob() {
+        return this.currentJobId;
+    }
+    /** 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
+        };
+    }
+    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':
+                {
+                    await this.exitPrivateState();
+                    break;
+                }
+            case 'PUBLIC':
+                {
+                    await this.exitPublicState();
+                    break;
+                }
+            case 'UTILITY':
+                {
+                    this.exitUtilityContext();
+                    break;
+                }
+            case 'TOP_LEVEL':
+                {
+                    throw new Error(`Expected to be in state other than TOP_LEVEL`);
+                }
+            default:
+                {
+                    this.state;
+                }
+        }
+        // Commit all staged stores from the job that was just completed, then begin a new job
+        await this.cycleJob();
+        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.nextBlockTimestamp, this.version, this.chainId, this.authwits, this.artifactResolver, this.rootPath, this.packageName);
+        this.state = {
+            name: 'TOP_LEVEL'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
+    }
+    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.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,
+            version: this.version,
+            chainId: this.chainId
+        });
+        const txRequestHash = getSingleTxBlockRequestHash(nextBlockGlobalVariables.blockNumber);
+        const protocolNullifier = await computeProtocolNullifier(txRequestHash);
+        const noteCache = new ExecutionNoteCache(protocolNullifier);
+        const taggingIndexCache = new ExecutionTaggingIndexCache();
+        const utilityExecutor = this.utilityExecutorForContractSync(anchorBlock);
+        this.oracleHandler = new TXEPrivateExecutionOracle({
+            argsHash: Fr.ZERO,
+            txContext: new TxContext(this.chainId, this.version, gasSettings),
+            callContext: new CallContext(AztecAddress.ZERO, contractAddress, FunctionSelector.empty(), false),
+            anchorBlockHeader: anchorBlock,
+            utilityExecutor,
+            authWitnesses: [],
+            capsules: [],
+            executionCache: new HashedValuesCache(),
+            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, await this.keyStore.getAccounts()),
+            privateEventStore: this.privateEventStore,
+            contractSyncService: this.stateMachine.contractSyncService,
+            l2TipsStore: this.stateMachine.l2TipsProvider,
+            jobId: this.currentJobId,
+            scopes: await this.keyStore.getAccounts(),
+            messageContextService: this.stateMachine.messageContextService,
+            simulator: new WASMSimulator()
+        });
+        // 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
+        // will be ongoing as the different oracles will be invoked from the Noir test, until eventually the private
+        // execution finishes.
+        this.state = {
+            name: 'PRIVATE',
+            nextBlockGlobalVariables,
+            noteCache,
+            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(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 latestHeader = (await this.stateMachine.node.getBlockData('latest')).header;
+        const globalVariables = makeGlobalVariables(undefined, {
+            blockNumber: BlockNumber(latestHeader.globalVariables.blockNumber + 1),
+            timestamp: this.nextBlockTimestamp,
+            version: this.version,
+            chainId: this.chainId
+        });
+        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(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, await this.keyStore.getAccounts());
+        this.oracleHandler = new UtilityExecutionOracle({
+            contractAddress,
+            authWitnesses: [],
+            capsules: [],
+            anchorBlockHeader,
+            contractStore: this.contractStore,
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: this.stateMachine.node,
+            recipientTaggingStore: this.recipientTaggingStore,
+            senderAddressBookStore: this.senderAddressBookStore,
+            capsuleService: new CapsuleService(this.capsuleStore, await this.keyStore.getAccounts()),
+            privateEventStore: this.privateEventStore,
+            messageContextService: this.stateMachine.messageContextService,
+            contractSyncService: this.stateMachine.contractSyncService,
+            l2TipsStore: this.stateMachine.l2TipsProvider,
+            jobId: this.currentJobId,
+            scopes: await this.keyStore.getAccounts(),
+            simulator: new WASMSimulator(),
+            utilityExecutor: this.utilityExecutorForContractSync(anchorBlockHeader)
+        });
+        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 `advanceBlocksBy` and `deploy`), create blocks with transactions via
+        // `privateCallNewFlow` and `publicCallNewFlow`, add accounts to PXE via `addAccount`, 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();
+    }
+    async exitPrivateState() {
+        if (this.state.name != 'PRIVATE') {
+            throw new Error(`Expected to be in state 'PRIVATE', but got '${this.state.name}' instead`);
+        }
+        this.logger.debug('Exiting Private state, building block with collected side effects', {
+            blockNumber: this.state.nextBlockGlobalVariables.blockNumber
+        });
+        // We rely on the note cache to determine the effects of the transaction. This is incomplete as it doesn't private
+        // logs (other effects like enqueued public calls don't need to be considered since those are not allowed).
+        const txEffect = await makeTxEffect(this.state.noteCache, this.state.nextBlockGlobalVariables.blockNumber);
+        // We build a block holding just this transaction
+        const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
+        await insertTxEffectIntoWorldTrees(txEffect, forkedWorldTrees);
+        const block = await makeTXEBlock(forkedWorldTrees, this.state.nextBlockGlobalVariables, [
+            txEffect
+        ]);
+        await this.stateMachine.handleL2Block(block);
+        await forkedWorldTrees.close();
+        this.logger.debug('Exited PublicContext with built block', {
+            blockNumber: block.number,
+            txEffects: block.body.txEffects
+        });
+    }
+    async exitPublicState() {
+        if (this.state.name != 'PUBLIC') {
+            throw new Error(`Expected to be in state 'PUBLIC', but got '${this.state.name}' instead`);
+        }
+        const block = await this.oracleHandler.close();
+        await this.stateMachine.handleL2Block(block);
+    }
+    exitUtilityContext() {
+        if (this.state.name != 'UTILITY') {
+            throw new Error(`Expected to be in state 'UTILITY', but got '${this.state.name}' instead`);
+        }
+    }
+    utilityExecutorForContractSync(anchorBlock) {
+        return async (call, scopes)=>{
+            const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+            if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
+                throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
+            }
+            try {
+                const simulator = new WASMSimulator();
+                const oracle = new UtilityExecutionOracle({
+                    contractAddress: call.to,
+                    authWitnesses: [],
+                    capsules: [],
+                    anchorBlockHeader: anchorBlock,
+                    contractStore: this.contractStore,
+                    noteStore: this.noteStore,
+                    keyStore: this.keyStore,
+                    addressStore: this.addressStore,
+                    aztecNode: this.stateMachine.node,
+                    recipientTaggingStore: this.recipientTaggingStore,
+                    senderAddressBookStore: this.senderAddressBookStore,
+                    capsuleService: new CapsuleService(this.capsuleStore, scopes),
+                    privateEventStore: this.privateEventStore,
+                    messageContextService: this.stateMachine.messageContextService,
+                    contractSyncService: this.stateMachine.contractSyncService,
+                    l2TipsStore: this.stateMachine.l2TipsProvider,
+                    jobId: this.currentJobId,
+                    scopes,
+                    simulator,
+                    utilityExecutor: this.utilityExecutorForContractSync(anchorBlock)
+                });
+                await simulator.executeUserCircuit(toACVMWitness(0, call.args), entryPointArtifact, new Oracle(oracle).toACIRCallback()).catch((err)=>{
+                    err.message = resolveAssertionMessageFromError(err, entryPointArtifact);
+                    throw new ExecutionError(err.message, {
+                        contractAddress: call.to,
+                        functionSelector: call.selector
+                    }, extractCallStack(err, entryPointArtifact.debug), {
+                        cause: err
+                    });
+                });
+            } catch (err) {
+                throw createSimulationError(err instanceof Error ? err : new Error('Unknown error contract data sync'));
+            }
+        };
+    }
+}

package/dest/utils/block_creation.d.ts

@@ -0,0 +1,28 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { L2Block } from '@aztec/stdlib/block';
+import { type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { BlockHeader, GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
+/**
+ * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
+ * @param blockNumber The number for the block in which there is a single transaction.
+ * @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 makeTXEBlockHeader(worldTrees: MerkleTreeWriteOperations, globalVariables: GlobalVariables): Promise<BlockHeader>;
+/**
+ * Creates an L2Block with proper archive chaining.
+ * This function:
+ * 1. Gets the current archive state as lastArchive for the header
+ * 2. Creates the block header
+ * 3. Updates the archive tree with the header hash
+ * 4. Gets the new archive state for the block's archive
+ *
+ * @param worldTrees - The world trees to read/write from
+ * @param globalVariables - Global variables for the block
+ * @param txEffects - Transaction effects to include in the block
+ * @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=

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

@@ -0,0 +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"}

package/dest/utils/block_creation.js

@@ -0,0 +1,58 @@
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Body, L2Block } from '@aztec/stdlib/block';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { BlockHeader } from '@aztec/stdlib/tx';
+/**
+ * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
+ * @param blockNumber The number for the block in which there is a single transaction.
+ * @returns The transaction request hash.
+ */ 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) {
+    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));
+// We do not need to add public data writes because we apply them as we go.
+}
+export async function makeTXEBlockHeader(worldTrees, globalVariables) {
+    const stateReference = await worldTrees.getStateReference();
+    const archiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
+    return BlockHeader.from({
+        lastArchive: new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
+        spongeBlobHash: Fr.ZERO,
+        state: stateReference,
+        globalVariables,
+        totalFees: Fr.ZERO,
+        totalManaUsed: Fr.ZERO
+    });
+}
+/**
+ * Creates an L2Block with proper archive chaining.
+ * This function:
+ * 1. Gets the current archive state as lastArchive for the header
+ * 2. Creates the block header
+ * 3. Updates the archive tree with the header hash
+ * 4. Gets the new archive state for the block's archive
+ *
+ * @param worldTrees - The world trees to read/write from
+ * @param globalVariables - Global variables for the block
+ * @param txEffects - Transaction effects to include in the block
+ * @returns The created L2Block with proper archive chaining
+ */ export async function makeTXEBlock(worldTrees, globalVariables, txEffects) {
+    const header = await makeTXEBlockHeader(worldTrees, globalVariables);
+    // Update the archive tree with this block's header hash
+    await worldTrees.updateArchive(header);
+    // Get the new archive state after updating
+    const newArchiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
+    const newArchive = new AppendOnlyTreeSnapshot(new Fr(newArchiveInfo.root), Number(newArchiveInfo.size));
+    // L2Block requires checkpointNumber and indexWithinCheckpoint.
+    // TXE uses 1-block-per-checkpoint for testing simplicity, so we can use block number as checkpoint number.
+    // This uses the deprecated fromBlockNumber method intentionally for the TXE testing environment.
+    const checkpointNumber = CheckpointNumber.fromBlockNumber(globalVariables.blockNumber);
+    const indexWithinCheckpoint = IndexWithinCheckpoint(0);
+    return new L2Block(newArchive, header, new Body(txEffects), checkpointNumber, indexWithinCheckpoint);
+}