@aztec/ethereum 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/test/index.ts

@@ -1,3 +1,4 @@
+export * from './blob_kzg_warmup.js';
 export * from './eth_cheat_codes.js';
 export * from './eth_cheat_codes_with_state.js';
 export * from './start_anvil.js';

package/src/test/rollup_cheat_codes.ts

@@ -4,6 +4,7 @@ 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 { retryUntil } from '@aztec/foundation/retry';
 import type { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
@@ -244,6 +245,56 @@ export class RollupCheatCodes {
     });
   }
 
+  /**
+   * Polls the rollup until its current epoch reaches `epoch`. Unlike {@link advanceToEpoch} this does
+   * not warp the L1 clock; it only waits for the chain to reach `epoch` through external activity.
+   */
+  public async waitForEpoch(epoch: EpochNumber, opts: { timeout?: number; interval?: number } = {}): Promise<void> {
+    await retryUntil(
+      async () => (await this.getEpoch()) >= epoch || undefined,
+      `rollup epoch >= ${epoch}`,
+      opts.timeout ?? 60,
+      opts.interval ?? 1,
+    );
+  }
+
+  /**
+   * Polls the rollup until its current slot reaches `slot`. Unlike {@link advanceToSlot} this does not
+   * warp the L1 clock; it only waits for the chain to reach `slot` through external activity.
+   */
+  public async waitForSlot(slot: SlotNumber, opts: { timeout?: number; interval?: number } = {}): Promise<void> {
+    await retryUntil(
+      async () => (await this.getSlot()) >= slot || undefined,
+      `rollup slot >= ${slot}`,
+      opts.timeout ?? 60,
+      opts.interval ?? 1,
+    );
+  }
+
+  /**
+   * Polls the rollup until its pending checkpoint settles below `checkpoint` on a freshly mined, non-zero
+   * checkpoint, and returns that new pending checkpoint number. Reads the L1 rollup contract directly
+   * rather than a node, since a rollback lands on L1 first.
+   *
+   * A prune can momentarily drop the pending checkpoint to 0 before the post-deadline propose mines its
+   * replacement, so a caller detecting a rollback wants the new lower checkpoint, not that transient
+   * empty state — hence the non-zero guard.
+   */
+  public async waitForCheckpointBelow(
+    checkpoint: CheckpointNumber,
+    opts: { timeout?: number; interval?: number } = {},
+  ): Promise<CheckpointNumber> {
+    return await retryUntil(
+      async () => {
+        const { pending } = await this.getTips();
+        return pending > 0 && pending < checkpoint ? pending : undefined;
+      },
+      `rollup checkpoint in (0, ${checkpoint})`,
+      opts.timeout ?? 60,
+      opts.interval ?? 1,
+    );
+  }
+
   /**
    * Overrides the inProgress field of the Inbox contract state
    * @param howMuch - How many checkpoints to move it forward

package/src/test/start_anvil.ts

@@ -1,10 +1,10 @@
 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 ChildProcess, spawn } from 'child_process';
-import { dirname, resolve } from 'path';
+
+import { resolveFoundryBinary } from '../foundry_binary.js';
 
 /** Minimal interface matching the @viem/anvil Anvil shape used by callers. */
 export interface Anvil {
@@ -14,6 +14,30 @@ export interface Anvil {
   stop(): Promise<void>;
 }
 
+// Watchdog wrapper: instead of spawning anvil directly, we spawn a small bash supervisor that runs
+// anvil as a background child and polls its own parent (this node process). If the parent dies for
+// ANY reason — including SIGKILL / crash / OOM, where node's own exit handlers never run — the poll
+// loop ends and the EXIT trap reaps anvil. The script is inlined (rather than shipped as a `.sh`) so
+// it works from the published npm tarball too, and the resolved anvil binary is passed via
+// `$ANVIL_BIN` so it works without `anvil` on PATH.
+//
+// `$@` is the anvil argv; `bash -c <script> bash <...args>` puts the args in `$@` and `$0` = 'bash'.
+//
+// The EXIT trap reaps anvil; INT/TERM just `exit` (which fires the EXIT trap) so a signal terminates
+// the supervisor promptly instead of being swallowed — a trapped TERM does NOT terminate the shell,
+// so trapping the kill directly on TERM would leave the poll loop running and the caller's teardown
+// hanging until its SIGKILL escalation. `sleep & wait` makes the poll interruptible, so INT/TERM are
+// handled immediately rather than after the current `sleep` returns.
+const ANVIL_WATCHDOG = `
+set -u
+parent=$PPID
+"$ANVIL_BIN" "$@" &
+anvil_pid=$!
+trap 'kill "$anvil_pid" 2>/dev/null' EXIT
+trap 'exit 0' INT TERM
+while kill -0 "$parent" 2>/dev/null; do sleep 1 & wait $!; done
+`;
+
 /**
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */
@@ -42,7 +66,7 @@ export async function startAnvil(
     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 anvilBinary = resolveFoundryBinary('anvil');
   const logger = opts.log ? createLogger('ethereum:anvil') : undefined;
   const methodCalls = opts.captureMethodCalls ? ([] as string[]) : undefined;
 
@@ -50,6 +74,9 @@ export async function startAnvil(
 
   const anvil = await retry(
     async () => {
+      // `--port 0` lets anvil bind an OS-assigned ephemeral port; the actual port is read back from
+      // its "Listening on host:port" stdout below, so independent suites can spawn their own anvil
+      // in parallel without fighting over a fixed port.
       const port = opts.port ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : 8545);
       const args: string[] = [
         '--host',
@@ -71,9 +98,11 @@ export async function startAnvil(
       }
       args.push('--slots-in-an-epoch', String(opts.slotsInAnEpoch ?? 1));
 
-      const child = spawn(anvilBinary, args, {
+      // Spawn the watchdog (see ANVIL_WATCHDOG). It launches anvil with these args and reaps it if we
+      // die; `$0` is 'bash' and `$@` is the anvil argv.
+      const child = spawn('bash', ['-c', ANVIL_WATCHDOG, 'bash', ...args], {
         stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, RAYON_NUM_THREADS: '1' },
+        env: { ...process.env, ANVIL_BIN: anvilBinary, RAYON_NUM_THREADS: '1' },
       });
 
       // Wait for "Listening on" or an early exit.
@@ -183,7 +212,10 @@ function syncDateProviderFromAnvilOutput(text: string, dateProvider: TestDatePro
   }
 }
 
-/** Send SIGTERM, wait up to 5 s, then SIGKILL. All timers are always cleared. */
+/**
+ * Send SIGTERM to the watchdog, wait up to 5 s, then SIGKILL. The watchdog's trap forwards the
+ * signal to anvil, so terminating it tears down anvil too. All timers are always cleared.
+ */
 function killChild(child: ChildProcess): Promise<void> {
   return new Promise<void>(resolve => {
     if (child.exitCode !== null || child.killed) {

package/src/utils.ts

@@ -27,8 +27,8 @@ export interface L2Claim {
 export class FormattedViemError extends Error {
   metaMessages?: any[];
 
-  constructor(message: string, metaMessages?: any[]) {
-    super(message);
+  constructor(message: string, metaMessages?: any[], options?: ErrorOptions) {
+    super(message, options);
     this.name = 'FormattedViemError';
     this.metaMessages = metaMessages;
   }
@@ -197,6 +197,8 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
     return error;
   }
 
+  const originalError = error;
+
   // First try to decode as a custom error using the ABI
   try {
     const data = getNestedErrorData(error);
@@ -207,7 +209,9 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
         data: data as Hex,
       });
       if (decoded) {
-        return new FormattedViemError(`${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`, error?.metaMessages);
+        return new FormattedViemError(`${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`, error?.metaMessages, {
+          cause: originalError,
+        });
       }
     }
 
@@ -224,7 +228,7 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
           revertError.metaMessages && revertError.metaMessages?.length > 1
             ? revertError.metaMessages[1].trimStart()
             : '';
-        return new FormattedViemError(`${errorName}${args}`, error?.metaMessages);
+        return new FormattedViemError(`${errorName}${args}`, error?.metaMessages, { cause: originalError });
       }
     }
   } catch {
@@ -247,10 +251,12 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
 
   // If it's a regular Error instance, return it with its message
   if (error instanceof Error) {
-    return new FormattedViemError(truncateErrorMessage(error.message), (error as any)?.metaMessages);
+    return new FormattedViemError(truncateErrorMessage(error.message), (error as any)?.metaMessages, {
+      cause: originalError,
+    });
   }
 
-  return new FormattedViemError(truncateErrorMessage(String(error)));
+  return new FormattedViemError(truncateErrorMessage(String(error)), undefined, { cause: originalError });
 }
 
 function stripAbis(obj: any) {

package/dest/generated/l1-contracts-defaults.d.ts

@@ -1,30 +0,0 @@
-/** Default L1 contracts configuration values from network-defaults.yml */
-export declare const l1ContractsDefaultEnv: {
-    readonly ETHEREUM_SLOT_DURATION: 12;
-    readonly AZTEC_SLOT_DURATION: 72;
-    readonly AZTEC_EPOCH_DURATION: 32;
-    readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
-    readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
-    readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
-    readonly AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000;
-    readonly AZTEC_EJECTION_THRESHOLD: 50000000000000000000;
-    readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000;
-    readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
-    readonly AZTEC_INBOX_LAG: 1;
-    readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
-    readonly AZTEC_MANA_TARGET: 100000000;
-    readonly AZTEC_PROVING_COST_PER_MANA: 100;
-    readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
-    readonly AZTEC_SLASHER_ENABLED: true;
-    readonly AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4;
-    readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5;
-    readonly AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0;
-    readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
-    readonly AZTEC_SLASHING_VETOER: "0x0000000000000000000000000000000000000000";
-    readonly AZTEC_SLASHING_DISABLE_DURATION: 432000;
-    readonly AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000;
-    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000;
-    readonly AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000;
-    readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300;
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDEtY29udHJhY3RzLWRlZmF1bHRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2VuZXJhdGVkL2wxLWNvbnRyYWN0cy1kZWZhdWx0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSwwRUFBMEU7QUFDMUUsZUFBTyxNQUFNLHFCQUFxQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBMkJ4QixDQUFDIn0=

package/dest/generated/l1-contracts-defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l1-contracts-defaults.d.ts","sourceRoot":"","sources":["../../src/generated/l1-contracts-defaults.ts"],"names":[],"mappings":"AAGA,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BxB,CAAC"}

package/dest/generated/l1-contracts-defaults.js

@@ -1,30 +0,0 @@
-// Auto-generated from spartan/environments/network-defaults.yml
-// Do not edit manually - run yarn generate to regenerate
-/** Default L1 contracts configuration values from network-defaults.yml */ export const l1ContractsDefaultEnv = {
-    ETHEREUM_SLOT_DURATION: 12,
-    AZTEC_SLOT_DURATION: 72,
-    AZTEC_EPOCH_DURATION: 32,
-    AZTEC_TARGET_COMMITTEE_SIZE: 48,
-    AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
-    AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
-    AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
-    AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
-    AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
-    AZTEC_EXIT_DELAY_SECONDS: 172800,
-    AZTEC_INBOX_LAG: 1,
-    AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
-    AZTEC_MANA_TARGET: 100000000,
-    AZTEC_PROVING_COST_PER_MANA: 100,
-    AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-    AZTEC_SLASHER_ENABLED: true,
-    AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
-    AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
-    AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
-    AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
-    AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
-    AZTEC_SLASHING_DISABLE_DURATION: 432000,
-    AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
-    AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
-    AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
-    AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300
-};

package/src/generated/l1-contracts-defaults.ts

@@ -1,32 +0,0 @@
-// Auto-generated from spartan/environments/network-defaults.yml
-// Do not edit manually - run yarn generate to regenerate
-
-/** Default L1 contracts configuration values from network-defaults.yml */
-export const l1ContractsDefaultEnv = {
-  ETHEREUM_SLOT_DURATION: 12,
-  AZTEC_SLOT_DURATION: 72,
-  AZTEC_EPOCH_DURATION: 32,
-  AZTEC_TARGET_COMMITTEE_SIZE: 48,
-  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
-  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
-  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
-  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
-  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
-  AZTEC_EXIT_DELAY_SECONDS: 172800,
-  AZTEC_INBOX_LAG: 1,
-  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
-  AZTEC_MANA_TARGET: 100000000,
-  AZTEC_PROVING_COST_PER_MANA: 100,
-  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-  AZTEC_SLASHER_ENABLED: true,
-  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
-  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
-  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
-  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
-  AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
-  AZTEC_SLASHING_DISABLE_DURATION: 432000,
-  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
-  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
-  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
-  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
-} as const;