@aztec/aztec 1.2.1 → 2.0.0-nightly.20250813

package/src/testing/anvil_test_watcher.ts

@@ -0,0 +1,167 @@
+import type { ViemClient } from '@aztec/ethereum';
+import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import type { TestDateProvider } from '@aztec/foundation/timer';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+
+import { type GetContractReturnType, getAddress, getContract } from 'viem';
+
+/**
+ * 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 {
+  private isSandbox: boolean = false;
+
+  private rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
+  private rollupCheatCodes: RollupCheatCodes;
+  private l2SlotDuration!: bigint;
+
+  private filledRunningPromise?: RunningPromise;
+  private syncDateProviderPromise?: RunningPromise;
+  private markingAsProvenRunningPromise?: RunningPromise;
+
+  private logger: Logger = createLogger(`aztecjs:utils:watcher`);
+
+  private isMarkingAsProven = true;
+
+  constructor(
+    private cheatcodes: EthCheatCodes,
+    rollupAddress: EthAddress,
+    l1Client: ViemClient,
+    private dateProvider?: TestDateProvider,
+  ) {
+    this.rollup = getContract({
+      address: getAddress(rollupAddress.toString()),
+      abi: RollupAbi,
+      client: l1Client,
+    });
+
+    this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
+      rollupAddress,
+    });
+
+    this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
+  }
+
+  setIsMarkingAsProven(isMarkingAsProven: boolean) {
+    this.isMarkingAsProven = isMarkingAsProven;
+  }
+
+  setIsSandbox(isSandbox: boolean) {
+    this.isSandbox = isSandbox;
+  }
+
+  async start() {
+    if (this.filledRunningPromise) {
+      throw new Error('Watcher already watching for filled slot');
+    }
+
+    const config = await this.rollupCheatCodes.getConfig();
+    this.l2SlotDuration = config.slotDuration;
+
+    // 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, 200);
+      this.filledRunningPromise.start();
+      this.syncDateProviderPromise = new RunningPromise(() => this.syncDateProviderToL1IfBehind(), this.logger, 200);
+      this.syncDateProviderPromise.start();
+      this.markingAsProvenRunningPromise = new RunningPromise(() => this.markAsProven(), this.logger, 200);
+      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.syncDateProviderPromise?.stop();
+    await this.markingAsProvenRunningPromise?.stop();
+  }
+
+  async trigger() {
+    await this.filledRunningPromise?.trigger();
+    await this.syncDateProviderPromise?.trigger();
+    await this.markingAsProvenRunningPromise?.trigger();
+  }
+
+  async markAsProven() {
+    if (!this.isMarkingAsProven) {
+      return;
+    }
+    await this.rollupCheatCodes.markAsProven();
+  }
+
+  async syncDateProviderToL1IfBehind() {
+    // 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 (l1Time > wallTime) {
+      this.logger.warn(`L1 is ahead of wall time. Syncing wall time to L1 time`);
+      this.dateProvider.setTime(l1Time);
+    } else if (l1Time + Number(this.l2SlotDuration) * 1000 < wallTime) {
+      this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to wall time`);
+      await this.cheatcodes.warp(Math.ceil(wallTime / 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, {
+            resetBlockInterval: true,
+            updateDateProvider: this.dateProvider,
+          });
+        } 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, {
+            resetBlockInterval: true,
+            updateDateProvider: this.dateProvider,
+          });
+        } catch (e) {
+          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+        }
+
+        this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
+      }
+    } catch {
+      this.logger.error('mineIfSlotFilled failed');
+    }
+  }
+}

package/src/testing/aztec_cheat_codes.ts

@@ -0,0 +1,77 @@
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { Note } from '@aztec/stdlib/note';
+
+/**
+ * A class that provides utility functions for interacting with the aztec chain.
+ */
+export class AztecCheatCodes {
+  constructor(
+    /**
+     * The PXE Service to use for interacting with the chain
+     */
+    public pxe: PXE,
+    /**
+     * The logger to use for the aztec cheatcodes
+     */
+    public logger = createLogger('aztecjs:cheat_codes'),
+  ) {}
+
+  /**
+   * Computes the slot value for a given map and key.
+   * @param mapSlot - The slot of the map (specified in Aztec.nr contract)
+   * @param key - The key to lookup in the map
+   * @returns The storage slot of the value in the map
+   */
+  public computeSlotInMap(mapSlot: Fr | bigint, key: Fr | bigint | AztecAddress): Promise<Fr> {
+    const keyFr = typeof key === 'bigint' ? new Fr(key) : key.toField();
+    return deriveStorageSlotInMap(mapSlot, keyFr);
+  }
+
+  /**
+   * Get the current blocknumber
+   * @returns The current block number
+   */
+  public async blockNumber(): Promise<number> {
+    return await this.pxe.getBlockNumber();
+  }
+
+  /**
+   * Get the current timestamp
+   * @returns The current timestamp
+   */
+  public async timestamp(): Promise<number> {
+    const res = await this.pxe.getBlock(await this.blockNumber());
+    return Number(res?.header.globalVariables.timestamp ?? 0);
+  }
+
+  /**
+   * Loads the value stored at the given slot in the public storage of the given contract.
+   * @param who - The address of the contract
+   * @param slot - The storage slot to lookup
+   * @returns The value stored at the given slot
+   */
+  public async loadPublic(who: AztecAddress, slot: Fr | bigint): Promise<Fr> {
+    const storageValue = await this.pxe.getPublicStorageAt(who, new Fr(slot));
+    return storageValue;
+  }
+
+  /**
+   * Loads the value stored at the given slot in the private storage of the given contract.
+   * @param contract - The address of the contract
+   * @param recipient - The address whose public key was used to encrypt the note
+   * @param slot - The storage slot to lookup
+   * @returns The notes stored at the given slot
+   */
+  public async loadPrivate(recipient: AztecAddress, contract: AztecAddress, slot: Fr | bigint): Promise<Note[]> {
+    const extendedNotes = await this.pxe.getNotes({
+      recipient,
+      contractAddress: contract,
+      storageSlot: new Fr(slot),
+    });
+    return extendedNotes.map(extendedNote => extendedNote.note);
+  }
+}

package/src/testing/cheat_codes.ts

@@ -0,0 +1,79 @@
+import { retryUntil } from '@aztec/aztec.js';
+import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import type { SequencerClient } from '@aztec/sequencer-client';
+import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+
+import { AztecCheatCodes } from './aztec_cheat_codes.js';
+
+/**
+ * A class that provides utility functions for interacting with the chain.
+ */
+export class CheatCodes {
+  constructor(
+    /** Cheat codes for L1.*/
+    public eth: EthCheatCodes,
+    /** Cheat codes for Aztec L2. */
+    public aztec: AztecCheatCodes,
+    /** Cheat codes for the Aztec Rollup contract on L1. */
+    public rollup: RollupCheatCodes,
+  ) {}
+
+  static async create(rpcUrls: string[], pxe: PXE): Promise<CheatCodes> {
+    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);
+  }
+
+  /**
+   * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
+   * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
+   * by the slot number, which advances in fixed intervals.
+   * This is useful for testing time-dependent contract behavior.
+   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+   * @param node - The Aztec node used to query if a new block has been mined.
+   * @param targetTimestamp - The target timestamp to warp to (in seconds)
+   */
+  async warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, targetTimestamp: bigint | number) {
+    const currentL2BlockNumber = await node.getBlockNumber();
+
+    // We warp the L1 timestamp
+    await this.eth.warp(targetTimestamp, { resetBlockInterval: true });
+
+    // Wait until an L2 block is mined
+    const sequencer = sequencerClient.getSequencer();
+    const minTxsPerBlock = sequencer.getConfig().minTxsPerBlock;
+    sequencer.updateConfig({ minTxsPerBlock: 0 });
+
+    await retryUntil(
+      async () => {
+        const newL2BlockNumber = await node.getBlockNumber();
+        return newL2BlockNumber > currentL2BlockNumber;
+      },
+      'new block after warping L2 time',
+      36,
+      1,
+    );
+
+    // Restore original minTxsPerBlock
+    sequencer.updateConfig({ minTxsPerBlock });
+  }
+
+  /**
+   * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
+   * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
+   * number, which advances in fixed intervals.
+   * This is useful for testing time-dependent contract behavior.
+   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+   * @param node - The Aztec node used to query if a new block has been mined.
+   * @param duration - The duration to advance time by (in seconds)
+   */
+  async warpL2TimeAtLeastBy(sequencerClient: SequencerClient, node: AztecNode, duration: bigint | number) {
+    const currentTimestamp = await this.eth.timestamp();
+    const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
+    await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+  }
+}

package/src/testing/index.ts

@@ -0,0 +1,4 @@
+export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+export { AztecCheatCodes } from './aztec_cheat_codes.js';
+export { CheatCodes } from './cheat_codes.js';