@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/dest/public/public_tx_simulator/public_tx_simulator.js

@@ -1,187 +1,179 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
+import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ProtocolContractAddress, ProtocolContractsList } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { AvmExecutionHints, AvmTxHint, PublicSimulatorConfig, PublicTxEffect, PublicTxResult } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
 import { NestedProcessReturnValues, TxExecutionPhase } from '@aztec/stdlib/tx';
-import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { strict as assert } from 'assert';
-import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import { AvmSimulator } from '../avm/index.js';
-import { NullifierCollisionError } from '../avm/journal/nullifiers.js';
-import { ExecutorMetrics } from '../executor_metrics.js';
+import { getPublicFunctionDebugName } from '../debug_fn_name.js';
+import { HintingMerkleWriteOperations, HintingPublicContractsDB } from '../hinting_db_sources.js';
+import { PublicTreesDB } from '../public_db_sources.js';
+import { L2ToL1MessageLimitReachedError, NoteHashLimitReachedError, NullifierCollisionError, NullifierLimitReachedError } from '../side_effect_errors.js';
 import { PublicTxContext } from './public_tx_context.js';
+// The errors below are only thrown here in the public tx simulator,
+// and only during revertible phases (revertible insertions, app logic and teardown).
+// These are strictly "checked" errors (not exported and never propagated).
+// They are used internally for control flow to trigger rollbacks to the post-setup state.
+/**
+ * Error thrown when public tx simulation reverts in a known/checked way during revertible insertions.
+ */ class TxSimRevertibleInsertionsRevert extends Error {
+    constructor(){
+        super('Public Tx Simulation reverted during Revertible Insertions');
+        this.name = 'TxSimRevertibleInsertionsRevert';
+    }
+}
+/**
+ * Error thrown when public tx simulation reverts during app logic.
+ */ class TxSimAppLogicRevert extends Error {
+    constructor(){
+        super('Public Tx Simulation reverted during App Logic');
+        this.name = 'TxSimAppLogicRevert';
+    }
+}
+/**
+ * Error thrown when public tx simulation reverts during teardown.
+ */ class TxSimTeardownRevert extends Error {
+    constructor(){
+        super('Public Tx Simulation reverted during Teardown');
+        this.name = 'TxSimTeardownRevert';
+    }
+}
 export class PublicTxSimulator {
-    db;
-    worldStateDB;
+    merkleTree;
+    contractsDB;
     globalVariables;
-    doMerkleOperations;
-    skipFeeEnforcement;
-    metrics;
     log;
-    constructor(db, worldStateDB, globalVariables, doMerkleOperations = false, skipFeeEnforcement = false, telemetryClient = getTelemetryClient()){
-        this.db = db;
-        this.worldStateDB = worldStateDB;
+    config;
+    constructor(merkleTree, contractsDB, globalVariables, config){
+        this.merkleTree = merkleTree;
+        this.contractsDB = contractsDB;
         this.globalVariables = globalVariables;
-        this.doMerkleOperations = doMerkleOperations;
-        this.skipFeeEnforcement = skipFeeEnforcement;
+        this.config = PublicSimulatorConfig.from(config ?? {});
         this.log = createLogger(`simulator:public_tx_simulator`);
-        this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
-    }
-    get tracer() {
-        return this.metrics.tracer;
     }
     /**
    * Simulate a transaction's public portion including all of its phases.
    * @param tx - The transaction to simulate.
    * @returns The result of the transaction's public execution.
    */ async simulate(tx) {
-        try {
-            const startTime = process.hrtime.bigint();
-            const txHash = await tx.getTxHash();
-            this.log.debug(`Simulating ${tx.enqueuedPublicFunctionCalls.length} public calls for tx ${txHash}`, {
-                txHash
-            });
-            const context = await PublicTxContext.create(this.db, this.worldStateDB, tx, this.globalVariables, this.doMerkleOperations);
-            const nonRevertStart = process.hrtime.bigint();
-            await this.insertNonRevertiblesFromPrivate(context);
-            // add new contracts to the contracts db so that their functions may be found and called
-            // TODO(#6464): Should we allow emitting contracts in the private setup phase?
-            await this.worldStateDB.addNewNonRevertibleContracts(tx);
-            const nonRevertEnd = process.hrtime.bigint();
-            this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
-            const processedPhases = [];
-            if (context.hasPhase(TxExecutionPhase.SETUP)) {
-                const setupResult = await this.simulateSetupPhase(context);
-                processedPhases.push(setupResult);
+        const txHash = this.computeTxHash(tx);
+        this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
+            txHash
+        });
+        // Create hinting DBs.
+        const hints = new AvmExecutionHints(this.globalVariables, AvmTxHint.fromTx(tx, this.globalVariables.gasFees), ProtocolContractsList);
+        const hintingMerkleTree = await HintingMerkleWriteOperations.create(this.merkleTree, hints);
+        const hintingTreesDB = new PublicTreesDB(hintingMerkleTree);
+        const hintingContractsDB = new HintingPublicContractsDB(this.contractsDB, hints);
+        const context = await PublicTxContext.create(hintingTreesDB, hintingContractsDB, tx, this.globalVariables, ProtocolContractsList, this.config.proverId);
+        // This will throw if there is a nullifier collision.
+        // In that case the transaction will be thrown out.
+        await this.insertNonRevertiblesFromPrivate(context);
+        const processedPhases = [];
+        if (context.hasPhase(TxExecutionPhase.SETUP)) {
+            // This will throw if the setup phase reverts.
+            // In that case the transaction will be thrown out.
+            const setupResult = await this.simulatePhase(TxExecutionPhase.SETUP, context);
+            if (setupResult.reverted) {
+                throw new Error(`[SETUP] UNRECOVERABLE ERROR! The transaction will be thrown out. ${setupResult.revertReason?.message}`);
             }
-            const revertStart = process.hrtime.bigint();
-            const success = await this.insertRevertiblesFromPrivate(context);
-            if (success) {
-                // add new contracts to the contracts db so that their functions may be found and called
-                await this.worldStateDB.addNewRevertibleContracts(tx);
-                const revertEnd = process.hrtime.bigint();
-                this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
-                // Only proceed with app logic if there was no revert during revertible insertion
-                if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
-                    const appLogicResult = await this.simulateAppLogicPhase(context);
-                    processedPhases.push(appLogicResult);
+            processedPhases.push(setupResult);
+        }
+        // The checkpoint we should go back to if anything from now on reverts.
+        await context.state.fork();
+        hintingContractsDB.createCheckpoint();
+        try {
+            // This will throw if there is a nullifier collision or other insertion error (limit reached).
+            await this.insertRevertiblesFromPrivate(context);
+            // Only proceed with app logic if there was no revert during revertible insertion.
+            if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
+                const appLogicResult = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
+                processedPhases.push(appLogicResult);
+                if (appLogicResult.reverted) {
+                    throw new TxSimAppLogicRevert();
                 }
+            }
+        } catch (e) {
+            if (e instanceof TxSimRevertibleInsertionsRevert || e instanceof TxSimAppLogicRevert) {
+                // We revert to the post-setup state.
+                await context.state.discardForkedState();
+                hintingContractsDB.revertCheckpoint();
+                // But we also create a new fork so that the teardown phase can transparently
+                // commit or rollback at the end of teardown.
+                await context.state.fork();
+                hintingContractsDB.createCheckpoint();
             } else {
-                this.log.debug(`Revertible insertions failed. Skipping app logic.`);
+                // Unchecked/unknown error - re-throw as-is
+                throw e;
             }
+        }
+        try {
             if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
-                const teardownResult = await this.simulateTeardownPhase(context);
+                const teardownResult = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
                 processedPhases.push(teardownResult);
+                if (teardownResult.reverted) {
+                    throw new TxSimTeardownRevert();
+                }
             }
-            await context.halt();
-            await this.payFee(context);
-            const endStateReference = await this.db.getStateReference();
-            const avmProvingRequest = await context.generateProvingRequest(endStateReference);
-            const revertCode = context.getFinalRevertCode();
-            if (!revertCode.isOK()) {
-                await tx.filterRevertedLogs();
+            // We commit the forked state and we are done.
+            await context.state.mergeForkedState();
+            hintingContractsDB.commitCheckpoint();
+        } catch (e) {
+            if (e instanceof TxSimTeardownRevert) {
+                // We revert to the post-setup state and we are done.
+                await context.state.discardForkedState();
+                hintingContractsDB.revertCheckpoint();
+            } else {
+                // Unchecked/unknown error - re-throw as-is
+                throw e;
             }
-            // Commit contracts from this TX to the block-level cache and clear tx cache
-            // If the tx reverted, only commit non-revertible contracts
-            // NOTE: You can't create contracts in public, so this is only relevant for private-created contracts
-            this.worldStateDB.commitContractsForTx(/*onlyNonRevertibles=*/ !revertCode.isOK());
-            const endTime = process.hrtime.bigint();
-            this.log.debug(`Public TX simulator took ${Number(endTime - startTime) / 1_000_000} ms\n`);
-            return {
-                avmProvingRequest,
-                gasUsed: {
-                    totalGas: context.getActualGasUsed(),
-                    teardownGas: context.teardownGasUsed,
-                    publicGas: context.getActualPublicGasUsed(),
-                    billedGas: context.getTotalGasUsed()
-                },
-                revertCode,
-                revertReason: context.revertReason,
-                processedPhases: processedPhases
-            };
-        } finally{
-            // Make sure there are no new contracts in the tx-level cache.
-            // They should either be committed to block-level cache or cleared.
-            this.worldStateDB.clearContractsForTx();
         }
-    }
-    /**
-   * Simulate the setup phase of a transaction's public execution.
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */ async simulateSetupPhase(context) {
-        return await this.simulatePhase(TxExecutionPhase.SETUP, context);
-    }
-    /**
-   * Simulate the app logic phase of a transaction's public execution.
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */ async simulateAppLogicPhase(context) {
-        assert(context.state.isForked(), 'App logic phase should operate with forked state.');
-        const result = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
-        if (result.reverted) {
-            // Drop the currently active forked state manager and rollback to end of setup.
-            await context.state.discardForkedState();
-        } else {
-            if (!context.hasPhase(TxExecutionPhase.TEARDOWN)) {
-                // Nothing to do after this (no teardown), so merge state updates now instead of letting teardown handle it.
-                await context.state.mergeForkedState();
-            }
+        context.halt();
+        // Such transactions should be filtered by GasTxValidator.
+        assert(context.getActualGasUsed().l2Gas <= AVM_MAX_PROCESSABLE_L2_GAS, `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the AVM maximum processable gas of ${AVM_MAX_PROCESSABLE_L2_GAS}`);
+        await this.payFee(context);
+        const publicInputs = await context.generateAvmCircuitPublicInputs();
+        const revertCode = context.getFinalRevertCode();
+        // We only return the app logic phase information, and only 1 per phase.
+        const appLogicReturnValues = processedPhases.find(({ phase })=>phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
+        // TODO(fcarreiro): This is a temporary backwards compatibility layer until we migrate to the C++ simulator.
+        if (context.revertReason !== undefined) {
+            appLogicReturnValues.revertReason = context.revertReason;
         }
-        return result;
+        // Create PublicTxEffect from PublicInputs.
+        const publicTxEffect = new PublicTxEffect(publicInputs.transactionFee, publicInputs.accumulatedData.noteHashes.filter((h)=>!h.isEmpty()), publicInputs.accumulatedData.nullifiers.filter((n)=>!n.isEmpty()), publicInputs.accumulatedData.l2ToL1Msgs.filter((m)=>!m.isEmpty()), publicInputs.accumulatedData.publicLogs.toLogs(), publicInputs.accumulatedData.publicDataWrites.filter((w)=>!w.isEmpty()));
+        return new PublicTxResult(/*gasUsed=*/ {
+            totalGas: context.getActualGasUsed(),
+            teardownGas: context.teardownGasUsed,
+            publicGas: context.getActualPublicGasUsed(),
+            billedGas: context.getTotalGasUsed()
+        }, /*revertCode=*/ revertCode, /*publicTxEffect=*/ publicTxEffect, /*callStackMetadata=*/ appLogicReturnValues, /*logs=*/ context.state.getActiveStateManager().getLogs(), /*hints=*/ hints, /*publicInputs=*/ publicInputs);
     }
-    /**
-   * Simulate the teardown phase of a transaction's public execution.
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */ async simulateTeardownPhase(context) {
-        if (!context.state.isForked()) {
-            // If state isn't forked (app logic reverted), fork now
-            // so we can rollback to the end of setup if teardown reverts.
-            await context.state.fork();
-        }
-        const result = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
-        if (result.reverted) {
-            // Drop the currently active forked state manager and rollback to end of setup.
-            await context.state.discardForkedState();
-        } else {
-            // Merge state updates from teardown,
-            await context.state.mergeForkedState();
-        }
-        return result;
+    computeTxHash(tx) {
+        return tx.getTxHash();
     }
     /**
-   * Simulate a phase of a transaction's public execution.
-   * @param phase - The current phase
+   * Simulate the setup phase of a transaction's public execution.
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
    * @returns The phase result.
    */ async simulatePhase(phase, context) {
         const callRequests = context.getCallRequestsForPhase(phase);
-        const executionRequests = context.getExecutionRequestsForPhase(phase);
         this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.txHash}`, {
             txHash: context.txHash.toString(),
             phase: TxExecutionPhase[phase],
-            callRequests: callRequests.length,
-            executionRequests: executionRequests.length
+            callRequests: callRequests.length
         });
         const returnValues = [];
         let reverted = false;
         let revertReason;
-        const phaseTimer = new Timer();
-        for(let i = callRequests.length - 1; i >= 0; i--){
+        for(let i = 0; i < callRequests.length; i++){
             if (reverted) {
                 break;
             }
             const callRequest = callRequests[i];
-            const executionRequest = executionRequests[i];
-            const enqueuedCallResult = await this.simulateEnqueuedCall(phase, context, callRequest, executionRequest);
+            const enqueuedCallResult = await this.simulateEnqueuedCall(phase, context, callRequest);
             returnValues.push(new NestedProcessReturnValues(enqueuedCallResult.output));
             if (enqueuedCallResult.reverted) {
                 reverted = true;
@@ -190,7 +182,6 @@ export class PublicTxSimulator {
         }
         return {
             phase,
-            durationMs: phaseTimer.ms(),
             returnValues,
             reverted,
             revertReason
@@ -200,22 +191,20 @@ export class PublicTxSimulator {
    * Simulate an enqueued public call.
    * @param phase - The current phase of public execution
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @param callRequest - The enqueued call to execute
-   * @param executionRequest - The execution request (includes args)
+   * @param callRequest - The public function call request, including the calldata.
    * @returns The result of execution.
-   */ async simulateEnqueuedCall(phase, context, callRequest, executionRequest) {
+   */ async simulateEnqueuedCall(phase, context, callRequest) {
         const stateManager = context.state.getActiveStateManager();
-        const address = executionRequest.callContext.contractAddress;
-        const fnName = await getPublicFunctionDebugName(this.worldStateDB, address, executionRequest.args);
+        const contractAddress = callRequest.request.contractAddress;
+        const fnName = await getPublicFunctionDebugName(this.contractsDB, contractAddress, callRequest.calldata);
         const allocatedGas = context.getGasLeftAtPhase(phase);
-        const result = await this.simulateEnqueuedCallInternal(context.state.getActiveStateManager(), executionRequest, allocatedGas, /*transactionFee=*/ context.getTransactionFee(phase), fnName);
+        const result = await this.simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, /*transactionFee=*/ context.getTransactionFee(phase), fnName);
         const gasUsed = allocatedGas.sub(result.gasLeft); // by enqueued call
         context.consumeGas(phase, gasUsed);
         this.log.debug(`Simulated enqueued public call (${fnName}) consumed ${gasUsed.l2Gas} L2 gas ending with ${result.gasLeft.l2Gas} L2 gas left.`);
-        stateManager.traceEnqueuedCall(callRequest, executionRequest.args, result.reverted);
         if (result.reverted) {
-            const culprit = `${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector}`;
-            context.revert(phase, result.revertReason, culprit); // throws if in setup (non-revertible) phase
+            const culprit = `${contractAddress}:${fnName}`;
+            context.revert(phase, result.revertReason, culprit);
         }
         return result;
     }
@@ -227,78 +216,110 @@ export class PublicTxSimulator {
    * while still simulating phases and generating a proving request.
    *
    * @param stateManager - The state manager for AvmSimulation
-   * @param context - The context of the currently executing public transaction portion
-   * @param executionRequest - The execution request (includes args)
+   * @param callRequest - The public function call request, including the calldata.
    * @param allocatedGas - The gas allocated to the enqueued call
    * @param fnName - The name of the function
    * @returns The result of execution.
-   */ async simulateEnqueuedCallInternal(stateManager, executionRequest, allocatedGas, transactionFee, fnName) {
-        const address = executionRequest.callContext.contractAddress;
-        const sender = executionRequest.callContext.msgSender;
+   */ async simulateEnqueuedCallInternal(stateManager, { request, calldata }, allocatedGas, transactionFee, fnName) {
+        const address = request.contractAddress;
+        const sender = request.msgSender;
         this.log.debug(`Executing enqueued public call to external function ${fnName}@${address} with ${allocatedGas.l2Gas} allocated L2 gas.`);
-        const timer = new Timer();
-        const simulator = await AvmSimulator.create(stateManager, address, sender, transactionFee, this.globalVariables, executionRequest.callContext.isStaticCall, executionRequest.args, allocatedGas);
+        const simulator = await AvmSimulator.create(stateManager, address, sender, transactionFee, this.globalVariables, request.isStaticCall, calldata, allocatedGas, this.config);
         const avmCallResult = await simulator.execute();
-        const result = avmCallResult.finalize();
-        this.log.verbose(result.reverted ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason}.` : `Simulation of enqueued public call ${fnName} completed successfully.`, {
-            eventName: 'avm-simulation',
-            appCircuitName: fnName,
-            duration: timer.ms()
-        });
-        if (result.reverted) {
-            this.metrics.recordFunctionSimulationFailure();
-        } else {
-            this.metrics.recordFunctionSimulation(timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, fnName);
-        }
-        return result;
+        return avmCallResult.finalize();
     }
     /**
    * Insert the non-revertible accumulated data from private into the public state.
    */ async insertNonRevertiblesFromPrivate(context) {
         const stateManager = context.state.getActiveStateManager();
-        try {
-            await stateManager.writeSiloedNullifiersFromPrivate(context.nonRevertibleAccumulatedDataFromPrivate.nullifiers);
-        } catch (e) {
-            if (e instanceof NullifierCollisionError) {
-                throw new NullifierCollisionError(`Nullifier collision encountered when inserting non-revertible nullifiers from private.\nDetails: ${e.message}\nStack:${e.stack}`);
-            }
+        for (const siloedNullifier of context.nonRevertibleAccumulatedDataFromPrivate.nullifiers.filter((n)=>!n.isEmpty())){
+            await stateManager.writeSiloedNullifier(siloedNullifier);
         }
         for (const noteHash of context.nonRevertibleAccumulatedDataFromPrivate.noteHashes){
             if (!noteHash.isEmpty()) {
                 await stateManager.writeUniqueNoteHash(noteHash);
             }
         }
+        for (const l2ToL1Message of context.nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs){
+            if (!l2ToL1Message.isEmpty()) {
+                stateManager.writeScopedL2ToL1Message(l2ToL1Message);
+            }
+        }
+        // add new contracts to the contracts db so that their code may be found and called
+        // FIXME(fcarreiro): this should conceptually use the hinting contracts db.
+        // However, things work as expected because later calls to getters on the hintingContractsDB
+        // will pick up the new contracts and will generate the necessary hints.
+        // So, a consumer of the hints will always see the new contracts.
+        await this.contractsDB.addContracts(context.nonRevertibleContractDeploymentData);
     }
     /**
    * Insert the revertible accumulated data from private into the public state.
-   * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
+   * Throws TxSimRevertibleInsertionsRevert if there is some checked error during revertible insertions.
+   * This function checks for the following errors:
+   * - NullifierLimitReachedError
+   * - NullifierCollisionError
+   * - NoteHashLimitReachedError
+   * - L2ToL1MessageLimitReachedError
    */ async insertRevertiblesFromPrivate(context) {
-        // Fork the state manager so we can rollback to end of setup if app logic reverts.
-        await context.state.fork();
         const stateManager = context.state.getActiveStateManager();
         try {
-            await stateManager.writeSiloedNullifiersFromPrivate(context.revertibleAccumulatedDataFromPrivate.nullifiers);
+            for (const siloedNullifier of context.revertibleAccumulatedDataFromPrivate.nullifiers.filter((n)=>!n.isEmpty())){
+                await stateManager.writeSiloedNullifier(siloedNullifier);
+            }
         } catch (e) {
-            if (e instanceof NullifierCollisionError) {
-                // Instead of throwing, revert the app_logic phase
-                context.revert(TxExecutionPhase.APP_LOGIC, new SimulationError(`Nullifier collision encountered when inserting revertible nullifiers from private\nDetails: ${e.message}\nError stack: ${e.stack}`, []), /*culprit=*/ 'insertRevertiblesFromPrivate');
-                return /*success=*/ false;
+            if (e instanceof NullifierLimitReachedError || e instanceof NullifierCollisionError) {
+                context.revert(TxExecutionPhase.APP_LOGIC, new SimulationError(`Error encountered when inserting revertible nullifiers from private.\nDetails: ${e.message}`, []));
+                throw new TxSimRevertibleInsertionsRevert();
             } else {
+                // Unchecked/unknown error - re-throw as-is
                 throw e;
             }
         }
-        for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes){
-            if (!noteHash.isEmpty()) {
-                // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
-                await stateManager.writeSiloedNoteHash(noteHash);
+        try {
+            for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes){
+                if (!noteHash.isEmpty()) {
+                    // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
+                    await stateManager.writeSiloedNoteHash(noteHash);
+                }
+            }
+        } catch (e) {
+            if (e instanceof NoteHashLimitReachedError) {
+                context.revert(TxExecutionPhase.APP_LOGIC, new SimulationError(`Error encountered when inserting revertible note hashes from private.\nDetails: ${e.message}`, []));
+                throw new TxSimRevertibleInsertionsRevert();
+            } else {
+                // Unchecked/unknown error - re-throw as-is
+                throw e;
+            }
+        }
+        try {
+            for (const l2ToL1Message of context.revertibleAccumulatedDataFromPrivate.l2ToL1Msgs){
+                if (!l2ToL1Message.isEmpty()) {
+                    stateManager.writeScopedL2ToL1Message(l2ToL1Message);
+                }
+            }
+        } catch (e) {
+            if (e instanceof L2ToL1MessageLimitReachedError) {
+                context.revert(TxExecutionPhase.APP_LOGIC, new SimulationError(`Error encountered when inserting revertible L2-to-L1 messages from private.\nDetails: ${e.message}`, []));
+                throw new TxSimRevertibleInsertionsRevert();
+            } else {
+                // Unchecked/unknown error - re-throw as-is
+                throw e;
             }
         }
-        return /*success=*/ true;
+        // add new contracts to the contracts db so that their functions may be found and called
+        // FIXME(fcarreiro): this should conceptually use the hinting contracts db.
+        // However, things work as expected because later calls to getters on the hintingContractsDB
+        // will pick up the new contracts and will generate the necessary hints.
+        // So, a consumer of the hints will always see the new contracts.
+        await this.contractsDB.addContracts(context.revertibleContractDeploymentData);
     }
     async payFee(context) {
         const txFee = context.getTransactionFee(TxExecutionPhase.TEARDOWN);
         if (context.feePayer.isZero()) {
-            this.log.debug(`No one is paying the fee of ${txFee.toBigInt()}`);
+            // Real transactions are enforced by private kernel to have nonzero fee payer.
+            // Real transactions cannot skip fee enforcement (skipping fee enforcement makes them unprovable).
+            assert(this.config.skipFeeEnforcement, 'Fee payer cannot be 0 unless skipping fee enforcement for simulation');
+            this.log.debug(`Fee payer is 0. Skipping fee enforcement. No one is paying the fee of ${txFee.toBigInt()}`);
             return;
         }
         const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
@@ -309,26 +330,13 @@ export class PublicTxSimulator {
         // We allow to fake the balance of the fee payer to allow fee estimation
         // When mocking the balance of the fee payer, the circuit should not be able to prove the simulation
         if (currentBalance.lt(txFee)) {
-            if (!this.skipFeeEnforcement) {
-                throw new Error(`Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`);
-            } else {
-                currentBalance = txFee;
-            }
+            // Without "skipFeeEnforcement", such transactions should be filtered by GasTxValidator.
+            assert(this.config.skipFeeEnforcement, `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`);
+            this.log.debug(`Fee payer balance insufficient, but we're skipping fee enforcement`);
+            // We still proceed and perform the storage write to minimize deviation from normal execution.
+            currentBalance = txFee;
         }
         const updatedBalance = currentBalance.sub(txFee);
         await stateManager.writeStorage(feeJuiceAddress, balanceSlot, updatedBalance, true);
     }
 }
-_ts_decorate([
-    trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, _callRequest, executionRequest)=>({
-            [Attributes.TX_HASH]: context.txHash.toString(),
-            [Attributes.TARGET_ADDRESS]: executionRequest.callContext.contractAddress.toString(),
-            [Attributes.SENDER_ADDRESS]: executionRequest.callContext.msgSender.toString(),
-            [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString()
-        }))
-], PublicTxSimulator.prototype, "simulateEnqueuedCall", null);
-_ts_decorate([
-    trackSpan('PublicTxSimulator.simulateEnqueuedCallInternal', (_stateManager, _executionRequest, _allocatedGas, _transactionFee, fnName)=>({
-            [Attributes.APP_CIRCUIT_NAME]: fnName
-        }))
-], PublicTxSimulator.prototype, "simulateEnqueuedCallInternal", null);

package/dest/public/public_tx_simulator/public_tx_simulator_interface.d.ts

@@ -0,0 +1,32 @@
+import type { PublicTxResult } from '@aztec/stdlib/avm';
+import type { Tx } from '@aztec/stdlib/tx';
+export interface PublicTxSimulatorInterface {
+    simulate(tx: Tx): Promise<PublicTxResult>;
+    /**
+     * Cancel the current simulation if one is in progress.
+     * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+     * Safe to call even if no simulation is in progress.
+     * Optional - not all implementations support cancellation.
+     *
+     * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+     *                        This is important because signaling cancellation doesn't immediately stop C++ -
+     *                        it only sets a flag that C++ checks at certain points. If C++ is in the middle
+     *                        of a slow operation (e.g., pad_trees), it won't stop until that completes.
+     * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
+     */
+    cancel?(waitTimeoutMs?: number): Promise<void>;
+}
+export interface MeasuredPublicTxSimulatorInterface {
+    simulate(tx: Tx, txLabel: string): Promise<PublicTxResult>;
+    /**
+     * Cancel the current simulation if one is in progress.
+     * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+     * Safe to call even if no simulation is in progress.
+     * Optional - not all implementations support cancellation.
+     *
+     * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+     * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
+     */
+    cancel?(waitTimeoutMs?: number): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX3R4X3NpbXVsYXRvcl9pbnRlcmZhY2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvcHVibGljX3R4X3NpbXVsYXRvci9wdWJsaWNfdHhfc2ltdWxhdG9yX2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN4RCxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUzQyxNQUFNLFdBQVcsMEJBQTBCO0lBQ3pDLFFBQVEsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUMxQzs7Ozs7Ozs7Ozs7T0FXRztJQUNILE1BQU0sQ0FBQyxDQUFDLGFBQWEsQ0FBQyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7Q0FDaEQ7QUFFRCxNQUFNLFdBQVcsa0NBQWtDO0lBQ2pELFFBQVEsQ0FBQyxFQUFFLEVBQUUsRUFBRSxFQUFFLE9BQU8sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzNEOzs7Ozs7OztPQVFHO0lBQ0gsTUFBTSxDQUFDLENBQUMsYUFBYSxDQUFDLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztDQUNoRCJ9

package/dest/public/public_tx_simulator/public_tx_simulator_interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_tx_simulator_interface.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/public_tx_simulator_interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAC1C;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3D;;;;;;;;OAQG;IACH,MAAM,CAAC,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD"}

package/dest/public/public_tx_simulator/public_tx_simulator_interface.js

@@ -0,0 +1 @@
+export { };

package/dest/public/public_tx_simulator/telemetry_public_tx_simulator.d.ts

@@ -0,0 +1,21 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import type { Gas } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { type GlobalVariables, PublicCallRequestWithCalldata, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import type { PublicContractsDB } from '../public_db_sources.js';
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
+import { MeasuredPublicTxSimulator } from './measured_public_tx_simulator.js';
+import { PublicTxContext } from './public_tx_context.js';
+/**
+ * A public tx simulator that tracks runtime/production metrics with telemetry.
+ */
+export declare class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
+    readonly tracer: Tracer;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, telemetryClient?: TelemetryClient, config?: Partial<PublicSimulatorConfig>);
+    protected simulateEnqueuedCall(phase: TxExecutionPhase, context: PublicTxContext, callRequest: PublicCallRequestWithCalldata): Promise<AvmFinalizedCallResult>;
+    protected simulateEnqueuedCallInternal(stateManager: PublicPersistableStateManager, callRequest: PublicCallRequestWithCalldata, allocatedGas: Gas, transactionFee: Fr, fnName: string): Promise<AvmFinalizedCallResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVsZW1ldHJ5X3B1YmxpY190eF9zaW11bGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvcHVibGljX3R4X3NpbXVsYXRvci90ZWxlbWV0cnlfcHVibGljX3R4X3NpbXVsYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQy9ELE9BQU8sS0FBSyxFQUFFLEdBQUcsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzdDLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckUsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFFLDZCQUE2QixFQUFFLGdCQUFnQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDekcsT0FBTyxFQUFjLEtBQUssZUFBZSxFQUFFLEtBQUssTUFBTSxFQUFpQyxNQUFNLHlCQUF5QixDQUFDO0FBRXZILE9BQU8sS0FBSyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFFakYsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSw2QkFBNkIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3ZGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQzlFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUV6RDs7R0FFRztBQUNILHFCQUFhLDBCQUEyQixTQUFRLHlCQUF5QjtJQUV2RSxTQUFnQixNQUFNLEVBQUUsTUFBTSxDQUFDO0lBRS9CLFlBQ0UsVUFBVSxFQUFFLHlCQUF5QixFQUNyQyxXQUFXLEVBQUUsaUJBQWlCLEVBQzlCLGVBQWUsRUFBRSxlQUFlLEVBQ2hDLGVBQWUsR0FBRSxlQUFzQyxFQUN2RCxNQUFNLENBQUMsRUFBRSxPQUFPLENBQUMscUJBQXFCLENBQUMsRUFLeEM7SUFFRCxVQU15QixvQkFBb0IsQ0FDM0MsS0FBSyxFQUFFLGdCQUFnQixFQUN2QixPQUFPLEVBQUUsZUFBZSxFQUN4QixXQUFXLEVBQUUsNkJBQTZCLEdBQ3pDLE9BQU8sQ0FBQyxzQkFBc0IsQ0FBQyxDQUVqQztJQUVELFVBTXlCLDRCQUE0QixDQUNuRCxZQUFZLEVBQUUsNkJBQTZCLEVBQzNDLFdBQVcsRUFBRSw2QkFBNkIsRUFDMUMsWUFBWSxFQUFFLEdBQUcsRUFDakIsY0FBYyxFQUFFLEVBQUUsRUFDbEIsTUFBTSxFQUFFLE1BQU0sR0FDYixPQUFPLENBQUMsc0JBQXNCLENBQUMsQ0FFakM7Q0FDRiJ9

package/dest/public/public_tx_simulator/telemetry_public_tx_simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry_public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/telemetry_public_tx_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzG,OAAO,EAAc,KAAK,eAAe,EAAE,KAAK,MAAM,EAAiC,MAAM,yBAAyB,CAAC;AAEvH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAEjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AACvF,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,yBAAyB;IAEvE,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,YACE,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,eAAe,GAAE,eAAsC,EACvD,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EAKxC;IAED,UAMyB,oBAAoB,CAC3C,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,6BAA6B,GACzC,OAAO,CAAC,sBAAsB,CAAC,CAEjC;IAED,UAMyB,4BAA4B,CACnD,YAAY,EAAE,6BAA6B,EAC3C,WAAW,EAAE,6BAA6B,EAC1C,YAAY,EAAE,GAAG,EACjB,cAAc,EAAE,EAAE,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,sBAAsB,CAAC,CAEjC;CACF"}