@aztec/aztec.js 0.0.0-test.0

package/dest/api/addresses.js

@@ -0,0 +1,2 @@
+export { AztecAddress } from '@aztec/stdlib/aztec-address';
+export { CompleteAddress } from '@aztec/stdlib/contract';

package/dest/api/cheat_codes.d.ts

@@ -0,0 +1,26 @@
+import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { AztecCheatCodes } from '../utils/aztec_cheatcodes.js';
+import { RollupCheatCodes } from './ethereum/cheat_codes.js';
+/**
+ * A class that provides utility functions for interacting with the chain.
+ */
+export declare class CheatCodes {
+    /** Cheat codes for L1.*/
+    eth: EthCheatCodes;
+    /** Cheat codes for Aztec L2. */
+    aztec: AztecCheatCodes;
+    /** Cheat codes for the Aztec Rollup contract on L1. */
+    rollup: RollupCheatCodes;
+    constructor(
+    /** Cheat codes for L1.*/
+    eth: EthCheatCodes, 
+    /** Cheat codes for Aztec L2. */
+    aztec: AztecCheatCodes, 
+    /** Cheat codes for the Aztec Rollup contract on L1. */
+    rollup: RollupCheatCodes);
+    static create(rpcUrls: string[], pxe: PXE): Promise<CheatCodes>;
+    static createRollup(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>): RollupCheatCodes;
+}
+//# sourceMappingURL=cheat_codes.d.ts.map

package/dest/api/cheat_codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cheat_codes.d.ts","sourceRoot":"","sources":["../../src/api/cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;GAEG;AACH,qBAAa,UAAU;IAEnB,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,gCAAgC;IACzB,KAAK,EAAE,eAAe;IAC7B,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;;IAL/B,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,gCAAgC;IACzB,KAAK,EAAE,eAAe;IAC7B,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;WAGpB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC;IAUrE,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,GAAG,gBAAgB;CAIhH"}

package/dest/api/cheat_codes.js

@@ -0,0 +1,25 @@
+import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
+import { AztecCheatCodes } from '../utils/aztec_cheatcodes.js';
+import { RollupCheatCodes } from './ethereum/cheat_codes.js';
+/**
+ * A class that provides utility functions for interacting with the chain.
+ */ export class CheatCodes {
+    eth;
+    aztec;
+    rollup;
+    constructor(/** Cheat codes for L1.*/ eth, /** Cheat codes for Aztec L2. */ aztec, /** Cheat codes for the Aztec Rollup contract on L1. */ rollup){
+        this.eth = eth;
+        this.aztec = aztec;
+        this.rollup = rollup;
+    }
+    static async create(rpcUrls, pxe) {
+        const ethCheatCodes = new EthCheatCodes(rpcUrls);
+        const aztecCheatCodes = new AztecCheatCodes(pxe);
+        const rollupCheatCodes = new RollupCheatCodes(ethCheatCodes, await pxe.getNodeInfo().then((n)=>n.l1ContractAddresses));
+        return new CheatCodes(ethCheatCodes, aztecCheatCodes, rollupCheatCodes);
+    }
+    static createRollup(rpcUrls, addresses) {
+        const ethCheatCodes = new EthCheatCodes(rpcUrls);
+        return new RollupCheatCodes(ethCheatCodes, addresses);
+    }
+}

package/dest/api/deployment.d.ts

@@ -0,0 +1,4 @@
+export { registerContractClass } from '../deployment/register_class.js';
+export { broadcastPrivateFunction, broadcastUnconstrainedFunction } from '../deployment/broadcast_function.js';
+export { deployInstance } from '../deployment/deploy_instance.js';
+//# sourceMappingURL=deployment.d.ts.map

package/dest/api/deployment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../../src/api/deployment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AAC/G,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC"}

package/dest/api/deployment.js

@@ -0,0 +1,3 @@
+export { registerContractClass } from '../deployment/register_class.js';
+export { broadcastPrivateFunction, broadcastUnconstrainedFunction } from '../deployment/broadcast_function.js';
+export { deployInstance } from '../deployment/deploy_instance.js';

package/dest/api/entrypoint.d.ts

@@ -0,0 +1,2 @@
+export * from '../entrypoint/entrypoint.js';
+//# sourceMappingURL=entrypoint.d.ts.map

package/dest/api/entrypoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoint.d.ts","sourceRoot":"","sources":["../../src/api/entrypoint.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/dest/api/entrypoint.js

@@ -0,0 +1 @@
+export * from '../entrypoint/entrypoint.js';

package/dest/api/eth_address.d.ts

@@ -0,0 +1,2 @@
+export { EthAddress } from '@aztec/foundation/eth-address';
+//# sourceMappingURL=eth_address.d.ts.map

package/dest/api/eth_address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eth_address.d.ts","sourceRoot":"","sources":["../../src/api/eth_address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC"}

package/dest/api/eth_address.js

@@ -0,0 +1 @@
+export { EthAddress } from '@aztec/foundation/eth-address';

package/dest/api/ethereum/anvil_test_watcher.d.ts

@@ -0,0 +1,32 @@
+import type { ViemPublicClient } from '@aztec/ethereum';
+import type { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { TestDateProvider } from '@aztec/foundation/timer';
+/**
+ * Represents a watcher for a rollup contract.
+ *
+ * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
+ * it will periodically check if the current slot have already been filled, e.g., there was an L2
+ * block within the slot. And if so, it will time travel into the next slot.
+ */
+export declare class AnvilTestWatcher {
+    private cheatcodes;
+    private dateProvider?;
+    private isSandbox;
+    private rollup;
+    private rollupCheatCodes;
+    private filledRunningPromise?;
+    private mineIfOutdatedPromise?;
+    private markingAsProvenRunningPromise?;
+    private logger;
+    private isMarkingAsProven;
+    constructor(cheatcodes: EthCheatCodes, rollupAddress: EthAddress, publicClient: ViemPublicClient, dateProvider?: TestDateProvider | undefined);
+    setIsMarkingAsProven(isMarkingAsProven: boolean): void;
+    setIsSandbox(isSandbox: boolean): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    markAsProven(): Promise<void>;
+    mineIfOutdated(): Promise<void>;
+    warpTimeIfNeeded(): Promise<void>;
+}
+//# sourceMappingURL=anvil_test_watcher.d.ts.map

package/dest/api/ethereum/anvil_test_watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anvil_test_watcher.d.ts","sourceRoot":"","sources":["../../../src/api/ethereum/anvil_test_watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAOhE;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAezB,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,YAAY,CAAC;IAjBvB,OAAO,CAAC,SAAS,CAAkB;IAEnC,OAAO,CAAC,MAAM,CAA4D;IAC1E,OAAO,CAAC,gBAAgB,CAAmB;IAE3C,OAAO,CAAC,oBAAoB,CAAC,CAAiB;IAC9C,OAAO,CAAC,qBAAqB,CAAC,CAAiB;IAC/C,OAAO,CAAC,6BAA6B,CAAC,CAAiB;IAEvD,OAAO,CAAC,MAAM,CAAiD;IAE/D,OAAO,CAAC,iBAAiB,CAAQ;gBAGvB,UAAU,EAAE,aAAa,EACjC,aAAa,EAAE,UAAU,EACzB,YAAY,EAAE,gBAAgB,EACtB,YAAY,CAAC,8BAAkB;IAezC,oBAAoB,CAAC,iBAAiB,EAAE,OAAO;IAI/C,YAAY,CAAC,SAAS,EAAE,OAAO;IAIzB,KAAK;IAwBL,IAAI;IAMJ,YAAY;IAOZ,cAAc;IAoBd,gBAAgB;CAwCvB"}

package/dest/api/ethereum/anvil_test_watcher.js

@@ -0,0 +1,133 @@
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { getAddress, getContract } from 'viem';
+import { RollupCheatCodes } from './cheat_codes.js';
+/**
+ * Represents a watcher for a rollup contract.
+ *
+ * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
+ * it will periodically check if the current slot have already been filled, e.g., there was an L2
+ * block within the slot. And if so, it will time travel into the next slot.
+ */ export class AnvilTestWatcher {
+    cheatcodes;
+    dateProvider;
+    isSandbox;
+    rollup;
+    rollupCheatCodes;
+    filledRunningPromise;
+    mineIfOutdatedPromise;
+    markingAsProvenRunningPromise;
+    logger;
+    isMarkingAsProven;
+    constructor(cheatcodes, rollupAddress, publicClient, dateProvider){
+        this.cheatcodes = cheatcodes;
+        this.dateProvider = dateProvider;
+        this.isSandbox = false;
+        this.logger = createLogger(`aztecjs:utils:watcher`);
+        this.isMarkingAsProven = true;
+        this.rollup = getContract({
+            address: getAddress(rollupAddress.toString()),
+            abi: RollupAbi,
+            client: publicClient
+        });
+        this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
+            rollupAddress
+        });
+        this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
+    }
+    setIsMarkingAsProven(isMarkingAsProven) {
+        this.isMarkingAsProven = isMarkingAsProven;
+    }
+    setIsSandbox(isSandbox) {
+        this.isSandbox = isSandbox;
+    }
+    async start() {
+        if (this.filledRunningPromise) {
+            throw new Error('Watcher already watching for filled slot');
+        }
+        // If auto mining is not supported (e.g., we are on a real network), then we
+        // will simple do nothing. But if on an anvil or the like, this make sure that
+        // the sandbox and tests don't break because time is frozen and we never get to
+        // the next slot.
+        const isAutoMining = await this.cheatcodes.isAutoMining();
+        if (isAutoMining) {
+            this.filledRunningPromise = new RunningPromise(()=>this.warpTimeIfNeeded(), this.logger, 1000);
+            this.filledRunningPromise.start();
+            this.mineIfOutdatedPromise = new RunningPromise(()=>this.mineIfOutdated(), this.logger, 1000);
+            this.mineIfOutdatedPromise.start();
+            this.markingAsProvenRunningPromise = new RunningPromise(()=>this.markAsProven(), this.logger, 1000);
+            this.markingAsProvenRunningPromise.start();
+            this.logger.info(`Watcher started for rollup at ${this.rollup.address}`);
+        } else {
+            this.logger.info(`Watcher not started because not auto mining`);
+        }
+    }
+    async stop() {
+        await this.filledRunningPromise?.stop();
+        await this.mineIfOutdatedPromise?.stop();
+        await this.markingAsProvenRunningPromise?.stop();
+    }
+    async markAsProven() {
+        if (!this.isMarkingAsProven) {
+            return;
+        }
+        await this.rollupCheatCodes.markAsProven();
+    }
+    async mineIfOutdated() {
+        // this doesn't apply to the sandbox, because we don't have a date provider in the sandbox
+        if (!this.dateProvider) {
+            return;
+        }
+        const l1Time = await this.cheatcodes.timestamp() * 1000;
+        const wallTime = this.dateProvider.now();
+        // If the wall time is more than 24 seconds away from L1 time,
+        // mine a block and sync the clocks
+        if (Math.abs(wallTime - l1Time) > 24 * 1000) {
+            this.logger.warn(`Wall time is more than 24 seconds away from L1 time, mining a block and syncing clocks`);
+            await this.cheatcodes.evmMine();
+            const newL1Time = await this.cheatcodes.timestamp();
+            this.logger.info(`New L1 time: ${newL1Time}`);
+            this.dateProvider.setTime(newL1Time * 1000);
+        }
+    }
+    async warpTimeIfNeeded() {
+        try {
+            const currentSlot = await this.rollup.read.getCurrentSlot();
+            const pendingBlockNumber = BigInt(await this.rollup.read.getPendingBlockNumber());
+            const blockLog = await this.rollup.read.getBlock([
+                pendingBlockNumber
+            ]);
+            const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([
+                currentSlot + 1n
+            ]));
+            if (currentSlot === blockLog.slotNumber) {
+                // We should jump to the next slot
+                try {
+                    await this.cheatcodes.warp(nextSlotTimestamp);
+                    this.dateProvider?.setTime(nextSlotTimestamp * 1000);
+                } catch (e) {
+                    this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+                }
+                this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+                return;
+            }
+            // If we are not in sandbox, we don't need to warp time
+            if (!this.isSandbox) {
+                return;
+            }
+            const currentTimestamp = this.dateProvider?.now() ?? Date.now();
+            if (currentTimestamp > nextSlotTimestamp * 1000) {
+                try {
+                    await this.cheatcodes.warp(nextSlotTimestamp);
+                    this.dateProvider?.setTime(nextSlotTimestamp * 1000);
+                } catch (e) {
+                    this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+                }
+                this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
+            }
+        } catch (err) {
+            this.logger.error('mineIfSlotFilled failed');
+        }
+    }
+}

package/dest/api/ethereum/chain_monitor.d.ts

@@ -0,0 +1,25 @@
+import type { RollupContract } from '@aztec/ethereum/contracts';
+/** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
+export declare class ChainMonitor {
+    private readonly rollup;
+    private logger;
+    private readonly intervalMs;
+    private readonly l1Client;
+    private handle;
+    /** Current L1 block number */
+    l1BlockNumber: number;
+    /** Current L2 block number */
+    l2BlockNumber: number;
+    /** Current L2 proven block number */
+    l2ProvenBlockNumber: number;
+    /** L1 timestamp for the current L2 block */
+    l2BlockTimestamp: bigint;
+    /** L1 timestamp for the proven L2 block */
+    l2ProvenBlockTimestamp: bigint;
+    constructor(rollup: RollupContract, logger?: import("@aztec/foundation/log").Logger, intervalMs?: number);
+    start(): this;
+    stop(): void;
+    private safeRun;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=chain_monitor.d.ts.map

package/dest/api/ethereum/chain_monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain_monitor.d.ts","sourceRoot":"","sources":["../../../src/api/ethereum/chain_monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAKhE,8GAA8G;AAC9G,qBAAa,YAAY;IAgBrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,UAAU;IAjB7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,MAAM,CAA6B;IAE3C,8BAA8B;IACvB,aAAa,EAAG,MAAM,CAAC;IAC9B,8BAA8B;IACvB,aAAa,EAAG,MAAM,CAAC;IAC9B,qCAAqC;IAC9B,mBAAmB,EAAG,MAAM,CAAC;IACpC,4CAA4C;IACrC,gBAAgB,EAAG,MAAM,CAAC;IACjC,2CAA2C;IACpC,sBAAsB,EAAG,MAAM,CAAC;gBAGpB,MAAM,EAAE,cAAc,EAC/B,MAAM,yCAA8C,EAC3C,UAAU,SAAM;IAKnC,KAAK;IAQL,IAAI;IAOJ,OAAO,CAAC,OAAO;IAMT,GAAG;CAqCV"}

package/dest/api/ethereum/chain_monitor.js

@@ -0,0 +1,74 @@
+import { createLogger } from '@aztec/foundation/log';
+/** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */ export class ChainMonitor {
+    rollup;
+    logger;
+    intervalMs;
+    l1Client;
+    handle;
+    /** Current L1 block number */ l1BlockNumber;
+    /** Current L2 block number */ l2BlockNumber;
+    /** Current L2 proven block number */ l2ProvenBlockNumber;
+    /** L1 timestamp for the current L2 block */ l2BlockTimestamp;
+    /** L1 timestamp for the proven L2 block */ l2ProvenBlockTimestamp;
+    constructor(rollup, logger = createLogger('aztecjs:utils:chain_monitor'), intervalMs = 200){
+        this.rollup = rollup;
+        this.logger = logger;
+        this.intervalMs = intervalMs;
+        this.l1Client = rollup.client;
+    }
+    start() {
+        if (this.handle) {
+            throw new Error('Chain monitor already started');
+        }
+        this.handle = setInterval(this.safeRun.bind(this), this.intervalMs);
+        return this;
+    }
+    stop() {
+        if (this.handle) {
+            clearInterval(this.handle);
+            this.handle = undefined;
+        }
+    }
+    safeRun() {
+        void this.run().catch((error)=>{
+            this.logger.error('Error in chain monitor loop', error);
+        });
+    }
+    async run() {
+        const newL1BlockNumber = Number(await this.l1Client.getBlockNumber({
+            cacheTime: 0
+        }));
+        if (this.l1BlockNumber === newL1BlockNumber) {
+            return;
+        }
+        this.l1BlockNumber = newL1BlockNumber;
+        const block = await this.l1Client.getBlock({
+            blockNumber: BigInt(newL1BlockNumber),
+            includeTransactions: false
+        });
+        const timestamp = block.timestamp;
+        const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
+        let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
+        const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
+        if (this.l2BlockNumber !== newL2BlockNumber) {
+            const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2BlockNumber));
+            msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
+            this.l2BlockNumber = newL2BlockNumber;
+            this.l2BlockTimestamp = timestamp;
+        }
+        const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
+        if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
+            const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2ProvenBlockNumber));
+            msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
+            this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
+            this.l2ProvenBlockTimestamp = timestamp;
+        }
+        this.logger.info(msg, {
+            l1Timestamp: timestamp,
+            l1BlockNumber: this.l1BlockNumber,
+            l2SlotNumber: await this.rollup.getSlotNumber(),
+            l2BlockNumber: this.l2BlockNumber,
+            l2ProvenBlockNumber: this.l2ProvenBlockNumber
+        });
+    }
+}

package/dest/api/ethereum/cheat_codes.d.ts

@@ -0,0 +1,63 @@
+import type { ViemPublicClient } from '@aztec/ethereum';
+import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { type GetContractReturnType, type Hex } from 'viem';
+export { EthCheatCodes };
+/** 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'>);
+    /** Returns the current slot */
+    getSlot(): Promise<bigint>;
+    /** Returns the current epoch */
+    getEpoch(): Promise<bigint>;
+    /**
+     * Returns the pending and proven chain tips
+     * @returns The pending and proven chain tips
+     */
+    getTips(): Promise<{
+        /** The pending chain tip */ pending: bigint;
+        /** The proven chain tip */ proven: bigint;
+    }>;
+    /** Fetches the epoch and slot duration config from the rollup contract */
+    getConfig(): Promise<{
+        /** Epoch duration */ epochDuration: bigint;
+        /** Slot duration */ slotDuration: bigint;
+    }>;
+    /** Warps time in L1 until the next epoch */
+    advanceToNextEpoch(): Promise<void>;
+    /** Warps time in L1 until the beginning of the next slot. */
+    advanceToNextSlot(): Promise<bigint[]>;
+    /**
+     * Warps time in L1 equivalent to however many slots.
+     * @param howMany - The number of slots to advance.
+     */
+    advanceSlots(howMany: number): Promise<void>;
+    /**
+     * Marks the specified block (or latest if none) as proven
+     * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
+     */
+    markAsProven(maybeBlockNumber?: number | bigint): Promise<void>;
+    /**
+     * Executes an action impersonated as the owner of the Rollup contract.
+     * @param action - The action to execute
+     */
+    asOwner(action: (owner: Hex, rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>) => Promise<void>): Promise<void>;
+    /** 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=cheat_codes.d.ts.map

package/dest/api/ethereum/cheat_codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cheat_codes.d.ts","sourceRoot":"","sources":["../../../src/api/ethereum/cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAGjF,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,GAAG,EAA8D,MAAM,MAAM,CAAC;AAGxH,OAAO,EAAE,aAAa,EAAE,CAAC;AAEzB,8CAA8C;AAC9C,qBAAa,gBAAgB;IAMf,OAAO,CAAC,aAAa;IALjC,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAA4D;IAE1E,OAAO,CAAC,MAAM,CAAuC;gBAEjC,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC;IAYvG,+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,0EAA0E;IAC7D,SAAS,IAAI,OAAO,CAAC;QAChC,qBAAqB,CAAC,aAAa,EAAE,MAAM,CAAC;QAC5C,oBAAoB,CAAC,YAAY,EAAE,MAAM,CAAC;KAC3C,CAAC;IAQF,4CAA4C;IAC/B,kBAAkB;IAU/B,6DAA6D;IAChD,iBAAiB;IAQ9B;;;OAGG;IACU,YAAY,CAAC,OAAO,EAAE,MAAM;IASzC;;;OAGG;IACU,YAAY,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM;IAiC5D;;;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,4CAA4C;IAC/B,oBAAoB;IAQjC;;;OAGG;IACU,sBAAsB,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM;IAMtE;;;OAGG;IACU,qBAAqB,CAAC,QAAQ,EAAE,MAAM;CAOpD"}

package/dest/api/ethereum/cheat_codes.js

@@ -0,0 +1,162 @@
+import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { createPublicClient, fallback, getContract, http, keccak256 } from 'viem';
+import { foundry } from 'viem/chains';
+export { EthCheatCodes };
+/** Cheat codes for the L1 rollup contract. */ export class RollupCheatCodes {
+    ethCheatCodes;
+    client;
+    rollup;
+    logger;
+    constructor(ethCheatCodes, addresses){
+        this.ethCheatCodes = ethCheatCodes;
+        this.logger = createLogger('aztecjs:cheat_codes');
+        this.client = createPublicClient({
+            chain: foundry,
+            transport: fallback(ethCheatCodes.rpcUrls.map((url)=>http(url)))
+        });
+        this.rollup = getContract({
+            abi: RollupAbi,
+            address: addresses.rollupAddress.toString(),
+            client: this.client
+        });
+    }
+    /** Returns the current slot */ async getSlot() {
+        const ts = BigInt((await this.client.getBlock()).timestamp);
+        return await this.rollup.read.getSlotAt([
+            ts
+        ]);
+    }
+    /** Returns the current epoch */ async getEpoch() {
+        const slotNumber = await this.getSlot();
+        return await this.rollup.read.getEpochAtSlot([
+            slotNumber
+        ]);
+    }
+    /**
+   * Returns the pending and proven chain tips
+   * @returns The pending and proven chain tips
+   */ async getTips() {
+        const res = await this.rollup.read.getTips();
+        return {
+            pending: res.pendingBlockNumber,
+            proven: res.provenBlockNumber
+        };
+    }
+    /** 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
+        };
+    }
+    /** 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), true);
+        this.logger.warn(`Advanced to next epoch`);
+    }
+    /** Warps time in L1 until the beginning of the next slot. */ async advanceToNextSlot() {
+        const currentSlot = await this.getSlot();
+        const timestamp = await this.rollup.read.getTimestampForSlot([
+            currentSlot + 1n
+        ]);
+        await this.ethCheatCodes.warp(Number(timestamp));
+        this.logger.warn(`Advanced to slot ${currentSlot + 1n}`);
+        return [
+            timestamp,
+            currentSlot + 1n
+        ];
+    }
+    /**
+   * Warps time in L1 equivalent to however many slots.
+   * @param howMany - The number of slots to advance.
+   */ async advanceSlots(howMany) {
+        const l1Timestamp = (await this.client.getBlock()).timestamp;
+        const slotDuration = await this.rollup.read.getSlotDuration();
+        const timeToWarp = BigInt(howMany) * slotDuration;
+        await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, true);
+        const [slot, epoch] = await Promise.all([
+            this.getSlot(),
+            this.getEpoch()
+        ]);
+        this.logger.warn(`Advanced ${howMany} slots up to slot ${slot} in epoch ${epoch}`);
+    }
+    /**
+   * Marks the specified block (or latest if none) as proven
+   * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
+   */ async markAsProven(maybeBlockNumber) {
+        const { pending, proven } = await this.getTips();
+        let blockNumber = maybeBlockNumber;
+        if (blockNumber === undefined || blockNumber > pending) {
+            blockNumber = pending;
+        }
+        if (blockNumber <= proven) {
+            this.logger.warn(`Block ${blockNumber} is already proven`);
+            return;
+        }
+        // @note @LHerskind this is heavily dependent on the storage layout and size of values
+        // The rollupStore is a struct and if the size of elements or the struct changes, this can break
+        // Convert string to bytes and then compute keccak256
+        const storageSlot = keccak256(Buffer.from('aztec.stf.storage', 'utf-8'));
+        const provenBlockNumberSlot = BigInt(storageSlot) + 1n;
+        const tipsBefore = await this.getTips();
+        await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenBlockNumberSlot, BigInt(blockNumber));
+        const tipsAfter = await this.getTips();
+        this.logger.info(`Proven tip moved: ${tipsBefore.proven} -> ${tipsAfter.proven}. Pending tip: ${tipsAfter.pending}.`);
+    }
+    /**
+   * Executes an action impersonated as the owner of the Rollup contract.
+   * @param action - The action to execute
+   */ async asOwner(action) {
+        const owner = await this.rollup.read.owner();
+        await this.ethCheatCodes.startImpersonating(owner);
+        await action(owner, this.rollup);
+        await this.ethCheatCodes.stopImpersonating(owner);
+    }
+    /** Directly calls the L1 gas fee oracle. */ async updateL1GasFeeOracle() {
+        await this.asOwner(async (account, rollup)=>{
+            const hash = await rollup.write.updateL1GasFeeOracle({
+                account,
+                chain: this.client.chain
+            });
+            await this.client.waitForTransactionReceipt({
+                hash
+            });
+            this.logger.warn(`Updated L1 gas fee oracle`);
+        });
+    }
+    /**
+   * Bumps proving cost per mana.
+   * @param bumper - Callback to calculate the new proving cost per mana based on current value.
+   */ async bumpProvingCostPerMana(bumper) {
+        const currentCost = await this.rollup.read.getProvingCostPerManaInEth();
+        const newCost = bumper(currentCost);
+        await this.setProvingCostPerMana(newCost);
+    }
+    /**
+   * Directly updates proving cost per mana.
+   * @param ethValue - The new proving cost per mana in ETH
+   */ async setProvingCostPerMana(ethValue) {
+        await this.asOwner(async (account, rollup)=>{
+            const hash = await rollup.write.setProvingCostPerMana([
+                ethValue
+            ], {
+                account,
+                chain: this.client.chain
+            });
+            await this.client.waitForTransactionReceipt({
+                hash
+            });
+            this.logger.warn(`Updated proving cost per mana to ${ethValue}`);
+        });
+    }
+}

package/dest/api/ethereum/index.d.ts

@@ -0,0 +1,7 @@
+export { L1FeeJuicePortalManager, L1ToL2TokenPortalManager, L1TokenManager, L1TokenPortalManager, type L2AmountClaim, type L2AmountClaimWithRecipient, type L2Claim, generateClaimSecret, } from './portal_manager.js';
+export { getL1ContractAddresses } from './l1_contracts.js';
+export { RollupCheatCodes, EthCheatCodes } from './cheat_codes.js';
+export { ChainMonitor } from './chain_monitor.js';
+export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { deployL1Contract, deployL1Contracts, type DeployL1ContractsReturnType, } from '@aztec/ethereum/deploy-l1-contracts';
+//# sourceMappingURL=index.d.ts.map

package/dest/api/ethereum/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/ethereum/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACd,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,0BAA0B,EAC/B,KAAK,OAAO,EACZ,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,2BAA2B,GACjC,MAAM,qCAAqC,CAAC"}

package/dest/api/ethereum/index.js

@@ -0,0 +1,6 @@
+export { L1FeeJuicePortalManager, L1ToL2TokenPortalManager, L1TokenManager, L1TokenPortalManager, generateClaimSecret } from './portal_manager.js';
+export { getL1ContractAddresses } from './l1_contracts.js';
+export { RollupCheatCodes, EthCheatCodes } from './cheat_codes.js';
+export { ChainMonitor } from './chain_monitor.js';
+export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { deployL1Contract, deployL1Contracts } from '@aztec/ethereum/deploy-l1-contracts';

package/dest/api/ethereum/l1_contracts.d.ts

@@ -0,0 +1,3 @@
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+export declare const getL1ContractAddresses: (url: string) => Promise<L1ContractAddresses>;
+//# sourceMappingURL=l1_contracts.d.ts.map

package/dest/api/ethereum/l1_contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_contracts.d.ts","sourceRoot":"","sources":["../../../src/api/ethereum/l1_contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAKjF,eAAO,MAAM,sBAAsB,QAAe,MAAM,KAAG,QAAQ,mBAAmB,CAerF,CAAC"}

package/dest/api/ethereum/l1_contracts.js

@@ -0,0 +1,13 @@
+import { retryUntil } from '@aztec/foundation/retry';
+import { createPXEClient } from '../../rpc_clients/index.js';
+export const getL1ContractAddresses = async (url)=>{
+    const pxeClient = createPXEClient(url, {});
+    const response = await retryUntil(async ()=>{
+        try {
+            return (await pxeClient.getNodeInfo()).l1ContractAddresses;
+        } catch (err) {
+        // do nothing
+        }
+    }, 'isNodeReady', 120, 1);
+    return response;
+};