@aztec/txe 0.0.0-test.1 → 0.0.1-commit.001888fc

package/dest/oracle/txe_oracle_top_level_context.d.ts

@@ -0,0 +1,65 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { KeyStore } from '@aztec/key-store';
+import { AddressStore, CapsuleStore, type ContractStore, NoteStore, PrivateEventStore, RecipientTaggingStore, SenderAddressBookStore, SenderTaggingStore } from '@aztec/pxe/server';
+import { type IMiscOracle } from '@aztec/pxe/simulator';
+import { type ContractArtifact, EventSelector, FunctionSelector } from '@aztec/stdlib/abi';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { TxHash } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+import type { TXEStateMachine } from '../state_machine/index.js';
+import type { TXEAccountStore } from '../util/txe_account_store.js';
+import type { ITxeExecutionOracle } from './interfaces.js';
+export declare class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracle {
+    private stateMachine;
+    private contractStore;
+    private noteStore;
+    private keyStore;
+    private addressStore;
+    private accountStore;
+    private senderTaggingStore;
+    private recipientTaggingStore;
+    private senderAddressBookStore;
+    private capsuleStore;
+    private privateEventStore;
+    private nextBlockTimestamp;
+    private version;
+    private chainId;
+    private authwits;
+    isMisc: true;
+    isTxe: true;
+    private logger;
+    constructor(stateMachine: TXEStateMachine, contractStore: ContractStore, noteStore: NoteStore, keyStore: KeyStore, addressStore: AddressStore, accountStore: TXEAccountStore, senderTaggingStore: SenderTaggingStore, recipientTaggingStore: RecipientTaggingStore, senderAddressBookStore: SenderAddressBookStore, capsuleStore: CapsuleStore, privateEventStore: PrivateEventStore, nextBlockTimestamp: bigint, version: Fr, chainId: Fr, authwits: Map<string, AuthWitness>);
+    assertCompatibleOracleVersion(version: number): void;
+    getRandomField(): Fr;
+    log(level: number, message: string, fields: Fr[]): Promise<void>;
+    getDefaultAddress(): AztecAddress;
+    getNextBlockNumber(): Promise<BlockNumber>;
+    getNextBlockTimestamp(): Promise<bigint>;
+    getLastBlockTimestamp(): Promise<bigint>;
+    getLastTxEffects(): Promise<{
+        txHash: TxHash;
+        noteHashes: Fr[];
+        nullifiers: Fr[];
+    }>;
+    syncContractNonOracleMethod(contractAddress: AztecAddress, scope: AztecAddress, jobId: string): Promise<void>;
+    getPrivateEvents(selector: EventSelector, contractAddress: AztecAddress, scope: AztecAddress): Promise<Fr[][]>;
+    advanceBlocksBy(blocks: number): Promise<void>;
+    advanceTimestampBy(duration: UInt64): void;
+    deploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, secret: Fr): Promise<void>;
+    addAccount(artifact: ContractArtifact, instance: ContractInstanceWithAddress, secret: Fr): Promise<import("@aztec/stdlib/contract").CompleteAddress>;
+    createAccount(secret: Fr): Promise<import("@aztec/stdlib/contract").CompleteAddress>;
+    addAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+    mineBlock(options?: {
+        nullifiers?: Fr[];
+    }): Promise<void>;
+    privateCallNewFlow(from: AztecAddress, targetContractAddress: AztecAddress | undefined, functionSelector: FunctionSelector | undefined, args: Fr[], argsHash: Fr | undefined, isStaticCall: boolean | undefined, jobId: string): Promise<Fr[]>;
+    publicCallNewFlow(from: AztecAddress, targetContractAddress: AztecAddress, calldata: Fr[], isStaticCall: boolean): Promise<Fr[]>;
+    executeUtilityFunction(targetContractAddress: AztecAddress, functionSelector: FunctionSelector, args: Fr[], jobId: string): Promise<Fr[]>;
+    private executeUtilityCall;
+    close(): [bigint, Map<string, AuthWitness>];
+    private getLastBlockNumber;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/oracle/txe_oracle_top_level_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txe_oracle_top_level_context.d.ts","sourceRoot":"","sources":["../../src/oracle/txe_oracle_top_level_context.ts"],"names":[],"mappings":"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"}

package/dest/oracle/txe_oracle_top_level_context.js

@@ -0,0 +1,542 @@
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT, DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Schnorr } from '@aztec/foundation/crypto/schnorr';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { LogLevels, applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import { TestDateProvider } from '@aztec/foundation/timer';
+import { ORACLE_VERSION, enrichPublicSimulationError } from '@aztec/pxe/server';
+import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, Oracle, PrivateExecutionOracle, UtilityExecutionOracle, executePrivateFunction, generateSimulatedProvingResult } from '@aztec/pxe/simulator';
+import { ExecutionError, WASMSimulator, createSimulationError, extractCallStack, resolveAssertionMessageFromError, toACVMWitness, witnessMapToFields } from '@aztec/simulator/client';
+import { CppPublicTxSimulator, GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor } from '@aztec/simulator/server';
+import { FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computePartialAddress } from '@aztec/stdlib/contract';
+import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
+import { computeCalldataHash, computeProtocolNullifier, siloNullifier } from '@aztec/stdlib/hash';
+import { PartialPrivateTailPublicInputsForPublic, PrivateKernelTailCircuitPublicInputs, PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { makeGlobalVariables } from '@aztec/stdlib/testing';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { CallContext, HashedValues, PrivateExecutionResult, Tx, TxConstantData, TxContext, TxEffect, TxHash, collectNested } from '@aztec/stdlib/tx';
+import { ForkCheckpoint } from '@aztec/world-state';
+import { DEFAULT_ADDRESS } from '../constants.js';
+import { TXEPublicContractDataSource } from '../util/txe_public_contract_data_source.js';
+import { getSingleTxBlockRequestHash, insertTxEffectIntoWorldTrees, makeTXEBlock } from '../utils/block_creation.js';
+export class TXEOracleTopLevelContext {
+    stateMachine;
+    contractStore;
+    noteStore;
+    keyStore;
+    addressStore;
+    accountStore;
+    senderTaggingStore;
+    recipientTaggingStore;
+    senderAddressBookStore;
+    capsuleStore;
+    privateEventStore;
+    nextBlockTimestamp;
+    version;
+    chainId;
+    authwits;
+    isMisc;
+    isTxe;
+    logger;
+    constructor(stateMachine, contractStore, noteStore, keyStore, addressStore, accountStore, senderTaggingStore, recipientTaggingStore, senderAddressBookStore, capsuleStore, privateEventStore, nextBlockTimestamp, version, chainId, authwits){
+        this.stateMachine = stateMachine;
+        this.contractStore = contractStore;
+        this.noteStore = noteStore;
+        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.nextBlockTimestamp = nextBlockTimestamp;
+        this.version = version;
+        this.chainId = chainId;
+        this.authwits = authwits;
+        this.isMisc = true;
+        this.isTxe = true;
+        this.logger = createLogger('txe:top_level_context');
+        this.logger.debug('Entering Top Level Context');
+    }
+    assertCompatibleOracleVersion(version) {
+        if (version !== ORACLE_VERSION) {
+            throw new Error(`Incompatible oracle version. TXE is using version '${ORACLE_VERSION}', but got a request for '${version}'.`);
+        }
+    }
+    // This is typically only invoked in private contexts, but it is convenient to also have it in top-level for testing
+    // setup.
+    getRandomField() {
+        return Fr.random();
+    }
+    // We instruct users to debug contracts via this oracle, so it makes sense that they'd expect it to also work in tests
+    log(level, message, fields) {
+        if (!LogLevels[level]) {
+            throw new Error(`Invalid log level: ${level}`);
+        }
+        const levelName = LogLevels[level];
+        this.logger[levelName](`${applyStringFormatting(message, fields)}`, {
+            module: `${this.logger.module}:debug_log`
+        });
+        return Promise.resolve();
+    }
+    getDefaultAddress() {
+        return DEFAULT_ADDRESS;
+    }
+    async getNextBlockNumber() {
+        return BlockNumber(await this.getLastBlockNumber() + 1);
+    }
+    getNextBlockTimestamp() {
+        return Promise.resolve(this.nextBlockTimestamp);
+    }
+    async getLastBlockTimestamp() {
+        return (await this.stateMachine.node.getBlockHeader('latest')).globalVariables.timestamp;
+    }
+    async getLastTxEffects() {
+        const latestBlockNumber = await this.stateMachine.archiver.getBlockNumber();
+        const block = await this.stateMachine.archiver.getBlock(latestBlockNumber);
+        if (block.body.txEffects.length != 1) {
+            // Note that calls like env.mine() will result in blocks with no transactions, hitting this
+            throw new Error(`Expected a single transaction in the last block, found ${block.body.txEffects.length}`);
+        }
+        const txEffects = block.body.txEffects[0];
+        return {
+            txHash: txEffects.txHash,
+            noteHashes: txEffects.noteHashes,
+            nullifiers: txEffects.nullifiers
+        };
+    }
+    async syncContractNonOracleMethod(contractAddress, scope, jobId) {
+        if (contractAddress.equals(DEFAULT_ADDRESS)) {
+            this.logger.debug(`Skipping sync in getPrivateEvents because the events correspond to the default address.`);
+            return;
+        }
+        const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        await this.stateMachine.contractSyncService.ensureContractSynced(contractAddress, null, async (call, execScopes)=>{
+            await this.executeUtilityCall(call, execScopes, jobId);
+        }, blockHeader, jobId, [
+            scope
+        ]);
+    }
+    async getPrivateEvents(selector, contractAddress, scope) {
+        return (await this.privateEventStore.getPrivateEvents(selector, {
+            contractAddress,
+            scopes: [
+                scope
+            ],
+            fromBlock: 0,
+            toBlock: await this.getLastBlockNumber() + 1
+        })).map((e)=>e.packedEvent);
+    }
+    async advanceBlocksBy(blocks) {
+        this.logger.debug(`time traveling ${blocks} blocks`);
+        for(let i = 0; i < blocks; i++){
+            await this.mineBlock();
+        }
+    }
+    advanceTimestampBy(duration) {
+        this.logger.debug(`time traveling ${duration} seconds`);
+        this.nextBlockTimestamp += duration;
+    }
+    async deploy(artifact, instance, secret) {
+        // Emit deployment nullifier
+        await this.mineBlock({
+            nullifiers: [
+                await siloNullifier(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), instance.address.toField())
+            ]
+        });
+        if (!secret.equals(Fr.ZERO)) {
+            await this.addAccount(artifact, instance, secret);
+        } else {
+            await this.contractStore.addContractInstance(instance);
+            await this.contractStore.addContractArtifact(artifact);
+            this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
+        }
+    }
+    async addAccount(artifact, instance, secret) {
+        const partialAddress = await computePartialAddress(instance);
+        this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
+        await this.contractStore.addContractInstance(instance);
+        await this.contractStore.addContractArtifact(artifact);
+        const completeAddress = await this.keyStore.addAccount(secret, partialAddress);
+        await this.accountStore.setAccount(completeAddress.address, completeAddress);
+        await this.addressStore.addCompleteAddress(completeAddress);
+        this.logger.debug(`Created account ${completeAddress.address}`);
+        return completeAddress;
+    }
+    async createAccount(secret) {
+        // This is a foot gun !
+        const completeAddress = await this.keyStore.addAccount(secret, secret);
+        await this.accountStore.setAccount(completeAddress.address, completeAddress);
+        await this.addressStore.addCompleteAddress(completeAddress);
+        this.logger.debug(`Created account ${completeAddress.address}`);
+        return completeAddress;
+    }
+    async addAuthWitness(address, messageHash) {
+        const account = await this.accountStore.getAccount(address);
+        const privateKey = await this.keyStore.getMasterSecretKey(account.publicKeys.masterIncomingViewingPublicKey);
+        const schnorr = new Schnorr();
+        const signature = await schnorr.constructSignature(messageHash.toBuffer(), privateKey);
+        const authWitness = new AuthWitness(messageHash, [
+            ...signature.toBuffer()
+        ]);
+        this.authwits.set(authWitness.requestHash.toString(), authWitness);
+    }
+    async mineBlock(options = {}) {
+        const blockNumber = await this.getNextBlockNumber();
+        const txEffect = TxEffect.empty();
+        txEffect.nullifiers = [
+            getSingleTxBlockRequestHash(blockNumber),
+            ...options.nullifiers ?? []
+        ];
+        txEffect.txHash = new TxHash(new Fr(blockNumber));
+        const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
+        await insertTxEffectIntoWorldTrees(txEffect, forkedWorldTrees);
+        const globals = makeGlobalVariables(undefined, {
+            blockNumber,
+            timestamp: this.nextBlockTimestamp,
+            version: this.version,
+            chainId: this.chainId
+        });
+        const block = await makeTXEBlock(forkedWorldTrees, globals, [
+            txEffect
+        ]);
+        await forkedWorldTrees.close();
+        this.logger.info(`Created block ${blockNumber} with timestamp ${block.header.globalVariables.timestamp}`);
+        await this.stateMachine.handleL2Block(block);
+    }
+    async privateCallNewFlow(from, targetContractAddress = AztecAddress.zero(), functionSelector = FunctionSelector.empty(), args, argsHash = Fr.zero(), isStaticCall = false, jobId) {
+        this.logger.verbose(`Executing external function ${await this.contractStore.getDebugFunctionName(targetContractAddress, functionSelector)}@${targetContractAddress} isStaticCall=${isStaticCall}`);
+        const artifact = await this.contractStore.getFunctionArtifact(targetContractAddress, functionSelector);
+        if (!artifact) {
+            const message = functionSelector.equals(await FunctionSelector.fromSignature('verify_private_authwit(Field)')) ? 'Found no account contract artifact for a private authwit check - use `create_contract_account` instead of `create_light_account` for authwit support.' : 'Function Artifact does not exist';
+            throw new Error(message);
+        }
+        // When `from` is the zero address (e.g. when deploying a new account contract), we return an
+        // empty scope list which acts as deny-all: no notes are visible and no keys are accessible.
+        const effectiveScopes = from.isZero() ? [] : [
+            from
+        ];
+        // Sync notes before executing private function to discover notes from previous transactions
+        const utilityExecutor = async (call, execScopes)=>{
+            await this.executeUtilityCall(call, execScopes, jobId);
+        };
+        const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        await this.stateMachine.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, utilityExecutor, blockHeader, jobId, effectiveScopes);
+        const blockNumber = await this.getNextBlockNumber();
+        const callContext = new CallContext(from, targetContractAddress, functionSelector, isStaticCall);
+        const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
+        const teardownGasLimits = new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT);
+        const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
+        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,
+            capsuleStore: this.capsuleStore,
+            privateEventStore: this.privateEventStore,
+            contractSyncService: this.stateMachine.contractSyncService,
+            jobId,
+            totalPublicCalldataCount: 0,
+            sideEffectCounter: minRevertibleSideEffectCounter,
+            scopes: effectiveScopes,
+            // In TXE, the typical transaction entrypoint is skipped, so we need to simulate the actions that such a
+            // contract would perform, including setting senderForTags.
+            senderForTags: from,
+            simulator,
+            messageContextService: this.stateMachine.messageContextService
+        });
+        // 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.loadFromExecutionCache(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 CppPublicTxSimulator(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');
+            }
+        }
+        if (isStaticCall) {
+            await checkpoint.revert();
+            await forkedWorldTrees.close();
+            return executionResult.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);
+        await forkedWorldTrees.close();
+        return executionResult.returnValues ?? [];
+    }
+    async publicCallNewFlow(from, targetContractAddress, calldata, isStaticCall) {
+        this.logger.verbose(`Executing public function ${await this.contractStore.getDebugFunctionName(targetContractAddress, FunctionSelector.fromField(calldata[0]))}@${targetContractAddress} isStaticCall=${isStaticCall}`);
+        const blockNumber = await this.getNextBlockNumber();
+        const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
+        const teardownGasLimits = new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT);
+        const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
+        const txContext = new TxContext(this.chainId, this.version, gasSettings);
+        const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        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 CppPublicTxSimulator(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, 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 returnValues = results[3][0].values;
+        if (isStaticCall) {
+            await checkpoint.revert();
+            await forkedWorldTrees.close();
+            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);
+        await forkedWorldTrees.close();
+        return returnValues ?? [];
+    }
+    async executeUtilityFunction(targetContractAddress, functionSelector, args, jobId) {
+        const artifact = await this.contractStore.getFunctionArtifact(targetContractAddress, functionSelector);
+        if (!artifact) {
+            throw new Error(`Cannot call ${functionSelector} as there is no artifact found at ${targetContractAddress}.`);
+        }
+        // Sync notes before executing utility function to discover notes from previous transactions
+        const blockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+        await this.stateMachine.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, async (call, execScopes)=>{
+            await this.executeUtilityCall(call, execScopes, jobId);
+        }, blockHeader, jobId, 'ALL_SCOPES');
+        const call = FunctionCall.from({
+            name: artifact.name,
+            to: targetContractAddress,
+            selector: functionSelector,
+            type: FunctionType.UTILITY,
+            hideMsgSender: false,
+            isStatic: false,
+            args,
+            returnTypes: []
+        });
+        return this.executeUtilityCall(call, 'ALL_SCOPES', jobId);
+    }
+    async executeUtilityCall(call, scopes, jobId) {
+        const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+        if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
+            throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
+        }
+        this.logger.verbose(`Executing utility function ${entryPointArtifact.name}`, {
+            contract: call.to,
+            selector: call.selector
+        });
+        try {
+            const anchorBlockHeader = await this.stateMachine.anchorBlockStore.getBlockHeader();
+            const oracle = new UtilityExecutionOracle({
+                contractAddress: call.to,
+                authWitnesses: [],
+                capsules: [],
+                anchorBlockHeader,
+                contractStore: this.contractStore,
+                noteStore: this.noteStore,
+                keyStore: this.keyStore,
+                addressStore: this.addressStore,
+                aztecNode: this.stateMachine.node,
+                recipientTaggingStore: this.recipientTaggingStore,
+                senderAddressBookStore: this.senderAddressBookStore,
+                capsuleStore: this.capsuleStore,
+                privateEventStore: this.privateEventStore,
+                messageContextService: this.stateMachine.messageContextService,
+                jobId,
+                scopes
+            });
+            const acirExecutionResult = await new WASMSimulator().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
+                });
+            });
+            this.logger.verbose(`Utility execution for ${call.to}.${call.selector} completed`);
+            return witnessMapToFields(acirExecutionResult.returnWitness);
+        } catch (err) {
+            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during utility execution'));
+        }
+    }
+    close() {
+        this.logger.debug('Exiting Top Level Context');
+        return [
+            this.nextBlockTimestamp,
+            this.authwits
+        ];
+    }
+    async getLastBlockNumber() {
+        const header = await this.stateMachine.node.getBlockHeader('latest');
+        return header ? header.globalVariables.blockNumber : BlockNumber.ZERO;
+    }
+}