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

package/dest/test/eth_cheat_codes.js

@@ -2,27 +2,34 @@ import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
 import { keccak256 } from '@aztec/foundation/crypto';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
-import { createPublicClient, fallback, http } from 'viem';
+import { pluralize } from '@aztec/foundation/string';
+import { createPublicClient, fallback, hexToNumber, http } from 'viem';
 /**
  * A class that provides utility functions for interacting with ethereum (L1).
  */ export class EthCheatCodes {
     rpcUrls;
+    dateProvider;
     logger;
     publicClient;
     constructor(/**
      * The RPC URL to use for interacting with the chain
      */ rpcUrls, /**
+     * The date provider to use for time operations
+     */ dateProvider, /**
      * The logger to use for the eth cheatcodes
      */ logger = createLogger('ethereum:cheat_codes')){
         this.rpcUrls = rpcUrls;
+        this.dateProvider = dateProvider;
         this.logger = logger;
         this.publicClient = createPublicClient({
             transport: fallback(this.rpcUrls.map((url)=>http(url)))
         });
     }
-    async rpcCall(method, params) {
-        const paramsString = jsonStringify(params);
-        this.logger.debug(`Calling ${method} with params: ${paramsString} on ${this.rpcUrls.join(', ')}`);
+    rpcCall(method, params) {
+        this.logger.debug(`Calling ${method} with params: ${jsonStringify(params)} on ${this.rpcUrls.join(', ')}`);
+        return this.doRpcCall(method, params);
+    }
+    async doRpcCall(method, params) {
         return await this.publicClient.transport.request({
             method,
             params
@@ -33,7 +40,7 @@ import { createPublicClient, fallback, http } from 'viem';
    * @returns True if automine is on, false otherwise
    */ async isAutoMining() {
         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);
@@ -44,21 +51,21 @@ import { createPublicClient, fallback, http } from 'viem';
    * Get the current blocknumber
    * @returns The current block number
    */ async blockNumber() {
-        const res = await this.rpcCall('eth_blockNumber', []);
+        const res = await this.doRpcCall('eth_blockNumber', []);
         return parseInt(res, 16);
     }
     /**
    * Get the current chainId
    * @returns The current chainId
    */ async chainId() {
-        const res = await this.rpcCall('eth_chainId', []);
+        const res = await this.doRpcCall('eth_chainId', []);
         return parseInt(res, 16);
     }
     /**
    * Get the current timestamp
    * @returns The current timestamp
    */ async timestamp() {
-        const res = await this.rpcCall('eth_getBlockByNumber', [
+        const res = await this.doRpcCall('eth_getBlockByNumber', [
             'latest',
             true
         ]);
@@ -73,7 +80,7 @@ import { createPublicClient, fallback, http } from 'viem';
     }
     async doMine(numberOfBlocks = 1) {
         try {
-            await this.rpcCall('hardhat_mine', [
+            await this.doRpcCall('hardhat_mine', [
                 numberOfBlocks
             ]);
         } catch (err) {
@@ -84,7 +91,8 @@ import { createPublicClient, fallback, http } from 'viem';
    * Mines a single block with evm_mine
    */ async evmMine() {
         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}`);
         }
@@ -105,7 +113,7 @@ import { createPublicClient, fallback, http } from 'viem';
         this.logger.warn(`Set balance for ${account} to ${balance}`);
     }
     async getBalance(account) {
-        const res = await this.rpcCall('eth_getBalance', [
+        const res = await this.doRpcCall('eth_getBalance', [
             account.toString(),
             'latest'
         ]);
@@ -142,7 +150,7 @@ import { createPublicClient, fallback, http } from 'viem';
    * @param seconds - The interval to use between blocks
    */ getIntervalMining() {
         try {
-            return this.rpcCall('anvil_getIntervalMining', []);
+            return this.doRpcCall('anvil_getIntervalMining', []);
         } catch (err) {
             throw new Error(`Error getting interval mining: ${err}`);
         }
@@ -206,7 +214,7 @@ import { createPublicClient, fallback, http } from 'viem';
     /**
    * 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
    */ async warp(timestamp, opts = {}) {
         let blockInterval = null;
@@ -226,8 +234,10 @@ import { createPublicClient, fallback, http } from 'viem';
             ]);
             // 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{
@@ -260,7 +270,7 @@ import { createPublicClient, fallback, http } from 'viem';
    * @param contract - The contract address
    * @param slot - The storage slot
    * @param value - The value to set the storage slot to
-   */ async store(contract, slot, value) {
+   */ async store(contract, slot, value, opts = {}) {
         // for the rpc call, we need to change value to be a 32 byte hex string.
         try {
             await this.rpcCall('hardhat_setStorageAt', [
@@ -271,7 +281,9 @@ import { createPublicClient, fallback, http } from 'viem';
         } 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}`);
+        }
     }
     /**
    * Computes the slot value for a given map and key.
@@ -333,31 +345,28 @@ import { createPublicClient, fallback, http } from 'viem';
    * @param contract - The contract address
    * @returns The bytecode for the contract
    */ async getBytecode(contract) {
-        const res = await this.rpcCall('eth_getCode', [
+        return await this.doRpcCall('eth_getCode', [
             contract.toString(),
             'latest'
         ]);
-        return res;
     }
     /**
    * Get the raw transaction object for a given transaction hash
    * @param txHash - The transaction hash
    * @returns The raw transaction
    */ async getRawTransaction(txHash) {
-        const res = await this.rpcCall('debug_getRawTransaction', [
+        return await this.doRpcCall('debug_getRawTransaction', [
             txHash
         ]);
-        return res;
     }
     /**
    * Get the trace for a given transaction hash
    * @param txHash - The transaction hash
    * @returns The trace
    */ async debugTraceTransaction(txHash) {
-        const res = await this.rpcCall('debug_traceTransaction', [
+        return await this.doRpcCall('debug_traceTransaction', [
             txHash
         ]);
-        return res;
     }
     /**
    * Triggers a reorg of the given depth, removing those blocks from the chain.
@@ -373,9 +382,6 @@ import { createPublicClient, fallback, http } from 'viem';
    * Causes Anvil to reorg until the given block number is the new tip
    * @param blockNumber - The block number that's going to be the new tip
    */ reorgTo(blockNumber) {
-        this.logger.info('reorgTo', {
-            blockNumber
-        });
         if (blockNumber <= 0) {
             throw new Error(`Can't reorg to block before genesis: ${blockNumber}`);
         }
@@ -389,6 +395,7 @@ import { createPublicClient, fallback, http } from 'viem';
             await this.rpcCall('anvil_rollback', [
                 depth
             ]);
+            this.logger.warn(`Reorged L1 chain to block number ${blockNumber} (depth ${depth})`);
         });
     }
     /**
@@ -418,10 +425,68 @@ import { createPublicClient, fallback, http } from 'viem';
         });
     }
     traceTransaction(txHash) {
-        return this.rpcCall('trace_transaction', [
+        return this.doRpcCall('trace_transaction', [
             txHash
         ]);
     }
+    async getTxPoolStatus() {
+        const { pending, queued } = await this.doRpcCall('txpool_status', []);
+        return {
+            pending: hexToNumber(pending),
+            queued: hexToNumber(queued)
+        };
+    }
+    async getTxPoolContents() {
+        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.
+   */ async mineEmptyBlock(blockCount = 1) {
+        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 = [];
+            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)}`);
+    }
     async execWithPausedAnvil(fn) {
         const [blockInterval, wasAutoMining] = await Promise.all([
             this.getIntervalMining(),
@@ -438,7 +503,7 @@ import { createPublicClient, fallback, http } from 'viem';
                     silent: true
                 });
             }
-            await fn();
+            return await fn();
         } finally{
             try {
                 // restore automine if necessary
@@ -462,4 +527,26 @@ import { createPublicClient, fallback, http } from 'viem';
             }
         }
     }
+    async syncDateProvider() {
+        const timestamp = await this.timestamp();
+        if ('setTime' in this.dateProvider) {
+            this.dateProvider.setTime(timestamp * 1000);
+        }
+    }
+}
+function mapTxPoolContent(content) {
+    const result = [];
+    const processPool = (pool, poolState)=>{
+        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/dest/test/rollup_cheat_codes.d.ts

@@ -1,6 +1,6 @@
 import { type ViemPublicClient } from '@aztec/ethereum';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
-import type { TestDateProvider } from '@aztec/foundation/timer';
+import type { DateProvider } 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';
@@ -11,7 +11,7 @@ export declare class RollupCheatCodes {
     private rollup;
     private logger;
     constructor(ethCheatCodes: EthCheatCodes, addresses: Pick<L1ContractAddresses, 'rollupAddress'>);
-    static create(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>): RollupCheatCodes;
+    static create(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>, dateProvider: DateProvider): RollupCheatCodes;
     /** Returns the current slot */
     getSlot(): Promise<bigint>;
     /** Returns the current epoch */
@@ -38,15 +38,12 @@ export declare class RollupCheatCodes {
      * @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;
+    advanceToEpoch(epoch: bigint | number, opts?: {
+        /** Offset in seconds */
+        offset?: number;
     }): Promise<bigint>;
     /** Warps time in L1 until the next epoch */
-    advanceToNextEpoch(opts?: {
-        /** Optional test date provider to update with the epoch timestamp */
-        updateDateProvider?: TestDateProvider;
-    }): Promise<void>;
+    advanceToNextEpoch(): Promise<void>;
     /** Warps time in L1 until the beginning of the next slot. */
     advanceToNextSlot(): Promise<bigint[]>;
     /**
@@ -59,6 +56,11 @@ export declare class RollupCheatCodes {
      * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
      */
     markAsProven(maybeBlockNumber?: number | bigint): Promise<void>;
+    /**
+     * Overrides the inProgress field of the Inbox contract state
+     * @param howMuch - How many blocks to move it forward
+     */
+    advanceInboxInProgress(howMuch: number | bigint): Promise<bigint>;
     /**
      * Executes an action impersonated as the owner of the Rollup contract.
      * @param action - The action to execute

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

@@ -1 +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,CAC7B,IAAI,GAAE;QACJ,qEAAqE;QACrE,kBAAkB,CAAC,EAAE,gBAAgB,CAAC;KAClC;IAeR,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;CAWpD"}
+{"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,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,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,CACX,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,EACrD,YAAY,EAAE,YAAY,GACzB,gBAAgB;IAKnB,+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,GAAG,MAAM,EACtB,IAAI,GAAE;QACJ,wBAAwB;QACxB,MAAM,CAAC,EAAE,MAAM,CAAC;KACZ;IAcR,4CAA4C;IAC/B,kBAAkB;IAa/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;IACI,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqCxE;;;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;CAWpD"}

package/dest/test/rollup_cheat_codes.js

@@ -23,8 +23,8 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
             client: this.client
         });
     }
-    static create(rpcUrls, addresses) {
-        const ethCheatCodes = new EthCheatCodes(rpcUrls);
+    static create(rpcUrls, addresses, dateProvider) {
+        const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
         return new RollupCheatCodes(ethCheatCodes, addresses);
     }
     /** Returns the current slot */ async getSlot() {
@@ -85,8 +85,8 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
    */ async advanceToEpoch(epoch, opts = {}) {
         const { epochDuration: slotsInEpoch } = await this.getConfig();
         const timestamp = await this.rollup.read.getTimestampForSlot([
-            epoch * slotsInEpoch
-        ]);
+            BigInt(epoch) * slotsInEpoch
+        ]) + BigInt(opts.offset ?? 0);
         try {
             await this.ethCheatCodes.warp(Number(timestamp), {
                 ...opts,
@@ -99,14 +99,13 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
         }
         return timestamp;
     }
-    /** Warps time in L1 until the next epoch */ async advanceToNextEpoch(opts = {}) {
+    /** 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), {
-            ...opts,
             silent: true,
             resetBlockInterval: true
         });
@@ -173,6 +172,39 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
         });
     }
     /**
+   * Overrides the inProgress field of the Inbox contract state
+   * @param howMuch - How many blocks to move it forward
+   */ advanceInboxInProgress(howMuch) {
+        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
    */ async asOwner(action) {

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

@@ -1 +1 @@
-{"version":3,"file":"upgrade_utils.d.ts","sourceRoot":"","sources":["../../src/test/upgrade_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAe,MAAM,MAAM,CAAC;AAGvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG9E,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,qBAAqB,CAAC,OAAO,aAAa,EAAE,gBAAgB,CAAC,EACzE,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,iBAAiB,EAC7B,QAAQ,EAAE,wBAAwB,EAClC,OAAO,EAAE,MAAM,EAAE,EACjB,MAAM,EAAE,MAAM,iBAmCf;AAED,wBAAsB,wBAAwB,CAC5C,cAAc,EAAE,KAAK,MAAM,EAAE,EAC7B,SAAS,EAAE,mBAAmB,EAC9B,UAAU,EAAE,iBAAiB,EAC7B,YAAY,EAAE,gBAAgB,EAC9B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IACT,UAAU,EAAE,qBAAqB,CAAC,OAAO,aAAa,EAAE,gBAAgB,CAAC,CAAC;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CAyCD"}
+{"version":3,"file":"upgrade_utils.d.ts","sourceRoot":"","sources":["../../src/test/upgrade_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAe,MAAM,MAAM,CAAC;AAGvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG9E,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,qBAAqB,CAAC,OAAO,aAAa,EAAE,gBAAgB,CAAC,EACzE,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,iBAAiB,EAC7B,QAAQ,EAAE,wBAAwB,EAClC,OAAO,EAAE,MAAM,EAAE,EACjB,MAAM,EAAE,MAAM,iBAmCf;AAED,wBAAsB,wBAAwB,CAC5C,cAAc,EAAE,KAAK,MAAM,EAAE,EAC7B,SAAS,EAAE,mBAAmB,EAC9B,UAAU,EAAE,iBAAiB,EAC7B,YAAY,EAAE,gBAAgB,EAC9B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IACT,UAAU,EAAE,qBAAqB,CAAC,OAAO,aAAa,EAAE,gBAAgB,CAAC,CAAC;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CAyCD"}

package/dest/test/upgrade_utils.js

@@ -1,8 +1,9 @@
+import { DateProvider } from '@aztec/foundation/timer';
 import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
 import { TestERC20Abi as StakingAssetAbi } from '@aztec/l1-artifacts/TestERC20Abi';
 import { getContract } from 'viem';
 import { extractProposalIdFromLogs } from '../contracts/governance.js';
-import { createL1TxUtilsFromViemWallet } from '../l1_tx_utils.js';
+import { createL1TxUtilsFromViemWallet } from '../l1_tx_utils/index.js';
 import { EthCheatCodes } from './eth_cheat_codes.js';
 export async function executeGovernanceProposal(proposalId, governance, voteAmount, privateKey, l1Client, rpcUrls, logger) {
     const proposal = await governance.read.getProposal([
@@ -15,7 +16,7 @@ export async function executeGovernanceProposal(proposalId, governance, voteAmou
             value: 1n
         });
     };
-    const cheatCodes = new EthCheatCodes(rpcUrls, logger);
+    const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), logger);
     const timeToActive = proposal.creation + proposal.config.votingDelay;
     logger.info(`Warping to ${timeToActive + 1n}`);
     await cheatCodes.warp(Number(timeToActive + 1n));

package/dest/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EACL,KAAK,GAAG,EAER,KAAK,iBAAiB,EAEtB,KAAK,wBAAwB,EAC7B,KAAK,GAAG,EACR,KAAK,GAAG,EAGT,MAAM,MAAM,CAAC;AAEd,MAAM,WAAW,OAAO;IACtB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,GAAG,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC;gBAET,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE;CAKlD;AAED,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,CAMZ;AAED,wBAAgB,eAAe,CAC7B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,GAAG,SAAS,CAgBxB;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,OAW7C;AA0BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,GAAE,GAAe,GAAG,kBAAkB,CA8FpF;AA+KD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,sBAa7C"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EACL,KAAK,GAAG,EAER,KAAK,iBAAiB,EAEtB,KAAK,wBAAwB,EAC7B,KAAK,GAAG,EACR,KAAK,GAAG,EAGT,MAAM,MAAM,CAAC;AAEd,MAAM,WAAW,OAAO;IACtB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,GAAG,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC;gBAET,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE;CAKlD;AAED,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,CAMZ;AAED,wBAAgB,eAAe,CAC7B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,GAAG,SAAS,CAgBxB;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,OAW7C;AA0BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,GAAE,GAAe,GAAG,kBAAkB,CAwEpF;AAyBD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,sBAa7C"}

package/dest/utils.js

@@ -118,34 +118,16 @@ function getNestedErrorData(error) {
     if (error instanceof Error) {
         return new FormattedViemError(error.message, error?.metaMessages);
     }
-    // Extract the actual error message and highlight it for clarity
-    let formattedRes = extractAndFormatRequestBody(error?.message || String(error));
-    let errorDetail = '';
-    // Look for specific details in known locations
-    if (error) {
-        // Check for details property which often has the most specific error message
-        if (typeof error.details === 'string' && error.details) {
-            errorDetail = error.details;
-        } else if (typeof error.shortMessage === 'string' && error.shortMessage) {
-            errorDetail = error.shortMessage;
-        }
-    }
-    // If we found a specific error detail, format it clearly
-    if (errorDetail) {
-        // Look for key sections of the formatted result to replace with highlighted error
-        let replaced = false;
-        // Try to find the Details: section
-        const detailsMatch = formattedRes.match(/Details: ([^\n]+)/);
-        if (detailsMatch) {
-            formattedRes = formattedRes.replace(detailsMatch[0], `Details: *${errorDetail}*`);
-            replaced = true;
-        }
-        // If we didn't find a Details section, add the error at the beginning
-        if (!replaced) {
-            formattedRes = `Error: *${errorDetail}*\n\n${formattedRes}`;
-        }
-    }
-    return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
+    const body = String(error);
+    const length = body.length;
+    // LogExplorer can only render up to 2500 characters in it's summary view. Try to keep the whole message below this number
+    // Limit the error to 2000 chacaters in order to allow code higher up to decorate this error with extra details (up to 500 characters)
+    if (length > 2000) {
+        const chunk = 950;
+        const truncated = length - 2 * chunk;
+        return new FormattedViemError(body.slice(0, chunk) + `...${truncated} characters truncated...` + body.slice(-1 * chunk));
+    }
+    return new FormattedViemError(body);
 }
 function stripAbis(obj) {
     if (!obj || typeof obj !== 'object') {
@@ -166,139 +148,6 @@ function stripAbis(obj) {
         }
     });
 }
-function extractAndFormatRequestBody(message) {
-    // First check if message is extremely large and contains very large hex strings
-    if (message.length > 50000) {
-        message = replaceHexStrings(message, {
-            minLength: 10000,
-            truncateLength: 200
-        });
-    }
-    // Add a specific check for RPC calls with large params
-    if (message.includes('"method":"eth_sendRawTransaction"')) {
-        message = replaceHexStrings(message, {
-            pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-            transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
-        });
-    }
-    // First handle Request body JSON
-    const requestBodyRegex = /Request body: ({[\s\S]*?})\n/g;
-    let result = message.replace(requestBodyRegex, (match, body)=>{
-        return `Request body: ${formatRequestBody(body)}\n`;
-    });
-    // Then handle Arguments section
-    const argsRegex = /((?:Request |Estimate Gas )?Arguments:[\s\S]*?(?=\n\n|$))/g;
-    result = result.replace(argsRegex, (section)=>{
-        const lines = section.split('\n');
-        const processedLines = lines.map((line)=>{
-            // Check if line contains a colon followed by content
-            const colonIndex = line.indexOf(':');
-            if (colonIndex !== -1) {
-                const [prefix, content] = [
-                    line.slice(0, colonIndex + 1),
-                    line.slice(colonIndex + 1).trim()
-                ];
-                // If content contains a hex string, truncate it
-                if (content.includes('0x')) {
-                    const processedContent = replaceHexStrings(content);
-                    return `${prefix} ${processedContent}`;
-                }
-            }
-            return line;
-        });
-        return processedLines.join('\n');
-    });
-    // Finally, catch any remaining hex strings in the message
-    result = replaceHexStrings(result);
-    return result;
-}
-function truncateHex(hex, length = 100) {
-    if (!hex || typeof hex !== 'string') {
-        return hex;
-    }
-    if (!hex.startsWith('0x')) {
-        return hex;
-    }
-    if (hex.length <= length * 2) {
-        return hex;
-    }
-    // For extremely large hex strings, use more aggressive truncation
-    if (hex.length > 10000) {
-        return `${hex.slice(0, length)}...<${hex.length - length * 2} chars omitted>...${hex.slice(-length)}`;
-    }
-    return `${hex.slice(0, length)}...${hex.slice(-length)}`;
-}
-function replaceHexStrings(text, options = {}) {
-    const { minLength = 10, maxLength = Infinity, truncateLength = 100, pattern, transform = (hex)=>truncateHex(hex, truncateLength) } = options;
-    const hexRegex = pattern ?? new RegExp(`(0x[a-fA-F0-9]{${minLength},${maxLength}})`, 'g');
-    return text.replace(hexRegex, (match)=>transform(match));
-}
-function formatRequestBody(body) {
-    try {
-        // Special handling for eth_sendRawTransaction
-        if (body.includes('"method":"eth_sendRawTransaction"')) {
-            try {
-                const parsed = JSON.parse(body);
-                if (parsed.params && Array.isArray(parsed.params) && parsed.params.length > 0) {
-                    // These are likely large transaction hex strings
-                    parsed.params = parsed.params.map((param)=>{
-                        if (typeof param === 'string' && param.startsWith('0x') && param.length > 1000) {
-                            return truncateHex(param, 200);
-                        }
-                        return param;
-                    });
-                }
-                return JSON.stringify(parsed, null, 2);
-            } catch  {
-                // If specific parsing fails, fall back to regex-based truncation
-                return replaceHexStrings(body, {
-                    pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-                    transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
-                });
-            }
-        }
-        // For extremely large request bodies, use simple truncation instead of parsing
-        if (body.length > 50000) {
-            const jsonStart = body.indexOf('{');
-            const jsonEnd = body.lastIndexOf('}');
-            if (jsonStart >= 0 && jsonEnd > jsonStart) {
-                return replaceHexStrings(body, {
-                    minLength: 10000,
-                    truncateLength: 200
-                });
-            }
-        }
-        const parsed = JSON.parse(body);
-        // Process the entire request body
-        const processed = processParams(parsed);
-        return JSON.stringify(processed, null, 2);
-    } catch  {
-        // If JSON parsing fails, do a simple truncation of any large hex strings
-        return replaceHexStrings(body, {
-            minLength: 1000,
-            truncateLength: 150
-        });
-    }
-}
-// Recursively process all parameters that might contain hex strings
-function processParams(obj) {
-    if (Array.isArray(obj)) {
-        return obj.map((item)=>processParams(item));
-    }
-    if (typeof obj === 'object' && obj !== null) {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)){
-            result[key] = processParams(value);
-        }
-        return result;
-    }
-    if (typeof obj === 'string') {
-        if (obj.startsWith('0x')) {
-            return truncateHex(obj);
-        }
-    }
-    return obj;
-}
 export function tryGetCustomErrorName(err) {
     try {
         // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors