@aztec/ethereum 1.2.1 → 2.0.0-nightly.20250813

package/src/test/rollup_cheat_codes.ts

@@ -0,0 +1,257 @@
+import { RollupContract, type ViemPublicClient } from '@aztec/ethereum';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import type { TestDateProvider } from '@aztec/foundation/timer';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+
+import {
+  type GetContractReturnType,
+  type Hex,
+  createPublicClient,
+  fallback,
+  getContract,
+  hexToBigInt,
+  http,
+} from 'viem';
+import { foundry } from 'viem/chains';
+
+import { EthCheatCodes } from './eth_cheat_codes.js';
+
+/** Cheat codes for the L1 rollup contract. */
+export class RollupCheatCodes {
+  private client: ViemPublicClient;
+  private rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>;
+
+  private logger = createLogger('aztecjs:cheat_codes');
+
+  constructor(
+    private ethCheatCodes: EthCheatCodes,
+    addresses: Pick<L1ContractAddresses, 'rollupAddress'>,
+  ) {
+    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,
+    });
+  }
+
+  static create(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>): RollupCheatCodes {
+    const ethCheatCodes = new EthCheatCodes(rpcUrls);
+    return new RollupCheatCodes(ethCheatCodes, addresses);
+  }
+
+  /** Returns the current slot */
+  public async getSlot() {
+    const ts = BigInt((await this.client.getBlock()).timestamp);
+    return await this.rollup.read.getSlotAt([ts]);
+  }
+
+  /** Returns the current epoch */
+  public 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
+   */
+  public async getTips(): Promise<{
+    /** The pending chain tip */ pending: bigint;
+    /** The proven chain tip */ proven: bigint;
+  }> {
+    const res = await this.rollup.read.getTips();
+    return {
+      pending: res.pendingBlockNumber,
+      proven: res.provenBlockNumber,
+    };
+  }
+
+  /**
+   * Logs the current state of the rollup contract.
+   */
+  public async debugRollup() {
+    const rollup = new RollupContract(this.client, this.rollup.address);
+    const pendingNum = await rollup.getBlockNumber();
+    const provenNum = await rollup.getProvenBlockNumber();
+    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(`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 */
+  public async getConfig(): Promise<{
+    /** Epoch duration */ epochDuration: bigint;
+    /** Slot duration */ slotDuration: bigint;
+  }> {
+    const [epochDuration, slotDuration] = await Promise.all([
+      this.rollup.read.getEpochDuration(),
+      this.rollup.read.getSlotDuration(),
+    ]);
+    return { epochDuration, slotDuration };
+  }
+
+  /**
+   * Advances time to the beginning of the given epoch
+   * @param epoch - The epoch to advance to
+   * @param opts - Options
+   */
+  public async advanceToEpoch(
+    epoch: bigint,
+    opts: {
+      /** Optional test date provider to update with the epoch timestamp */
+      updateDateProvider?: TestDateProvider;
+    } = {},
+  ) {
+    const { epochDuration: slotsInEpoch } = await this.getConfig();
+    const timestamp = await this.rollup.read.getTimestampForSlot([epoch * slotsInEpoch]);
+    try {
+      await this.ethCheatCodes.warp(Number(timestamp), { ...opts, silent: true, resetBlockInterval: true });
+      this.logger.warn(`Warped to epoch ${epoch}`);
+    } catch (err) {
+      this.logger.warn(`Warp to epoch ${epoch} failed: ${err}`);
+    }
+    return timestamp;
+  }
+
+  /** Warps time in L1 until the next epoch */
+  public 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), { silent: true, resetBlockInterval: true });
+    this.logger.warn(`Advanced to next epoch`);
+  }
+
+  /** Warps time in L1 until the beginning of the next slot. */
+  public async advanceToNextSlot() {
+    const currentSlot = await this.getSlot();
+    const timestamp = await this.rollup.read.getTimestampForSlot([currentSlot + 1n]);
+    await this.ethCheatCodes.warp(Number(timestamp), { silent: true, resetBlockInterval: true });
+    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.
+   */
+  public async advanceSlots(howMany: number) {
+    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, { 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 block (or latest if none) as proven
+   * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
+   */
+  public markAsProven(maybeBlockNumber?: number | bigint) {
+    return this.ethCheatCodes.execWithPausedAnvil(async () => {
+      const tipsBefore = await this.getTips();
+      const { pending, proven } = tipsBefore;
+
+      let blockNumber = maybeBlockNumber;
+      if (blockNumber === undefined || blockNumber > pending) {
+        blockNumber = pending;
+      }
+      if (blockNumber <= proven) {
+        this.logger.debug(`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
+      const provenBlockNumberSlot = 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 tipsAfter = await this.getTips();
+      if (tipsAfter.pending < tipsAfter.proven) {
+        throw new Error('Overwrote pending tip to a block in the past');
+      }
+
+      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
+   */
+  public async asOwner(
+    action: (owner: Hex, rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>) => Promise<void>,
+  ) {
+    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.
+   */
+  public 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. */
+  public 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.
+   */
+  public async bumpProvingCostPerMana(bumper: (before: bigint) => bigint) {
+    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
+   */
+  public async setProvingCostPerMana(ethValue: bigint) {
+    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/src/test/start_anvil.ts

@@ -1,3 +1,4 @@
+import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { fileURLToPath } from '@aztec/foundation/url';
 
@@ -11,11 +12,13 @@ export async function startAnvil(
   opts: {
     port?: number;
     l1BlockTime?: number;
+    log?: boolean;
     captureMethodCalls?: boolean;
     accounts?: number;
   } = {},
 ): Promise<{ anvil: Anvil; methodCalls?: string[]; rpcUrl: string; stop: () => Promise<void> }> {
   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 ? ([] as string[]) : undefined;
 
   let port: number | undefined;
@@ -35,13 +38,18 @@ export async function startAnvil(
 
       // Listen to the anvil output to get the port.
       const removeHandler = anvil.on('message', (message: string) => {
+        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',

package/src/test/tx_delayer.ts

@@ -1,6 +1,7 @@
 import { omit } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
+import type { DateProvider } from '@aztec/foundation/timer';
 
 import { inspect } from 'util';
 import {
@@ -71,13 +72,24 @@ export interface Delayer {
   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;
 }
 
 class DelayerImpl implements Delayer {
-  constructor(opts: { ethereumSlotDuration: bigint | number }) {
+  private logger = createLogger('ethereum:tx_delayer');
+  constructor(
+    public dateProvider: DateProvider,
+    opts: { ethereumSlotDuration: bigint | number },
+  ) {
     this.ethereumSlotDuration = BigInt(opts.ethereumSlotDuration);
   }
 
+  public maxInclusionTimeIntoSlot: number | undefined = undefined;
   public ethereumSlotDuration: bigint;
   public nextWait: { l1Timestamp: bigint } | { l1BlockNumber: bigint } | { indefinitely: true } | undefined = undefined;
   public sentTxHashes: Hex[] = [];
@@ -102,6 +114,10 @@ class DelayerImpl implements Delayer {
   cancelNextTx() {
     this.nextWait = { indefinitely: true };
   }
+
+  setMaxInclusionTimeIntoSlot(seconds: number | undefined) {
+    this.maxInclusionTimeIntoSlot = seconds;
+  }
 }
 
 /**
@@ -111,13 +127,14 @@ class DelayerImpl implements Delayer {
  */
 export function withDelayer<T extends ViemClient>(
   client: T,
+  dateProvider: DateProvider,
   opts: { ethereumSlotDuration: bigint | number },
 ): { client: T; delayer: Delayer } {
   if (!isExtendedClient(client)) {
     throw new Error('withDelayer has to be instantiated with a wallet viem client.');
   }
   const logger = createLogger('ethereum:tx_delayer');
-  const delayer = new DelayerImpl(opts);
+  const delayer = new DelayerImpl(dateProvider, opts);
 
   const extended = client
     // Tweak sendRawTransaction so it uses the delay defined in the delayer.
@@ -126,13 +143,19 @@ export function withDelayer<T extends ViemClient>(
     // but we do not use them in our codebase at all.
     .extend(client => ({
       async sendRawTransaction(...args) {
+        let wait: Promise<unknown> | undefined;
+        let txHash: Hex | undefined;
+
+        const { serializedTransaction } = args[0];
+        const publicClient = client as unknown as PublicClient;
+
         if (delayer.nextWait !== undefined) {
+          // Check if we have been instructed to delay the next tx.
           const waitUntil = delayer.nextWait;
           delayer.nextWait = undefined;
 
           // Compute the tx hash manually so we emulate sendRawTransaction response
-          const { serializedTransaction } = args[0];
-          const txHash = computeTxHash(serializedTransaction);
+          txHash = computeTxHash(serializedTransaction);
 
           // Cancel tx outright if instructed
           if ('indefinitely' in waitUntil && waitUntil.indefinitely) {
@@ -141,8 +164,8 @@ export function withDelayer<T extends ViemClient>(
             return Promise.resolve(txHash);
           }
 
-          const publicClient = client as unknown as PublicClient;
-          const wait =
+          // Or wait until the desired block number or timestamp
+          wait =
             'l1BlockNumber' in waitUntil
               ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger)
               : 'l1Timestamp' in waitUntil
@@ -153,7 +176,31 @@ export function withDelayer<T extends ViemClient>(
             argsLen: args.length,
             ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
           });
+        } else if (delayer.maxInclusionTimeIntoSlot !== undefined) {
+          // Check if we need to delay txs sent too close to the end of the slot.
+          const currentBlock = await publicClient.getBlock({ includeTransactions: false });
+          const { timestamp: lastBlockTimestamp, number } = currentBlock;
+          const now = delayer.dateProvider.now();
+
+          txHash = computeTxHash(serializedTransaction);
+          const logData = {
+            ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
+            lastBlockTimestamp,
+            now,
+            maxInclusionTimeIntoSlot: delayer.maxInclusionTimeIntoSlot,
+          };
+
+          if (now / 1000 - Number(lastBlockTimestamp) > delayer.maxInclusionTimeIntoSlot) {
+            // If the last block was mined more than `maxInclusionTimeIntoSlot` seconds ago, then we cannot include
+            // any txs in the current slot, so we delay the tx until the next slot.
+            logger.info(`Delaying inclusion of tx ${txHash} until the next slot since it was sent too late`, logData);
+            wait = waitUntilBlock(publicClient, number + 1n, logger);
+          } else {
+            logger.debug(`Immediately sending tx ${txHash} as it was received early enough in the slot`, logData);
+          }
+        }
 
+        if (wait !== undefined) {
           // Do not await here so we can return the tx hash immediately as if it had been sent on the spot.
           // Instead, delay it so it lands on the desired block number or timestamp, assuming anvil will
           // mine it immediately.
@@ -166,12 +213,11 @@ export function withDelayer<T extends ViemClient>(
                   computedTxHash: txHash,
                 });
               }
-              logger.info(`Sent previously delayed tx ${clientTxHash} to land on ${inspect(waitUntil)}`);
+              logger.info(`Sent previously delayed tx ${clientTxHash}`);
               delayer.sentTxHashes.push(clientTxHash);
             })
             .catch(err => logger.error(`Error sending tx after delay`, err));
-
-          return Promise.resolve(txHash);
+          return Promise.resolve(txHash!);
         } else {
           const txHash = await client.sendRawTransaction(...args);
           logger.verbose(`Sent tx immediately ${txHash}`);

package/src/test/upgrade_utils.ts

@@ -5,10 +5,10 @@ import { TestERC20Abi as StakingAssetAbi } from '@aztec/l1-artifacts/TestERC20Ab
 import { type GetContractReturnType, type PrivateKeyAccount, getContract } from 'viem';
 
 import { extractProposalIdFromLogs } from '../contracts/governance.js';
-import { EthCheatCodes } from '../eth_cheat_codes.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
 import { L1TxUtils } from '../l1_tx_utils.js';
 import type { ExtendedViemWalletClient, ViemPublicClient } from '../types.js';
+import { EthCheatCodes } from './eth_cheat_codes.js';
 
 export async function executeGovernanceProposal(
   proposalId: bigint,

package/src/utils.ts

@@ -50,7 +50,7 @@ export function extractEvent<
   return event;
 }
 
-function tryExtractEvent<
+export function tryExtractEvent<
   const TAbi extends Abi | readonly unknown[],
   TEventName extends ContractEventName<TAbi>,
   TEventType = DecodeEventLogReturnType<TAbi, TEventName, Hex[], undefined, true>,

package/dest/eth_cheat_codes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eth_cheat_codes.d.ts","sourceRoot":"","sources":["../src/eth_cheat_codes.ts"],"names":[],"mappings":"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"}