@aztec-labs/ethereum 6.0.0-nightly.20260829

package/dest/test/eth_cheat_codes.js

@@ -0,0 +1,608 @@
+import { toBigIntBE, toHex } from '@aztec-labs/foundation/bigint-buffer';
+import { keccak256 } from '@aztec-labs/foundation/crypto/keccak';
+import { jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { pluralize } from '@aztec-labs/foundation/string';
+import { createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { foundry } from 'viem/chains';
+/**
+ * A class that provides utility functions for interacting with ethereum (L1).
+ */ export class EthCheatCodes {
+    rpcUrls;
+    dateProvider;
+    logger;
+    chain;
+    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'), /**
+     * The chain configuration provided to Anvil
+     */ chain = foundry){
+        this.rpcUrls = rpcUrls;
+        this.dateProvider = dateProvider;
+        this.logger = logger;
+        this.chain = chain;
+        this.publicClient = createPublicClient({
+            transport: fallback(this.rpcUrls.map((url)=>http(url, {
+                    batch: false
+                }))),
+            chain: chain
+        });
+    }
+    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
+        });
+    }
+    /**
+   * Get the auto mine status of the underlying chain
+   * @returns True if automine is on, false otherwise
+   */ async isAutoMining() {
+        try {
+            const res = await this.doRpcCall('anvil_getAutomine', []);
+            return res;
+        } catch (err) {
+            this.logger.error(`Calling "anvil_getAutomine" failed with:`, err);
+        }
+        return false;
+    }
+    /**
+   * Get the current blocknumber
+   * @returns The current block number
+   */ async 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.doRpcCall('eth_chainId', []);
+        return parseInt(res, 16);
+    }
+    /**
+   * Get the timestamp of the latest mined L1 block.
+   * Note: this is NOT the current time — it's the discrete timestamp of the last block.
+   * Between blocks, the actual chain time advances but no new block reflects it.
+   * @returns The latest block timestamp in seconds
+   */ async lastBlockTimestamp() {
+        const res = await this.doRpcCall('eth_getBlockByNumber', [
+            'latest',
+            true
+        ]);
+        return parseInt(res.timestamp, 16);
+    }
+    /**
+   * Get the timestamp of the pending L1 block — the block that anvil will mine next.
+   * Reflects any prior `setNextBlockTimestamp` call or the configured block interval.
+   * @returns The pending block timestamp in seconds.
+   */ async nextBlockTimestamp() {
+        const res = await this.doRpcCall('eth_getBlockByNumber', [
+            'pending',
+            false
+        ]);
+        return parseInt(res.timestamp, 16);
+    }
+    /**
+   * Advance the chain by a number of blocks
+   * @param numberOfBlocks - The number of blocks to mine
+   */ async mine(numberOfBlocks = 1) {
+        await this.doMine(Number(numberOfBlocks));
+        this.logger.warn(`Mined ${numberOfBlocks} L1 blocks`);
+    }
+    async doMine(numberOfBlocks = 1) {
+        try {
+            await this.doRpcCall('hardhat_mine', [
+                numberOfBlocks
+            ]);
+        } catch (err) {
+            throw new Error(`Error mining: ${err}`);
+        }
+    }
+    /**
+   * Mines a single block with evm_mine
+   */ async evmMine() {
+        try {
+            await this.doRpcCall('evm_mine', []);
+            this.logger.warn(`Mined 1 L1 block with evm_mine`);
+        } catch (err) {
+            throw new Error(`Error mining: ${err}`);
+        }
+    }
+    /**
+   * Set the balance of an account
+   * @param account - The account to set the balance for
+   * @param balance - The balance to set
+   */ async setBalance(account, balance) {
+        try {
+            await this.rpcCall('anvil_setBalance', [
+                account.toString(),
+                toHex(balance)
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting balance for ${account}: ${err}`);
+        }
+        this.logger.warn(`Set balance for ${account} to ${balance}`);
+    }
+    async getBalance(account) {
+        const res = await this.doRpcCall('eth_getBalance', [
+            account.toString(),
+            'latest'
+        ]);
+        return BigInt(res);
+    }
+    /**
+   * Set the interval between successive blocks (block time). This does NOT enable interval mining.
+   * @param interval - The interval to use between blocks
+   */ async setBlockInterval(interval) {
+        try {
+            await this.rpcCall('anvil_setBlockTimestampInterval', [
+                interval
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting block interval: ${err}`);
+        }
+        this.logger.warn(`Set L1 block interval to ${interval}`);
+    }
+    /**
+   * Set the next block base fee per gas
+   * @param baseFee - The base fee to set
+   */ async setNextBlockBaseFeePerGas(baseFee) {
+        try {
+            await this.rpcCall('anvil_setNextBlockBaseFeePerGas', [
+                baseFee.toString()
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting next block base fee per gas: ${err}`);
+        }
+        this.logger.warn(`Set L1 next block base fee per gas to ${baseFee}`);
+    }
+    /**
+   * Get interval mining if set.
+   * @param seconds - The interval to use between blocks
+   */ getIntervalMining() {
+        try {
+            return this.doRpcCall('anvil_getIntervalMining', []);
+        } catch (err) {
+            throw new Error(`Error getting interval mining: ${err}`);
+        }
+    }
+    /**
+   * Enable interval mining at the given interval (block time)
+   * @param seconds - The interval to use between blocks
+   */ async setIntervalMining(seconds, opts = {}) {
+        try {
+            await this.rpcCall('anvil_setIntervalMining', [
+                seconds
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting interval mining: ${err}`);
+        }
+        if (!opts.silent) {
+            this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
+        }
+    }
+    /**
+   * Starts interval mining from a freshly mined block and syncs the date provider to the block timestamp.
+   */ async startIntervalMiningWithFreshBlock(seconds) {
+        if (seconds <= 0) {
+            throw new Error(`Interval mining requires a positive interval, got ${seconds}`);
+        }
+        await this.setAutomine(false);
+        await this.setIntervalMining(0, {
+            silent: true
+        });
+        await this.evmMine();
+        await this.syncDateProvider();
+        await this.setIntervalMining(seconds);
+        this.logger.warn(`Started L1 interval mining at ${seconds} seconds from a fresh block`);
+    }
+    /**
+   * Set the automine status of the underlying anvil chain
+   * @param automine - The automine status to set
+   */ async setAutomine(automine, opts = {}) {
+        try {
+            await this.rpcCall('anvil_setAutomine', [
+                automine
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting automine: ${err}`);
+        }
+        if (!opts.silent) {
+            this.logger.warn(`Set L1 automine to ${automine}`);
+        }
+    }
+    /**
+   * Drop a transaction from the mempool
+   * @param txHash - The transaction hash
+   */ async dropTransaction(txHash) {
+        try {
+            await this.rpcCall('anvil_dropTransaction', [
+                txHash
+            ]);
+        } catch (err) {
+            throw new Error(`Error dropping transaction: ${err}`);
+        }
+        this.logger.warn(`Dropped transaction ${txHash}`);
+    }
+    /**
+   * Set the next block timestamp
+   * @param timestamp - The timestamp to set the next block to
+   */ async setNextBlockTimestamp(timestamp) {
+        try {
+            await this.rpcCall('evm_setNextBlockTimestamp', [
+                timestamp instanceof Date ? Math.floor(timestamp.getTime() / 1000) : timestamp
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting next block timestamp: ${err.message}`);
+        }
+        this.logger.warn(`Set L1 next block timestamp to ${timestamp}`);
+    }
+    /**
+   * Set the next block timestamp and mines the block.
+   * Optionally resets interval mining so the next block is mined in `blockInterval` seconds from now.
+   * 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;
+        try {
+            // Load current block interval and disable it
+            if (opts.resetBlockInterval) {
+                blockInterval = await this.getIntervalMining();
+                if (blockInterval !== null) {
+                    await this.setIntervalMining(0, {
+                        silent: true
+                    });
+                }
+            }
+            // Set the timestamp of the next block to be mined
+            await this.rpcCall('evm_setNextBlockTimestamp', [
+                Number(timestamp)
+            ]);
+            // And mine a block so the timestamp goes into effect now
+            await this.doMine();
+            // 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{
+            // 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, {
+                    silent: true
+                });
+            }
+        }
+        if (!opts.silent) {
+            this.logger.warn(`Warped L1 timestamp to ${timestamp}`);
+        }
+    }
+    /**
+   * Load the value at a storage slot of a contract address on eth
+   * @param contract - The contract address
+   * @param slot - The storage slot
+   * @returns - The value at the storage slot
+   */ async load(contract, slot) {
+        const res = await this.rpcCall('eth_getStorageAt', [
+            contract.toString(),
+            toHex(slot),
+            'latest'
+        ]);
+        return BigInt(res);
+    }
+    /**
+   * Set the value at a storage slot of a contract address on eth
+   * @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, opts = {}) {
+        // 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}`);
+        }
+        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.
+   * @param baseSlot - The base slot of the map (specified in Aztec.nr contract)
+   * @param key - The key to lookup in the map
+   * @returns The storage slot of the value in the map
+   */ keccak256(baseSlot, key) {
+        // abi encode (removing the 0x) - concat key and baseSlot (both padded to 32 bytes)
+        const abiEncoded = toHex(key, true).substring(2) + toHex(baseSlot, true).substring(2);
+        return toBigIntBE(keccak256(Buffer.from(abiEncoded, 'hex')));
+    }
+    /**
+   * Send transactions impersonating an externally owned account or contract.
+   * @param who - The address to impersonate
+   */ async startImpersonating(who) {
+        try {
+            // Since the `who` impersonated will sometimes be a contract without funds, we fund it if needed.
+            if (await this.getBalance(who) === 0n) {
+                await this.setBalance(who, 10n * 10n ** 18n);
+            }
+            await this.rpcCall('hardhat_impersonateAccount', [
+                who.toString()
+            ]);
+        } catch (err) {
+            throw new Error(`Error impersonating ${who}: ${err}`);
+        }
+        this.logger.warn(`Impersonating ${who}`);
+    }
+    /**
+   * Stop impersonating an account that you are currently impersonating.
+   * @param who - The address to stop impersonating
+   */ async stopImpersonating(who) {
+        try {
+            await this.rpcCall('hardhat_stopImpersonatingAccount', [
+                who.toString()
+            ]);
+        } catch (err) {
+            throw new Error(`Error when stopping the impersonation of ${who}: ${err}`);
+        }
+        this.logger.warn(`Stopped impersonating ${who}`);
+    }
+    /**
+   * Set the bytecode for a contract
+   * @param contract - The contract address
+   * @param bytecode - The bytecode to set
+   */ async etch(contract, bytecode) {
+        try {
+            await this.rpcCall('hardhat_setCode', [
+                contract.toString(),
+                bytecode
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting bytecode for ${contract}: ${err}`);
+        }
+        this.logger.warn(`Set bytecode for ${contract} to ${bytecode}`);
+    }
+    /**
+   * Get the bytecode for a contract
+   * @param contract - The contract address
+   * @returns The bytecode for the contract
+   */ async getBytecode(contract) {
+        return await this.doRpcCall('eth_getCode', [
+            contract.toString(),
+            'latest'
+        ]);
+    }
+    /**
+   * Get the raw transaction object for a given transaction hash
+   * @param txHash - The transaction hash
+   * @returns The raw transaction
+   */ async getRawTransaction(txHash) {
+        return await this.doRpcCall('debug_getRawTransaction', [
+            txHash
+        ]);
+    }
+    /**
+   * Get the trace for a given transaction hash
+   * @param txHash - The transaction hash
+   * @returns The trace
+   */ async debugTraceTransaction(txHash) {
+        return await this.doRpcCall('debug_traceTransaction', [
+            txHash
+        ]);
+    }
+    /**
+   * Triggers a reorg of the given depth, removing those blocks from the chain.
+   * @param depth - The depth of the reorg
+   */ reorg(depth) {
+        return this.execWithPausedAnvil(()=>{
+            return this.rpcCall('anvil_rollback', [
+                depth
+            ]);
+        });
+    }
+    /**
+   * 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) {
+        if (blockNumber <= 0) {
+            throw new Error(`Can't reorg to block before genesis: ${blockNumber}`);
+        }
+        return this.execWithPausedAnvil(async ()=>{
+            const currentTip = await this.publicClient.getBlockNumber();
+            if (currentTip < BigInt(blockNumber)) {
+                this.logger.warn(`Can't call anvil_rollback, chain tip is behind target block: ${currentTip} < ${BigInt(blockNumber)}`);
+                return;
+            }
+            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})`);
+        });
+    }
+    /**
+   * Triggers a reorg of the given depth, optionally replacing it with new blocks.
+   * The resulting block height will be the same as the original chain.
+   * @param depth - The depth of the reorg
+   * @param newBlocks - The blocks to replace the old ones with, each represented as a list of txs.
+   */ async reorgWithReplacement(depth, newBlocks = []) {
+        this.logger.verbose(`Preparing L1 reorg with depth ${depth}`);
+        try {
+            await this.rpcCall('anvil_reorg', [
+                depth,
+                newBlocks.flatMap((txs, index)=>txs.map((tx)=>[
+                            typeof tx === 'string' ? tx : {
+                                value: 0,
+                                ...tx
+                            },
+                            index
+                        ]))
+            ]);
+        } catch (err) {
+            throw new Error(`Error reorging: ${err}`);
+        }
+        this.logger.warn(`Reorged L1 chain with depth ${depth} and ${newBlocks.length} new blocks`, {
+            depth,
+            newBlocks
+        });
+    }
+    traceTransaction(txHash) {
+        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 empty blocks while leaving any pending transactions untouched in the mempool.
+   *
+   * Never manipulates the mempool, so it is immune to the race that dropping and re-adding txs has against a
+   * concurrent publisher that is monitoring and re-broadcasting the same in-flight tx (with that approach the
+   * in-flight tx could reappear in the pool and be swept into the "empty" block, mining a proposal the caller
+   * expected to stay pending). Works in two steps: first the block gas limit is temporarily lowered below the
+   * intrinsic cost of any transaction (21000 gas) and the blocks are mined, so no pending tx is includable;
+   * then those blocks are reorged out and replaced with empty blocks mined at the restored gas limit. The
+   * reorg is needed because anvil applies a new gas limit only to future blocks: without it the just-mined
+   * blocks would keep the tiny gas limit, and an `eth_call` against `latest` (whose gas is capped by the
+   * block gas limit) would revert with "intrinsic gas too high".
+   *
+   * The replacement blocks advance L1 time. `anvil_reorg` stamps each replacement as `parent + N*interval`,
+   * so on its own it would freeze L1 time at the parent timestamp; callers that measure elapsed L1 time
+   * (L1TxUtils stall/timeout detection, `syncDateProvider`-driven slot advancement) rely on it moving
+   * forward. We reproduce the wall-clock advance the mine step just made (at least 1s per block) via a
+   * temporary block-timestamp interval, then restore any pre-existing interval.
+   */ async mineEmptyBlock(blockCount = 1) {
+        await this.execWithPausedAnvil(async ()=>{
+            const originalGasLimit = await this.getBlockGasLimit();
+            const parentTimestamp = await this.lastBlockTimestamp();
+            // anvil has no getter for the block-timestamp interval, but the pending block is stamped
+            // `latest + interval`, so this delta is the standing interval (0 when none is set).
+            const priorInterval = await this.nextBlockTimestamp() - parentTimestamp;
+            try {
+                await this.setBlockGasLimit(1n);
+                await this.doMine(blockCount);
+            } finally{
+                await this.setBlockGasLimit(originalGasLimit);
+            }
+            const advance = await this.lastBlockTimestamp() - parentTimestamp;
+            const perBlockInterval = Math.max(1, Math.floor(advance / blockCount));
+            // Replace the tiny-gas-limit blocks with empty blocks at the restored gas limit, keeping the same
+            // height. The reorged-out blocks held no transactions, so nothing returns to the pool.
+            await this.doRpcCall('anvil_setBlockTimestampInterval', [
+                perBlockInterval
+            ]);
+            try {
+                await this.doRpcCall('anvil_reorg', [
+                    blockCount,
+                    []
+                ]);
+            } finally{
+                if (priorInterval > 0) {
+                    await this.doRpcCall('anvil_setBlockTimestampInterval', [
+                        priorInterval
+                    ]);
+                } else {
+                    await this.doRpcCall('anvil_removeBlockTimestampInterval', []);
+                }
+            }
+        });
+        this.logger.warn(`Mined ${blockCount} empty L1 ${pluralize('block', blockCount)}`);
+    }
+    /** Returns the gas limit of the latest mined L1 block. */ async getBlockGasLimit() {
+        const block = await this.doRpcCall('eth_getBlockByNumber', [
+            'latest',
+            false
+        ]);
+        return BigInt(block.gasLimit);
+    }
+    /** Sets the block gas limit applied to subsequently mined L1 blocks. */ async setBlockGasLimit(gasLimit) {
+        await this.doRpcCall('anvil_setBlockGasLimit', [
+            toHex(gasLimit)
+        ]);
+    }
+    async execWithPausedAnvil(fn) {
+        const [blockInterval, wasAutoMining] = await Promise.all([
+            this.getIntervalMining(),
+            this.isAutoMining()
+        ]);
+        try {
+            if (blockInterval !== null) {
+                await this.setIntervalMining(0, {
+                    silent: true
+                });
+            }
+            if (wasAutoMining) {
+                await this.setAutomine(false, {
+                    silent: true
+                });
+            }
+            return await fn();
+        } finally{
+            try {
+                // restore automine if necessary
+                if (wasAutoMining) {
+                    await this.setAutomine(true, {
+                        silent: true
+                    });
+                }
+            } catch (err) {
+                this.logger.warn(`Failed to reenable automining: ${err}`);
+            }
+            try {
+                // restore automine if necessary
+                if (blockInterval !== null) {
+                    await this.setIntervalMining(blockInterval, {
+                        silent: true
+                    });
+                }
+            } catch (err) {
+                this.logger.warn(`Failed to reenable interval mining: ${err}`);
+            }
+        }
+    }
+    async syncDateProvider() {
+        const timestamp = await this.lastBlockTimestamp();
+        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/eth_cheat_codes_with_state.d.ts

@@ -0,0 +1,18 @@
+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.
+ */
+export declare class EthCheatCodesWithState extends EthCheatCodes {
+    /**
+     * Dumps the current chain state to a file.
+     * @param fileName - The file name to dump state into
+     */
+    dumpChainState(fileName: string): Promise<void>;
+    /**
+     * Loads the chain state from a file.
+     * @param fileName - The file name to load state from
+     */
+    loadChainState(fileName: string): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXRoX2NoZWF0X2NvZGVzX3dpdGhfc3RhdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2V0aF9jaGVhdF9jb2Rlc193aXRoX3N0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVyRDs7O0dBR0c7QUFDSCxxQkFBYSxzQkFBdUIsU0FBUSxhQUFhO0lBQ3ZEOzs7T0FHRztJQUNVLGNBQWMsQ0FBQyxRQUFRLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FTM0Q7SUFFRDs7O09BR0c7SUFDVSxjQUFjLENBQUMsUUFBUSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBUTNEO0NBQ0YifQ==

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

@@ -0,0 +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,sBAAsB,CAAC;AAErD;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACvD;;;OAGG;IACU,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS3D;IAED;;;OAGG;IACU,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ3D;CACF"}

package/dest/test/eth_cheat_codes_with_state.js

@@ -0,0 +1,34 @@
+import fs from 'fs';
+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.
+ */ export class EthCheatCodesWithState extends EthCheatCodes {
+    /**
+   * Dumps the current chain state to a file.
+   * @param fileName - The file name to dump state into
+   */ async dumpChainState(fileName) {
+        let res;
+        try {
+            res = await this.rpcCall('hardhat_dumpState', []);
+        } catch (e) {
+            throw new Error(`Error dumping state: ${e}`);
+        }
+        fs.writeFileSync(`${fileName}.json`, res, 'utf8');
+        this.logger.verbose(`Dumped state to ${fileName}`);
+    }
+    /**
+   * Loads the chain state from a file.
+   * @param fileName - The file name to load state from
+   */ async loadChainState(fileName) {
+        const data = JSON.parse(fs.readFileSync(`${fileName}.json`, 'utf8'));
+        try {
+            await this.rpcCall('hardhat_loadState', [
+                data
+            ]);
+        } catch (e) {
+            throw new Error(`Error loading state: ${e}`);
+        }
+        this.logger.verbose(`Loaded state from ${fileName}`);
+    }
+}

package/dest/test/index.d.ts

@@ -0,0 +1,8 @@
+export * from './blob_kzg_warmup.js';
+export * from './eth_cheat_codes.js';
+export * from './eth_cheat_codes_with_state.js';
+export * from './start_anvil.js';
+export * from './upgrade_utils.js';
+export * from './chain_monitor.js';
+export * from './rollup_cheat_codes.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMseUJBQXlCLENBQUMifQ==

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

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

package/dest/test/index.js

@@ -0,0 +1,7 @@
+export * from './blob_kzg_warmup.js';
+export * from './eth_cheat_codes.js';
+export * from './eth_cheat_codes_with_state.js';
+export * from './start_anvil.js';
+export * from './upgrade_utils.js';
+export * from './chain_monitor.js';
+export * from './rollup_cheat_codes.js';