@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.24de95ac

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

@@ -0,0 +1,41 @@
+import { type Logger } from '@aztec/foundation/log';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import type { GlobalVariables, Tx } from '@aztec/stdlib/tx';
+import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
+import type { PublicContractsDB } from '../public_db_sources.js';
+import { type PublicTxResult, PublicTxSimulator, type PublicTxSimulatorConfig } from './public_tx_simulator.js';
+import type { MeasuredPublicTxSimulatorInterface, PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
+/**
+ * C++ implementation of PublicTxSimulator using pre-collected hints.
+ * This implementation runs TS simulation first to collect all hints,
+ * then passes the complete AvmCircuitInputs (hints + public inputs)
+ * to C++ to run hinted simulation.
+ */
+export declare class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements PublicTxSimulatorInterface {
+    protected log: Logger;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, config?: Partial<PublicTxSimulatorConfig>);
+    /**
+     * Simulate a transaction's public portion using the C++ vm2 simulator with hinted DBs.
+     *
+     * This implementation:
+     * 1. Runs the full TypeScript simulation to generate AvmCircuitInputs (hints + public inputs)
+     * 2. Passes the complete AvmCircuitInputs to C++ to run hinted simulation
+     *
+     * @param tx - The transaction to simulate.
+     * @returns The result of the transaction's public execution.
+     */
+    simulate(tx: Tx): Promise<PublicTxResult>;
+}
+/**
+ * Class to record metrics for simulation.
+ *
+ * Note(dbanks12): We might not be able to collect all the same metrics in C++ as we do in TS!
+ * Unless we move some of the metrics collection to C++, we don't have inner functions exposed
+ * to TS for tracking.
+ */
+export declare class MeasuredCppPublicTxSimulatorHintedDbs extends CppPublicTxSimulatorHintedDbs implements MeasuredPublicTxSimulatorInterface {
+    protected readonly metrics: ExecutorMetricsInterface;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicTxSimulatorConfig>);
+    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
+}
+//# sourceMappingURL=cpp_public_tx_simulator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cpp_public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/cpp_public_tx_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,iBAAiB,EAAE,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAChH,OAAO,KAAK,EACV,kCAAkC,EAClC,0BAA0B,EAC3B,MAAM,oCAAoC,CAAC;AAE5C;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,iBAAkB,YAAW,0BAA0B;IACxG,UAAmB,GAAG,EAAE,MAAM,CAAC;gBAG7B,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC;IAM3C;;;;;;;;;OASG;IACmB,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;CAkDhE;AAED;;;;;;GAMG;AACH,qBAAa,qCACX,SAAQ,6BACR,YAAW,kCAAkC;IAM3C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wBAAwB;gBAHpD,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACb,OAAO,EAAE,wBAAwB,EACpD,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC;IAKrB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC;CAUjG"}

package/dest/public/public_tx_simulator/cpp_public_tx_simulator.js

@@ -0,0 +1,89 @@
+import { createLogger } from '@aztec/foundation/log';
+import { avmSimulateWithHintedDbs } from '@aztec/native';
+import { deserializeFromMessagePack } from '@aztec/stdlib/avm';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { PublicTxSimulator } from './public_tx_simulator.js';
+/**
+ * C++ implementation of PublicTxSimulator using pre-collected hints.
+ * This implementation runs TS simulation first to collect all hints,
+ * then passes the complete AvmCircuitInputs (hints + public inputs)
+ * to C++ to run hinted simulation.
+ */ export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator {
+    log;
+    constructor(merkleTree, contractsDB, globalVariables, config){
+        super(merkleTree, contractsDB, globalVariables, config);
+        this.log = createLogger(`simulator:cpp_public_tx_simulator_hinted_dbs`);
+    }
+    /**
+   * Simulate a transaction's public portion using the C++ vm2 simulator with hinted DBs.
+   *
+   * This implementation:
+   * 1. Runs the full TypeScript simulation to generate AvmCircuitInputs (hints + public inputs)
+   * 2. Passes the complete AvmCircuitInputs to C++ to run hinted simulation
+   *
+   * @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++ hinted DB simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
+            txHash
+        });
+        // First, run TS simulation to generate hints and public inputs
+        this.log.debug(`Running TS simulation for tx ${txHash}`);
+        let tsResult;
+        try {
+            // Run the full TypeScript simulation using the parent class
+            // This will modify the merkle tree with the transaction's state changes
+            tsResult = await super.simulate(tx);
+            this.log.debug(`TS simulation succeeded for tx ${txHash}`);
+        } catch (error) {
+            // If TS simulation fails, clear any partial contract additions and re-throw the error
+            this.contractsDB.clearContractsForTx();
+            throw error;
+        }
+        // Extract the full AvmCircuitInputs from the TS result
+        const avmCircuitInputs = tsResult.avmProvingRequest.inputs;
+        // Second, run C++ simulation with hinted DBs
+        this.log.debug(`Running C++ simulation with hinted DBs for tx ${txHash}`);
+        // Serialize to msgpack and call the C++ simulator
+        const inputBuffer = avmCircuitInputs.serializeWithMessagePack();
+        let resultBuffer;
+        try {
+            resultBuffer = await avmSimulateWithHintedDbs(inputBuffer);
+        } catch (error) {
+            throw new SimulationError(`C++ hinted simulation failed: ${error.message}`, []);
+        }
+        // Deserialize the msgpack result
+        const _success = deserializeFromMessagePack(resultBuffer);
+        this.log.debug(`C++ hinted simulation completed for tx ${txHash}`, {
+            txHash,
+            reverted: !tsResult.revertCode.isOK(),
+            tsGasUsed: tsResult.gasUsed.totalGas.l2Gas,
+            cppGasUsed: tsResult.gasUsed.totalGas.l2Gas
+        });
+        // TODO(dbanks12): C++ should return PublicTxResult (or something similar)
+        return tsResult;
+    }
+}
+/**
+ * Class to record metrics for simulation.
+ *
+ * Note(dbanks12): We might not be able to collect all the same metrics in C++ as we do in TS!
+ * Unless we move some of the metrics collection to C++, we don't have inner functions exposed
+ * to TS for tracking.
+ */ export class MeasuredCppPublicTxSimulatorHintedDbs extends CppPublicTxSimulatorHintedDbs {
+    metrics;
+    constructor(merkleTree, contractsDB, globalVariables, metrics, config){
+        super(merkleTree, contractsDB, globalVariables, config), this.metrics = metrics;
+    }
+    async simulate(tx, txLabel = 'unlabeledTx') {
+        this.metrics.startRecordingTxSimulation(txLabel);
+        let result;
+        try {
+            result = await super.simulate(tx);
+        } finally{
+            this.metrics.stopRecordingTxSimulation(txLabel, result?.revertCode);
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './public_tx_simulator.js';
+export type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
+export { TelemetryPublicTxSimulator } from './telemetry_public_tx_simulator.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,YAAY,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC"}

package/dest/public/public_tx_simulator/index.js

@@ -0,0 +1,2 @@
+export * from './public_tx_simulator.js';
+export { TelemetryPublicTxSimulator } from './telemetry_public_tx_simulator.js';

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

@@ -0,0 +1,24 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { Gas } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { type GlobalVariables, PublicCallRequestWithCalldata, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import type { ExecutorMetricsInterface } from '../executor_metrics_interface.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 ProcessedPhase, type PublicTxResult, PublicTxSimulator, type PublicTxSimulatorConfig } from './public_tx_simulator.js';
+import type { MeasuredPublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
+/**
+ * A public tx simulator that tracks miscellaneous simulation metrics without telemetry.
+ */
+export declare class MeasuredPublicTxSimulator extends PublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
+    protected readonly metrics: ExecutorMetricsInterface;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicTxSimulatorConfig>);
+    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
+    protected insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<void>;
+    protected insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<void>;
+    protected simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase>;
+    protected simulateEnqueuedCallInternal(stateManager: PublicPersistableStateManager, callRequest: PublicCallRequestWithCalldata, allocatedGas: Gas, transactionFee: Fr, fnName: string): Promise<AvmFinalizedCallResult>;
+}
+//# sourceMappingURL=measured_public_tx_simulator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measured_public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/measured_public_tx_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAE,6BAA6B,EAAE,EAAE,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAE7G,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AACvF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,iBAAiB,EACjB,KAAK,uBAAuB,EAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,oCAAoC,CAAC;AAE7F;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,iBAAkB,YAAW,kCAAkC;IAK1G,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wBAAwB;gBAHpD,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACb,OAAO,EAAE,wBAAwB,EACpD,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC;IAKrB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC;cAWvE,+BAA+B,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,EAAE;cAMhE,4BAA4B,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,EAAE;cAM7D,aAAa,CAAC,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;cAOzF,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;CAsCnC"}

package/dest/public/public_tx_simulator/measured_public_tx_simulator.js

@@ -0,0 +1,51 @@
+import { Timer } from '@aztec/foundation/timer';
+import { PublicTxSimulator } from './public_tx_simulator.js';
+/**
+ * A public tx simulator that tracks miscellaneous simulation metrics without telemetry.
+ */ export class MeasuredPublicTxSimulator extends PublicTxSimulator {
+    metrics;
+    constructor(merkleTree, contractsDB, globalVariables, metrics, config){
+        super(merkleTree, contractsDB, globalVariables, config), this.metrics = metrics;
+    }
+    async simulate(tx, txLabel = 'unlabeledTx') {
+        this.metrics.startRecordingTxSimulation(txLabel);
+        let avmResult;
+        try {
+            avmResult = await super.simulate(tx);
+        } finally{
+            this.metrics.stopRecordingTxSimulation(txLabel, avmResult?.revertCode);
+        }
+        return avmResult;
+    }
+    async insertNonRevertiblesFromPrivate(context, tx) {
+        const timer = new Timer();
+        await super.insertNonRevertiblesFromPrivate(context, tx);
+        this.metrics.recordPrivateEffectsInsertion(timer.us(), 'non-revertible');
+    }
+    async insertRevertiblesFromPrivate(context, tx) {
+        const timer = new Timer();
+        await super.insertRevertiblesFromPrivate(context, tx);
+        this.metrics.recordPrivateEffectsInsertion(timer.us(), 'revertible');
+    }
+    async simulatePhase(phase, context) {
+        const timer = new Timer();
+        const result = await super.simulatePhase(phase, context);
+        result.durationMs = timer.ms();
+        return result;
+    }
+    async simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName) {
+        const timer = new Timer();
+        const result = await super.simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName);
+        this.log.verbose(result.reverted ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason?.message}.` : `Simulation of enqueued public call ${fnName} completed successfully.`, {
+            eventName: 'avm-simulation',
+            appCircuitName: fnName,
+            duration: timer.ms()
+        });
+        if (result.reverted) {
+            this.metrics.recordEnqueuedCallSimulationFailure(fnName, timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, result.totalInstructions);
+        } else {
+            this.metrics.recordEnqueuedCallSimulation(fnName, timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, result.totalInstructions);
+        }
+        return result;
+    }
+}

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

@@ -1,50 +1,48 @@
 import { Fr } from '@aztec/foundation/fields';
-import { type AvmProvingRequest, RevertCode } from '@aztec/stdlib/avm';
+import { AvmCircuitPublicInputs, RevertCode } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { SimulationError } from '@aztec/stdlib/errors';
-import { Gas, GasSettings } from '@aztec/stdlib/gas';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
-import { type PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
-import { type GlobalVariables, type PublicExecutionRequest, type StateReference, type Tx, TxExecutionPhase, type TxHash } from '@aztec/stdlib/tx';
-import { AvmPersistableStateManager } from '../avm/index.js';
-import type { WorldStateDB } from '../public_db_sources.js';
-import { SideEffectTrace } from '../side_effect_trace.js';
+import { Gas } from '@aztec/stdlib/gas';
+import { PrivateToPublicAccumulatedData } from '@aztec/stdlib/kernel';
+import { type GlobalVariables, ProtocolContracts, PublicCallRequestWithCalldata, type Tx, TxExecutionPhase, type TxHash } from '@aztec/stdlib/tx';
+import type { PublicContractsDBInterface } from '../db_interfaces.js';
+import type { PublicTreesDB } from '../public_db_sources.js';
+import { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 /**
  * The transaction-level context for public execution.
  */
 export declare class PublicTxContext {
     readonly txHash: TxHash;
     readonly state: PhaseStateManager;
+    private readonly startTreeSnapshots;
     private readonly globalVariables;
-    private readonly startStateReference;
+    private readonly protocolContracts;
+    private readonly proverId;
     private readonly gasSettings;
     private readonly gasUsedByPrivate;
     private readonly gasAllocatedToPublic;
+    private readonly gasAllocatedToPublicTeardown;
     private readonly setupCallRequests;
     private readonly appLogicCallRequests;
     private readonly teardownCallRequests;
-    private readonly setupExecutionRequests;
-    private readonly appLogicExecutionRequests;
-    private readonly teardownExecutionRequests;
     readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData;
     readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData;
     readonly feePayer: AztecAddress;
-    trace: SideEffectTrace;
+    private readonly trace;
     private log;
     private gasUsedByPublic;
     teardownGasUsed: Gas;
     private halted;
     private revertCode;
     revertReason: SimulationError | undefined;
-    avmProvingRequest: AvmProvingRequest | undefined;
-    constructor(txHash: TxHash, state: PhaseStateManager, globalVariables: GlobalVariables, startStateReference: StateReference, gasSettings: GasSettings, gasUsedByPrivate: Gas, gasAllocatedToPublic: Gas, setupCallRequests: PublicCallRequest[], appLogicCallRequests: PublicCallRequest[], teardownCallRequests: PublicCallRequest[], setupExecutionRequests: PublicExecutionRequest[], appLogicExecutionRequests: PublicExecutionRequest[], teardownExecutionRequests: PublicExecutionRequest[], nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData, revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData, feePayer: AztecAddress, trace: SideEffectTrace);
-    static create(db: MerkleTreeReadOperations, worldStateDB: WorldStateDB, tx: Tx, globalVariables: GlobalVariables, doMerkleOperations: boolean): Promise<PublicTxContext>;
+    private constructor();
+    static create(treesDB: PublicTreesDB, contractsDB: PublicContractsDBInterface, tx: Tx, globalVariables: GlobalVariables, protocolContracts: ProtocolContracts, doMerkleOperations: boolean, proverId: Fr): Promise<PublicTxContext>;
     /**
      * 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.
      */
-    halt(): Promise<void>;
+    halt(): void;
     /**
      * Revert execution a phase. Populate revertReason & revertCode.
      * If in setup, throw an error (transaction will be thrown out).
@@ -63,11 +61,7 @@ export declare class PublicTxContext {
     /**
      * Get the call requests for the specified phase (including args hashes).
      */
-    getCallRequestsForPhase(phase: TxExecutionPhase): PublicCallRequest[];
-    /**
-     * Get the call requests for the specified phase (including actual args).
-     */
-    getExecutionRequestsForPhase(phase: TxExecutionPhase): PublicExecutionRequest[];
+    getCallRequestsForPhase(phase: TxExecutionPhase): PublicCallRequestWithCalldata[];
     /**
      * How much gas is left as of the specified phase?
      */
@@ -106,11 +100,7 @@ export declare class PublicTxContext {
     /**
      * Generate the public inputs for the AVM circuit.
      */
-    private generateAvmCircuitPublicInputs;
-    /**
-     * Generate the proving request for the AVM circuit.
-     */
-    generateProvingRequest(endStateReference: StateReference): Promise<AvmProvingRequest>;
+    generateAvmCircuitPublicInputs(): Promise<AvmCircuitPublicInputs>;
 }
 /**
  * Thin wrapper around the state manager to handle forking and merging for phases.
@@ -126,9 +116,9 @@ declare class PhaseStateManager {
     private readonly txStateManager;
     private log;
     private currentlyActiveStateManager;
-    constructor(txStateManager: AvmPersistableStateManager);
+    constructor(txStateManager: PublicPersistableStateManager);
     fork(): Promise<void>;
-    getActiveStateManager(): AvmPersistableStateManager;
+    getActiveStateManager(): PublicPersistableStateManager;
     isForked(): boolean;
     mergeForkedState(): Promise<void>;
     discardForkedState(): Promise<void>;

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

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

package/dest/public/public_tx_simulator/public_tx_context.js

@@ -1,36 +1,36 @@
-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 { 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 { 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;
     nonRevertibleAccumulatedDataFromPrivate;
     revertibleAccumulatedDataFromPrivate;
     feePayer;
@@ -41,21 +41,20 @@ 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, nonRevertibleAccumulatedDataFromPrivate, revertibleAccumulatedDataFromPrivate, feePayer, trace){
         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.nonRevertibleAccumulatedDataFromPrivate = nonRevertibleAccumulatedDataFromPrivate;
         this.revertibleAccumulatedDataFromPrivate = revertibleAccumulatedDataFromPrivate;
         this.feePayer = feePayer;
@@ -66,27 +65,24 @@ import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js
         this.revertCode = RevertCode.OK;
         this.log = createLogger(`simulator:public_tx_context`);
     }
-    static async create(db, worldStateDB, tx, globalVariables, doMerkleOperations) {
+    static async create(treesDB, contractsDB, tx, globalVariables, protocolContracts, doMerkleOperations, proverId) {
         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();
         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, doMerkleOperations, firstNullifier, globalVariables.timestamp);
         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), await txStateManager.getTreeSnapshots(), globalVariables, protocolContracts, proverId, gasSettings, gasUsedByPrivate, gasAllocatedToPublic, gasAllocatedToPublicTeardown, getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP), getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.APP_LOGIC), getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.TEARDOWN), tx.data.forPublic.nonRevertibleAccumulatedData, tx.data.forPublic.revertibleAccumulatedData, tx.data.feePayer, trace);
     }
     /**
    * 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 +90,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,11 +98,6 @@ 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) {
@@ -149,22 +140,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;
@@ -228,46 +208,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());
     }
 }
 /**
@@ -313,8 +290,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));
-}