@aztec/simulator 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

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

@@ -1,53 +1,86 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
-import { type PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
+import { PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { Gas } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
-import type { GlobalVariables, Tx } from '@aztec/stdlib/tx';
-import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
-import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
-import type { PublicContractsDB } from '../public_db_sources.js';
-import { PublicTxSimulatorBase } from './public_tx_simulator_base.js';
-import type { MeasuredPublicTxSimulatorInterface, PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
-/**
- * Simulates a transaction's public portion using the C++ AVM simulator.
- * The C++ simulator accesses the world state directly/natively within C++.
- * For contract DB accesses, it makes callbacks through NAPI back to the TS PublicContractsDB cache.
- */
-export declare class PublicTxSimulator extends PublicTxSimulatorBase implements PublicTxSimulatorInterface {
+import { type GlobalVariables, NestedProcessReturnValues, ProtocolContracts, PublicCallRequestWithCalldata, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+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 { PublicTxContext } from './public_tx_context.js';
+import type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
+/** Only used internally. */
+type ProcessedPhase = {
+    phase: TxExecutionPhase;
+    durationMs?: number;
+    returnValues: NestedProcessReturnValues[];
+    reverted: boolean;
+    revertReason?: SimulationError;
+};
+export declare class PublicTxSimulator implements PublicTxSimulatorInterface {
+    protected merkleTree: MerkleTreeWriteOperations;
+    protected contractsDB: PublicContractsDB;
+    protected globalVariables: GlobalVariables;
+    protected protocolContracts: ProtocolContracts;
     protected log: Logger;
-    /** Current cancellation token for in-flight simulation. */
-    private cancellationToken?;
-    /** Current simulation promise, used to wait for completion after cancellation. */
-    private simulationPromise?;
-    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, config?: Partial<PublicSimulatorConfig>, bindings?: LoggerBindings);
+    protected readonly config: PublicSimulatorConfig;
+    protected readonly bindings?: LoggerBindings;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, config?: Partial<PublicSimulatorConfig>, protocolContracts?: ProtocolContracts, bindings?: LoggerBindings);
     /**
-     * Simulate a transaction's public portion using the C++ avvm simulator.
-     *
+     * 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.
      */
     simulate(tx: Tx): Promise<PublicTxResult>;
+    protected computeTxHash(tx: Tx): import("@aztec/stdlib/tx").TxHash;
+    /**
+     * 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.
+     */
+    protected simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase>;
     /**
-     * Cancel the current simulation if one is in progress.
-     * This signals the C++ simulator to stop at the next opcode or before the next WorldState write.
-     * Safe to call even if no simulation is in progress.
+     * 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 public function call request, including the calldata.
+     * @returns The result of execution.
+     */
+    protected simulateEnqueuedCall(phase: TxExecutionPhase, context: PublicTxContext, callRequest: PublicCallRequestWithCalldata): Promise<AvmFinalizedCallResult>;
+    /**
+     * Simulate an enqueued public call, without modifying the context (PublicTxContext).
+     * Resulting modifications to the context can be applied by the caller.
+     *
+     * This function can be mocked for testing to skip actual AVM simulation
+     * while still simulating phases and generating a proving request.
      *
-     * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
-     *                        This is important because C++ might be in the middle of a slow operation
-     *                        (e.g., pad_trees) and won't check the cancellation flag until it completes.
-     *                        Default timeout of 100ms after cancellation.
+     * @param stateManager - The state manager for AvmSimulation
+     * @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.
      */
-    cancel(waitTimeoutMs?: number): Promise<void>;
-}
-export declare class MeasuredPublicTxSimulator extends PublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
-    protected readonly metrics: ExecutorMetricsInterface;
-    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicSimulatorConfig>, bindings?: LoggerBindings);
-    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
-}
-/**
- * A C++ 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>, bindings?: LoggerBindings);
+    protected simulateEnqueuedCallInternal(stateManager: PublicPersistableStateManager, { request, calldata }: PublicCallRequestWithCalldata, allocatedGas: Gas, transactionFee: Fr, fnName: string): Promise<AvmFinalizedCallResult>;
+    /**
+     * Insert the non-revertible accumulated data from private into the public state.
+     */
+    protected insertNonRevertiblesFromPrivate(context: PublicTxContext): Promise<void>;
+    /**
+     * Insert the revertible accumulated data from private into the public state.
+     * Throws TxSimRevertibleInsertionsRevert if there is some checked error during revertible insertions.
+     * This function checks for the following errors:
+     * - NullifierLimitReachedError
+     * - NoteHashLimitReachedError
+     * - L2ToL1MessageLimitReachedError
+     *
+     * Note: NullifierCollisionError is intentionally NOT caught here. A nullifier collision
+     * during revertible insertions is unprovable (the nullifier originated from private, so
+     * a collision indicates the tx should never have been proposed). It propagates as-is to
+     * make the transaction unrecoverable, matching the AVM circuit behavior.
+     */
+    protected insertRevertiblesFromPrivate(context: PublicTxContext): Promise<void>;
+    private payFee;
 }
-//# sourceMappingURL=data:application/json;base64,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
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/public_tx_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAIvF,OAAO,EAGL,KAAK,qBAAqB,EAC1B,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,MAAM,EAAsB,MAAM,yBAAyB,CAAC;AAGhG,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EACV,kCAAkC,EAClC,0BAA0B,EAC3B,MAAM,oCAAoC,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,qBAAsB,YAAW,0BAA0B;IAChG,UAAmB,GAAG,EAAE,MAAM,CAAC;IAC/B,2DAA2D;IAC3D,OAAO,CAAC,iBAAiB,CAAC,CAAoB;IAC9C,kFAAkF;IAClF,OAAO,CAAC,iBAAiB,CAAC,CAAkB;IAE5C,YACE,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EACvC,QAAQ,CAAC,EAAE,cAAc,EAI1B;IAED;;;;;OAKG;IACU,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAwErD;IAED;;;;;;;;;OASG;IACU,MAAM,CAAC,aAAa,GAAE,MAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAe9D;CACF;AAED,qBAAa,yBAA0B,SAAQ,iBAAkB,YAAW,kCAAkC;IAK1G,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wBAAwB;IAJtD,YACE,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACb,OAAO,EAAE,wBAAwB,EACpD,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EACvC,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAEqB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAS/F;CACF;AAED;;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,EACvC,QAAQ,CAAC,EAAE,cAAc,EAK1B;CACF"}
+{"version":3,"file":"public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/public_tx_simulator.ts"],"names":[],"mappings":"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"}

package/dest/public/public_tx_simulator/public_tx_simulator.js

@@ -1,126 +1,352 @@
+import { MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
-import { sleep } from '@aztec/foundation/sleep';
-import { avmSimulate, cancelSimulation, createCancellationToken } from '@aztec/native';
-import { ProtocolContractsList } from '@aztec/protocol-contracts';
-import { AvmFastSimulationInputs, AvmTxHint, PublicTxResult, deserializeFromMessagePack } from '@aztec/stdlib/avm';
+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 { getTelemetryClient } from '@aztec/telemetry-client';
-import { ExecutorMetrics } from '../executor_metrics.js';
-import { ContractProviderForCpp } from './contract_provider_for_cpp.js';
-import { PublicTxSimulatorBase } from './public_tx_simulator_base.js';
+import { NestedProcessReturnValues, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { strict as assert } from 'assert';
+import { CallDataArray } from '../avm/calldata.js';
+import { AvmSimulator } from '../avm/index.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, 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.
 /**
- * Simulates a transaction's public portion using the C++ AVM simulator.
- * The C++ simulator accesses the world state directly/natively within C++.
- * For contract DB accesses, it makes callbacks through NAPI back to the TS PublicContractsDB cache.
- */ export class PublicTxSimulator extends PublicTxSimulatorBase {
+ * 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 {
+    merkleTree;
+    contractsDB;
+    globalVariables;
+    protocolContracts;
     log;
-    /** Current cancellation token for in-flight simulation. */ cancellationToken;
-    /** Current simulation promise, used to wait for completion after cancellation. */ simulationPromise;
-    constructor(merkleTree, contractsDB, globalVariables, config, bindings){
-        super(merkleTree, contractsDB, globalVariables, config, undefined, bindings);
+    config;
+    bindings;
+    constructor(merkleTree, contractsDB, globalVariables, config, protocolContracts = ProtocolContractsList, bindings){
+        this.merkleTree = merkleTree;
+        this.contractsDB = contractsDB;
+        this.globalVariables = globalVariables;
+        this.protocolContracts = protocolContracts;
+        this.config = PublicSimulatorConfig.from(config ?? {});
+        this.bindings = bindings;
         this.log = createLogger(`simulator:public_tx_simulator`, bindings);
     }
     /**
-   * Simulate a transaction's public portion using the C++ avvm simulator.
-   *
+   * 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) {
         const txHash = this.computeTxHash(tx);
-        this.log.debug(`C++ simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
+        this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
             txHash
         });
-        const wsRevision = this.merkleTree.getRevision();
-        const wsdbIpcPath = this.merkleTree.getIpcPath();
-        this.log.trace(`Running C++ simulation with world state revision ${JSON.stringify(wsRevision)}`);
-        // Create the fast simulation inputs
-        const txHint = AvmTxHint.fromTx(tx, this.globalVariables.gasFees);
-        const protocolContracts = ProtocolContractsList;
-        const fastSimInputs = new AvmFastSimulationInputs(wsRevision, this.config, txHint, this.globalVariables, protocolContracts);
-        // Create contract provider for callbacks to TypeScript PublicContractsDB from C++
-        const contractProvider = new ContractProviderForCpp(this.contractsDB, this.globalVariables, this.bindings);
-        // Serialize to msgpack and call the C++ simulator
-        this.log.trace(`Serializing fast simulation inputs to msgpack...`);
-        const inputBuffer = fastSimInputs.serializeWithMessagePack();
-        // Create cancellation token for this simulation
-        this.cancellationToken = createCancellationToken();
-        // Store the promise so cancel() can wait for it
-        this.log.debug(`Calling C++ simulator for tx ${txHash}`);
-        this.simulationPromise = avmSimulate(inputBuffer, contractProvider, wsdbIpcPath, this.log.level, undefined, this.cancellationToken);
-        let resultBuffer;
+        // Create hinting DBs.
+        const hints = new AvmExecutionHints(this.globalVariables, AvmTxHint.fromTx(tx, this.globalVariables.gasFees), this.protocolContracts);
+        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, this.protocolContracts, this.config.proverId, this.bindings);
+        // 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}`);
+            }
+            processedPhases.push(setupResult);
+        }
+        // The checkpoint we should go back to if anything from now on reverts.
+        await context.state.fork();
+        hintingContractsDB.createCheckpoint();
+        try {
+            // This may throw: a side-effect limit error triggers a soft revert (caught below), while a
+            // nullifier collision is unrecoverable and propagates out of simulate() to throw out the tx.
+            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 {
+                // Unchecked/unknown error - re-throw as-is
+                throw e;
+            }
+        }
         try {
-            resultBuffer = await this.simulationPromise;
-        } catch (error) {
-            // Check if this was a cancellation
-            if (error.message?.includes('Simulation cancelled')) {
-                throw new SimulationError(`C++ simulation cancelled`, []);
+            if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+                const teardownResult = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
+                processedPhases.push(teardownResult);
+                if (teardownResult.reverted) {
+                    throw new TxSimTeardownRevert();
+                }
             }
-            throw new SimulationError(`C++ simulation failed: ${error.message}`, []);
-        } finally{
-            this.cancellationToken = undefined;
-            this.simulationPromise = undefined;
+            // 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;
+            }
+        }
+        context.halt();
+        // Such transactions should be filtered by GasTxValidator.
+        assert(context.getActualGasUsed().l2Gas <= MAX_PROCESSABLE_L2_GAS, `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the maximum processable gas of ${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;
         }
-        // If we've reached this point, C++ succeeded during simulation,
-        // Deserialize the msgpack result
-        this.log.trace(`Deserializing C++ from buffer (size: ${resultBuffer.length})...`);
-        const cppResultJSON = deserializeFromMessagePack(resultBuffer);
-        this.log.trace(`Deserializing C++ result to PublicTxResult...`);
-        const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
-        this.log.trace(`C++ simulation completed for tx ${txHash}`, {
-            txHash,
-            reverted: !cppResult.revertCode.isOK(),
-            cppGasUsed: cppResult.gasUsed.totalGas.l2Gas
+        // 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);
+    }
+    computeTxHash(tx) {
+        return tx.getTxHash();
+    }
+    /**
+   * 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);
+        this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.txHash}`, {
+            txHash: context.txHash.toString(),
+            phase: TxExecutionPhase[phase],
+            callRequests: callRequests.length
         });
-        return cppResult;
+        const returnValues = [];
+        let reverted = false;
+        let revertReason;
+        for(let i = 0; i < callRequests.length; i++){
+            if (reverted) {
+                break;
+            }
+            const callRequest = callRequests[i];
+            const enqueuedCallResult = await this.simulateEnqueuedCall(phase, context, callRequest);
+            returnValues.push(new NestedProcessReturnValues(enqueuedCallResult.output.bestEffortReadAll()));
+            if (enqueuedCallResult.reverted) {
+                reverted = true;
+                revertReason = enqueuedCallResult.revertReason;
+            }
+        }
+        return {
+            phase,
+            returnValues,
+            reverted,
+            revertReason
+        };
+    }
+    /**
+   * 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 public function call request, including the calldata.
+   * @returns The result of execution.
+   */ async simulateEnqueuedCall(phase, context, callRequest) {
+        const stateManager = context.state.getActiveStateManager();
+        const contractAddress = callRequest.request.contractAddress;
+        const fnName = await getPublicFunctionDebugName(this.contractsDB, contractAddress, new CallDataArray(callRequest.calldata));
+        const allocatedGas = context.getGasLeftAtPhase(phase);
+        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.`);
+        if (result.reverted) {
+            const culprit = `${contractAddress}:${fnName}`;
+            context.revert(phase, result.revertReason, culprit);
+        }
+        return result;
     }
     /**
-   * Cancel the current simulation if one is in progress.
-   * This signals the C++ simulator to stop at the next opcode or before the next WorldState write.
-   * Safe to call even if no simulation is in progress.
+   * Simulate an enqueued public call, without modifying the context (PublicTxContext).
+   * Resulting modifications to the context can be applied by the caller.
+   *
+   * This function can be mocked for testing to skip actual AVM simulation
+   * while still simulating phases and generating a proving request.
    *
-   * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
-   *                        This is important because C++ might be in the middle of a slow operation
-   *                        (e.g., pad_trees) and won't check the cancellation flag until it completes.
-   *                        Default timeout of 100ms after cancellation.
-   */ async cancel(waitTimeoutMs = 100) {
-        if (this.cancellationToken) {
-            this.log.debug('Cancelling C++ simulation');
-            cancelSimulation(this.cancellationToken);
+   * @param stateManager - The state manager for AvmSimulation
+   * @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, { 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 simulator = await AvmSimulator.create(stateManager, address, sender, transactionFee, this.globalVariables, request.isStaticCall, new CallDataArray(calldata), allocatedGas, this.config);
+        const avmCallResult = await simulator.execute();
+        return avmCallResult.finalize();
+    }
+    /**
+   * Insert the non-revertible accumulated data from private into the public state.
+   */ async insertNonRevertiblesFromPrivate(context) {
+        const stateManager = context.state.getActiveStateManager();
+        for (const siloedNullifier of context.nonRevertibleAccumulatedDataFromPrivate.nullifiers.filter((n)=>!n.isEmpty())){
+            await stateManager.writeSiloedNullifier(siloedNullifier);
         }
-        // Wait for the simulation to actually complete if not already done
-        if (this.simulationPromise) {
-            this.log.debug(`Waiting up to ${waitTimeoutMs}ms for C++ simulation to stop`);
-            await Promise.race([
-                this.simulationPromise.catch(()=>{}),
-                sleep(waitTimeoutMs)
-            ]);
-            this.log.debug('C++ simulation stopped or wait timed out');
+        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.
+        this.contractsDB.addContractsFromLogs(context.nonRevertibleContractDeploymentData);
     }
-}
-export class MeasuredPublicTxSimulator extends PublicTxSimulator {
-    metrics;
-    constructor(merkleTree, contractsDB, globalVariables, metrics, config, bindings){
-        super(merkleTree, contractsDB, globalVariables, config, bindings), this.metrics = metrics;
-    }
-    async simulate(tx, txLabel = 'unlabeledTx') {
-        this.metrics.startRecordingTxSimulation(txLabel);
-        let result;
+    /**
+   * Insert the revertible accumulated data from private into the public state.
+   * Throws TxSimRevertibleInsertionsRevert if there is some checked error during revertible insertions.
+   * This function checks for the following errors:
+   * - NullifierLimitReachedError
+   * - NoteHashLimitReachedError
+   * - L2ToL1MessageLimitReachedError
+   *
+   * Note: NullifierCollisionError is intentionally NOT caught here. A nullifier collision
+   * during revertible insertions is unprovable (the nullifier originated from private, so
+   * a collision indicates the tx should never have been proposed). It propagates as-is to
+   * make the transaction unrecoverable, matching the AVM circuit behavior.
+   */ async insertRevertiblesFromPrivate(context) {
+        const stateManager = context.state.getActiveStateManager();
+        try {
+            for (const siloedNullifier of context.revertibleAccumulatedDataFromPrivate.nullifiers.filter((n)=>!n.isEmpty())){
+                await stateManager.writeSiloedNullifier(siloedNullifier);
+            }
+        } catch (e) {
+            if (e instanceof NullifierLimitReachedError) {
+                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 or NullifierCollisionError (unrecoverable) - re-throw as-is
+                throw e;
+            }
+        }
         try {
-            result = await super.simulate(tx);
-        } finally{
-            this.metrics.stopRecordingTxSimulation(txLabel, result?.gasUsed, result?.revertCode);
+            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;
+            }
         }
-        return result;
+        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;
+            }
+        }
+        // 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.
+        this.contractsDB.addContractsFromLogs(context.revertibleContractDeploymentData);
     }
-}
-/**
- * A C++ public tx simulator that tracks runtime/production metrics with telemetry.
- */ export class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
-    /* tracer needed by trackSpans */ tracer;
-    constructor(merkleTree, contractsDB, globalVariables, telemetryClient = getTelemetryClient(), config, bindings){
-        const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
-        super(merkleTree, contractsDB, globalVariables, metrics, config, bindings);
-        this.tracer = metrics.tracer;
+    async payFee(context) {
+        const txFee = context.getTransactionFee(TxExecutionPhase.TEARDOWN);
+        if (context.feePayer.isZero()) {
+            // 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;
+        const balanceSlot = await computeFeePayerBalanceStorageSlot(context.feePayer);
+        this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${context.feePayer}`);
+        const stateManager = context.state.getActiveStateManager();
+        let currentBalance = await stateManager.readStorage(feeJuiceAddress, balanceSlot);
+        // 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)) {
+            // 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);
     }
 }