@aztec/ethereum 0.0.1-commit.5476d83 → 0.0.1-commit.5914bae

package/src/test/rollup_cheat_codes.ts

@@ -1,6 +1,7 @@
-import { RollupContract, type ViemPublicClient } from '@aztec/ethereum';
+import { OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
-import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
@@ -31,7 +32,7 @@ export class RollupCheatCodes {
   ) {
     this.client = createPublicClient({
       chain: ethCheatCodes.chain,
-      transport: fallback(ethCheatCodes.rpcUrls.map(url => http(url))),
+      transport: fallback(ethCheatCodes.rpcUrls.map(url => http(url, { batch: false }))),
     });
     this.rollup = getContract({
       abi: RollupAbi,
@@ -52,7 +53,26 @@ export class RollupCheatCodes {
   /** Returns the current slot */
   public async getSlot(): Promise<SlotNumber> {
     const ts = BigInt((await this.client.getBlock()).timestamp);
-    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([ts]));
+    return this.getSlotAt(ts);
+  }
+
+  /** Returns the slot number at a given timestamp. */
+  public async getSlotAt(timestamp: bigint): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([timestamp]));
+  }
+
+  /** Returns the timestamp for the start of a given slot. */
+  public async getTimestampForSlot(slot: SlotNumber): Promise<bigint> {
+    return await this.rollup.read.getTimestampForSlot([BigInt(slot)]);
+  }
+
+  /** Returns the number of seconds until the start of the given slot based on L1 block timestamp. */
+  public async getSecondsUntilSlot(slot: SlotNumber): Promise<number> {
+    const [currentTimestamp, targetTimestamp] = await Promise.all([
+      this.client.getBlock().then(b => BigInt(b.timestamp)),
+      this.rollup.read.getTimestampForSlot([BigInt(slot)]),
+    ]);
+    return Math.max(0, Number(targetTimestamp - currentTimestamp));
   }
 
   /** Returns the current epoch */
@@ -66,10 +86,14 @@ export class RollupCheatCodes {
    * @returns The pending and proven chain tips
    */
   public async getTips(): Promise<{
-    /** The pending chain tip */ pending: bigint;
-    /** The proven chain tip */ proven: bigint;
+    /** The pending chain tip */ pending: CheckpointNumber;
+    /** The proven chain tip */ proven: CheckpointNumber;
   }> {
-    return await this.rollup.read.getTips();
+    const { pending, proven } = await this.rollup.read.getTips();
+    return {
+      pending: CheckpointNumber.fromBigInt(pending),
+      proven: CheckpointNumber.fromBigInt(proven),
+    };
   }
 
   /**
@@ -119,11 +143,11 @@ export class RollupCheatCodes {
     } = {},
   ) {
     const { epochDuration: slotsInEpoch } = await this.getConfig();
-    const slotNumber = SlotNumber(epoch * Number(slotsInEpoch));
+    const slotNumber = SlotNumber(Number(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}`);
+      this.logger.warn(`Warped to epoch ${epoch}`, { offset: opts.offset, timestamp });
     } catch (err) {
       this.logger.warn(`Warp to epoch ${epoch} failed: ${err}`);
     }
@@ -171,7 +195,7 @@ export class RollupCheatCodes {
    * Marks the specified checkpoint (or latest if none) as proven
    * @param maybeCheckpointNumber - The checkpoint number to mark as proven (defaults to latest pending)
    */
-  public markAsProven(maybeCheckpointNumber?: number | bigint) {
+  public markAsProven(maybeCheckpointNumber?: CheckpointNumber) {
     return this.ethCheatCodes.execWithPausedAnvil(async () => {
       const tipsBefore = await this.getTips();
       const { pending, proven } = tipsBefore;
@@ -245,6 +269,15 @@ export class RollupCheatCodes {
     });
   }
 
+  public insertOutbox(epoch: EpochNumber, outHash: bigint) {
+    return this.ethCheatCodes.execWithPausedAnvil(async () => {
+      const outboxAddress = await this.rollup.read.getOutbox();
+      const epochRootSlot = OutboxContract.getEpochRootStorageSlot(epoch);
+      await this.ethCheatCodes.store(EthAddress.fromString(outboxAddress), epochRootSlot, outHash);
+      this.logger.warn(`Advanced outbox to epoch ${epoch} with out hash ${outHash}`);
+    });
+  }
+
   /**
    * Executes an action impersonated as the owner of the Rollup contract.
    * @param action - The action to execute

package/src/test/start_anvil.ts

@@ -1,10 +1,19 @@
 import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
+import type { TestDateProvider } from '@aztec/foundation/timer';
 import { fileURLToPath } from '@aztec/foundation/url';
 
-import { type Anvil, createAnvil } from '@viem/anvil';
+import { type ChildProcess, spawn } from 'child_process';
 import { dirname, resolve } from 'path';
 
+/** Minimal interface matching the @viem/anvil Anvil shape used by callers. */
+export interface Anvil {
+  readonly port: number;
+  readonly host: string;
+  readonly status: 'listening' | 'idle';
+  stop(): Promise<void>;
+}
+
 /**
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */
@@ -16,54 +25,195 @@ export async function startAnvil(
     captureMethodCalls?: boolean;
     accounts?: number;
     chainId?: number;
+    /** The hardfork to use (e.g. 'cancun', 'latest'). */
+    hardfork?: string;
+    /**
+     * Number of slots per epoch used by anvil to compute the 'finalized' and 'safe' block tags.
+     * Anvil reports `finalized = latest - slotsInAnEpoch * 2`.
+     * Defaults to 1 so the finalized block advances immediately, making tests that check
+     * L1-finality-based logic work without needing hundreds of mined blocks.
+     */
+    slotsInAnEpoch?: number;
+    /**
+     * If provided, the date provider will be synced to anvil's block time on every mined block.
+     * This keeps the dateProvider in lockstep with anvil's chain time, avoiding drift between
+     * the wall clock and the L1 chain when computing L1 slot timestamps.
+     */
+    dateProvider?: TestDateProvider;
   } = {},
 ): Promise<{ anvil: Anvil; methodCalls?: string[]; rpcUrl: string; stop: () => Promise<void> }> {
   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;
+  let detectedPort: number | undefined;
 
-  // 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,
-        host: '127.0.0.1',
-        port: opts.port ?? 8545,
-        blockTime: opts.l1BlockTime,
-        stopTimeout: 1000,
-        accounts: opts.accounts ?? 20,
-        gasLimit: 45_000_000n,
-        chainId: opts.chainId ?? 31337,
+      const port = opts.port ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : 8545);
+      const args: string[] = [
+        '--host',
+        '127.0.0.1',
+        '--port',
+        String(port),
+        '--accounts',
+        String(opts.accounts ?? 20),
+        '--gas-limit',
+        String(45_000_000),
+        '--chain-id',
+        String(opts.chainId ?? 31337),
+      ];
+      if (opts.l1BlockTime !== undefined) {
+        args.push('--block-time', String(opts.l1BlockTime));
+      }
+      if (opts.hardfork !== undefined) {
+        args.push('--hardfork', opts.hardfork);
+      }
+      args.push('--slots-in-an-epoch', String(opts.slotsInAnEpoch ?? 1));
+
+      const child = spawn(anvilBinary, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, RAYON_NUM_THREADS: '1' },
       });
 
-      // Listen to the anvil output to get the port.
-      const removeHandler = anvil.on('message', (message: string) => {
-        logger?.debug(message.trim());
+      // Wait for "Listening on" or an early exit.
+      await new Promise<void>((resolve, reject) => {
+        let stderr = '';
+
+        const onStdout = (data: Buffer) => {
+          const text = data.toString();
+          logger?.debug(text.trim());
+          methodCalls?.push(...(text.match(/eth_[^\s]+/g) || []));
+
+          if (detectedPort === undefined && text.includes('Listening on')) {
+            const match = text.match(/Listening on ([^:]+):(\d+)/);
+            if (match) {
+              detectedPort = parseInt(match[2]);
+            }
+          }
+          if (detectedPort !== undefined) {
+            child.stdout?.removeListener('data', onStdout);
+            child.stderr?.removeListener('data', onStderr);
+            child.removeListener('close', onClose);
+            resolve();
+          }
+        };
 
-        methodCalls?.push(...(message.match(/eth_[^\s]+/g) || []));
-        if (port === undefined && message.includes('Listening on')) {
-          port = parseInt(message.match(/Listening on ([^:]+):(\d+)/)![2]);
-        }
+        const onStderr = (data: Buffer) => {
+          stderr += data.toString();
+          logger?.debug(data.toString().trim());
+        };
+
+        const onClose = (code: number | null) => {
+          child.stdout?.removeListener('data', onStdout);
+          child.stderr?.removeListener('data', onStderr);
+          reject(new Error(`Anvil exited with code ${code} before listening. stderr: ${stderr}`));
+        };
+
+        child.stdout?.on('data', onStdout);
+        child.stderr?.on('data', onStderr);
+        child.once('close', onClose);
       });
-      await anvil.start();
-      if (!logger && !opts.captureMethodCalls) {
-        removeHandler();
+
+      // Continue piping for logging, method-call capture, and/or dateProvider sync after startup.
+      if (logger || opts.captureMethodCalls || opts.dateProvider) {
+        child.stdout?.on('data', (data: Buffer) => {
+          const text = data.toString();
+          logger?.debug(text.trim());
+          methodCalls?.push(...(text.match(/eth_[^\s]+/g) || []));
+          if (opts.dateProvider) {
+            syncDateProviderFromAnvilOutput(text, opts.dateProvider);
+          }
+        });
+        child.stderr?.on('data', (data: Buffer) => {
+          logger?.debug(data.toString().trim());
+        });
+      } else {
+        // Consume streams so the child process doesn't block on full pipe buffers.
+        child.stdout?.resume();
+        child.stderr?.resume();
       }
 
-      return anvil;
+      return child;
     },
     'Start anvil',
     makeBackoff([5, 5, 5]),
   );
 
-  if (!port) {
+  if (!detectedPort) {
     throw new Error('Failed to start anvil');
   }
 
-  // Monkeypatch the anvil instance to include the actually assigned port
-  // Object.defineProperty(anvil, 'port', { value: port, writable: false });
-  return { anvil, methodCalls, stop: () => anvil.stop(), rpcUrl: `http://127.0.0.1:${port}` };
+  const port = detectedPort;
+  let status: 'listening' | 'idle' = 'listening';
+
+  anvil.once('close', () => {
+    status = 'idle';
+  });
+
+  const stop = async () => {
+    if (status === 'idle') {
+      return;
+    }
+    await killChild(anvil);
+  };
+
+  const anvilObj: Anvil = {
+    port,
+    host: '127.0.0.1',
+    get status() {
+      return status;
+    },
+    stop,
+  };
+
+  return { anvil: anvilObj, methodCalls, stop, rpcUrl: `http://127.0.0.1:${port}` };
+}
+
+/** Extracts block time from anvil stdout and syncs the dateProvider. */
+function syncDateProviderFromAnvilOutput(text: string, dateProvider: TestDateProvider): void {
+  // Anvil logs mined blocks as:
+  //   Block Time: "Fri, 20 Mar 2026 02:10:46 +0000"
+  const match = text.match(/Block Time:\s*"([^"]+)"/);
+  if (match) {
+    const blockTimeMs = new Date(match[1]).getTime();
+    if (!isNaN(blockTimeMs)) {
+      dateProvider.setTime(blockTimeMs);
+    }
+  }
+}
+
+/** Send SIGTERM, wait up to 5 s, then SIGKILL. All timers are always cleared. */
+function killChild(child: ChildProcess): Promise<void> {
+  return new Promise<void>(resolve => {
+    if (child.exitCode !== null || child.killed) {
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve();
+      return;
+    }
+
+    let killTimer: NodeJS.Timeout | undefined;
+
+    const onClose = () => {
+      if (killTimer !== undefined) {
+        clearTimeout(killTimer);
+      }
+      // Destroy stdio streams so their PipeWrap handles don't keep the event loop alive.
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve();
+    };
+
+    child.once('close', onClose);
+    child.kill('SIGTERM');
+
+    killTimer = setTimeout(() => {
+      killTimer = undefined;
+      child.kill('SIGKILL');
+    }, 5000);
+
+    // Ensure the timer does not prevent Node from exiting.
+    killTimer.unref();
+  });
 }

package/src/test/upgrade_utils.ts

@@ -7,7 +7,7 @@ import { type GetContractReturnType, type PrivateKeyAccount, getContract } from
 
 import { extractProposalIdFromLogs } from '../contracts/governance.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
-import { createL1TxUtilsFromViemWallet } from '../l1_tx_utils/index.js';
+import { createL1TxUtils } from '../l1_tx_utils/index.js';
 import type { ExtendedViemWalletClient, ViemPublicClient } from '../types.js';
 import { EthCheatCodes } from './eth_cheat_codes.js';
 
@@ -22,7 +22,7 @@ export async function executeGovernanceProposal(
 ) {
   const proposal = await governance.read.getProposal([proposalId]);
 
-  const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
+  const l1TxUtils = createL1TxUtils(l1Client);
 
   const waitL1Block = async () => {
     await l1TxUtils.sendAndMonitorTransaction({

package/src/types.ts

@@ -5,6 +5,7 @@ import type {
   Client,
   FallbackTransport,
   GetContractReturnType,
+  Hex,
   HttpTransport,
   PublicActions,
   PublicClient,
@@ -16,6 +17,67 @@ import type {
 /** Type for a viem public client */
 export type ViemPublicClient = PublicClient<FallbackTransport<HttpTransport[]>, Chain>;
 
+export type PublicRpcDebugSchema = [
+  {
+    Method: 'debug_traceTransaction';
+    Parameters: [txHash: `0x${string}`, options: { tracer: 'callTracer' }];
+    ReturnType: DebugCallTrace;
+  },
+  {
+    Method: 'trace_transaction';
+    Parameters: [txHash: `0x${string}`];
+    ReturnType: TraceTransactionResponse[];
+  },
+];
+
+/** Return type for a debug_traceTransaction call */
+export type DebugCallTrace = {
+  from: Hex;
+  to?: Hex;
+  type: string;
+  input?: Hex;
+  output?: Hex;
+  gas?: Hex;
+  gasUsed?: Hex;
+  value?: Hex;
+  error?: string;
+  calls?: DebugCallTrace[];
+};
+
+/** Action object for a trace_transaction call */
+export type TraceAction = {
+  from: Hex;
+  to?: Hex;
+  callType: string;
+  gas?: Hex;
+  input?: Hex;
+  value?: Hex;
+};
+
+/** Result object for a trace_transaction call */
+export type TraceResult = {
+  gasUsed?: Hex;
+  output?: Hex;
+};
+
+/** Return type for a single trace in trace_transaction response */
+export type TraceTransactionResponse = {
+  action: TraceAction;
+  result?: TraceResult;
+  error?: string;
+  subtraces: number;
+  traceAddress: number[];
+  type: string;
+};
+
+/** Type for a viem public client with support for debug methods */
+export type ViemPublicDebugClient = PublicClient<
+  FallbackTransport<HttpTransport[]>,
+  Chain,
+  undefined,
+  [...PublicRpcSchema, ...PublicRpcDebugSchema]
+>;
+
 export type ExtendedViemWalletClient = Client<
   FallbackTransport<readonly HttpTransport[]>,
   Chain,

package/src/utils.ts

@@ -1,18 +1,21 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
 import { ErrorsAbi } from '@aztec/l1-artifacts/ErrorsAbi';
 
 import {
   type Abi,
+  type AbiItem,
   BaseError,
   type ContractEventName,
   ContractFunctionRevertedError,
   type DecodeEventLogReturnType,
+  type FormattedTransaction,
   type Hex,
   type Log,
   decodeErrorResult,
   decodeEventLog,
 } from 'viem';
+import { formatAbiItem, formatAbiParams } from 'viem/utils';
 
 export interface L2Claim {
   claimSecret: Fr;
@@ -92,6 +95,57 @@ export function prettyLogViemErrorMsg(err: any) {
   return err?.message ?? err;
 }
 
+export function mergeAbis(abis: Abi[]): Abi {
+  let merged: Abi = [];
+  const seen = new Set<string>();
+
+  for (const abi of abis) {
+    for (const item of abi) {
+      const key = getAbiItemKey(item);
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged = [...merged, item];
+      }
+    }
+  }
+
+  return merged;
+}
+
+function getAbiItemKey(item: AbiItem): string {
+  if (item.type === 'function') {
+    const signature = formatAbiItem(item);
+    const outputs = formatAbiParams(item.outputs);
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `function:${signature}:${outputs}:${stateMutability}`;
+  }
+
+  if (item.type === 'event') {
+    const signature = formatAbiItem(item);
+    const indexed = (item.inputs ?? []).map(input => ((input as { indexed?: boolean }).indexed ? '1' : '0')).join('');
+    const anonymous = item.anonymous ? 'anonymous' : 'not-anonymous';
+    return `event:${signature}:${indexed}:${anonymous}`;
+  }
+
+  if (item.type === 'error') {
+    const signature = formatAbiItem(item);
+    return `error:${signature}`;
+  }
+
+  if (item.type === 'constructor') {
+    const inputs = formatAbiParams(item.inputs);
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `constructor::${inputs}:${stateMutability}`;
+  }
+
+  if (item.type === 'fallback' || item.type === 'receive') {
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `${item.type}:::${stateMutability}`;
+  }
+
+  return 'unknown';
+}
+
 function getNestedErrorData(error: unknown): string | undefined {
   // If nothing, bail
   if (!error) {
@@ -233,3 +287,31 @@ export function tryGetCustomErrorName(err: any) {
     return undefined;
   }
 }
+
+/**
+ * Type guard to check if a transaction is a blob transaction (EIP-4844).
+ * Blob transactions have maxFeePerBlobGas and blobVersionedHashes fields.
+ */
+export function isBlobTransaction(tx: FormattedTransaction): tx is FormattedTransaction & {
+  maxFeePerBlobGas: bigint;
+  blobVersionedHashes: readonly Hex[];
+} {
+  return (
+    'maxFeePerBlobGas' in tx &&
+    tx.maxFeePerBlobGas !== undefined &&
+    'blobVersionedHashes' in tx &&
+    tx.blobVersionedHashes !== undefined
+  );
+}
+
+/**
+ * Calculates a percentile from an array of bigints
+ */
+export function calculatePercentile(values: bigint[], percentile: number): bigint {
+  if (values.length === 0) {
+    return 0n;
+  }
+  const sorted = [...values].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+  const index = Math.ceil((sorted.length - 1) * (percentile / 100));
+  return sorted[index];
+}