@aztec/ethereum 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/queries.ts

@@ -1,7 +1,4 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
-
-import { getContract } from 'viem';
 
 import type { L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
@@ -27,8 +24,7 @@ export async function getL1ContractsConfig(
   const rollupAddress = addresses.rollupAddress ?? (await governanceProposer.getRollupAddress());
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
-  const slasherAddress = await rollup.getSlasher();
-  const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: publicClient });
+  const slasher = await rollup.getSlasherContract();
 
   const [
     l1StartBlock,
@@ -37,8 +33,10 @@ export async function getL1ContractsConfig(
     aztecSlotDuration,
     aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
+    lagInEpochs,
     activationThreshold,
     ejectionThreshold,
+    localEjectionThreshold,
     governanceProposerQuorum,
     governanceProposerRoundSize,
     slashingQuorum,
@@ -48,6 +46,7 @@ export async function getL1ContractsConfig(
     slashingOffsetInRounds,
     slashingAmounts,
     slashingVetoer,
+    slashingDisableDuration,
     manaTarget,
     provingCostPerMana,
     rollupVersion,
@@ -60,8 +59,10 @@ export async function getL1ContractsConfig(
     rollup.getSlotDuration(),
     rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
+    rollup.getLagInEpochs(),
     rollup.getActivationThreshold(),
     rollup.getEjectionThreshold(),
+    rollup.getLocalEjectionThreshold(),
     governanceProposer.getQuorumSize(),
     governanceProposer.getRoundSize(),
     slasherProposer?.getQuorumSize() ?? 0n,
@@ -70,7 +71,8 @@ export async function getL1ContractsConfig(
     slasherProposer?.getExecutionDelayInRounds() ?? 0n,
     slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
     slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
-    slasher.read.VETOER(),
+    slasher?.getVetoer() ?? EthAddress.ZERO,
+    slasher?.getSlashingDisableDuration() ?? 0,
     rollup.getManaTarget(),
     rollup.getProvingCostPerMana(),
     rollup.getVersion(),
@@ -85,16 +87,19 @@ export async function getL1ContractsConfig(
     aztecSlotDuration: Number(aztecSlotDuration),
     aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+    lagInEpochs: Number(lagInEpochs),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
     activationThreshold,
     ejectionThreshold,
+    localEjectionThreshold,
     slashingQuorum: Number(slashingQuorum),
     slashingRoundSizeInEpochs: Number(slashingRoundSize / aztecEpochDuration),
     slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
-    slashingVetoer: EthAddress.fromString(slashingVetoer),
-    manaTarget: manaTarget,
+    slashingVetoer,
+    slashingDisableDuration,
+    manaTarget,
     provingCostPerMana: provingCostPerMana,
     rollupVersion: Number(rollupVersion),
     genesisArchiveTreeRoot,

package/src/test/chain_monitor.ts

@@ -10,10 +10,11 @@ import type { ViemClient } from '../types.js';
 
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
-  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
+  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; l2SlotNumber: number; timestamp: bigint }];
   'l2-block-proven': [{ l2ProvenBlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
   'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
   'l2-epoch': [{ l2EpochNumber: number; timestamp: bigint; committee: EthAddress[] | undefined }];
+  'l2-slot': [{ l2SlotNumber: number; timestamp: bigint }];
 };
 
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
@@ -38,6 +39,8 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
   public totalL2Messages: number = 0;
   /** Current L2 epoch number */
   public l2EpochNumber!: bigint;
+  /** Current L2 slot number */
+  public l2SlotNumber!: bigint;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -99,8 +102,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     }
     this.l1BlockNumber = newL1BlockNumber;
 
-    const block = await this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false });
-    const timestamp = block.timestamp;
+    const [l2SlotNumber, l2Epoch, l1block] = await Promise.all([
+      this.rollup.getSlotNumber(),
+      this.rollup.getCurrentEpoch(),
+      this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false }),
+    ]);
+
+    const timestamp = l1block.timestamp;
     const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
 
     this.emit('l1-block', { l1BlockNumber: newL1BlockNumber, timestamp });
@@ -108,16 +116,21 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
     const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
     if (this.l2BlockNumber !== newL2BlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2BlockNumber));
+      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2BlockNumber));
       msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
       this.l2BlockNumber = newL2BlockNumber;
       this.l2BlockTimestamp = timestamp;
-      this.emit('l2-block', { l2BlockNumber: newL2BlockNumber, l1BlockNumber: newL1BlockNumber, timestamp });
+      this.emit('l2-block', {
+        l2BlockNumber: newL2BlockNumber,
+        l1BlockNumber: newL1BlockNumber,
+        l2SlotNumber: Number(l2SlotNumber),
+        timestamp,
+      });
     }
 
     const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
     if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2ProvenBlockNumber));
+      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2ProvenBlockNumber));
       msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
       this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
       this.l2ProvenBlockTimestamp = timestamp;
@@ -136,14 +149,17 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.emit('l2-messages', { totalL2Messages: newTotalL2Messages, l1BlockNumber: newL1BlockNumber });
     }
 
-    const [l2SlotNumber, l2Epoch] = await Promise.all([this.rollup.getSlotNumber(), this.rollup.getCurrentEpoch()]);
-
     let committee: EthAddress[] | undefined;
     if (l2Epoch !== this.l2EpochNumber) {
       this.l2EpochNumber = l2Epoch;
       committee = (await this.rollup.getCurrentEpochCommittee())?.map(addr => EthAddress.fromString(addr));
       this.emit('l2-epoch', { l2EpochNumber: Number(l2Epoch), timestamp, committee });
-      msg += ` starting new epoch ${this.l2EpochNumber} with committee ${committee?.join(', ') ?? 'undefined'}`;
+      msg += ` starting new epoch ${this.l2EpochNumber} `;
+    }
+
+    if (l2SlotNumber !== this.l2SlotNumber) {
+      this.l2SlotNumber = l2SlotNumber;
+      this.emit('l2-slot', { l2SlotNumber: Number(l2SlotNumber), timestamp });
     }
 
     this.logger.info(msg, {
@@ -160,4 +176,68 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
     return this;
   }
+
+  public waitUntilL2Slot(slot: number | bigint): Promise<void> {
+    const targetSlot = typeof slot === 'bigint' ? slot.valueOf() : slot;
+    if (this.l2SlotNumber >= targetSlot) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l2SlotNumber: number; timestamp: bigint }) => {
+        if (data.l2SlotNumber >= targetSlot) {
+          this.off('l2-slot', listener);
+          resolve();
+        }
+      };
+      this.on('l2-slot', listener);
+    });
+  }
+
+  public waitUntilL1Block(block: number | bigint): Promise<void> {
+    const targetBlock = typeof block === 'bigint' ? block.valueOf() : block;
+    if (this.l1BlockNumber >= targetBlock) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.l1BlockNumber >= targetBlock) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilL1Timestamp(timestamp: number | bigint): Promise<void> {
+    const targetTimestamp = typeof timestamp === 'bigint' ? timestamp.valueOf() : timestamp;
+    if (this.l1BlockNumber >= targetTimestamp) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.timestamp >= targetTimestamp) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilL2Block(l2BlockNumber: number | bigint): Promise<void> {
+    const targetBlock = typeof l2BlockNumber === 'bigint' ? l2BlockNumber.valueOf() : l2BlockNumber;
+    if (this.l2BlockNumber >= targetBlock) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l2BlockNumber: number; timestamp: bigint }) => {
+        if (data.l2BlockNumber >= targetBlock) {
+          this.off('l2-block', listener);
+          resolve();
+        }
+      };
+      this.on('l2-block', listener);
+    });
+  }
 }

package/src/test/delayed_tx_utils.ts

@@ -2,8 +2,8 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 
-import { type L1TxUtilsConfig, createViemSigner } from '../l1_tx_utils.js';
-import { L1TxUtilsWithBlobs } from '../l1_tx_utils_with_blobs.js';
+import { type L1TxUtilsConfig, createViemSigner } from '../l1_tx_utils/index.js';
+import { L1TxUtilsWithBlobs } from '../l1_tx_utils/l1_tx_utils_with_blobs.js';
 import type { ExtendedViemWalletClient } from '../types.js';
 import { type Delayer, withDelayer } from './tx_delayer.js';
 

package/src/test/eth_cheat_codes.ts

@@ -3,9 +3,10 @@ import { keccak256 } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
-import type { TestDateProvider } from '@aztec/foundation/timer';
+import { pluralize } from '@aztec/foundation/string';
+import type { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 
-import { type Hex, createPublicClient, fallback, http } from 'viem';
+import { type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
 
 import type { ViemPublicClient } from '../types.js';
 
@@ -19,6 +20,10 @@ export class EthCheatCodes {
      * The RPC URL to use for interacting with the chain
      */
     public rpcUrls: string[],
+    /**
+     * The date provider to use for time operations
+     */
+    public dateProvider: DateProvider | TestDateProvider,
     /**
      * The logger to use for the eth cheatcodes
      */
@@ -29,9 +34,12 @@ export class EthCheatCodes {
     });
   }
 
-  async rpcCall(method: string, params: any[]) {
-    const paramsString = jsonStringify(params);
-    this.logger.debug(`Calling ${method} with params: ${paramsString} on ${this.rpcUrls.join(', ')}`);
+  public rpcCall(method: string, params: any[]) {
+    this.logger.debug(`Calling ${method} with params: ${jsonStringify(params)} on ${this.rpcUrls.join(', ')}`);
+    return this.doRpcCall(method, params);
+  }
+
+  private async doRpcCall(method: string, params: any[]) {
     return (await this.publicClient.transport.request({
       method,
       params,
@@ -44,7 +52,7 @@ export class EthCheatCodes {
    */
   public async isAutoMining(): Promise<boolean> {
     try {
-      const res = await this.rpcCall('anvil_getAutomine', []);
+      const res = await this.doRpcCall('anvil_getAutomine', []);
       return res;
     } catch (err) {
       this.logger.error(`Calling "anvil_getAutomine" failed with:`, err);
@@ -57,7 +65,7 @@ export class EthCheatCodes {
    * @returns The current block number
    */
   public async blockNumber(): Promise<number> {
-    const res = await this.rpcCall('eth_blockNumber', []);
+    const res = await this.doRpcCall('eth_blockNumber', []);
     return parseInt(res, 16);
   }
 
@@ -66,7 +74,7 @@ export class EthCheatCodes {
    * @returns The current chainId
    */
   public async chainId(): Promise<number> {
-    const res = await this.rpcCall('eth_chainId', []);
+    const res = await this.doRpcCall('eth_chainId', []);
     return parseInt(res, 16);
   }
 
@@ -75,7 +83,7 @@ export class EthCheatCodes {
    * @returns The current timestamp
    */
   public async timestamp(): Promise<number> {
-    const res = await this.rpcCall('eth_getBlockByNumber', ['latest', true]);
+    const res = await this.doRpcCall('eth_getBlockByNumber', ['latest', true]);
     return parseInt(res.timestamp, 16);
   }
 
@@ -90,7 +98,7 @@ export class EthCheatCodes {
 
   private async doMine(numberOfBlocks = 1): Promise<void> {
     try {
-      await this.rpcCall('hardhat_mine', [numberOfBlocks]);
+      await this.doRpcCall('hardhat_mine', [numberOfBlocks]);
     } catch (err) {
       throw new Error(`Error mining: ${err}`);
     }
@@ -101,7 +109,8 @@ export class EthCheatCodes {
    */
   public async evmMine(): Promise<void> {
     try {
-      await this.rpcCall('evm_mine', []);
+      await this.doRpcCall('evm_mine', []);
+      this.logger.warn(`Mined 1 L1 block with evm_mine`);
     } catch (err) {
       throw new Error(`Error mining: ${err}`);
     }
@@ -122,7 +131,7 @@ export class EthCheatCodes {
   }
 
   public async getBalance(account: EthAddress | Hex): Promise<bigint> {
-    const res = await this.rpcCall('eth_getBalance', [account.toString(), 'latest']);
+    const res = await this.doRpcCall('eth_getBalance', [account.toString(), 'latest']);
     return BigInt(res);
   }
 
@@ -158,7 +167,7 @@ export class EthCheatCodes {
    */
   public getIntervalMining(): Promise<number | null> {
     try {
-      return this.rpcCall('anvil_getIntervalMining', []);
+      return this.doRpcCall('anvil_getIntervalMining', []);
     } catch (err) {
       throw new Error(`Error getting interval mining: ${err}`);
     }
@@ -225,12 +234,12 @@ export class EthCheatCodes {
   /**
    * Set the next block timestamp and mines the block.
    * Optionally resets interval mining so the next block is mined in `blockInterval` seconds from now.
-   * Optionally updates a provided date provider to follow L1 time.
+   * Always updates the injected date provider to follow L1 time.
    * @param timestamp - The timestamp to set the next block to
    */
   public async warp(
     timestamp: number | bigint,
-    opts: { silent?: boolean; resetBlockInterval?: boolean; updateDateProvider?: TestDateProvider } = {},
+    opts: { silent?: boolean; resetBlockInterval?: boolean } = {},
   ): Promise<void> {
     let blockInterval: number | null = null;
     try {
@@ -245,8 +254,10 @@ export class EthCheatCodes {
       await this.rpcCall('evm_setNextBlockTimestamp', [Number(timestamp)]);
       // And mine a block so the timestamp goes into effect now
       await this.doMine();
-      // Update the date provider if provided so it follows L1 time
-      opts.updateDateProvider?.setTime(Number(timestamp) * 1000);
+      // Update the injected date provider so it follows L1 time
+      if ('setTime' in this.dateProvider) {
+        this.dateProvider.setTime(Number(timestamp) * 1000);
+      }
     } catch (err) {
       throw new Error(`Error warping: ${err}`);
     } finally {
@@ -277,14 +288,21 @@ export class EthCheatCodes {
    * @param slot - The storage slot
    * @param value - The value to set the storage slot to
    */
-  public async store(contract: EthAddress, slot: bigint, value: bigint): Promise<void> {
+  public async store(
+    contract: EthAddress,
+    slot: bigint,
+    value: bigint,
+    opts: { silent?: boolean } = {},
+  ): Promise<void> {
     // for the rpc call, we need to change value to be a 32 byte hex string.
     try {
       await this.rpcCall('hardhat_setStorageAt', [contract.toString(), toHex(slot), toHex(value, true)]);
     } catch (err) {
       throw new Error(`Error setting storage for contract ${contract} at ${slot}: ${err}`);
     }
-    this.logger.warn(`Set L1 storage for contract ${contract} at ${slot} to ${value}`);
+    if (!opts.silent) {
+      this.logger.warn(`Set L1 storage for contract ${contract} at ${slot} to ${value}`);
+    }
   }
 
   /**
@@ -350,8 +368,7 @@ export class EthCheatCodes {
    * @returns The bytecode for the contract
    */
   public async getBytecode(contract: EthAddress): Promise<`0x${string}`> {
-    const res = await this.rpcCall('eth_getCode', [contract.toString(), 'latest']);
-    return res;
+    return await this.doRpcCall('eth_getCode', [contract.toString(), 'latest']);
   }
 
   /**
@@ -360,8 +377,7 @@ export class EthCheatCodes {
    * @returns The raw transaction
    */
   public async getRawTransaction(txHash: Hex): Promise<`0x${string}`> {
-    const res = await this.rpcCall('debug_getRawTransaction', [txHash]);
-    return res;
+    return await this.doRpcCall('debug_getRawTransaction', [txHash]);
   }
 
   /**
@@ -370,8 +386,7 @@ export class EthCheatCodes {
    * @returns The trace
    */
   public async debugTraceTransaction(txHash: Hex): Promise<any> {
-    const res = await this.rpcCall('debug_traceTransaction', [txHash]);
-    return res;
+    return await this.doRpcCall('debug_traceTransaction', [txHash]);
   }
 
   /**
@@ -389,7 +404,6 @@ export class EthCheatCodes {
    * @param blockNumber - The block number that's going to be the new tip
    */
   public reorgTo(blockNumber: number): Promise<void> {
-    this.logger.info('reorgTo', { blockNumber });
     if (blockNumber <= 0) {
       throw new Error(`Can't reorg to block before genesis: ${blockNumber}`);
     }
@@ -405,6 +419,7 @@ export class EthCheatCodes {
 
       const depth = Number(currentTip - BigInt(blockNumber) + 1n);
       await this.rpcCall('anvil_rollback', [depth]);
+      this.logger.warn(`Reorged L1 chain to block number ${blockNumber} (depth ${depth})`);
     });
   }
 
@@ -431,10 +446,73 @@ export class EthCheatCodes {
   }
 
   public traceTransaction(txHash: Hex): Promise<any> {
-    return this.rpcCall('trace_transaction', [txHash]);
+    return this.doRpcCall('trace_transaction', [txHash]);
+  }
+
+  public async getTxPoolStatus(): Promise<{ pending: number; queued: number }> {
+    const { pending, queued } = await this.doRpcCall('txpool_status', []);
+    return { pending: hexToNumber(pending), queued: hexToNumber(queued) };
+  }
+
+  public async getTxPoolContents(): Promise<TxPoolTransaction[]> {
+    const txpoolContent = await this.doRpcCall('txpool_content', []);
+    return mapTxPoolContent(txpoolContent);
+  }
+
+  /**
+   * Mines an empty block by temporarily removing all pending transactions from the mempool,
+   * mining a block, and then re-adding the transactions back to the pool.
+   */
+  public async mineEmptyBlock(blockCount: number = 1): Promise<void> {
+    await this.execWithPausedAnvil(async () => {
+      // Get all pending and queued transactions from the pool
+      const txs = await this.getTxPoolContents();
+
+      this.logger.debug(`Found ${txs.length} transactions in pool`);
+
+      // Get raw transactions before dropping them
+      const rawTxs: Hex[] = [];
+      for (const tx of txs) {
+        try {
+          const rawTx = await this.doRpcCall('debug_getRawTransaction', [tx.hash]);
+          if (rawTx) {
+            rawTxs.push(rawTx);
+            this.logger.debug(`Got raw tx for ${tx.hash}`);
+          } else {
+            this.logger.warn(`No raw tx found for ${tx.hash}`);
+          }
+        } catch {
+          this.logger.warn(`Failed to get raw transaction for ${tx.hash}`);
+        }
+      }
+
+      this.logger.debug(`Retrieved ${rawTxs.length} raw transactions`);
+
+      // Drop all transactions from the mempool
+      await this.doRpcCall('anvil_dropAllTransactions', []);
+
+      // Mine an empty block
+      await this.doMine(blockCount);
+
+      // Re-add the transactions to the pool
+      for (const rawTx of rawTxs) {
+        try {
+          const txHash = await this.doRpcCall('eth_sendRawTransaction', [rawTx]);
+          this.logger.debug(`Re-added transaction ${txHash}`);
+        } catch (err) {
+          this.logger.warn(`Failed to re-add transaction: ${err}`);
+        }
+      }
+
+      if (rawTxs.length !== txs.length) {
+        this.logger.warn(`Failed to add all txs back: had ${txs.length} but re-added ${rawTxs.length}`);
+      }
+    });
+
+    this.logger.warn(`Mined ${blockCount} empty L1 ${pluralize('block', blockCount)}`);
   }
 
-  public async execWithPausedAnvil(fn: () => Promise<void>): Promise<void> {
+  public async execWithPausedAnvil<T>(fn: () => Promise<T>): Promise<T> {
     const [blockInterval, wasAutoMining] = await Promise.all([this.getIntervalMining(), this.isAutoMining()]);
     try {
       if (blockInterval !== null) {
@@ -445,7 +523,7 @@ export class EthCheatCodes {
         await this.setAutomine(false, { silent: true });
       }
 
-      await fn();
+      return await fn();
     } finally {
       try {
         // restore automine if necessary
@@ -466,4 +544,39 @@ export class EthCheatCodes {
       }
     }
   }
+
+  public async syncDateProvider() {
+    const timestamp = await this.timestamp();
+    if ('setTime' in this.dateProvider) {
+      this.dateProvider.setTime(timestamp * 1000);
+    }
+  }
+}
+
+type TxPoolState = 'pending' | 'queued';
+
+interface TxPoolContent {
+  pending: Record<Hex, Record<string, Transaction>>;
+  queued: Record<Hex, Record<string, Transaction>>;
+}
+
+export type TxPoolTransaction = Transaction & {
+  poolState: TxPoolState;
+};
+
+function mapTxPoolContent(content: TxPoolContent): TxPoolTransaction[] {
+  const result: TxPoolTransaction[] = [];
+
+  const processPool = (pool: Record<Hex, Record<string, Transaction>>, poolState: TxPoolState) => {
+    for (const txsByNonce of Object.values(pool)) {
+      for (const tx of Object.values(txsByNonce)) {
+        result.push({ ...tx, poolState });
+      }
+    }
+  };
+
+  processPool(content.pending, 'pending');
+  processPool(content.queued, 'queued');
+
+  return result;
 }

package/src/test/rollup_cheat_codes.ts

@@ -2,7 +2,7 @@ import { RollupContract, type ViemPublicClient } from '@aztec/ethereum';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import type { TestDateProvider } from '@aztec/foundation/timer';
+import type { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
 import {
@@ -40,8 +40,12 @@ export class RollupCheatCodes {
     });
   }
 
-  static create(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>): RollupCheatCodes {
-    const ethCheatCodes = new EthCheatCodes(rpcUrls);
+  static create(
+    rpcUrls: string[],
+    addresses: Pick<L1ContractAddresses, 'rollupAddress'>,
+    dateProvider: DateProvider,
+  ): RollupCheatCodes {
+    const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
     return new RollupCheatCodes(ethCheatCodes, addresses);
   }
 
@@ -112,14 +116,15 @@ export class RollupCheatCodes {
    * @param opts - Options
    */
   public async advanceToEpoch(
-    epoch: bigint,
+    epoch: bigint | number,
     opts: {
-      /** Optional test date provider to update with the epoch timestamp */
-      updateDateProvider?: TestDateProvider;
+      /** Offset in seconds */
+      offset?: number;
     } = {},
   ) {
     const { epochDuration: slotsInEpoch } = await this.getConfig();
-    const timestamp = await this.rollup.read.getTimestampForSlot([epoch * slotsInEpoch]);
+    const timestamp =
+      (await this.rollup.read.getTimestampForSlot([BigInt(epoch) * slotsInEpoch])) + BigInt(opts.offset ?? 0);
     try {
       await this.ethCheatCodes.warp(Number(timestamp), { ...opts, silent: true, resetBlockInterval: true });
       this.logger.warn(`Warped to epoch ${epoch}`);
@@ -130,19 +135,13 @@ export class RollupCheatCodes {
   }
 
   /** Warps time in L1 until the next epoch */
-  public async advanceToNextEpoch(
-    opts: {
-      /** Optional test date provider to update with the epoch timestamp */
-      updateDateProvider?: TestDateProvider;
-    } = {},
-  ) {
+  public async advanceToNextEpoch() {
     const slot = await this.getSlot();
     const { epochDuration, slotDuration } = await this.getConfig();
     const slotsUntilNextEpoch = epochDuration - (slot % epochDuration) + 1n;
     const timeToNextEpoch = slotsUntilNextEpoch * slotDuration;
     const l1Timestamp = BigInt((await this.client.getBlock()).timestamp);
     await this.ethCheatCodes.warp(Number(l1Timestamp + timeToNextEpoch), {
-      ...opts,
       silent: true,
       resetBlockInterval: true,
     });
@@ -208,6 +207,47 @@ export class RollupCheatCodes {
     });
   }
 
+  /**
+   * Overrides the inProgress field of the Inbox contract state
+   * @param howMuch - How many blocks to move it forward
+   */
+  public advanceInboxInProgress(howMuch: number | bigint): Promise<bigint> {
+    return this.ethCheatCodes.execWithPausedAnvil(async () => {
+      // Storage slot 2 contains the InboxState struct
+      const inboxStateSlot = 2n;
+
+      // Get inbox and its current state values
+      const inboxAddress = await this.rollup.read.getInbox();
+      const currentStateValue = await this.ethCheatCodes.load(EthAddress.fromString(inboxAddress), inboxStateSlot);
+
+      // Extract current values from the packed storage slot
+      // Storage layout: rollingHash (128 bits) | totalMessagesInserted (64 bits) | inProgress (64 bits)
+      const currentRollingHash = currentStateValue & ((1n << 128n) - 1n);
+      const currentTotalMessages = (currentStateValue >> 128n) & ((1n << 64n) - 1n);
+      const currentInProgress = currentStateValue >> 192n;
+      const newInProgress = currentInProgress + BigInt(howMuch);
+
+      // Pack new values: rollingHash (low 128 bits) | totalMessages (middle 64 bits) | inProgress (high 64 bits)
+      const newValue = (BigInt(newInProgress) << 192n) | (currentTotalMessages << 128n) | currentRollingHash;
+
+      await this.ethCheatCodes.store(EthAddress.fromString(inboxAddress), inboxStateSlot, newValue, {
+        silent: true,
+      });
+
+      this.logger.warn(`Inbox inProgress advanced from ${currentInProgress} to ${newInProgress}`, {
+        inbox: inboxAddress,
+        oldValue: '0x' + currentStateValue.toString(16),
+        newValue: '0x' + newValue.toString(16),
+        rollingHash: currentRollingHash,
+        totalMessages: currentTotalMessages,
+        oldInProgress: currentInProgress,
+        newInProgress,
+      });
+
+      return newInProgress;
+    });
+  }
+
   /**
    * Executes an action impersonated as the owner of the Rollup contract.
    * @param action - The action to execute