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

package/dest/public/public_tx_simulator/public_tx_context.js

@@ -1,36 +1,39 @@
-import { MAX_L2_GAS_PER_TX_PUBLIC_PORTION, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec/constants';
+import { MAX_ENQUEUED_CALLS_PER_TX, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
-import { assertLength } from '@aztec/foundation/serialize';
-import { AvmCircuitInputs, PublicDataWrite, RevertCode } from '@aztec/stdlib/avm';
-import { computeTransactionFee } from '@aztec/stdlib/fees';
+import { AvmAccumulatedData, AvmAccumulatedDataArrayLengths, AvmCircuitPublicInputs, PublicDataWrite, RevertCode } from '@aztec/stdlib/avm';
+import { AllContractDeploymentData } from '@aztec/stdlib/contract';
+import { computeEffectiveGasFees, computeTransactionFee } from '@aztec/stdlib/fees';
 import { Gas } from '@aztec/stdlib/gas';
-import { PrivateToAvmAccumulatedData, PrivateToAvmAccumulatedDataArrayLengths, PublicCallRequest, countAccumulatedItems, mergeAccumulatedData } from '@aztec/stdlib/kernel';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { PrivateToAvmAccumulatedData, PrivateToAvmAccumulatedDataArrayLengths, PublicCallRequest, PublicCallRequestArrayLengths, countAccumulatedItems } from '@aztec/stdlib/kernel';
+import { FlatPublicLogs } from '@aztec/stdlib/logs';
+import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { TreeSnapshots, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { TxExecutionPhase } from '@aztec/stdlib/tx';
 import { strict as assert } from 'assert';
 import { inspect } from 'util';
-import { AvmPersistableStateManager } from '../avm/index.js';
-import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
-import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js';
+import { SideEffectTrace } from '../side_effect_trace.js';
+import { PublicPersistableStateManager } from '../state_manager/state_manager.js';
+import { getCallRequestsWithCalldataByPhase } from '../utils.js';
 /**
  * The transaction-level context for public execution.
  */ export class PublicTxContext {
     txHash;
     state;
+    startTreeSnapshots;
     globalVariables;
-    startStateReference;
+    protocolContracts;
+    proverId;
     gasSettings;
     gasUsedByPrivate;
     gasAllocatedToPublic;
+    gasAllocatedToPublicTeardown;
     setupCallRequests;
     appLogicCallRequests;
     teardownCallRequests;
-    setupExecutionRequests;
-    appLogicExecutionRequests;
-    teardownExecutionRequests;
+    nonRevertibleContractDeploymentData;
+    revertibleContractDeploymentData;
     nonRevertibleAccumulatedDataFromPrivate;
     revertibleAccumulatedDataFromPrivate;
     feePayer;
@@ -41,21 +44,22 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
     /* Entire transaction execution is done. */ halted;
     /* Where did reverts happen (if at all)? */ revertCode;
     /* What caused a revert (if one occurred)? */ revertReason;
-    avmProvingRequest;
-    constructor(txHash, state, globalVariables, startStateReference, gasSettings, gasUsedByPrivate, gasAllocatedToPublic, setupCallRequests, appLogicCallRequests, teardownCallRequests, setupExecutionRequests, appLogicExecutionRequests, teardownExecutionRequests, nonRevertibleAccumulatedDataFromPrivate, revertibleAccumulatedDataFromPrivate, feePayer, trace){
+    constructor(txHash, state, startTreeSnapshots, globalVariables, protocolContracts, proverId, gasSettings, gasUsedByPrivate, gasAllocatedToPublic, gasAllocatedToPublicTeardown, setupCallRequests, appLogicCallRequests, teardownCallRequests, nonRevertibleContractDeploymentData, revertibleContractDeploymentData, nonRevertibleAccumulatedDataFromPrivate, revertibleAccumulatedDataFromPrivate, feePayer, trace, bindings){
         this.txHash = txHash;
         this.state = state;
+        this.startTreeSnapshots = startTreeSnapshots;
         this.globalVariables = globalVariables;
-        this.startStateReference = startStateReference;
+        this.protocolContracts = protocolContracts;
+        this.proverId = proverId;
         this.gasSettings = gasSettings;
         this.gasUsedByPrivate = gasUsedByPrivate;
         this.gasAllocatedToPublic = gasAllocatedToPublic;
+        this.gasAllocatedToPublicTeardown = gasAllocatedToPublicTeardown;
         this.setupCallRequests = setupCallRequests;
         this.appLogicCallRequests = appLogicCallRequests;
         this.teardownCallRequests = teardownCallRequests;
-        this.setupExecutionRequests = setupExecutionRequests;
-        this.appLogicExecutionRequests = appLogicExecutionRequests;
-        this.teardownExecutionRequests = teardownExecutionRequests;
+        this.nonRevertibleContractDeploymentData = nonRevertibleContractDeploymentData;
+        this.revertibleContractDeploymentData = revertibleContractDeploymentData;
         this.nonRevertibleAccumulatedDataFromPrivate = nonRevertibleAccumulatedDataFromPrivate;
         this.revertibleAccumulatedDataFromPrivate = revertibleAccumulatedDataFromPrivate;
         this.feePayer = feePayer;
@@ -64,29 +68,29 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
         this.teardownGasUsed = Gas.empty();
         this.halted = false;
         this.revertCode = RevertCode.OK;
-        this.log = createLogger(`simulator:public_tx_context`);
+        this.log = createLogger(`simulator:public_tx_context`, bindings);
     }
-    static async create(db, worldStateDB, tx, globalVariables, doMerkleOperations) {
+    static async create(treesDB, contractsDB, tx, globalVariables, protocolContracts, proverId, bindings) {
+        const contractDeploymentData = AllContractDeploymentData.fromTx(tx);
+        const nonRevertibleContractDeploymentData = contractDeploymentData.getNonRevertibleContractDeploymentData();
+        const revertibleContractDeploymentData = contractDeploymentData.getRevertibleContractDeploymentData();
         const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic.nonRevertibleAccumulatedData;
-        const previousAccumulatedDataArrayLengths = new SideEffectArrayLengths(/*publicDataWrites*/ 0, /*protocolPublicDataWrites*/ 0, /*noteHashes*/ 0, /*nullifiers=*/ 0, countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs), /*publicLogs*/ 0);
-        const trace = new SideEffectTrace(/*startSideEffectCounter=*/ 0, previousAccumulatedDataArrayLengths);
+        const trace = new SideEffectTrace(0, bindings);
         const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
         // Transaction level state manager that will be forked for revertible phases.
-        const txStateManager = AvmPersistableStateManager.create(worldStateDB, trace, doMerkleOperations, firstNullifier);
+        const txStateManager = PublicPersistableStateManager.create(treesDB, contractsDB, trace, firstNullifier, globalVariables.timestamp, bindings);
         const gasSettings = tx.data.constants.txContext.gasSettings;
         const gasUsedByPrivate = tx.data.gasUsed;
-        // Gas allocated to public is "whatever's left" after private, but with some max applied.
-        const gasAllocatedToPublic = applyMaxToAvailableGas(gasSettings.gasLimits.sub(gasUsedByPrivate));
-        return new PublicTxContext(await tx.getTxHash(), new PhaseStateManager(txStateManager), globalVariables, await db.getStateReference(), gasSettings, gasUsedByPrivate, gasAllocatedToPublic, getCallRequestsByPhase(tx, TxExecutionPhase.SETUP), getCallRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC), getCallRequestsByPhase(tx, TxExecutionPhase.TEARDOWN), getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP), getExecutionRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC), getExecutionRequestsByPhase(tx, TxExecutionPhase.TEARDOWN), tx.data.forPublic.nonRevertibleAccumulatedData, tx.data.forPublic.revertibleAccumulatedData, tx.data.feePayer, trace);
+        const gasAllocatedToPublic = gasSettings.gasLimits.sub(gasUsedByPrivate);
+        const gasAllocatedToPublicTeardown = gasSettings.teardownGasLimits;
+        return new PublicTxContext(tx.getTxHash(), new PhaseStateManager(txStateManager, bindings), await txStateManager.getTreeSnapshots(), globalVariables, protocolContracts, proverId, gasSettings, gasUsedByPrivate, gasAllocatedToPublic, gasAllocatedToPublicTeardown, getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP), getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.APP_LOGIC), getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.TEARDOWN), nonRevertibleContractDeploymentData, revertibleContractDeploymentData, tx.data.forPublic.nonRevertibleAccumulatedData, tx.data.forPublic.revertibleAccumulatedData, tx.data.feePayer, trace, bindings);
     }
     /**
    * Signal that the entire transaction execution is done.
    * All phases have been processed.
    * Actual transaction fee and actual total consumed gas can now be queried.
-   */ async halt() {
-        if (this.state.isForked()) {
-            await this.state.mergeForkedState();
-        }
+   */ halt() {
+        assert(!this.state.isForked(), 'Cannot halt when state is forked');
         this.halted = true;
     }
     /**
@@ -94,7 +98,7 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
    * If in setup, throw an error (transaction will be thrown out).
    * NOTE: this does not "halt" the entire transaction execution.
    */ revert(phase, revertReason = undefined, culprit = '') {
-        this.log.warn(`${TxExecutionPhase[phase]} phase reverted! ${culprit} failed with reason: ${revertReason}`);
+        this.log.warn(`${TxExecutionPhase[phase]} phase reverted! ${culprit} failed with reason: ${revertReason?.message}`);
         if (revertReason && !this.revertReason) {
             // don't override revertReason
             // (if app logic and teardown both revert, we want app logic's reason)
@@ -102,19 +106,8 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
         }
         if (phase === TxExecutionPhase.SETUP) {
             this.log.warn(`Setup phase reverted! The transaction will be thrown out.`);
-            if (revertReason) {
-                throw revertReason;
-            } else {
-                throw new Error(`Setup phase reverted! The transaction will be thrown out. ${culprit} failed`);
-            }
-        } else if (phase === TxExecutionPhase.APP_LOGIC) {
-            this.revertCode = RevertCode.APP_LOGIC_REVERTED;
-        } else if (phase === TxExecutionPhase.TEARDOWN) {
-            if (this.revertCode.equals(RevertCode.APP_LOGIC_REVERTED)) {
-                this.revertCode = RevertCode.BOTH_REVERTED;
-            } else {
-                this.revertCode = RevertCode.TEARDOWN_REVERTED;
-            }
+        } else if (phase === TxExecutionPhase.APP_LOGIC || phase === TxExecutionPhase.TEARDOWN) {
+            this.revertCode = RevertCode.REVERTED;
         }
     }
     /**
@@ -149,22 +142,11 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
         }
     }
     /**
-   * Get the call requests for the specified phase (including actual args).
-   */ getExecutionRequestsForPhase(phase) {
-        switch(phase){
-            case TxExecutionPhase.SETUP:
-                return this.setupExecutionRequests;
-            case TxExecutionPhase.APP_LOGIC:
-                return this.appLogicExecutionRequests;
-            case TxExecutionPhase.TEARDOWN:
-                return this.teardownExecutionRequests;
-        }
-    }
-    /**
    * How much gas is left as of the specified phase?
    */ getGasLeftAtPhase(phase) {
         if (phase === TxExecutionPhase.TEARDOWN) {
-            return applyMaxToAvailableGas(this.gasSettings.teardownGasLimits);
+            const gasLeftForPublicTeardown = this.gasAllocatedToPublicTeardown.sub(this.teardownGasUsed);
+            return gasLeftForPublicTeardown;
         } else {
             const gasLeftForPublic = this.gasAllocatedToPublic.sub(this.gasUsedByPublic);
             return gasLeftForPublic;
@@ -180,8 +162,12 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
         }
     }
     /**
-   * The gasUsed by public and private,
-   * as if the entire teardown gas limit was consumed.
+   * The gasUsed by public and private, as if the entire teardown gas limit was consumed.
+   *
+   * This is intentional: teardown is used for gas accounting and refunds, so the transaction
+   * fee must be deterministic _before_ teardown executes. If fees depended on teardown's actual
+   * consumption there would be a circular dependency. Billing the full teardown gas limit
+   * (set by the user) makes the fee known in advance and available to the teardown function.
    */ getTotalGasUsed() {
         return this.gasUsedByPrivate.add(this.gasUsedByPublic);
     }
@@ -228,46 +214,43 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
     }
     /**
    * Generate the public inputs for the AVM circuit.
-   */ async generateAvmCircuitPublicInputs(endStateReference) {
+   */ async generateAvmCircuitPublicInputs() {
         assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
         const stateManager = this.state.getActiveStateManager();
-        const startTreeSnapshots = new TreeSnapshots(this.startStateReference.l1ToL2MessageTree, this.startStateReference.partial.noteHashTree, this.startStateReference.partial.nullifierTree, this.startStateReference.partial.publicDataTree);
-        // Will be patched/padded at the end of this fn
-        const endTreeSnapshots = new TreeSnapshots(endStateReference.l1ToL2MessageTree, endStateReference.partial.noteHashTree, endStateReference.partial.nullifierTree, endStateReference.partial.publicDataTree);
-        const avmCircuitPublicInputs = this.trace.toAvmCircuitPublicInputs(this.globalVariables, startTreeSnapshots, /*startGasUsed=*/ this.gasUsedByPrivate, this.gasSettings, this.feePayer, this.setupCallRequests, this.appLogicCallRequests, /*teardownCallRequest=*/ this.teardownCallRequests.length ? this.teardownCallRequests[0] : PublicCallRequest.empty(), endTreeSnapshots, /*endGasUsed=*/ this.getTotalGasUsed(), /*transactionFee=*/ this.getTransactionFeeUnsafe(), /*reverted=*/ !this.revertCode.isOK());
-        const getArrayLengths = (from)=>new PrivateToAvmAccumulatedDataArrayLengths(countAccumulatedItems(from.noteHashes), countAccumulatedItems(from.nullifiers), countAccumulatedItems(from.l2ToL1Msgs));
-        const convertAccumulatedData = (from)=>new PrivateToAvmAccumulatedData(from.noteHashes, from.nullifiers, from.l2ToL1Msgs);
-        // Temporary overrides as these entries aren't yet populated in trace
-        avmCircuitPublicInputs.previousNonRevertibleAccumulatedDataArrayLengths = getArrayLengths(this.nonRevertibleAccumulatedDataFromPrivate);
-        avmCircuitPublicInputs.previousRevertibleAccumulatedDataArrayLengths = getArrayLengths(this.revertibleAccumulatedDataFromPrivate);
-        avmCircuitPublicInputs.previousNonRevertibleAccumulatedData = convertAccumulatedData(this.nonRevertibleAccumulatedDataFromPrivate);
-        avmCircuitPublicInputs.previousRevertibleAccumulatedData = convertAccumulatedData(this.revertibleAccumulatedDataFromPrivate);
-        const msgsFromPrivate = this.revertCode.isOK() ? mergeAccumulatedData(avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs, avmCircuitPublicInputs.previousRevertibleAccumulatedData.l2ToL1Msgs) : avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs;
-        avmCircuitPublicInputs.accumulatedData.l2ToL1Msgs = assertLength(mergeAccumulatedData(msgsFromPrivate, avmCircuitPublicInputs.accumulatedData.l2ToL1Msgs), MAX_L2_TO_L1_MSGS_PER_TX);
+        // We get the side effects from the AVM.
+        // The AVM will already have handled the conditional insertion of most private side-effects.
+        // (depending on the revert code of each stage). Only l2ToL1Msgs and publicLogs still need to be "merged".
+        const { publicDataWrites: avmPublicDataWrites, noteHashes: avmNoteHashes, nullifiers: avmNullifiers, l2ToL1Msgs: avmL2ToL1Msgs, publicLogs: avmPublicLogs } = this.trace.getSideEffects();
+        // Private generates PrivateLogs, and public execution generates PublicLogs.
+        // Since these are two different categories, they should not be merged.
+        const finalPublicLogs = avmPublicLogs;
+        // We squash public data writes.
         // Maps slot to value. Maps in TS are iterable in insertion order, which is exactly what we want for
         // squashing "to the left", where the first occurrence of a slot uses the value of the last write to it,
-        // and the rest occurrences are omitted
-        const squashedPublicDataWrites = new Map();
-        for (const publicDataWrite of avmCircuitPublicInputs.accumulatedData.publicDataWrites){
-            squashedPublicDataWrites.set(publicDataWrite.leafSlot.toBigInt(), publicDataWrite.value);
-        }
-        avmCircuitPublicInputs.accumulatedData.publicDataWrites = padArrayEnd(Array.from(squashedPublicDataWrites.entries()).map(([slot, value])=>new PublicDataWrite(new Fr(slot), value)), PublicDataWrite.empty(), MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
-        const numNoteHashesToPad = MAX_NOTE_HASHES_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.noteHashes);
-        await stateManager.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd([], Fr.ZERO, numNoteHashesToPad));
-        const numNullifiersToPad = MAX_NULLIFIERS_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.nullifiers);
-        await stateManager.db.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd([], Fr.ZERO, numNullifiersToPad).map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
-        const paddedState = await stateManager.db.getStateReference();
-        avmCircuitPublicInputs.endTreeSnapshots = new TreeSnapshots(paddedState.l1ToL2MessageTree, paddedState.partial.noteHashTree, paddedState.partial.nullifierTree, paddedState.partial.publicDataTree);
-        return avmCircuitPublicInputs;
-    }
-    /**
-   * Generate the proving request for the AVM circuit.
-   */ async generateProvingRequest(endStateReference) {
-        const hints = this.trace.getAvmCircuitHints();
-        return {
-            type: ProvingRequestType.PUBLIC_VM,
-            inputs: new AvmCircuitInputs('public_dispatch', [], hints, await this.generateAvmCircuitPublicInputs(endStateReference))
-        };
+        // and the rest occurrences are omitted.
+        // Note: you can't write public state from private, so we only squash what we got from the AVM.
+        const finalPublicDataWrites = (()=>{
+            const squashedPublicDataWrites = new Map();
+            for (const publicDataWrite of avmPublicDataWrites){
+                squashedPublicDataWrites.set(publicDataWrite.leafSlot.toBigInt(), publicDataWrite.newValue);
+            }
+            return Array.from(squashedPublicDataWrites.entries()).map(([slot, value])=>new PublicDataWrite(new Fr(slot), value));
+        })();
+        // Count before padding.
+        const accumulatedDataArrayLengths = new AvmAccumulatedDataArrayLengths(avmNoteHashes.length, avmNullifiers.length, avmL2ToL1Msgs.length, finalPublicDataWrites.length);
+        const accumulatedData = new AvmAccumulatedData(/*noteHashes=*/ padArrayEnd(avmNoteHashes.map((n)=>n.value), Fr.zero(), MAX_NOTE_HASHES_PER_TX), /*nullifiers=*/ padArrayEnd(avmNullifiers.map((n)=>n.value), Fr.zero(), MAX_NULLIFIERS_PER_TX), /*l2ToL1Msgs=*/ padArrayEnd(avmL2ToL1Msgs, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX), /*publicLogs=*/ FlatPublicLogs.fromLogs(finalPublicLogs), /*publicDataWrites=*/ padArrayEnd(finalPublicDataWrites, PublicDataWrite.empty(), MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX));
+        // Now we finally have enough information to pad the trees.
+        // NOTE(fcarreiro): a bit weird that a method that generates the PIs does this,
+        // but we do need the end tree snapshots. We can consider moving things to the caller.
+        const numNoteHashesToPad = MAX_NOTE_HASHES_PER_TX - avmNoteHashes.length;
+        const numNullifiersToPad = MAX_NULLIFIERS_PER_TX - avmNullifiers.length;
+        await stateManager.padTree(MerkleTreeId.NOTE_HASH_TREE, numNoteHashesToPad);
+        await stateManager.padTree(MerkleTreeId.NULLIFIER_TREE, numNullifiersToPad);
+        const endTreeSnapshots = await stateManager.getTreeSnapshots();
+        // This converts the private accumulated data to the avm accumulated data format.
+        const convertAccumulatedData = (from)=>new PrivateToAvmAccumulatedData(from.noteHashes, from.nullifiers, from.l2ToL1Msgs);
+        const getPreviousAccumulatedDataArrayLengths = (from)=>new PrivateToAvmAccumulatedDataArrayLengths(countAccumulatedItems(from.noteHashes), countAccumulatedItems(from.nullifiers), countAccumulatedItems(from.l2ToL1Msgs));
+        return new AvmCircuitPublicInputs(this.globalVariables, this.protocolContracts, this.startTreeSnapshots, /*startGasUsed=*/ this.gasUsedByPrivate, this.gasSettings, computeEffectiveGasFees(this.globalVariables.gasFees, this.gasSettings), this.feePayer, this.proverId, /*publicCallRequestArrayLengths=*/ new PublicCallRequestArrayLengths(this.setupCallRequests.length, this.appLogicCallRequests.length, this.teardownCallRequests.length > 0), /*publicSetupCallRequests=*/ padArrayEnd(this.setupCallRequests.map((r)=>r.request), PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX), /*publicAppLogicCallRequests=*/ padArrayEnd(this.appLogicCallRequests.map((r)=>r.request), PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX), /*publicTeardownCallRequests=*/ this.teardownCallRequests.length > 0 ? this.teardownCallRequests[0].request : PublicCallRequest.empty(), getPreviousAccumulatedDataArrayLengths(this.nonRevertibleAccumulatedDataFromPrivate), getPreviousAccumulatedDataArrayLengths(this.revertibleAccumulatedDataFromPrivate), convertAccumulatedData(this.nonRevertibleAccumulatedDataFromPrivate), convertAccumulatedData(this.revertibleAccumulatedDataFromPrivate), endTreeSnapshots, this.getTotalGasUsed(), accumulatedDataArrayLengths, accumulatedData, /*transactionFee=*/ this.getTransactionFeeUnsafe(), /*isReverted=*/ !this.revertCode.isOK());
     }
 }
 /**
@@ -283,9 +266,9 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
     txStateManager;
     log;
     currentlyActiveStateManager;
-    constructor(txStateManager){
+    constructor(txStateManager, bindings){
         this.txStateManager = txStateManager;
-        this.log = createLogger(`simulator:public_phase_state_manager`);
+        this.log = createLogger(`simulator:public_phase_state_manager`, bindings);
     }
     async fork() {
         assert(!this.currentlyActiveStateManager, 'Cannot fork when already forked');
@@ -313,8 +296,3 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
         this.currentlyActiveStateManager = undefined;
     }
 }
-/**
- * Apply L2 gas maximum.
- */ function applyMaxToAvailableGas(availableGas) {
-    return new Gas(/*daGas=*/ availableGas.daGas, /*l2Gas=*/ Math.min(availableGas.l2Gas, MAX_L2_GAS_PER_TX_PUBLIC_PORTION));
-}

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

@@ -1,78 +1,53 @@
-import type { AvmProvingRequest, RevertCode } from '@aztec/stdlib/avm';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
+import { PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
-import type { GasUsed } from '@aztec/stdlib/gas';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
-import { type GlobalVariables, NestedProcessReturnValues, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
-import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
-import { ExecutorMetrics } from '../executor_metrics.js';
-import type { WorldStateDB } from '../public_db_sources.js';
+import { Gas } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+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';
-export type ProcessedPhase = {
+import type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
+/** Only used internally. */
+type ProcessedPhase = {
     phase: TxExecutionPhase;
-    durationMs: number;
+    durationMs?: number;
     returnValues: NestedProcessReturnValues[];
     reverted: boolean;
     revertReason?: SimulationError;
 };
-export type PublicTxResult = {
-    avmProvingRequest: AvmProvingRequest;
-    /** Gas used during the execution of this tx */
-    gasUsed: GasUsed;
-    revertCode: RevertCode;
-    /** Revert reason, if any */
-    revertReason?: SimulationError;
-    processedPhases: ProcessedPhase[];
-};
-export declare class PublicTxSimulator {
-    private db;
-    private worldStateDB;
-    private globalVariables;
-    private doMerkleOperations;
-    private skipFeeEnforcement;
-    metrics: ExecutorMetrics;
-    private log;
-    constructor(db: MerkleTreeReadOperations, worldStateDB: WorldStateDB, globalVariables: GlobalVariables, doMerkleOperations?: boolean, skipFeeEnforcement?: boolean, telemetryClient?: TelemetryClient);
-    get tracer(): Tracer;
+export declare class PublicTxSimulator implements PublicTxSimulatorInterface {
+    protected merkleTree: MerkleTreeWriteOperations;
+    protected contractsDB: PublicContractsDB;
+    protected globalVariables: GlobalVariables;
+    protected protocolContracts: ProtocolContracts;
+    protected log: Logger;
+    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 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.
      */
-    private simulateSetupPhase;
-    /**
-     * 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.
-     */
-    private simulateAppLogicPhase;
-    /**
-     * 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.
-     */
-    private simulateTeardownPhase;
-    /**
-     * Simulate a phase of a transaction's public execution.
-     * @param phase - The current phase
-     * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-     * @returns The phase result.
-     */
-    private simulatePhase;
+    protected simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase>;
     /**
      * 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.
      */
-    private simulateEnqueuedCall;
+    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.
@@ -81,22 +56,31 @@ export declare 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.
      */
-    private simulateEnqueuedCallInternal;
+    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.
      */
-    insertNonRevertiblesFromPrivate(context: PublicTxContext): Promise<void>;
+    protected insertNonRevertiblesFromPrivate(context: PublicTxContext): Promise<void>;
     /**
      * 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
+     * - 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.
      */
-    insertRevertiblesFromPrivate(context: PublicTxContext): Promise<boolean>;
+    protected insertRevertiblesFromPrivate(context: PublicTxContext): Promise<void>;
     private payFee;
 }
-//# sourceMappingURL=public_tx_simulator.d.ts.map
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX3R4X3NpbXVsYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9wdWJsaWNfdHhfc2ltdWxhdG9yL3B1YmxpY190eF9zaW11bGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBRSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUd2RixPQUFPLEVBQWdDLHFCQUFxQixFQUFrQixjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN4SCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDdkQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3hDLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckUsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUNwQix5QkFBeUIsRUFDekIsaUJBQWlCLEVBQ2pCLDZCQUE2QixFQUM3QixFQUFFLEVBQ0YsZ0JBQWdCLEVBQ2pCLE1BQU0sa0JBQWtCLENBQUM7QUFJMUIsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUtqRixPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBaUIsTUFBTSx5QkFBeUIsQ0FBQztBQU1oRixPQUFPLEtBQUssRUFBRSw2QkFBNkIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3ZGLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSwwQkFBMEIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBcUNyRiw0QkFBNEI7QUFDNUIsS0FBSyxjQUFjLEdBQUc7SUFDcEIsS0FBSyxFQUFFLGdCQUFnQixDQUFDO0lBQ3hCLFVBQVUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNwQixZQUFZLEVBQUUseUJBQXlCLEVBQUUsQ0FBQztJQUMxQyxRQUFRLEVBQUUsT0FBTyxDQUFDO0lBQ2xCLFlBQVksQ0FBQyxFQUFFLGVBQWUsQ0FBQztDQUNoQyxDQUFDO0FBRUYscUJBQWEsaUJBQWtCLFlBQVcsMEJBQTBCO0lBTWhFLFNBQVMsQ0FBQyxVQUFVLEVBQUUseUJBQXlCO0lBQy9DLFNBQVMsQ0FBQyxXQUFXLEVBQUUsaUJBQWlCO0lBQ3hDLFNBQVMsQ0FBQyxlQUFlLEVBQUUsZUFBZTtJQUUxQyxTQUFTLENBQUMsaUJBQWlCLEVBQUUsaUJBQWlCO0lBVGhELFNBQVMsQ0FBQyxHQUFHLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLFNBQVMsQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLHFCQUFxQixDQUFDO0lBQ2pELFNBQVMsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLEVBQUUsY0FBYyxDQUFDO0lBRTdDLFlBQ1ksVUFBVSxFQUFFLHlCQUF5QixFQUNyQyxXQUFXLEVBQUUsaUJBQWlCLEVBQzlCLGVBQWUsRUFBRSxlQUFlLEVBQzFDLE1BQU0sQ0FBQyxFQUFFLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxFQUM3QixpQkFBaUIsR0FBRSxpQkFBeUMsRUFDdEUsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUsxQjtJQUVEOzs7O09BSUc7SUFDVSxRQUFRLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBNElyRDtJQUVELFNBQVMsQ0FBQyxhQUFhLENBQUMsRUFBRSxFQUFFLEVBQUUscUNBRTdCO0lBRUQ7Ozs7T0FJRztJQUNILFVBQWdCLGFBQWEsQ0FBQyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsT0FBTyxFQUFFLGVBQWUsR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBbUN4RztJQUVEOzs7Ozs7T0FNRztJQUNILFVBQWdCLG9CQUFvQixDQUNsQyxLQUFLLEVBQUUsZ0JBQWdCLEVBQ3ZCLE9BQU8sRUFBRSxlQUFlLEVBQ3hCLFdBQVcsRUFBRSw2QkFBNkIsR0FDekMsT0FBTyxDQUFDLHNCQUFzQixDQUFDLENBK0JqQztJQUVEOzs7Ozs7Ozs7Ozs7T0FZRztJQUNILFVBQWdCLDRCQUE0QixDQUMxQyxZQUFZLEVBQUUsNkJBQTZCLEVBQzNDLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFLDZCQUE2QixFQUNwRCxZQUFZLEVBQUUsR0FBRyxFQUNqQixjQUFjLEVBQUUsRUFBRSxFQUNsQixNQUFNLEVBQUUsTUFBTSxHQUNiLE9BQU8sQ0FBQyxzQkFBc0IsQ0FBQyxDQXFCakM7SUFFRDs7T0FFRztJQUNILFVBQWdCLCtCQUErQixDQUFDLE9BQU8sRUFBRSxlQUFlLGlCQXlCdkU7SUFFRDs7Ozs7Ozs7Ozs7O09BWUc7SUFDSCxVQUFnQiw0QkFBNEIsQ0FBQyxPQUFPLEVBQUUsZUFBZSxpQkEwRXBFO1lBRWEsTUFBTTtDQW1DckIifQ==

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":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAO,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,OAAO,EACL,KAAK,eAAe,EACpB,yBAAyB,EAEzB,EAAE,EACF,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAc,KAAK,eAAe,EAAE,KAAK,MAAM,EAAiC,MAAM,yBAAyB,CAAC;AAQvH,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,gBAAgB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,yBAAyB,EAAE,CAAC;IAC1C,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,+CAA+C;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;IACvB,4BAA4B;IAC5B,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC,CAAC;AAEF,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,kBAAkB;IAT5B,OAAO,EAAE,eAAe,CAAC;IAEzB,OAAO,CAAC,GAAG,CAAS;gBAGV,EAAE,EAAE,wBAAwB,EAC5B,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,eAAe,EAChC,kBAAkB,GAAE,OAAe,EACnC,kBAAkB,GAAE,OAAe,EAC3C,eAAe,GAAE,eAAsC;IAMzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD;;;;OAIG;IACU,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IA0FtD;;;;OAIG;YACW,kBAAkB;IAIhC;;;;OAIG;YACW,qBAAqB;IAkBnC;;;;OAIG;YACW,qBAAqB;IAoBnC;;;;;OAKG;YACW,aAAa;IA0C3B;;;;;;;OAOG;YAOW,oBAAoB;IAoClC;;;;;;;;;;;;;OAaG;YAOW,4BAA4B;IAgD1C;;OAEG;IACU,+BAA+B,CAAC,OAAO,EAAE,eAAe;IAkBrE;;;OAGG;IACU,4BAA4B,CAAC,OAAO,EAAE,eAAe,GAAgB,OAAO,CAAC,OAAO,CAAC;YA+BpF,MAAM;CA+BrB"}
+{"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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"}