@aztec/ethereum 1.2.1 → 2.0.0-nightly.20250813

package/dest/test/chain_monitor.js

@@ -1,14 +1,17 @@
 import { InboxContract } from '@aztec/ethereum/contracts';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { DateProvider } from '@aztec/foundation/timer';
 import { EventEmitter } from 'events';
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */ export class ChainMonitor extends EventEmitter {
     rollup;
+    dateProvider;
     logger;
     intervalMs;
     l1Client;
     inbox;
     handle;
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
     running;
     /** Current L1 block number */ l1BlockNumber;
     /** Current L2 block number */ l2BlockNumber;
@@ -16,8 +19,8 @@ import { EventEmitter } from 'events';
     /** L1 timestamp for the current L2 block */ l2BlockTimestamp;
     /** L1 timestamp for the proven L2 block */ l2ProvenBlockTimestamp;
     /** Total number of L2 messages pushed into the Inbox */ totalL2Messages;
-    constructor(rollup, logger = createLogger('aztecjs:utils:chain_monitor'), intervalMs = 200){
-        super(), this.rollup = rollup, this.logger = logger, this.intervalMs = intervalMs, this.running = new Set(), this.totalL2Messages = 0;
+    constructor(rollup, dateProvider = new DateProvider(), logger = createLogger('aztecjs:utils:chain_monitor'), intervalMs = 200){
+        super(), this.rollup = rollup, this.dateProvider = dateProvider, this.logger = logger, this.intervalMs = intervalMs, this.running = new Set(), this.totalL2Messages = 0;
         this.l1Client = rollup.client;
     }
     start() {
@@ -111,10 +114,16 @@ import { EventEmitter } from 'events';
                 l1BlockNumber: newL1BlockNumber
             });
         }
+        const [l2SlotNumber, l2Epoch] = await Promise.all([
+            this.rollup.getSlotNumber(),
+            this.rollup.getCurrentEpoch()
+        ]);
         this.logger.info(msg, {
+            currentTimestamp: this.dateProvider.nowInSeconds(),
             l1Timestamp: timestamp,
             l1BlockNumber: this.l1BlockNumber,
-            l2SlotNumber: await this.rollup.getSlotNumber(),
+            l2SlotNumber,
+            l2Epoch,
             l2BlockNumber: this.l2BlockNumber,
             l2ProvenBlockNumber: this.l2ProvenBlockNumber,
             totalL2Messages: this.totalL2Messages

package/dest/test/delayed_tx_utils.js

@@ -3,7 +3,7 @@ import { withDelayer } from './tx_delayer.js';
 export class DelayedTxUtils extends L1TxUtilsWithBlobs {
     delayer;
     static fromL1TxUtils(l1TxUtils, ethereumSlotDuration) {
-        const { client, delayer } = withDelayer(l1TxUtils.client, {
+        const { client, delayer } = withDelayer(l1TxUtils.client, l1TxUtils.dateProvider, {
             ethereumSlotDuration
         });
         const casted = l1TxUtils;
@@ -12,7 +12,7 @@ export class DelayedTxUtils extends L1TxUtilsWithBlobs {
         return casted;
     }
     enableDelayer(ethereumSlotDuration) {
-        const { client, delayer } = withDelayer(this.client, {
+        const { client, delayer } = withDelayer(this.client, this.dateProvider, {
             ethereumSlotDuration
         });
         this.delayer = delayer;

package/dest/{eth_cheat_codes.d.ts → test/eth_cheat_codes.d.ts}

@@ -79,12 +79,16 @@ export declare class EthCheatCodes {
      * Enable interval mining at the given interval (block time)
      * @param seconds - The interval to use between blocks
      */
-    setIntervalMining(seconds: number): Promise<void>;
+    setIntervalMining(seconds: number, opts?: {
+        silent?: boolean;
+    }): Promise<void>;
     /**
      * Set the automine status of the underlying anvil chain
      * @param automine - The automine status to set
      */
-    setAutomine(automine: boolean): Promise<void>;
+    setAutomine(automine: boolean, opts?: {
+        silent?: boolean;
+    }): Promise<void>;
     /**
      * Drop a transaction from the mempool
      * @param txHash - The transaction hash
@@ -94,7 +98,7 @@ export declare class EthCheatCodes {
      * Set the next block timestamp
      * @param timestamp - The timestamp to set the next block to
      */
-    setNextBlockTimestamp(timestamp: number): Promise<void>;
+    setNextBlockTimestamp(timestamp: number | Date): Promise<void>;
     /**
      * Set the next block timestamp and mines the block.
      * Optionally resets interval mining so the next block is mined in `blockInterval` seconds from now.
@@ -184,6 +188,6 @@ export declare class EthCheatCodes {
         value?: number | bigint;
     })[][]): Promise<void>;
     traceTransaction(txHash: Hex): Promise<any>;
-    private execWithPausedAnvil;
+    execWithPausedAnvil(fn: () => Promise<void>): Promise<void>;
 }
 //# sourceMappingURL=eth_cheat_codes.d.ts.map

package/dest/test/eth_cheat_codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eth_cheat_codes.d.ts","sourceRoot":"","sources":["../../src/test/eth_cheat_codes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,KAAK,GAAG,EAAsC,MAAM,MAAM,CAAC;AAIpE;;GAEG;AACH,qBAAa,aAAa;IAGtB;;OAEG;IACI,OAAO,EAAE,MAAM,EAAE;IACxB;;OAEG;IACI,MAAM;IATf,OAAO,CAAC,YAAY,CAAmB;;IAErC;;OAEG;IACI,OAAO,EAAE,MAAM,EAAE;IACxB;;OAEG;IACI,MAAM,yCAAuC;IAOhD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE;IAS3C;;;OAGG;IACU,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAU7C;;;OAGG;IACU,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAK3C;;;OAGG;IACU,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAKvC;;;OAGG;IACU,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAKzC;;;OAGG;IACU,IAAI,CAAC,cAAc,SAAI,GAAG,OAAO,CAAC,IAAI,CAAC;YAKtC,MAAM;IAQpB;;OAEG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQrC;;;;OAIG;IACU,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5E;;;OAGG;IACU,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS9D;;;OAGG;IACU,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/E;;;OAGG;IACI,iBAAiB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAQlD;;;OAGG;IACU,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAW/F;;;OAGG;IACU,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAW3F;;;OAGG;IACU,eAAe,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IASxD;;;OAGG;IACU,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAW3E;;;;;OAKG;IACU,IAAI,CACf,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAAC,kBAAkB,CAAC,EAAE,gBAAgB,CAAA;KAAO,GACnG,OAAO,CAAC,IAAI,CAAC;IA6BhB;;;;;OAKG;IACU,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKtE;;;;;OAKG;IACU,KAAK,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUpF;;;;;OAKG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAMvD;;;OAGG;IACU,kBAAkB,CAAC,GAAG,EAAE,UAAU,GAAG,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IASrE;;;OAGG;IACU,iBAAiB,CAAC,GAAG,EAAE,UAAU,GAAG,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IASpE;;;;OAIG;IACU,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/E;;;;OAIG;IACU,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC;IAKtE;;;;OAIG;IACU,iBAAiB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC;IAKnE;;;;OAIG;IACU,qBAAqB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAK7D;;;OAGG;IACI,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1C;;;OAGG;IACI,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBlD;;;;;OAKG;IACU,oBAAoB,CAC/B,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,CAAC,GAAG,GAAG;QAAE,EAAE,EAAE,UAAU,GAAG,GAAG,CAAC;QAAC,KAAK,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,UAAU,GAAG,GAAG,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,EAAE,EAAO,GAClH,OAAO,CAAC,IAAI,CAAC;IAaT,gBAAgB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAIrC,mBAAmB,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAgCzE"}

package/dest/{eth_cheat_codes.js → test/eth_cheat_codes.js}

@@ -143,7 +143,7 @@ import { createPublicClient, fallback, http } from 'viem';
     /**
    * Enable interval mining at the given interval (block time)
    * @param seconds - The interval to use between blocks
-   */ async setIntervalMining(seconds) {
+   */ async setIntervalMining(seconds, opts = {}) {
         try {
             await this.rpcCall('anvil_setIntervalMining', [
                 seconds
@@ -151,12 +151,14 @@ import { createPublicClient, fallback, http } from 'viem';
         } catch (err) {
             throw new Error(`Error setting interval mining: ${err}`);
         }
-        this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
+        if (!opts.silent) {
+            this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
+        }
     }
     /**
    * Set the automine status of the underlying anvil chain
    * @param automine - The automine status to set
-   */ async setAutomine(automine) {
+   */ async setAutomine(automine, opts = {}) {
         try {
             await this.rpcCall('anvil_setAutomine', [
                 automine
@@ -164,7 +166,9 @@ import { createPublicClient, fallback, http } from 'viem';
         } catch (err) {
             throw new Error(`Error setting automine: ${err}`);
         }
-        this.logger.warn(`Set L1 automine to ${automine}`);
+        if (!opts.silent) {
+            this.logger.warn(`Set L1 automine to ${automine}`);
+        }
     }
     /**
    * Drop a transaction from the mempool
@@ -185,7 +189,7 @@ import { createPublicClient, fallback, http } from 'viem';
    */ async setNextBlockTimestamp(timestamp) {
         try {
             await this.rpcCall('evm_setNextBlockTimestamp', [
-                timestamp
+                timestamp instanceof Date ? Math.floor(timestamp.getTime() / 1000) : timestamp
             ]);
         } catch (err) {
             throw new Error(`Error setting next block timestamp: ${err.message}`);
@@ -204,7 +208,9 @@ import { createPublicClient, fallback, http } from 'viem';
             if (opts.resetBlockInterval) {
                 blockInterval = await this.getIntervalMining();
                 if (blockInterval !== null) {
-                    await this.setIntervalMining(0);
+                    await this.setIntervalMining(0, {
+                        silent: true
+                    });
                 }
             }
             // Set the timestamp of the next block to be mined
@@ -220,7 +226,9 @@ import { createPublicClient, fallback, http } from 'viem';
         } finally{
             // Restore interval mining so the next block is mined in `blockInterval` seconds from this one
             if (opts.resetBlockInterval && blockInterval !== null && blockInterval > 0) {
-                await this.setIntervalMining(blockInterval);
+                await this.setIntervalMining(blockInterval, {
+                    silent: true
+                });
             }
         }
         if (!opts.silent) {
@@ -410,17 +418,23 @@ import { createPublicClient, fallback, http } from 'viem';
         ]);
         try {
             if (blockInterval !== null) {
-                await this.setIntervalMining(0);
+                await this.setIntervalMining(0, {
+                    silent: true
+                });
             }
             if (wasAutoMining) {
-                await this.setAutomine(false);
+                await this.setAutomine(false, {
+                    silent: true
+                });
             }
             await fn();
         } finally{
             try {
                 // restore automine if necessary
                 if (wasAutoMining) {
-                    await this.setAutomine(true);
+                    await this.setAutomine(true, {
+                        silent: true
+                    });
                 }
             } catch (err) {
                 this.logger.warn(`Failed to reenable automining: ${err}`);
@@ -428,7 +442,9 @@ import { createPublicClient, fallback, http } from 'viem';
             try {
                 // restore automine if necessary
                 if (blockInterval !== null) {
-                    await this.setIntervalMining(blockInterval);
+                    await this.setIntervalMining(blockInterval, {
+                        silent: true
+                    });
                 }
             } catch (err) {
                 this.logger.warn(`Failed to reenable interval mining: ${err}`);

package/dest/test/eth_cheat_codes_with_state.d.ts

@@ -1,4 +1,4 @@
-import { EthCheatCodes } from '../eth_cheat_codes.js';
+import { EthCheatCodes } from './eth_cheat_codes.js';
 /**
  * A class that provides utility functions for interacting with ethereum (L1) dumping/loading state to/from a file.
  * It is separated to avoid importing fs in the main EthCheatCodes class, which might be used in the browser.

package/dest/test/eth_cheat_codes_with_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eth_cheat_codes_with_state.d.ts","sourceRoot":"","sources":["../../src/test/eth_cheat_codes_with_state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACvD;;;OAGG;IACU,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW5D;;;OAGG;IACU,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAS7D"}
+{"version":3,"file":"eth_cheat_codes_with_state.d.ts","sourceRoot":"","sources":["../../src/test/eth_cheat_codes_with_state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACvD;;;OAGG;IACU,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW5D;;;OAGG;IACU,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAS7D"}

package/dest/test/eth_cheat_codes_with_state.js

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { EthCheatCodes } from '../eth_cheat_codes.js';
+import { EthCheatCodes } from './eth_cheat_codes.js';
 /**
  * A class that provides utility functions for interacting with ethereum (L1) dumping/loading state to/from a file.
  * It is separated to avoid importing fs in the main EthCheatCodes class, which might be used in the browser.

package/dest/test/index.d.ts

@@ -1,7 +1,9 @@
 export * from './delayed_tx_utils.js';
+export * from './eth_cheat_codes.js';
 export * from './eth_cheat_codes_with_state.js';
 export * from './start_anvil.js';
 export * from './tx_delayer.js';
 export * from './upgrade_utils.js';
 export * from './chain_monitor.js';
+export * from './rollup_cheat_codes.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/test/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC"}

package/dest/test/index.js

@@ -1,6 +1,8 @@
 export * from './delayed_tx_utils.js';
+export * from './eth_cheat_codes.js';
 export * from './eth_cheat_codes_with_state.js';
 export * from './start_anvil.js';
 export * from './tx_delayer.js';
 export * from './upgrade_utils.js';
 export * from './chain_monitor.js';
+export * from './rollup_cheat_codes.js';

package/dest/test/rollup_cheat_codes.d.ts

@@ -0,0 +1,81 @@
+import { type ViemPublicClient } from '@aztec/ethereum';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { TestDateProvider } from '@aztec/foundation/timer';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { type GetContractReturnType, type Hex } from 'viem';
+import { EthCheatCodes } from './eth_cheat_codes.js';
+/** Cheat codes for the L1 rollup contract. */
+export declare class RollupCheatCodes {
+    private ethCheatCodes;
+    private client;
+    private rollup;
+    private logger;
+    constructor(ethCheatCodes: EthCheatCodes, addresses: Pick<L1ContractAddresses, 'rollupAddress'>);
+    static create(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>): RollupCheatCodes;
+    /** Returns the current slot */
+    getSlot(): Promise<bigint>;
+    /** Returns the current epoch */
+    getEpoch(): Promise<bigint>;
+    /**
+     * Returns the pending and proven chain tips
+     * @returns The pending and proven chain tips
+     */
+    getTips(): Promise<{
+        /** The pending chain tip */ pending: bigint;
+        /** The proven chain tip */ proven: bigint;
+    }>;
+    /**
+     * Logs the current state of the rollup contract.
+     */
+    debugRollup(): Promise<void>;
+    /** Fetches the epoch and slot duration config from the rollup contract */
+    getConfig(): Promise<{
+        /** Epoch duration */ epochDuration: bigint;
+        /** Slot duration */ slotDuration: bigint;
+    }>;
+    /**
+     * Advances time to the beginning of the given epoch
+     * @param epoch - The epoch to advance to
+     * @param opts - Options
+     */
+    advanceToEpoch(epoch: bigint, opts?: {
+        /** Optional test date provider to update with the epoch timestamp */
+        updateDateProvider?: TestDateProvider;
+    }): Promise<bigint>;
+    /** Warps time in L1 until the next epoch */
+    advanceToNextEpoch(): Promise<void>;
+    /** Warps time in L1 until the beginning of the next slot. */
+    advanceToNextSlot(): Promise<bigint[]>;
+    /**
+     * Warps time in L1 equivalent to however many slots.
+     * @param howMany - The number of slots to advance.
+     */
+    advanceSlots(howMany: number): Promise<void>;
+    /**
+     * Marks the specified block (or latest if none) as proven
+     * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
+     */
+    markAsProven(maybeBlockNumber?: number | bigint): Promise<void>;
+    /**
+     * Executes an action impersonated as the owner of the Rollup contract.
+     * @param action - The action to execute
+     */
+    asOwner(action: (owner: Hex, rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>) => Promise<void>): Promise<void>;
+    /**
+     * Sets up the epoch.
+     */
+    setupEpoch(): Promise<void>;
+    /** Directly calls the L1 gas fee oracle. */
+    updateL1GasFeeOracle(): Promise<void>;
+    /**
+     * Bumps proving cost per mana.
+     * @param bumper - Callback to calculate the new proving cost per mana based on current value.
+     */
+    bumpProvingCostPerMana(bumper: (before: bigint) => bigint): Promise<void>;
+    /**
+     * Directly updates proving cost per mana.
+     * @param ethValue - The new proving cost per mana in ETH
+     */
+    setProvingCostPerMana(ethValue: bigint): Promise<void>;
+}
+//# sourceMappingURL=rollup_cheat_codes.d.ts.map

package/dest/test/rollup_cheat_codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup_cheat_codes.d.ts","sourceRoot":"","sources":["../../src/test/rollup_cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAGjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE1D,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,GAAG,EAMT,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,8CAA8C;AAC9C,qBAAa,gBAAgB;IAOzB,OAAO,CAAC,aAAa;IANvB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAA4D;IAE1E,OAAO,CAAC,MAAM,CAAuC;gBAG3C,aAAa,EAAE,aAAa,EACpC,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC;IAavD,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,GAAG,gBAAgB;IAKzG,+BAA+B;IAClB,OAAO;IAKpB,gCAAgC;IACnB,QAAQ;IAKrB;;;OAGG;IACU,OAAO,IAAI,OAAO,CAAC;QAC9B,4BAA4B,CAAC,OAAO,EAAE,MAAM,CAAC;QAC7C,2BAA2B,CAAC,MAAM,EAAE,MAAM,CAAC;KAC5C,CAAC;IAQF;;OAEG;IACU,WAAW;IAmBxB,0EAA0E;IAC7D,SAAS,IAAI,OAAO,CAAC;QAChC,qBAAqB,CAAC,aAAa,EAAE,MAAM,CAAC;QAC5C,oBAAoB,CAAC,YAAY,EAAE,MAAM,CAAC;KAC3C,CAAC;IAQF;;;;OAIG;IACU,cAAc,CACzB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE;QACJ,qEAAqE;QACrE,kBAAkB,CAAC,EAAE,gBAAgB,CAAC;KAClC;IAaR,4CAA4C;IAC/B,kBAAkB;IAU/B,6DAA6D;IAChD,iBAAiB;IAQ9B;;;OAGG;IACU,YAAY,CAAC,OAAO,EAAE,MAAM;IASzC;;;OAGG;IACI,YAAY,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM;IAiCtD;;;OAGG;IACU,OAAO,CAClB,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,qBAAqB,CAAC,OAAO,SAAS,EAAE,gBAAgB,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC;IAQ1G;;OAEG;IACU,UAAU;IASvB,4CAA4C;IAC/B,oBAAoB;IAQjC;;;OAGG;IACU,sBAAsB,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM;IAMtE;;;OAGG;IACU,qBAAqB,CAAC,QAAQ,EAAE,MAAM;CAOpD"}

package/dest/test/rollup_cheat_codes.js

@@ -0,0 +1,234 @@
+import { RollupContract } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { createPublicClient, fallback, getContract, hexToBigInt, http } from 'viem';
+import { foundry } from 'viem/chains';
+import { EthCheatCodes } from './eth_cheat_codes.js';
+/** Cheat codes for the L1 rollup contract. */ export class RollupCheatCodes {
+    ethCheatCodes;
+    client;
+    rollup;
+    logger;
+    constructor(ethCheatCodes, addresses){
+        this.ethCheatCodes = ethCheatCodes;
+        this.logger = createLogger('aztecjs:cheat_codes');
+        this.client = createPublicClient({
+            chain: foundry,
+            transport: fallback(ethCheatCodes.rpcUrls.map((url)=>http(url)))
+        });
+        this.rollup = getContract({
+            abi: RollupAbi,
+            address: addresses.rollupAddress.toString(),
+            client: this.client
+        });
+    }
+    static create(rpcUrls, addresses) {
+        const ethCheatCodes = new EthCheatCodes(rpcUrls);
+        return new RollupCheatCodes(ethCheatCodes, addresses);
+    }
+    /** Returns the current slot */ async getSlot() {
+        const ts = BigInt((await this.client.getBlock()).timestamp);
+        return await this.rollup.read.getSlotAt([
+            ts
+        ]);
+    }
+    /** Returns the current epoch */ async getEpoch() {
+        const slotNumber = await this.getSlot();
+        return await this.rollup.read.getEpochAtSlot([
+            slotNumber
+        ]);
+    }
+    /**
+   * Returns the pending and proven chain tips
+   * @returns The pending and proven chain tips
+   */ async getTips() {
+        const res = await this.rollup.read.getTips();
+        return {
+            pending: res.pendingBlockNumber,
+            proven: res.provenBlockNumber
+        };
+    }
+    /**
+   * Logs the current state of the rollup contract.
+   */ async debugRollup() {
+        const rollup = new RollupContract(this.client, this.rollup.address);
+        const pendingNum = await rollup.getBlockNumber();
+        const provenNum = await rollup.getProvenBlockNumber();
+        const validators = await rollup.getAttesters();
+        const committee = await rollup.getCurrentEpochCommittee();
+        const archive = await rollup.archive();
+        const slot = await this.getSlot();
+        const epochNum = await rollup.getEpochNumberForSlotNumber(slot);
+        this.logger.info(`Pending block num: ${pendingNum}`);
+        this.logger.info(`Proven block num: ${provenNum}`);
+        this.logger.info(`Validators: ${validators.map((v)=>v.toString()).join(', ')}`);
+        this.logger.info(`Committee: ${committee?.map((v)=>v.toString()).join(', ')}`);
+        this.logger.info(`Archive: ${archive}`);
+        this.logger.info(`Epoch num: ${epochNum}`);
+        this.logger.info(`Slot: ${slot}`);
+    }
+    /** Fetches the epoch and slot duration config from the rollup contract */ async getConfig() {
+        const [epochDuration, slotDuration] = await Promise.all([
+            this.rollup.read.getEpochDuration(),
+            this.rollup.read.getSlotDuration()
+        ]);
+        return {
+            epochDuration,
+            slotDuration
+        };
+    }
+    /**
+   * Advances time to the beginning of the given epoch
+   * @param epoch - The epoch to advance to
+   * @param opts - Options
+   */ async advanceToEpoch(epoch, opts = {}) {
+        const { epochDuration: slotsInEpoch } = await this.getConfig();
+        const timestamp = await this.rollup.read.getTimestampForSlot([
+            epoch * slotsInEpoch
+        ]);
+        try {
+            await this.ethCheatCodes.warp(Number(timestamp), {
+                ...opts,
+                silent: true,
+                resetBlockInterval: true
+            });
+            this.logger.warn(`Warped to epoch ${epoch}`);
+        } catch (err) {
+            this.logger.warn(`Warp to epoch ${epoch} failed: ${err}`);
+        }
+        return timestamp;
+    }
+    /** Warps time in L1 until the next epoch */ 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), {
+            silent: true,
+            resetBlockInterval: true
+        });
+        this.logger.warn(`Advanced to next epoch`);
+    }
+    /** Warps time in L1 until the beginning of the next slot. */ async advanceToNextSlot() {
+        const currentSlot = await this.getSlot();
+        const timestamp = await this.rollup.read.getTimestampForSlot([
+            currentSlot + 1n
+        ]);
+        await this.ethCheatCodes.warp(Number(timestamp), {
+            silent: true,
+            resetBlockInterval: true
+        });
+        this.logger.warn(`Advanced to slot ${currentSlot + 1n}`);
+        return [
+            timestamp,
+            currentSlot + 1n
+        ];
+    }
+    /**
+   * Warps time in L1 equivalent to however many slots.
+   * @param howMany - The number of slots to advance.
+   */ async advanceSlots(howMany) {
+        const l1Timestamp = (await this.client.getBlock()).timestamp;
+        const slotDuration = await this.rollup.read.getSlotDuration();
+        const timeToWarp = BigInt(howMany) * slotDuration;
+        await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, {
+            silent: true,
+            resetBlockInterval: true
+        });
+        const [slot, epoch] = await Promise.all([
+            this.getSlot(),
+            this.getEpoch()
+        ]);
+        this.logger.warn(`Advanced ${howMany} slots up to slot ${slot} in epoch ${epoch}`);
+    }
+    /**
+   * Marks the specified block (or latest if none) as proven
+   * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
+   */ markAsProven(maybeBlockNumber) {
+        return this.ethCheatCodes.execWithPausedAnvil(async ()=>{
+            const tipsBefore = await this.getTips();
+            const { pending, proven } = tipsBefore;
+            let blockNumber = maybeBlockNumber;
+            if (blockNumber === undefined || blockNumber > pending) {
+                blockNumber = pending;
+            }
+            if (blockNumber <= proven) {
+                this.logger.debug(`Block ${blockNumber} is already proven`);
+                return;
+            }
+            // @note @LHerskind this is heavily dependent on the storage layout and size of values
+            // The rollupStore is a struct and if the size of elements or the struct changes, this can break
+            const provenBlockNumberSlot = hexToBigInt(RollupContract.stfStorageSlot);
+            // Need to pack it as a single 32 byte word
+            const newValue = BigInt(tipsBefore.pending) << 128n | BigInt(blockNumber);
+            await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenBlockNumberSlot, newValue);
+            const tipsAfter = await this.getTips();
+            if (tipsAfter.pending < tipsAfter.proven) {
+                throw new Error('Overwrote pending tip to a block in the past');
+            }
+            this.logger.info(`Proven tip moved: ${tipsBefore.proven} -> ${tipsAfter.proven}. Pending tip: ${tipsAfter.pending}.`);
+        });
+    }
+    /**
+   * Executes an action impersonated as the owner of the Rollup contract.
+   * @param action - The action to execute
+   */ async asOwner(action) {
+        const owner = await this.rollup.read.owner();
+        await this.ethCheatCodes.startImpersonating(owner);
+        await action(owner, this.rollup);
+        await this.ethCheatCodes.stopImpersonating(owner);
+    }
+    /**
+   * Sets up the epoch.
+   */ async setupEpoch() {
+        // Doesn't need to be done as owner, but the functionality is here...
+        await this.asOwner(async (account, rollup)=>{
+            const hash = await rollup.write.setupEpoch({
+                account
+            });
+            await this.client.waitForTransactionReceipt({
+                hash
+            });
+            this.logger.warn(`Setup epoch`);
+        });
+    }
+    /** Directly calls the L1 gas fee oracle. */ async updateL1GasFeeOracle() {
+        await this.asOwner(async (account, rollup)=>{
+            const hash = await rollup.write.updateL1GasFeeOracle({
+                account,
+                chain: this.client.chain
+            });
+            await this.client.waitForTransactionReceipt({
+                hash
+            });
+            this.logger.warn(`Updated L1 gas fee oracle`);
+        });
+    }
+    /**
+   * Bumps proving cost per mana.
+   * @param bumper - Callback to calculate the new proving cost per mana based on current value.
+   */ async bumpProvingCostPerMana(bumper) {
+        const currentCost = await this.rollup.read.getProvingCostPerManaInEth();
+        const newCost = bumper(currentCost);
+        await this.setProvingCostPerMana(newCost);
+    }
+    /**
+   * Directly updates proving cost per mana.
+   * @param ethValue - The new proving cost per mana in ETH
+   */ async setProvingCostPerMana(ethValue) {
+        await this.asOwner(async (account, rollup)=>{
+            const hash = await rollup.write.setProvingCostPerMana([
+                ethValue
+            ], {
+                account,
+                chain: this.client.chain
+            });
+            await this.client.waitForTransactionReceipt({
+                hash
+            });
+            this.logger.warn(`Updated proving cost per mana to ${ethValue}`);
+        });
+    }
+}

package/dest/test/start_anvil.d.ts

@@ -5,6 +5,7 @@ import { type Anvil } from '@viem/anvil';
 export declare function startAnvil(opts?: {
     port?: number;
     l1BlockTime?: number;
+    log?: boolean;
     captureMethodCalls?: boolean;
     accounts?: number;
 }): Promise<{

package/dest/test/start_anvil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start_anvil.d.ts","sourceRoot":"","sources":["../../src/test/start_anvil.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,aAAa,CAAC;AAGtD;;GAEG;AACH,wBAAsB,UAAU,CAC9B,IAAI,GAAE;IACJ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,GACL,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAyC9F"}
+{"version":3,"file":"start_anvil.d.ts","sourceRoot":"","sources":["../../src/test/start_anvil.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,aAAa,CAAC;AAGtD;;GAEG;AACH,wBAAsB,UAAU,CAC9B,IAAI,GAAE;IACJ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,GACL,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CA+C9F"}

package/dest/test/start_anvil.js

@@ -1,3 +1,4 @@
+import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { fileURLToPath } from '@aztec/foundation/url';
 import { createAnvil } from '@viem/anvil';
@@ -6,6 +7,7 @@ import { dirname, resolve } from 'path';
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */ export async function startAnvil(opts = {}) {
     const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
+    const logger = opts.log ? createLogger('ethereum:anvil') : undefined;
     const methodCalls = opts.captureMethodCalls ? [] : undefined;
     let port;
     // Start anvil.
@@ -21,13 +23,16 @@ import { dirname, resolve } from 'path';
         });
         // Listen to the anvil output to get the port.
         const removeHandler = anvil.on('message', (message)=>{
+            logger?.debug(message.trim());
             methodCalls?.push(...message.match(/eth_[^\s]+/g) || []);
             if (port === undefined && message.includes('Listening on')) {
                 port = parseInt(message.match(/Listening on ([^:]+):(\d+)/)[2]);
             }
         });
         await anvil.start();
-        removeHandler();
+        if (!logger && !opts.captureMethodCalls) {
+            removeHandler();
+        }
         return anvil;
     }, 'Start anvil', makeBackoff([
         5,

package/dest/test/tx_delayer.d.ts

@@ -1,4 +1,5 @@
 import { type Logger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
 import { type Client, type Hex } from 'viem';
 import { type ViemClient } from '../types.js';
 export declare function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger): Promise<boolean>;
@@ -14,13 +15,19 @@ export interface Delayer {
     pauseNextTxUntilTimestamp(l1Timestamp: number | bigint | undefined): void;
     /** Delays the next tx to be sent indefinitely. */
     cancelNextTx(): void;
+    /**
+     * Sets max inclusion time into slot. If more than this many seconds have passed
+     * since the last L1 block was mined, then any tx will not be mined in the current
+     * L1 slot but will be deferred for the next one.
+     */
+    setMaxInclusionTimeIntoSlot(seconds: number | bigint | undefined): void;
 }
 /**
  * Returns a new client (without modifying the one passed in) with an injected tx delayer.
  * The delayer can be used to hold off the next tx to be sent until a given block number.
  * TODO(#10824): This doesn't play along well with blob txs for some reason.
  */
-export declare function withDelayer<T extends ViemClient>(client: T, opts: {
+export declare function withDelayer<T extends ViemClient>(client: T, dateProvider: DateProvider, opts: {
     ethereumSlotDuration: bigint | number;
 }): {
     client: T;