@aztec/simulator 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -3,7 +3,6 @@ import {
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -28,11 +27,12 @@ import {
   PublicCallRequestArrayLengths,
   countAccumulatedItems,
 } from '@aztec/stdlib/kernel';
-import { PublicLog } from '@aztec/stdlib/logs';
+import { FlatPublicLogs } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type GlobalVariables,
+  ProtocolContracts,
   PublicCallRequestWithCalldata,
   TreeSnapshots,
   type Tx,
@@ -71,6 +71,8 @@ export class PublicTxContext {
     public readonly state: PhaseStateManager,
     private readonly startTreeSnapshots: TreeSnapshots,
     private readonly globalVariables: GlobalVariables,
+    private readonly protocolContracts: ProtocolContracts,
+    private readonly proverId: Fr,
     private readonly gasSettings: GasSettings,
     private readonly gasUsedByPrivate: Gas,
     private readonly gasAllocatedToPublic: Gas,
@@ -91,7 +93,9 @@ export class PublicTxContext {
     contractsDB: PublicContractsDBInterface,
     tx: Tx,
     globalVariables: GlobalVariables,
+    protocolContracts: ProtocolContracts,
     doMerkleOperations: boolean,
+    proverId: Fr,
   ) {
     const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic!.nonRevertibleAccumulatedData;
 
@@ -119,6 +123,8 @@ export class PublicTxContext {
       new PhaseStateManager(txStateManager),
       await txStateManager.getTreeSnapshots(),
       globalVariables,
+      protocolContracts,
+      proverId,
       gasSettings,
       gasUsedByPrivate,
       gasAllocatedToPublic,
@@ -331,7 +337,6 @@ export class PublicTxContext {
       avmNoteHashes.length,
       avmNullifiers.length,
       avmL2ToL1Msgs.length,
-      finalPublicLogs.length,
       finalPublicDataWrites.length,
     );
 
@@ -347,7 +352,7 @@ export class PublicTxContext {
         MAX_NULLIFIERS_PER_TX,
       ),
       /*l2ToL1Msgs=*/ padArrayEnd(avmL2ToL1Msgs, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
-      /*publicLogs=*/ padArrayEnd(finalPublicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_TX),
+      /*publicLogs=*/ FlatPublicLogs.fromLogs(finalPublicLogs),
       /*publicDataWrites=*/ padArrayEnd(
         finalPublicDataWrites,
         PublicDataWrite.empty(),
@@ -376,11 +381,13 @@ export class PublicTxContext {
 
     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,

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -1,7 +1,7 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
+import { AVM_MAX_PROCESSABLE_L2_GAS, DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ProtocolContractAddress, ProtocolContractsList } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import {
   AvmCircuitInputs,
@@ -13,6 +13,7 @@ import {
 } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
 import type { Gas, GasUsed } from '@aztec/stdlib/gas';
+import type { DebugLog } from '@aztec/stdlib/logs';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import {
@@ -23,13 +24,22 @@ import {
   TxExecutionPhase,
 } from '@aztec/stdlib/tx';
 
+import { strict as assert } from 'assert';
+
 import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
 import { AvmSimulator } from '../avm/index.js';
 import { getPublicFunctionDebugName } from '../debug_fn_name.js';
 import { HintingMerkleWriteOperations, HintingPublicContractsDB } from '../hinting_db_sources.js';
 import { type PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
+import {
+  L2ToL1MessageLimitReachedError,
+  NoteHashLimitReachedError,
+  NullifierCollisionError,
+  NullifierLimitReachedError,
+} from '../side_effect_errors.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';
 
 export type ProcessedPhase = {
   phase: TxExecutionPhase;
@@ -47,19 +57,69 @@ export type PublicTxResult = {
   /** Revert reason, if any */
   revertReason?: SimulationError;
   processedPhases: ProcessedPhase[];
+  logs: DebugLog[];
+};
+
+export type PublicTxSimulatorConfig = {
+  proverId: Fr;
+  doMerkleOperations: boolean;
+  skipFeeEnforcement: boolean;
+  clientInitiatedSimulation: boolean;
+  maxDebugLogMemoryReads: number;
 };
 
-export class PublicTxSimulator {
+// The errors below are only thrown here in the public tx simulator,
+// and only during revertible phases (revertible insertions, app logic and teardown).
+// These are strictly "checked" errors (not exported and never propagated).
+// They are used internally for control flow to trigger rollbacks to the post-setup state.
+
+/**
+ * Error thrown when public tx simulation reverts in a known/checked way during revertible insertions.
+ */
+class TxSimRevertibleInsertionsRevert extends Error {
+  constructor() {
+    super('Public Tx Simulation reverted during Revertible Insertions');
+    this.name = 'TxSimRevertibleInsertionsRevert';
+  }
+}
+
+/**
+ * Error thrown when public tx simulation reverts during app logic.
+ */
+class TxSimAppLogicRevert extends Error {
+  constructor() {
+    super('Public Tx Simulation reverted during App Logic');
+    this.name = 'TxSimAppLogicRevert';
+  }
+}
+
+/**
+ * Error thrown when public tx simulation reverts during teardown.
+ */
+class TxSimTeardownRevert extends Error {
+  constructor() {
+    super('Public Tx Simulation reverted during Teardown');
+    this.name = 'TxSimTeardownRevert';
+  }
+}
+
+export class PublicTxSimulator implements PublicTxSimulatorInterface {
   protected log: Logger;
+  private config: PublicTxSimulatorConfig;
 
   constructor(
-    private merkleTree: MerkleTreeWriteOperations,
-    private contractsDB: PublicContractsDB,
-    private globalVariables: GlobalVariables,
-    private doMerkleOperations: boolean = false,
-    private skipFeeEnforcement: boolean = false,
-    private clientInitiatedSimulation: boolean = false,
+    protected merkleTree: MerkleTreeWriteOperations,
+    protected contractsDB: PublicContractsDB,
+    protected globalVariables: GlobalVariables,
+    config?: Partial<PublicTxSimulatorConfig>,
   ) {
+    this.config = {
+      proverId: config?.proverId ?? Fr.ZERO,
+      doMerkleOperations: config?.doMerkleOperations ?? false,
+      skipFeeEnforcement: config?.skipFeeEnforcement ?? false,
+      clientInitiatedSimulation: config?.clientInitiatedSimulation ?? false,
+      maxDebugLogMemoryReads: config?.maxDebugLogMemoryReads ?? DEFAULT_MAX_DEBUG_LOG_MEMORY_READS,
+    };
     this.log = createLogger(`simulator:public_tx_simulator`);
   }
 
@@ -74,7 +134,11 @@ export class PublicTxSimulator {
       this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, { txHash });
 
       // Create hinting DBs.
-      const hints = new AvmExecutionHints(this.globalVariables, AvmTxHint.fromTx(tx, this.globalVariables.gasFees));
+      const hints = new AvmExecutionHints(
+        this.globalVariables,
+        AvmTxHint.fromTx(tx, this.globalVariables.gasFees),
+        ProtocolContractsList, // imported from file
+      );
       const hintingMerkleTree = await HintingMerkleWriteOperations.create(this.merkleTree, hints);
       const hintingTreesDB = new PublicTreesDB(hintingMerkleTree);
       const hintingContractsDB = new HintingPublicContractsDB(this.contractsDB, hints);
@@ -84,7 +148,9 @@ export class PublicTxSimulator {
         hintingContractsDB,
         tx,
         this.globalVariables,
-        this.doMerkleOperations,
+        ProtocolContractsList, // imported from file
+        this.config.doMerkleOperations,
+        this.config.proverId,
       );
 
       // This will throw if there is a nullifier collision.
@@ -108,23 +174,28 @@ export class PublicTxSimulator {
       await context.state.fork();
 
       try {
-        // This will throw if there is a nullifier collision.
+        // This will throw if there is a nullifier collision or other insertion error (limit reached).
         await this.insertRevertiblesFromPrivate(context, tx);
+
         // 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 Error(`App logic phase reverted! ${appLogicResult.revertReason?.message}`);
+            throw new TxSimAppLogicRevert();
           }
         }
-      } catch (e) {
-        this.log.debug(String(e));
-        // We revert to the post-setup state.
-        await context.state.discardForkedState();
-        // 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();
+      } catch (e: any) {
+        if (e instanceof TxSimRevertibleInsertionsRevert || e instanceof TxSimAppLogicRevert) {
+          // We revert to the post-setup state.
+          await context.state.discardForkedState();
+          // 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();
+        } else {
+          // Unchecked/unknown error - re-throw as-is
+          throw e;
+        }
       }
 
       try {
@@ -132,25 +203,28 @@ export class PublicTxSimulator {
           const teardownResult = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
           processedPhases.push(teardownResult);
           if (teardownResult.reverted) {
-            throw new Error(`Teardown phase reverted! ${teardownResult.revertReason?.message}`);
+            throw new TxSimTeardownRevert();
           }
         }
-
         // We commit the forked state and we are done.
         await context.state.mergeForkedState();
-      } catch (e) {
-        this.log.debug(String(e));
-        // We rollback to the post-setup state.
-        await context.state.discardForkedState();
+      } catch (e: any) {
+        if (e instanceof TxSimTeardownRevert) {
+          // We revert to the post-setup state and we are done.
+          await context.state.discardForkedState();
+        } else {
+          // Unchecked/unknown error - re-throw as-is
+          throw e;
+        }
       }
 
       context.halt();
 
-      if (context.getActualGasUsed().l2Gas > AVM_MAX_PROCESSABLE_L2_GAS) {
-        throw new Error(
-          `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the AVM maximum processable gas of ${AVM_MAX_PROCESSABLE_L2_GAS}`,
-        );
-      }
+      // Such transactions should be filtered by GasTxValidator.
+      assert(
+        context.getActualGasUsed().l2Gas <= AVM_MAX_PROCESSABLE_L2_GAS,
+        `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the AVM maximum processable gas of ${AVM_MAX_PROCESSABLE_L2_GAS}`,
+      );
       await this.payFee(context);
 
       const publicInputs = await context.generateAvmCircuitPublicInputs();
@@ -176,6 +250,7 @@ export class PublicTxSimulator {
         revertCode,
         revertReason: context.revertReason,
         processedPhases: processedPhases,
+        logs: context.state.getActiveStateManager().getLogs(),
       };
     } finally {
       // Make sure there are no new contracts in the tx-level cache.
@@ -308,7 +383,8 @@ export class PublicTxSimulator {
       request.isStaticCall,
       calldata,
       allocatedGas,
-      this.clientInitiatedSimulation,
+      this.config.clientInitiatedSimulation,
+      this.config.maxDebugLogMemoryReads,
     );
     const avmCallResult = await simulator.execute();
     return avmCallResult.finalize();
@@ -345,42 +421,85 @@ export class PublicTxSimulator {
 
   /**
    * Insert the revertible accumulated data from private into the public state.
-   * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
+   * Throws TxSimRevertibleInsertionsRevert if there is some checked error during revertible insertions.
+   * This function checks for the following errors:
+   * - NullifierLimitReachedError
+   * - NullifierCollisionError
+   * - NoteHashLimitReachedError
+   * - L2ToL1MessageLimitReachedError
    */
-  protected async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): /*success=*/ Promise<boolean> {
+  protected async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
     const stateManager = context.state.getActiveStateManager();
 
     try {
       for (const siloedNullifier of context.revertibleAccumulatedDataFromPrivate.nullifiers.filter(n => !n.isEmpty())) {
         await stateManager.writeSiloedNullifier(siloedNullifier);
       }
-    } catch (e) {
-      context.revert(
-        TxExecutionPhase.APP_LOGIC,
-        new SimulationError(
-          `Nullifier collision encountered when inserting revertible nullifiers from private.\nDetails: ${String(e)}`,
-          [],
-        ),
-      );
-      throw e;
+    } catch (e: any) {
+      if (e instanceof NullifierLimitReachedError || e instanceof NullifierCollisionError) {
+        context.revert(
+          TxExecutionPhase.APP_LOGIC,
+          new SimulationError(
+            `Error encountered when inserting revertible nullifiers from private.\nDetails: ${e.message}`,
+            [],
+          ),
+        );
+        throw new TxSimRevertibleInsertionsRevert();
+      } else {
+        // Unchecked/unknown error - re-throw as-is
+        throw e;
+      }
     }
-    for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes) {
-      if (!noteHash.isEmpty()) {
-        // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
-        await stateManager.writeSiloedNoteHash(noteHash);
+
+    try {
+      for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes) {
+        if (!noteHash.isEmpty()) {
+          // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
+          await stateManager.writeSiloedNoteHash(noteHash);
+        }
+      }
+    } catch (e: any) {
+      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;
       }
     }
-    for (const l2ToL1Message of context.revertibleAccumulatedDataFromPrivate.l2ToL1Msgs) {
-      if (!l2ToL1Message.isEmpty()) {
-        stateManager.writeScopedL2ToL1Message(l2ToL1Message);
+
+    try {
+      for (const l2ToL1Message of context.revertibleAccumulatedDataFromPrivate.l2ToL1Msgs) {
+        if (!l2ToL1Message.isEmpty()) {
+          stateManager.writeScopedL2ToL1Message(l2ToL1Message);
+        }
+      }
+    } catch (e: any) {
+      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 hinted contracts db.
     // However things should work as they are now because the hinted db would still pick up the new contracts.
     await this.contractsDB.addNewRevertibleContracts(tx);
-
-    return /*success=*/ true;
   }
 
   private async payFee(context: PublicTxContext) {
@@ -402,13 +521,12 @@ export class PublicTxSimulator {
     // When mocking the balance of the fee payer, the circuit should not be able to prove the simulation
 
     if (currentBalance.lt(txFee)) {
-      if (!this.skipFeeEnforcement) {
-        throw new Error(
-          `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`,
-        );
-      } else {
-        currentBalance = txFee;
-      }
+      // Without "skipFeeEnforcement", such transactions should be filtered by GasTxValidator.
+      assert(
+        this.config.skipFeeEnforcement,
+        `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`,
+      );
+      currentBalance = txFee;
     }
 
     const updatedBalance = currentBalance.sub(txFee);

package/src/public/public_tx_simulator/public_tx_simulator_interface.ts

@@ -0,0 +1,11 @@
+import type { Tx } from '@aztec/stdlib/tx';
+
+import type { PublicTxResult } from './public_tx_simulator.js';
+
+export interface PublicTxSimulatorInterface {
+  simulate(tx: Tx): Promise<PublicTxResult>;
+}
+
+export interface MeasuredPublicTxSimulatorInterface {
+  simulate(tx: Tx, txLabel: string): Promise<PublicTxResult>;
+}

package/src/public/public_tx_simulator/telemetry_public_tx_simulator.ts

@@ -10,6 +10,7 @@ import type { PublicContractsDB } from '../public_db_sources.js';
 import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { MeasuredPublicTxSimulator } from './measured_public_tx_simulator.js';
 import { PublicTxContext } from './public_tx_context.js';
+import type { PublicTxSimulatorConfig } from './public_tx_simulator.js';
 
 /**
  * A public tx simulator that tracks runtime/production metrics with telemetry.
@@ -22,21 +23,11 @@ export class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
     merkleTree: MerkleTreeWriteOperations,
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
-    doMerkleOperations: boolean = false,
-    skipFeeEnforcement: boolean = false,
-    clientInitiatedSimulation: boolean = false,
     telemetryClient: TelemetryClient = getTelemetryClient(),
+    config?: Partial<PublicTxSimulatorConfig>,
   ) {
     const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
-    super(
-      merkleTree,
-      contractsDB,
-      globalVariables,
-      doMerkleOperations,
-      skipFeeEnforcement,
-      clientInitiatedSimulation,
-      metrics,
-    );
+    super(merkleTree, contractsDB, globalVariables, metrics, config);
     this.tracer = metrics.tracer;
   }
 

package/src/public/side_effect_errors.ts

@@ -1,6 +1,96 @@
-export class SideEffectLimitReachedError extends Error {
+import {
+  L1_TO_L2_MSG_TREE_LEAF_COUNT,
+  MAX_L2_TO_L1_MSGS_PER_TX,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+  NOTE_HASH_TREE_LEAF_COUNT,
+} from '@aztec/constants';
+
+import { CheckedPublicExecutionError } from './public_errors.js';
+
+/**
+ * Any error that can be thrown during side effect insertion in public.
+ * Includes SideEffectLimitReachedError and NullifierCollisionError.
+ */
+export abstract class SideEffectError extends CheckedPublicExecutionError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SideEffectInsertionError';
+  }
+}
+
+export class SideEffectLimitReachedError extends SideEffectError {
   constructor(sideEffectType: string, limit: number) {
     super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
     this.name = 'SideEffectLimitReachedError';
   }
 }
+
+export class MaxCallsToUniqueContractClassIdsError extends SideEffectLimitReachedError {
+  constructor() {
+    super('contract calls to unique class IDs', MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS);
+    this.name = 'MaxCallsToUniqueContractClassIdsError';
+  }
+}
+
+export class NullifierLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('nullifier', MAX_NULLIFIERS_PER_TX);
+    this.name = 'NullifierLimitReachedError';
+  }
+}
+
+export class NoteHashLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('note hash', MAX_NOTE_HASHES_PER_TX);
+    this.name = 'NoteHashLimitReachedError';
+  }
+}
+
+export class L2ToL1MessageLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+    this.name = 'L2ToL1MessageLimitReachedError';
+  }
+}
+
+export class NullifierCollisionError extends SideEffectError {
+  constructor(message: string) {
+    super(`Nullifier collision: ${message}`);
+    this.name = 'NullifierCollisionError';
+  }
+}
+
+/**
+ * Any error that can be thrown during side effect reads in public.
+ * Note: Thrown at state manager level and unknown by simulation, hence NOT considered
+ * CheckedPublicExecutionErrors. Currently only includes append-only tree reads.
+ */
+export abstract class SideEffectReadError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SideEffectReadError';
+  }
+}
+
+export class IndexOutOfRangeError extends SideEffectReadError {
+  constructor(tree: string, index: number, limit: number) {
+    super(`Attempting to read index ${index} of ${tree} tree with maximum ${limit} leaves`);
+    this.name = 'IndexOutOfRangeError';
+  }
+}
+
+export class NoteHashIndexOutOfRangeError extends IndexOutOfRangeError {
+  constructor(index: number) {
+    super('note hash', index, NOTE_HASH_TREE_LEAF_COUNT);
+    this.name = 'NoteHashIndexOutOfRangeError';
+  }
+}
+
+export class L1ToL2MessageIndexOutOfRangeError extends IndexOutOfRangeError {
+  constructor(index: number) {
+    super('l1 to l2 message', index, L1_TO_L2_MSG_TREE_LEAF_COUNT);
+    this.name = 'L1ToL2MessageIndexOutOfRangeError';
+  }
+}