@aztec/ethereum 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/test/rollup_cheat_codes.js

@@ -1,9 +1,10 @@
-import { RollupContract } from '@aztec/ethereum';
+import { OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
-import { createPublicClient, fallback, getContract, hexToBigInt, http } from 'viem';
-import { foundry } from 'viem/chains';
+import { createPublicClient, fallback, getContract, hexToBigInt, http, keccak256 } from 'viem';
 import { EthCheatCodes } from './eth_cheat_codes.js';
 /** Cheat codes for the L1 rollup contract. */ export class RollupCheatCodes {
     ethCheatCodes;
@@ -14,8 +15,10 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
         this.ethCheatCodes = ethCheatCodes;
         this.logger = createLogger('aztecjs:cheat_codes');
         this.client = createPublicClient({
-            chain: foundry,
-            transport: fallback(ethCheatCodes.rpcUrls.map((url)=>http(url)))
+            chain: ethCheatCodes.chain,
+            transport: fallback(ethCheatCodes.rpcUrls.map((url)=>http(url, {
+                    batch: false
+                })))
         });
         this.rollup = getContract({
             abi: RollupAbi,
@@ -29,39 +32,56 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
     }
     /** Returns the current slot */ async getSlot() {
         const ts = BigInt((await this.client.getBlock()).timestamp);
-        return await this.rollup.read.getSlotAt([
-            ts
+        return this.getSlotAt(ts);
+    }
+    /** Returns the slot number at a given timestamp. */ async getSlotAt(timestamp) {
+        return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([
+            timestamp
+        ]));
+    }
+    /** Returns the timestamp for the start of a given slot. */ async getTimestampForSlot(slot) {
+        return await this.rollup.read.getTimestampForSlot([
+            BigInt(slot)
+        ]);
+    }
+    /** Returns the number of seconds until the start of the given slot based on L1 block timestamp. */ async getSecondsUntilSlot(slot) {
+        const [currentTimestamp, targetTimestamp] = await Promise.all([
+            this.client.getBlock().then((b)=>BigInt(b.timestamp)),
+            this.rollup.read.getTimestampForSlot([
+                BigInt(slot)
+            ])
         ]);
+        return Math.max(0, Number(targetTimestamp - currentTimestamp));
     }
     /** Returns the current epoch */ async getEpoch() {
         const slotNumber = await this.getSlot();
-        return await this.rollup.read.getEpochAtSlot([
-            slotNumber
-        ]);
+        return EpochNumber.fromBigInt(await this.rollup.read.getEpochAtSlot([
+            BigInt(slotNumber)
+        ]));
     }
     /**
    * Returns the pending and proven chain tips
    * @returns The pending and proven chain tips
    */ async getTips() {
-        const res = await this.rollup.read.getTips();
+        const { pending, proven } = await this.rollup.read.getTips();
         return {
-            pending: res.pendingBlockNumber,
-            proven: res.provenBlockNumber
+            pending: CheckpointNumber.fromBigInt(pending),
+            proven: CheckpointNumber.fromBigInt(proven)
         };
     }
     /**
    * 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 pendingNum = await rollup.getCheckpointNumber();
+        const provenNum = await rollup.getProvenCheckpointNumber();
         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(`Pending checkpoint num: ${pendingNum}`);
+        this.logger.info(`Proven checkpoint 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}`);
@@ -75,7 +95,7 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
         ]);
         return {
             epochDuration,
-            slotDuration
+            slotDuration: Number(slotDuration)
         };
     }
     /**
@@ -84,8 +104,9 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
    * @param opts - Options
    */ async advanceToEpoch(epoch, opts = {}) {
         const { epochDuration: slotsInEpoch } = await this.getConfig();
+        const slotNumber = SlotNumber(Number(epoch) * Number(slotsInEpoch));
         const timestamp = await this.rollup.read.getTimestampForSlot([
-            BigInt(epoch) * slotsInEpoch
+            BigInt(slotNumber)
         ]) + BigInt(opts.offset ?? 0);
         try {
             await this.ethCheatCodes.warp(Number(timestamp), {
@@ -93,7 +114,10 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
                 silent: true,
                 resetBlockInterval: true
             });
-            this.logger.warn(`Warped to epoch ${epoch}`);
+            this.logger.warn(`Warped to epoch ${epoch}`, {
+                offset: opts.offset,
+                timestamp
+            });
         } catch (err) {
             this.logger.warn(`Warp to epoch ${epoch} failed: ${err}`);
         }
@@ -102,8 +126,8 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
     /** 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 slotsUntilNextEpoch = epochDuration - BigInt(slot) % epochDuration + 1n;
+        const timeToNextEpoch = slotsUntilNextEpoch * BigInt(slotDuration);
         const l1Timestamp = BigInt((await this.client.getBlock()).timestamp);
         await this.ethCheatCodes.warp(Number(l1Timestamp + timeToNextEpoch), {
             silent: true,
@@ -113,26 +137,47 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
     }
     /** Warps time in L1 until the beginning of the next slot. */ async advanceToNextSlot() {
         const currentSlot = await this.getSlot();
+        const nextSlot = SlotNumber(currentSlot + 1);
         const timestamp = await this.rollup.read.getTimestampForSlot([
-            currentSlot + 1n
+            BigInt(nextSlot)
         ]);
         await this.ethCheatCodes.warp(Number(timestamp), {
             silent: true,
             resetBlockInterval: true
         });
-        this.logger.warn(`Advanced to slot ${currentSlot + 1n}`);
+        this.logger.warn(`Advanced to slot ${nextSlot}`);
         return [
             timestamp,
-            currentSlot + 1n
+            nextSlot
         ];
     }
     /**
+   * Warps L1 time to the start of an explicit absolute slot. Unlike `advanceSlots(N)` which is
+   * relative to the current L1 timestamp at call time and therefore races with real-time
+   * progression between query and warp, this lands at the slot regardless of latency.
+   *
+   * Throws if the requested slot is in the past relative to current L1 time (anvil cannot
+   * rewind).
+   */ async advanceToSlot(slot) {
+        const timestamp = await this.rollup.read.getTimestampForSlot([
+            BigInt(slot)
+        ]);
+        await this.ethCheatCodes.warp(Number(timestamp), {
+            silent: true,
+            resetBlockInterval: true
+        });
+        this.logger.warn(`Advanced to slot ${slot}`, {
+            timestamp
+        });
+        return timestamp;
+    }
+    /**
    * 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;
+        const slotDuration = Number(await this.rollup.read.getSlotDuration());
+        const timeToWarp = BigInt(howMany) * BigInt(slotDuration);
         await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, {
             silent: true,
             resetBlockInterval: true
@@ -144,36 +189,62 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
         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) {
+   * Marks the specified checkpoint (or latest if none) as proven
+   * @param maybeCheckpointNumber - The checkpoint number to mark as proven (defaults to latest pending)
+   */ markAsProven(maybeCheckpointNumber) {
         return this.ethCheatCodes.execWithPausedAnvil(async ()=>{
             const tipsBefore = await this.getTips();
             const { pending, proven } = tipsBefore;
-            let blockNumber = maybeBlockNumber;
-            if (blockNumber === undefined || blockNumber > pending) {
-                blockNumber = pending;
+            let checkpointNumber = maybeCheckpointNumber;
+            if (checkpointNumber === undefined || checkpointNumber > pending) {
+                checkpointNumber = pending;
             }
-            if (blockNumber <= proven) {
-                this.logger.debug(`Block ${blockNumber} is already proven`);
+            if (checkpointNumber <= proven) {
+                this.logger.debug(`Checkpoint ${checkpointNumber} 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);
+            const provenCheckpointNumberSlot = 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 newValue = BigInt(tipsBefore.pending) << 128n | BigInt(checkpointNumber);
+            await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenCheckpointNumberSlot, newValue);
             const tipsAfter = await this.getTips();
             if (tipsAfter.pending < tipsAfter.proven) {
-                throw new Error('Overwrote pending tip to a block in the past');
+                throw new Error('Overwrote pending tip to a checkpoint in the past');
             }
             this.logger.info(`Proven tip moved: ${tipsBefore.proven} -> ${tipsAfter.proven}. Pending tip: ${tipsAfter.pending}.`);
         });
     }
     /**
+   * Polls the rollup until its current epoch reaches `epoch`. Unlike {@link advanceToEpoch} this does
+   * not warp the L1 clock; it only waits for the chain to reach `epoch` through external activity.
+   */ async waitForEpoch(epoch, opts = {}) {
+        await retryUntil(async ()=>await this.getEpoch() >= epoch || undefined, `rollup epoch >= ${epoch}`, opts.timeout ?? 60, opts.interval ?? 1);
+    }
+    /**
+   * Polls the rollup until its current slot reaches `slot`. Unlike {@link advanceToSlot} this does not
+   * warp the L1 clock; it only waits for the chain to reach `slot` through external activity.
+   */ async waitForSlot(slot, opts = {}) {
+        await retryUntil(async ()=>await this.getSlot() >= slot || undefined, `rollup slot >= ${slot}`, opts.timeout ?? 60, opts.interval ?? 1);
+    }
+    /**
+   * Polls the rollup until its pending checkpoint settles below `checkpoint` on a freshly mined, non-zero
+   * checkpoint, and returns that new pending checkpoint number. Reads the L1 rollup contract directly
+   * rather than a node, since a rollback lands on L1 first.
+   *
+   * A prune can momentarily drop the pending checkpoint to 0 before the post-deadline propose mines its
+   * replacement, so a caller detecting a rollback wants the new lower checkpoint, not that transient
+   * empty state — hence the non-zero guard.
+   */ async waitForCheckpointBelow(checkpoint, opts = {}) {
+        return await retryUntil(async ()=>{
+            const { pending } = await this.getTips();
+            return pending > 0 && pending < checkpoint ? pending : undefined;
+        }, `rollup checkpoint in (0, ${checkpoint})`, opts.timeout ?? 60, opts.interval ?? 1);
+    }
+    /**
    * Overrides the inProgress field of the Inbox contract state
-   * @param howMuch - How many blocks to move it forward
+   * @param howMuch - How many checkpoints to move it forward
    */ advanceInboxInProgress(howMuch) {
         return this.ethCheatCodes.execWithPausedAnvil(async ()=>{
             // Storage slot 2 contains the InboxState struct
@@ -204,6 +275,14 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
             return newInProgress;
         });
     }
+    insertOutbox(epoch, numCheckpointsInEpoch, outHash) {
+        return this.ethCheatCodes.execWithPausedAnvil(async ()=>{
+            const outboxAddress = await this.rollup.read.getOutbox();
+            const epochRootSlot = OutboxContract.getEpochRootStorageSlot(epoch, numCheckpointsInEpoch);
+            await this.ethCheatCodes.store(EthAddress.fromString(outboxAddress), epochRootSlot, outHash);
+            this.logger.warn(`Advanced outbox to epoch ${epoch} numCheckpointsInEpoch ${numCheckpointsInEpoch} with out hash ${outHash}`);
+        });
+    }
     /**
    * Executes an action impersonated as the owner of the Rollup contract.
    * @param action - The action to execute
@@ -248,7 +327,8 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
         await this.setProvingCostPerMana(newCost);
     }
     /**
-   * Directly updates proving cost per mana.
+   * Directly updates proving cost per mana. Throws if the on-chain tx reverts
+   * (e.g. rate-limit cooldown, step cap, or floor) instead of silently succeeding.
    * @param ethValue - The new proving cost per mana in ETH
    */ async setProvingCostPerMana(ethValue) {
         await this.asOwner(async (account, rollup)=>{
@@ -259,10 +339,33 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
                 chain: this.client.chain,
                 gasLimit: 1000000n
             });
-            await this.client.waitForTransactionReceipt({
+            const receipt = await this.client.waitForTransactionReceipt({
                 hash
             });
+            if (receipt.status !== 'success') {
+                throw new Error(`setProvingCostPerMana(${ethValue}) reverted on L1 (tx ${hash}). ` + `Likely FeeLib rate-limit (30-day cooldown or 1.5x step cap); ` + `use clearProvingCostCooldown() between successive updates.`);
+            }
             this.logger.warn(`Updated proving cost per mana to ${ethValue}`);
         });
     }
+    /**
+   * Resets the 30-day proving-cost update cooldown enforced by FeeLib.updateProvingCostPerMana
+   * by zeroing `FeeStore.provingCostLastUpdate` directly in contract storage. Use between
+   * successive setProvingCostPerMana / bumpProvingCostPerMana calls so the later update can
+   * land instead of reverting. Does not touch L1 time, so PXE/tx-expiration state stays intact.
+   *
+   * @note This is tightly coupled to the `FeeStore` layout in
+   * l1-contracts/src/core/libraries/rollup/FeeLib.sol:
+   *   slot + 0: CompressedFeeConfig config          (uint256)
+   *   slot + 1: L1GasOracleValues l1GasOracleValues (14+14+4 bytes, packed)
+   *   slot + 2: uint64 provingCostLastUpdate        (only member — zeroing the slot is safe)
+   * If the struct layout changes, update the offset below.
+   */ async clearProvingCostCooldown() {
+        const feeStoreBaseSlot = hexToBigInt(keccak256(Buffer.from('aztec.fee.storage', 'utf-8')));
+        const provingCostLastUpdateSlot = feeStoreBaseSlot + 2n;
+        await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provingCostLastUpdateSlot, 0n, {
+            silent: true
+        });
+        this.logger.warn(`Cleared proving-cost update cooldown`);
+    }
 }

package/dest/test/start_anvil.d.ts

@@ -1,4 +1,11 @@
-import { type Anvil } from '@viem/anvil';
+import type { TestDateProvider } from '@aztec/foundation/timer';
+/** Minimal interface matching the @viem/anvil Anvil shape used by callers. */
+export interface Anvil {
+    readonly port: number;
+    readonly host: string;
+    readonly status: 'listening' | 'idle';
+    stop(): Promise<void>;
+}
 /**
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */
@@ -8,10 +15,26 @@ export declare function startAnvil(opts?: {
     log?: boolean;
     captureMethodCalls?: boolean;
     accounts?: number;
+    chainId?: number;
+    /** The hardfork to use (e.g. 'cancun', 'latest'). */
+    hardfork?: string;
+    /**
+     * Number of slots per epoch used by anvil to compute the 'finalized' and 'safe' block tags.
+     * Anvil reports `finalized = latest - slotsInAnEpoch * 2`.
+     * Defaults to 1 so the finalized block advances immediately, making tests that check
+     * L1-finality-based logic work without needing hundreds of mined blocks.
+     */
+    slotsInAnEpoch?: number;
+    /**
+     * If provided, the date provider will be synced to anvil's block time on every mined block.
+     * This keeps the dateProvider in lockstep with anvil's chain time, avoiding drift between
+     * the wall clock and the L1 chain when computing L1 slot timestamps.
+     */
+    dateProvider?: TestDateProvider;
 }): Promise<{
     anvil: Anvil;
     methodCalls?: string[];
     rpcUrl: string;
     stop: () => Promise<void>;
 }>;
-//# sourceMappingURL=start_anvil.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnRfYW52aWwuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L3N0YXJ0X2FudmlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFNaEUsOEVBQThFO0FBQzlFLE1BQU0sV0FBVyxLQUFLO0lBQ3BCLFFBQVEsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLFFBQVEsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLFFBQVEsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE1BQU0sQ0FBQztJQUN0QyxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQ3ZCO0FBRUQ7O0dBRUc7QUFDSCx3QkFBc0IsVUFBVSxDQUM5QixJQUFJLEdBQUU7SUFDSixJQUFJLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDZCxXQUFXLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDckIsR0FBRyxDQUFDLEVBQUUsT0FBTyxDQUFDO0lBQ2Qsa0JBQWtCLENBQUMsRUFBRSxPQUFPLENBQUM7SUFDN0IsUUFBUSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLE9BQU8sQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNqQixxREFBcUQ7SUFDckQsUUFBUSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2xCOzs7OztPQUtHO0lBQ0gsY0FBYyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3hCOzs7O09BSUc7SUFDSCxZQUFZLENBQUMsRUFBRSxnQkFBZ0IsQ0FBQztDQUM1QixHQUNMLE9BQU8sQ0FBQztJQUFFLEtBQUssRUFBRSxLQUFLLENBQUM7SUFBQyxXQUFXLENBQUMsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUFDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFBQyxJQUFJLEVBQUUsTUFBTSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUE7Q0FBRSxDQUFDLENBK0g5RiJ9

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":"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,CAgD9F"}
+{"version":3,"file":"start_anvil.d.ts","sourceRoot":"","sources":["../../src/test/start_anvil.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAMhE,8EAA8E;AAC9E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAAC;IACtC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED;;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;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;CAC5B,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+H9F"}

package/dest/test/start_anvil.js

@@ -1,7 +1,7 @@
 import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { fileURLToPath } from '@aztec/foundation/url';
-import { createAnvil } from '@viem/anvil';
+import { spawn } from 'child_process';
 import { dirname, resolve } from 'path';
 /**
  * Ensures there's a running Anvil instance and returns the RPC URL.
@@ -9,46 +9,161 @@ import { dirname, resolve } from 'path';
     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.
-    // We go via a wrapper script to ensure if the parent dies, anvil dies.
+    let detectedPort;
     const anvil = await retry(async ()=>{
-        const anvil = createAnvil({
-            anvilBinary,
-            host: '127.0.0.1',
-            port: opts.port ?? 8545,
-            blockTime: opts.l1BlockTime,
-            stopTimeout: 1000,
-            accounts: opts.accounts ?? 20,
-            gasLimit: 45_000_000n
-        });
-        // 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]);
+        const port = opts.port ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : 8545);
+        const args = [
+            '--host',
+            '127.0.0.1',
+            '--port',
+            String(port),
+            '--accounts',
+            String(opts.accounts ?? 20),
+            '--gas-limit',
+            String(45_000_000),
+            '--chain-id',
+            String(opts.chainId ?? 31337)
+        ];
+        if (opts.l1BlockTime !== undefined) {
+            args.push('--block-time', String(opts.l1BlockTime));
+        }
+        if (opts.hardfork !== undefined) {
+            args.push('--hardfork', opts.hardfork);
+        }
+        args.push('--slots-in-an-epoch', String(opts.slotsInAnEpoch ?? 1));
+        const child = spawn(anvilBinary, args, {
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ],
+            env: {
+                ...process.env,
+                RAYON_NUM_THREADS: '1'
             }
         });
-        await anvil.start();
-        if (!logger && !opts.captureMethodCalls) {
-            removeHandler();
+        // Wait for "Listening on" or an early exit.
+        await new Promise((resolve, reject)=>{
+            let stderr = '';
+            const onStdout = (data)=>{
+                const text = data.toString();
+                logger?.debug(text.trim());
+                methodCalls?.push(...text.match(/eth_[^\s]+/g) || []);
+                if (detectedPort === undefined && text.includes('Listening on')) {
+                    const match = text.match(/Listening on ([^:]+):(\d+)/);
+                    if (match) {
+                        detectedPort = parseInt(match[2]);
+                    }
+                }
+                if (detectedPort !== undefined) {
+                    child.stdout?.removeListener('data', onStdout);
+                    child.stderr?.removeListener('data', onStderr);
+                    child.removeListener('close', onClose);
+                    resolve();
+                }
+            };
+            const onStderr = (data)=>{
+                stderr += data.toString();
+                logger?.debug(data.toString().trim());
+            };
+            const onClose = (code)=>{
+                child.stdout?.removeListener('data', onStdout);
+                child.stderr?.removeListener('data', onStderr);
+                reject(new Error(`Anvil exited with code ${code} before listening. stderr: ${stderr}`));
+            };
+            child.stdout?.on('data', onStdout);
+            child.stderr?.on('data', onStderr);
+            child.once('close', onClose);
+        });
+        // Continue piping for logging, method-call capture, and/or dateProvider sync after startup.
+        if (logger || opts.captureMethodCalls || opts.dateProvider) {
+            child.stdout?.on('data', (data)=>{
+                const text = data.toString();
+                logger?.debug(text.trim());
+                methodCalls?.push(...text.match(/eth_[^\s]+/g) || []);
+                if (opts.dateProvider) {
+                    syncDateProviderFromAnvilOutput(text, opts.dateProvider);
+                }
+            });
+            child.stderr?.on('data', (data)=>{
+                logger?.debug(data.toString().trim());
+            });
+        } else {
+            // Consume streams so the child process doesn't block on full pipe buffers.
+            child.stdout?.resume();
+            child.stderr?.resume();
         }
-        return anvil;
+        return child;
     }, 'Start anvil', makeBackoff([
         5,
         5,
         5
     ]));
-    if (!port) {
+    if (!detectedPort) {
         throw new Error('Failed to start anvil');
     }
-    // Monkeypatch the anvil instance to include the actually assigned port
-    // Object.defineProperty(anvil, 'port', { value: port, writable: false });
+    const port = detectedPort;
+    let status = 'listening';
+    anvil.once('close', ()=>{
+        status = 'idle';
+    });
+    const stop = async ()=>{
+        if (status === 'idle') {
+            return;
+        }
+        await killChild(anvil);
+    };
+    const anvilObj = {
+        port,
+        host: '127.0.0.1',
+        get status () {
+            return status;
+        },
+        stop
+    };
     return {
-        anvil,
+        anvil: anvilObj,
         methodCalls,
-        stop: ()=>anvil.stop(),
+        stop,
         rpcUrl: `http://127.0.0.1:${port}`
     };
 }
+/** Extracts block time from anvil stdout and syncs the dateProvider. */ function syncDateProviderFromAnvilOutput(text, dateProvider) {
+    // Anvil logs mined blocks as:
+    //   Block Time: "Fri, 20 Mar 2026 02:10:46 +0000"
+    const match = text.match(/Block Time:\s*"([^"]+)"/);
+    if (match) {
+        const blockTimeMs = new Date(match[1]).getTime();
+        if (!isNaN(blockTimeMs)) {
+            dateProvider.setTime(blockTimeMs);
+        }
+    }
+}
+/** Send SIGTERM, wait up to 5 s, then SIGKILL. All timers are always cleared. */ function killChild(child) {
+    return new Promise((resolve)=>{
+        if (child.exitCode !== null || child.killed) {
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            resolve();
+            return;
+        }
+        let killTimer;
+        const onClose = ()=>{
+            if (killTimer !== undefined) {
+                clearTimeout(killTimer);
+            }
+            // Destroy stdio streams so their PipeWrap handles don't keep the event loop alive.
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            resolve();
+        };
+        child.once('close', onClose);
+        child.kill('SIGTERM');
+        killTimer = setTimeout(()=>{
+            killTimer = undefined;
+            child.kill('SIGKILL');
+        }, 5000);
+        // Ensure the timer does not prevent Node from exiting.
+        killTimer.unref();
+    });
+}

package/dest/test/upgrade_utils.d.ts

@@ -9,4 +9,4 @@ export declare function createGovernanceProposal(payloadAddress: `0x${string}`,
     voteAmount: bigint;
     proposalId: bigint;
 }>;
-//# sourceMappingURL=upgrade_utils.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBncmFkZV91dGlscy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3QvdXBncmFkZV91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFHbEUsT0FBTyxFQUFFLEtBQUsscUJBQXFCLEVBQUUsS0FBSyxpQkFBaUIsRUFBZSxNQUFNLE1BQU0sQ0FBQztBQUd2RixPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRXZFLE9BQU8sS0FBSyxFQUFFLHdCQUF3QixFQUFFLGdCQUFnQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRzlFLHdCQUFzQix5QkFBeUIsQ0FDN0MsVUFBVSxFQUFFLE1BQU0sRUFDbEIsVUFBVSxFQUFFLHFCQUFxQixDQUFDLE9BQU8sYUFBYSxFQUFFLGdCQUFnQixDQUFDLEVBQ3pFLFVBQVUsRUFBRSxNQUFNLEVBQ2xCLFVBQVUsRUFBRSxpQkFBaUIsRUFDN0IsUUFBUSxFQUFFLHdCQUF3QixFQUNsQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQ2pCLE1BQU0sRUFBRSxNQUFNLGlCQW1DZjtBQUVELHdCQUFzQix3QkFBd0IsQ0FDNUMsY0FBYyxFQUFFLEtBQUssTUFBTSxFQUFFLEVBQzdCLFNBQVMsRUFBRSxtQkFBbUIsRUFDOUIsVUFBVSxFQUFFLGlCQUFpQixFQUM3QixZQUFZLEVBQUUsZ0JBQWdCLEVBQzlCLE1BQU0sRUFBRSxNQUFNLEdBQ2IsT0FBTyxDQUFDO0lBQ1QsVUFBVSxFQUFFLHFCQUFxQixDQUFDLE9BQU8sYUFBYSxFQUFFLGdCQUFnQixDQUFDLENBQUM7SUFDMUUsVUFBVSxFQUFFLE1BQU0sQ0FBQztJQUNuQixVQUFVLEVBQUUsTUFBTSxDQUFDO0NBQ3BCLENBQUMsQ0F5Q0QifQ==

package/dest/test/upgrade_utils.js

@@ -3,13 +3,13 @@ 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/index.js';
+import { createL1TxUtils } 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([
         proposalId
     ]);
-    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
+    const l1TxUtils = createL1TxUtils(l1Client);
     const waitL1Block = async ()=>{
         await l1TxUtils.sendAndMonitorTransaction({
             to: l1Client.account.address,