@aztec/ethereum 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/dest/test/rollup_cheat_codes.d.ts

@@ -0,0 +1,87 @@
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+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';
+/** Cheat codes for the L1 rollup contract. */
+export declare class RollupCheatCodes {
+    private ethCheatCodes;
+    private client;
+    private rollup;
+    private logger;
+    constructor(ethCheatCodes: EthCheatCodes, addresses: Pick<L1ContractAddresses, 'rollupAddress'>);
+    static create(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>, dateProvider: DateProvider): RollupCheatCodes;
+    /** Returns the current slot */
+    getSlot(): Promise<SlotNumber>;
+    /** Returns the current epoch */
+    getEpoch(): Promise<EpochNumber>;
+    /**
+     * Returns the pending and proven chain tips
+     * @returns The pending and proven chain tips
+     */
+    getTips(): Promise<{
+        /** The pending chain tip */ pending: CheckpointNumber;
+        /** The proven chain tip */ proven: CheckpointNumber;
+    }>;
+    /**
+     * Logs the current state of the rollup contract.
+     */
+    debugRollup(): Promise<void>;
+    /** Fetches the epoch and slot duration config from the rollup contract */
+    getConfig(): Promise<{
+        /** Epoch duration */ epochDuration: bigint;
+        /** Slot duration */ slotDuration: number;
+    }>;
+    /**
+     * Advances time to the beginning of the given epoch
+     * @param epoch - The epoch to advance to
+     * @param opts - Options
+     */
+    advanceToEpoch(epoch: EpochNumber, opts?: {
+        /** Offset in seconds */
+        offset?: number;
+    }): Promise<bigint>;
+    /** Warps time in L1 until the next epoch */
+    advanceToNextEpoch(): Promise<void>;
+    /** Warps time in L1 until the beginning of the next slot. */
+    advanceToNextSlot(): Promise<(bigint | SlotNumber)[]>;
+    /**
+     * Warps time in L1 equivalent to however many slots.
+     * @param howMany - The number of slots to advance.
+     */
+    advanceSlots(howMany: number): Promise<void>;
+    /**
+     * Marks the specified checkpoint (or latest if none) as proven
+     * @param maybeCheckpointNumber - The checkpoint number to mark as proven (defaults to latest pending)
+     */
+    markAsProven(maybeCheckpointNumber?: number | bigint): Promise<void>;
+    /**
+     * Overrides the inProgress field of the Inbox contract state
+     * @param howMuch - How many checkpoints 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
+     */
+    asOwner(action: (owner: Hex, rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>) => Promise<void>): Promise<void>;
+    /**
+     * Sets up the epoch.
+     */
+    setupEpoch(): Promise<void>;
+    /** Directly calls the L1 gas fee oracle. */
+    updateL1GasFeeOracle(): Promise<void>;
+    /**
+     * Bumps proving cost per mana.
+     * @param bumper - Callback to calculate the new proving cost per mana based on current value.
+     */
+    bumpProvingCostPerMana(bumper: (before: bigint) => bigint): Promise<void>;
+    /**
+     * Directly updates proving cost per mana.
+     * @param ethValue - The new proving cost per mana in ETH
+     */
+    setProvingCostPerMana(ethValue: bigint): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rollup_cheat_codes.d.ts","sourceRoot":"","sources":["../../src/test/rollup_cheat_codes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAG5F,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;AAEd,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;IAErD,YACU,aAAa,EAAE,aAAa,EACpC,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,EAWtD;IAED,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,EACrD,YAAY,EAAE,YAAY,GACzB,gBAAgB,CAGlB;IAED,+BAA+B;IAClB,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC,CAG1C;IAED,gCAAgC;IACnB,QAAQ,IAAI,OAAO,CAAC,WAAW,CAAC,CAG5C;IAED;;;OAGG;IACU,OAAO,IAAI,OAAO,CAAC;QAC9B,4BAA4B,CAAC,OAAO,EAAE,gBAAgB,CAAC;QACvD,2BAA2B,CAAC,MAAM,EAAE,gBAAgB,CAAC;KACtD,CAAC,CAMD;IAED;;OAEG;IACU,WAAW,kBAiBvB;IAED,0EAA0E;IAC7D,SAAS,IAAI,OAAO,CAAC;QAChC,qBAAqB,CAAC,aAAa,EAAE,MAAM,CAAC;QAC5C,oBAAoB,CAAC,YAAY,EAAE,MAAM,CAAC;KAC3C,CAAC,CAMD;IAED;;;;OAIG;IACU,cAAc,CACzB,KAAK,EAAE,WAAW,EAClB,IAAI,GAAE;QACJ,wBAAwB;QACxB,MAAM,CAAC,EAAE,MAAM,CAAC;KACZ,mBAYP;IAED,4CAA4C;IAC/B,kBAAkB,kBAW9B;IAED,6DAA6D;IAChD,iBAAiB,qCAO7B;IAED;;;OAGG;IACU,YAAY,CAAC,OAAO,EAAE,MAAM,iBAOxC;IAED;;;OAGG;IACI,YAAY,CAAC,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,iBA+B1D;IAED;;;OAGG;IACI,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAmCvE;IAED;;;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,iBAMzG;IAED;;OAEG;IACU,UAAU,kBAOtB;IAED,4CAA4C;IAC/B,oBAAoB,kBAMhC;IAED;;;OAGG;IACU,sBAAsB,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,iBAIrE;IAED;;;OAGG;IACU,qBAAqB,CAAC,QAAQ,EAAE,MAAM,iBAUlD;CACF"}

package/dest/test/rollup_cheat_codes.js

@@ -0,0 +1,275 @@
+import { 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 { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { createPublicClient, fallback, getContract, hexToBigInt, http } from 'viem';
+import { EthCheatCodes } from './eth_cheat_codes.js';
+/** Cheat codes for the L1 rollup contract. */ export class RollupCheatCodes {
+    ethCheatCodes;
+    client;
+    rollup;
+    logger;
+    constructor(ethCheatCodes, addresses){
+        this.ethCheatCodes = ethCheatCodes;
+        this.logger = createLogger('aztecjs:cheat_codes');
+        this.client = createPublicClient({
+            chain: ethCheatCodes.chain,
+            transport: fallback(ethCheatCodes.rpcUrls.map((url)=>http(url, {
+                    batch: false
+                })))
+        });
+        this.rollup = getContract({
+            abi: RollupAbi,
+            address: addresses.rollupAddress.toString(),
+            client: this.client
+        });
+    }
+    static create(rpcUrls, addresses, dateProvider) {
+        const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
+        return new RollupCheatCodes(ethCheatCodes, addresses);
+    }
+    /** Returns the current slot */ async getSlot() {
+        const ts = BigInt((await this.client.getBlock()).timestamp);
+        return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([
+            ts
+        ]));
+    }
+    /** Returns the current epoch */ async getEpoch() {
+        const slotNumber = await this.getSlot();
+        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 { pending, proven } = await this.rollup.read.getTips();
+        return {
+            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.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 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}`);
+        this.logger.info(`Epoch num: ${epochNum}`);
+        this.logger.info(`Slot: ${slot}`);
+    }
+    /** Fetches the epoch and slot duration config from the rollup contract */ async getConfig() {
+        const [epochDuration, slotDuration] = await Promise.all([
+            this.rollup.read.getEpochDuration(),
+            this.rollup.read.getSlotDuration()
+        ]);
+        return {
+            epochDuration,
+            slotDuration: Number(slotDuration)
+        };
+    }
+    /**
+   * Advances time to the beginning of the given epoch
+   * @param epoch - The epoch to advance to
+   * @param opts - Options
+   */ async advanceToEpoch(epoch, opts = {}) {
+        const { epochDuration: slotsInEpoch } = await this.getConfig();
+        const slotNumber = SlotNumber(epoch * Number(slotsInEpoch));
+        const timestamp = await this.rollup.read.getTimestampForSlot([
+            BigInt(slotNumber)
+        ]) + BigInt(opts.offset ?? 0);
+        try {
+            await this.ethCheatCodes.warp(Number(timestamp), {
+                ...opts,
+                silent: true,
+                resetBlockInterval: true
+            });
+            this.logger.warn(`Warped to epoch ${epoch}`, {
+                offset: opts.offset,
+                timestamp
+            });
+        } catch (err) {
+            this.logger.warn(`Warp to epoch ${epoch} failed: ${err}`);
+        }
+        return timestamp;
+    }
+    /** Warps time in L1 until the next epoch */ async advanceToNextEpoch() {
+        const slot = await this.getSlot();
+        const { epochDuration, slotDuration } = await this.getConfig();
+        const slotsUntilNextEpoch = epochDuration - 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,
+            resetBlockInterval: true
+        });
+        this.logger.warn(`Advanced to next epoch`);
+    }
+    /** Warps time in L1 until the beginning of the next slot. */ async advanceToNextSlot() {
+        const currentSlot = await this.getSlot();
+        const nextSlot = SlotNumber(currentSlot + 1);
+        const timestamp = await this.rollup.read.getTimestampForSlot([
+            BigInt(nextSlot)
+        ]);
+        await this.ethCheatCodes.warp(Number(timestamp), {
+            silent: true,
+            resetBlockInterval: true
+        });
+        this.logger.warn(`Advanced to slot ${nextSlot}`);
+        return [
+            timestamp,
+            nextSlot
+        ];
+    }
+    /**
+   * 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 = Number(await this.rollup.read.getSlotDuration());
+        const timeToWarp = BigInt(howMany) * BigInt(slotDuration);
+        await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, {
+            silent: true,
+            resetBlockInterval: true
+        });
+        const [slot, epoch] = await Promise.all([
+            this.getSlot(),
+            this.getEpoch()
+        ]);
+        this.logger.warn(`Advanced ${howMany} slots up to slot ${slot} in epoch ${epoch}`);
+    }
+    /**
+   * Marks the specified 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 checkpointNumber = maybeCheckpointNumber;
+            if (checkpointNumber === undefined || checkpointNumber > pending) {
+                checkpointNumber = pending;
+            }
+            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 provenCheckpointNumberSlot = hexToBigInt(RollupContract.stfStorageSlot);
+            // Need to pack it as a single 32 byte word
+            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 checkpoint in the past');
+            }
+            this.logger.info(`Proven tip moved: ${tipsBefore.proven} -> ${tipsAfter.proven}. Pending tip: ${tipsAfter.pending}.`);
+        });
+    }
+    /**
+   * Overrides the inProgress field of the Inbox contract state
+   * @param howMuch - How many checkpoints 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) {
+        const owner = await this.rollup.read.owner();
+        await this.ethCheatCodes.startImpersonating(owner);
+        await action(owner, this.rollup);
+        await this.ethCheatCodes.stopImpersonating(owner);
+    }
+    /**
+   * Sets up the epoch.
+   */ async setupEpoch() {
+        // Doesn't need to be done as owner, but the functionality is here...
+        await this.asOwner(async (account, rollup)=>{
+            const hash = await rollup.write.setupEpoch({
+                account
+            });
+            await this.client.waitForTransactionReceipt({
+                hash
+            });
+            this.logger.warn(`Setup epoch`);
+        });
+    }
+    /** Directly calls the L1 gas fee oracle. */ async updateL1GasFeeOracle() {
+        await this.asOwner(async (account, rollup)=>{
+            const hash = await rollup.write.updateL1GasFeeOracle({
+                account,
+                chain: this.client.chain
+            });
+            await this.client.waitForTransactionReceipt({
+                hash
+            });
+            this.logger.warn(`Updated L1 gas fee oracle`);
+        });
+    }
+    /**
+   * Bumps proving cost per mana.
+   * @param bumper - Callback to calculate the new proving cost per mana based on current value.
+   */ async bumpProvingCostPerMana(bumper) {
+        const currentCost = await this.rollup.read.getProvingCostPerManaInEth();
+        const newCost = bumper(currentCost);
+        await this.setProvingCostPerMana(newCost);
+    }
+    /**
+   * Directly updates proving cost per mana.
+   * @param ethValue - The new proving cost per mana in ETH
+   */ async setProvingCostPerMana(ethValue) {
+        await this.asOwner(async (account, rollup)=>{
+            const hash = await rollup.write.setProvingCostPerMana([
+                ethValue
+            ], {
+                account,
+                chain: this.client.chain,
+                gasLimit: 1000000n
+            });
+            await this.client.waitForTransactionReceipt({
+                hash
+            });
+            this.logger.warn(`Updated proving cost per mana to ${ethValue}`);
+        });
+    }
+}

package/dest/test/start_anvil.d.ts

@@ -3,10 +3,18 @@ import { type Anvil } from '@viem/anvil';
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */
 export declare function startAnvil(opts?: {
+    port?: number;
     l1BlockTime?: number;
+    log?: boolean;
+    captureMethodCalls?: boolean;
+    accounts?: number;
+    chainId?: number;
+    /** The hardfork to use - note: @viem/anvil types are out of date but 'cancun' and 'latest' work */
+    hardfork?: string;
 }): Promise<{
     anvil: Anvil;
+    methodCalls?: string[];
     rpcUrl: string;
     stop: () => Promise<void>;
 }>;
-//# sourceMappingURL=start_anvil.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnRfYW52aWwuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L3N0YXJ0X2FudmlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFBRSxLQUFLLEtBQUssRUFBZSxNQUFNLGFBQWEsQ0FBQztBQUd0RDs7R0FFRztBQUNILHdCQUFzQixVQUFVLENBQzlCLElBQUksR0FBRTtJQUNKLElBQUksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNkLFdBQVcsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNyQixHQUFHLENBQUMsRUFBRSxPQUFPLENBQUM7SUFDZCxrQkFBa0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQztJQUM3QixRQUFRLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbEIsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLG1HQUFtRztJQUNuRyxRQUFRLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDZCxHQUNMLE9BQU8sQ0FBQztJQUFFLEtBQUssRUFBRSxLQUFLLENBQUM7SUFBQyxXQUFXLENBQUMsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUFDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFBQyxJQUFJLEVBQUUsTUFBTSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUE7Q0FBRSxDQUFDLENBaUQ5RiJ9

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

@@ -1 +1 @@
-{"version":3,"file":"start_anvil.d.ts","sourceRoot":"","sources":["../../src/test/start_anvil.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,aAAa,CAAC;AAGtD;;GAEG;AACH,wBAAsB,UAAU,CAC9B,IAAI,GAAE;IACJ,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GACL,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAsCtE"}
+{"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;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,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,CAiD9F"}

package/dest/test/start_anvil.js

@@ -1,3 +1,4 @@
+import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { fileURLToPath } from '@aztec/foundation/url';
 import { createAnvil } from '@viem/anvil';
@@ -6,24 +7,34 @@ import { dirname, resolve } from 'path';
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */ export async function startAnvil(opts = {}) {
     const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
+    const logger = opts.log ? createLogger('ethereum:anvil') : undefined;
+    const methodCalls = opts.captureMethodCalls ? [] : undefined;
     let port;
     // Start anvil.
     // We go via a wrapper script to ensure if the parent dies, anvil dies.
     const anvil = await retry(async ()=>{
         const anvil = createAnvil({
             anvilBinary,
-            port: 0,
+            host: '127.0.0.1',
+            port: opts.port ?? 8545,
             blockTime: opts.l1BlockTime,
-            stopTimeout: 1000
+            stopTimeout: 1000,
+            accounts: opts.accounts ?? 20,
+            gasLimit: 45_000_000n,
+            chainId: opts.chainId ?? 31337
         });
         // Listen to the anvil output to get the port.
         const removeHandler = anvil.on('message', (message)=>{
+            logger?.debug(message.trim());
+            methodCalls?.push(...message.match(/eth_[^\s]+/g) || []);
             if (port === undefined && message.includes('Listening on')) {
                 port = parseInt(message.match(/Listening on ([^:]+):(\d+)/)[2]);
             }
         });
         await anvil.start();
-        removeHandler();
+        if (!logger && !opts.captureMethodCalls) {
+            removeHandler();
+        }
         return anvil;
     }, 'Start anvil', makeBackoff([
         5,
@@ -34,12 +45,10 @@ import { dirname, resolve } from 'path';
         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
-    });
+    // Object.defineProperty(anvil, 'port', { value: port, writable: false });
     return {
         anvil,
+        methodCalls,
         stop: ()=>anvil.stop(),
         rpcUrl: `http://127.0.0.1:${port}`
     };

package/dest/test/tx_delayer.d.ts

@@ -1,25 +1,36 @@
 import { type Logger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
 import { type Client, type Hex } from 'viem';
-import type { ViemWalletClient } from '../types.js';
-export declare function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger): Promise<boolean>;
-export declare function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: Logger): Promise<boolean>;
+import { type ViemClient } from '../types.js';
+export declare function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger, timeout?: number): Promise<boolean>;
+export declare function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: Logger, timeout?: number): Promise<boolean>;
 export interface Delayer {
-    /** Returns the list of all txs (not just the delayed ones) sent through the attached client. */
-    getTxs(): Hex[];
+    /** Returns the hashes of all effectively sent txs. */
+    getSentTxHashes(): Hex[];
+    /** Returns the raw hex for all cancelled txs. */
+    getCancelledTxs(): Hex[];
     /** Delays the next tx to be sent so it lands on the given L1 block number. */
     pauseNextTxUntilBlock(l1BlockNumber: number | bigint | undefined): void;
     /** Delays the next tx to be sent so it lands on the given timestamp. */
     pauseNextTxUntilTimestamp(l1Timestamp: number | bigint | undefined): void;
+    /** Delays the next tx to be sent indefinitely. */
+    cancelNextTx(): void;
+    /**
+     * Sets max inclusion time into slot. If more than this many seconds have passed
+     * since the last L1 block was mined, then any tx will not be mined in the current
+     * L1 slot but will be deferred for the next one.
+     */
+    setMaxInclusionTimeIntoSlot(seconds: number | bigint | undefined): void;
 }
 /**
  * Returns a new client (without modifying the one passed in) with an injected tx delayer.
  * The delayer can be used to hold off the next tx to be sent until a given block number.
  * TODO(#10824): This doesn't play along well with blob txs for some reason.
  */
-export declare function withDelayer<T extends ViemWalletClient>(client: T, opts: {
+export declare function withDelayer<T extends ViemClient>(client: T, dateProvider: DateProvider, opts: {
     ethereumSlotDuration: bigint | number;
 }): {
     client: T;
     delayer: Delayer;
 };
-//# sourceMappingURL=tx_delayer.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfZGVsYXllci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3QvdHhfZGVsYXllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFFbEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHNUQsT0FBTyxFQUNMLEtBQUssTUFBTSxFQUNYLEtBQUssR0FBRyxFQVFULE1BQU0sTUFBTSxDQUFDO0FBRWQsT0FBTyxFQUFFLEtBQUssVUFBVSxFQUFvQixNQUFNLGFBQWEsQ0FBQztBQUloRSx3QkFBZ0IsY0FBYyxDQUFDLENBQUMsU0FBUyxNQUFNLEVBQzdDLE1BQU0sRUFBRSxDQUFDLEVBQ1QsV0FBVyxFQUFFLE1BQU0sR0FBRyxNQUFNLEVBQzVCLE1BQU0sQ0FBQyxFQUFFLE1BQU0sRUFDZixPQUFPLENBQUMsRUFBRSxNQUFNLG9CQWlCakI7QUFFRCx3QkFBZ0Isb0JBQW9CLENBQUMsQ0FBQyxTQUFTLE1BQU0sRUFDbkQsTUFBTSxFQUFFLENBQUMsRUFDVCxTQUFTLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFDMUIsTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUNmLE9BQU8sQ0FBQyxFQUFFLE1BQU0sb0JBd0JqQjtBQUVELE1BQU0sV0FBVyxPQUFPO0lBQ3RCLHNEQUFzRDtJQUN0RCxlQUFlLElBQUksR0FBRyxFQUFFLENBQUM7SUFDekIsaURBQWlEO0lBQ2pELGVBQWUsSUFBSSxHQUFHLEVBQUUsQ0FBQztJQUN6Qiw4RUFBOEU7SUFDOUUscUJBQXFCLENBQUMsYUFBYSxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsU0FBUyxHQUFHLElBQUksQ0FBQztJQUN4RSx3RUFBd0U7SUFDeEUseUJBQXlCLENBQUMsV0FBVyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsU0FBUyxHQUFHLElBQUksQ0FBQztJQUMxRSxrREFBa0Q7SUFDbEQsWUFBWSxJQUFJLElBQUksQ0FBQztJQUNyQjs7OztPQUlHO0lBQ0gsMkJBQTJCLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsU0FBUyxHQUFHLElBQUksQ0FBQztDQUN6RTtBQTBDRDs7OztHQUlHO0FBQ0gsd0JBQWdCLFdBQVcsQ0FBQyxDQUFDLFNBQVMsVUFBVSxFQUM5QyxNQUFNLEVBQUUsQ0FBQyxFQUNULFlBQVksRUFBRSxZQUFZLEVBQzFCLElBQUksRUFBRTtJQUFFLG9CQUFvQixFQUFFLE1BQU0sR0FBRyxNQUFNLENBQUE7Q0FBRSxHQUM5QztJQUFFLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFBQyxPQUFPLEVBQUUsT0FBTyxDQUFBO0NBQUUsQ0EwR2pDIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"tx_delayer.d.ts","sourceRoot":"","sources":["../../src/test/tx_delayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,EACL,KAAK,MAAM,EACX,KAAK,GAAG,EAMT,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,oBAgBxG;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,oBAuB5G;AAED,MAAM,WAAW,OAAO;IACtB,gGAAgG;IAChG,MAAM,IAAI,GAAG,EAAE,CAAC;IAChB,8EAA8E;IAC9E,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACxE,wEAAwE;IACxE,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;CAC3E;AAwBD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,gBAAgB,EACpD,MAAM,EAAE,CAAC,EACT,IAAI,EAAE;IAAE,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAC9C;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA+DjC"}
+{"version":3,"file":"tx_delayer.d.ts","sourceRoot":"","sources":["../../src/test/tx_delayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EACL,KAAK,MAAM,EACX,KAAK,GAAG,EAQT,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,aAAa,CAAC;AAIhE,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,MAAM,EAAE,CAAC,EACT,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,oBAiBjB;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EACnD,MAAM,EAAE,CAAC,EACT,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,oBAwBjB;AAED,MAAM,WAAW,OAAO;IACtB,sDAAsD;IACtD,eAAe,IAAI,GAAG,EAAE,CAAC;IACzB,iDAAiD;IACjD,eAAe,IAAI,GAAG,EAAE,CAAC;IACzB,8EAA8E;IAC9E,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACxE,wEAAwE;IACxE,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IAC1E,kDAAkD;IAClD,YAAY,IAAI,IAAI,CAAC;IACrB;;;;OAIG;IACH,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;CACzE;AA0CD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,UAAU,EAC9C,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE;IAAE,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAC9C;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA0GjC"}