@aztec/ethereum 0.0.1-commit.3100065 → 0.0.1-commit.321f6a9

package/src/config.ts

@@ -9,8 +9,8 @@ import {
   optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import l1ContractsDefaultEnv from '@aztec/l1-artifacts/network-defaults.json' with { type: 'json' };
 
-import { l1ContractsDefaultEnv } from './generated/l1-contracts-defaults.js';
 import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './l1_tx_utils/config.js';
 
 export type GenesisStateConfig = {
@@ -81,11 +81,21 @@ export type L1ContractsConfig = {
   initialEthPerFeeAsset: bigint;
   /** The number of seconds to wait for an exit */
   exitDelaySeconds: number;
+  /** Validator set size at or below which the entry queue uses the bootstrap flush size. */
+  entryQueueBootstrapValidatorSetSize: number;
+  /** Number of validators admitted from the entry queue per flush during the bootstrap phase. */
+  entryQueueBootstrapFlushSize: number;
+  /** Minimum number of validators admitted from the entry queue per flush. */
+  entryQueueFlushSizeMin: number;
+  /** Divisor applied to the queue size to derive the normal per-flush admission count. */
+  entryQueueFlushSizeQuotient: number;
+  /** Maximum number of validators admitted from the entry queue per flush. */
+  entryQueueMaxFlushSize: number;
 } & L1TxUtilsConfig;
 
 /**
  * Config mappings for L1ContractsConfig.
- * Default values come from generated l1-contracts-defaults.json (source: defaults.yml).
+ * Default values come from l1-contracts/scripts/network-defaults.json (published via @aztec/l1-artifacts).
  * Real deployments use forge scripts which require explicit env vars (vm.envUint).
  */
 export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> = {
@@ -237,12 +247,37 @@ export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> =
     description: 'The delay before a validator can exit the set',
     ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_EXIT_DELAY_SECONDS),
   },
+  entryQueueBootstrapValidatorSetSize: {
+    env: 'AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE',
+    description: 'Validator set size at or below which the entry queue uses the bootstrap flush size.',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE),
+  },
+  entryQueueBootstrapFlushSize: {
+    env: 'AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE',
+    description: 'Number of validators admitted from the entry queue per flush during the bootstrap phase.',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE),
+  },
+  entryQueueFlushSizeMin: {
+    env: 'AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN',
+    description: 'Minimum number of validators admitted from the entry queue per flush.',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN),
+  },
+  entryQueueFlushSizeQuotient: {
+    env: 'AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT',
+    description: 'Divisor applied to the queue size to derive the normal per-flush admission count.',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT),
+  },
+  entryQueueMaxFlushSize: {
+    env: 'AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE',
+    description: 'Maximum number of validators admitted from the entry queue per flush.',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE),
+  },
   ...omitConfigMappings(l1TxUtilsConfigMappings, ['ethereumSlotDuration']),
 };
 
 /**
  * Default L1 contracts configuration derived from l1ContractsConfigMappings.
- * Source of truth: spartan/environments/defaults.yml -> defaults.l1-contracts
+ * Source of truth: l1-contracts/scripts/network-defaults.json (published via @aztec/l1-artifacts).
  */
 export const DefaultL1ContractsConfig = getDefaultConfig(l1ContractsConfigMappings);
 

package/src/contracts/multicall.ts

@@ -14,7 +14,7 @@ import {
   multicall3Abi,
 } from 'viem';
 
-import type { L1BlobInputs, L1TxConfig, L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
+import type { L1BlobInputs, L1TxConfig, L1TxRequest, L1TxState, L1TxUtils } from '../l1_tx_utils/index.js';
 import type { ExtendedViemWalletClient } from '../types.js';
 import { tryDecodeRevertReason } from '../utils.js';
 
@@ -26,7 +26,10 @@ export const MULTI_CALL_3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11'
  * treat it as a fatal on-chain failure rather than retrying on a different publisher.
  */
 export class MulticallForwarderRevertedError extends Error {
-  constructor(public readonly receipt: TransactionReceipt) {
+  constructor(
+    public readonly receipt: TransactionReceipt,
+    public readonly txState?: L1TxState,
+  ) {
     super(`Multicall3 forwarder tx reverted: ${receipt.transactionHash}`);
     this.name = 'MulticallForwarderRevertedError';
   }
@@ -209,7 +212,7 @@ export class Multicall3 {
       args: [args],
     });
 
-    const { receipt } = await l1TxUtils.sendAndMonitorTransaction(
+    const { receipt, state } = await l1TxUtils.sendAndMonitorTransaction(
       {
         to: MULTI_CALL_3_ADDRESS,
         data: encodedForwarderData,
@@ -223,11 +226,11 @@ export class Multicall3 {
     // allowFailure to true for all calls, so a reverted status here would indicate a problem with
     // the Multicall3 contract itself or the forwarder transaction (such as an out-of-gas).
     if (receipt.status !== 'success') {
-      throw new MulticallForwarderRevertedError(receipt);
+      throw new MulticallForwarderRevertedError(receipt, state);
     }
 
     const stats = await l1TxUtils.getTransactionStats(receipt.transactionHash);
-    return { receipt, stats, multicallData: encodedForwarderData };
+    return { receipt, stats, multicallData: encodedForwarderData, state };
   }
 
   /** Batch multiple value transfers into a single aggregate3Value call on Multicall3. */

package/src/deploy_aztec_l1_contracts.ts

@@ -5,12 +5,12 @@ import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import type { Fr } from '@aztec/foundation/schemas';
-import { fileURLToPath } from '@aztec/foundation/url';
 
 import { bn254 } from '@noble/curves/bn254';
 import type { Abi, Narrow } from 'abitype';
 import { spawn } from 'child_process';
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { createRequire } from 'node:module';
 import { tmpdir } from 'os';
 import { dirname, join, resolve } from 'path';
 import readline from 'readline';
@@ -22,11 +22,14 @@ import { createExtendedL1Client } from './client.js';
 import { type L1ContractsConfig, assertValidSlotDurations } from './config.js';
 import { deployMulticall3 } from './contracts/multicall.js';
 import { RollupContract } from './contracts/rollup.js';
+import { resolveFoundryBinary } from './foundry_binary.js';
 import type { L1ContractAddresses } from './l1_contract_addresses.js';
 import type { ExtendedViemWalletClient } from './types.js';
 
 const logger = createLogger('ethereum:deploy_aztec_l1_contracts');
 
+const require = createRequire(import.meta.url);
+
 const JSON_DEPLOY_RESULT_PREFIX = 'JSON DEPLOY RESULT:';
 
 /**
@@ -93,11 +96,16 @@ function runProcess<T>(
 
 // Covers an edge where where we may have a cached BlobLib that is not meant for production.
 // Despite the profile apparently sometimes cached code remains (so says Lasse after his ignition-monorepo arc).
-async function maybeForgeForceProductionBuild(l1ContractsPath: string, script: string, chainId: number) {
+async function maybeForgeForceProductionBuild(
+  forgeBin: string,
+  l1ContractsPath: string,
+  script: string,
+  chainId: number,
+) {
   if (chainId === mainnet.id) {
     logger.info(`Recompiling ${script} with production profile for mainnet deployment`);
     logger.info('This may take a minute but ensures production BlobLib is used.');
-    await runProcess('forge', ['build', script, '--force'], { FOUNDRY_PROFILE: 'production' }, l1ContractsPath);
+    await runProcess(forgeBin, ['build', script, '--force'], { FOUNDRY_PROFILE: 'production' }, l1ContractsPath);
   }
 }
 
@@ -123,15 +131,13 @@ export interface ValidatorJson {
 }
 
 /**
- * Gets the path to the l1-contracts foundry artifacts directory.
- * These are copied from l1-contracts to yarn-project/l1-artifacts/l1-contracts
- * during build to make yarn-project self-contained.
+ * Gets the path to the l1-contracts foundry artifacts directory bundled inside @aztec/l1-artifacts.
+ * Resolved through the package (its "." export -> dest/index.js) so it works whether the package is
+ * linked via portal (monorepo) or installed under node_modules (published npm) — resolution follows
+ * the symlink in the portal case. The bundled foundry subtree sits alongside dest/, at <pkg>/l1-contracts.
  */
 export function getL1ContractsPath(): string {
-  const currentDir = dirname(fileURLToPath(import.meta.url));
-  // Go up from yarn-project/ethereum/dest to yarn-project, then to l1-artifacts/l1-contracts
-  const l1ContractsPath = resolve(currentDir, '..', '..', 'l1-artifacts', 'l1-contracts');
-  return l1ContractsPath;
+  return resolve(dirname(require.resolve('@aztec/l1-artifacts')), '..', 'l1-contracts');
 }
 
 // Cached deployment directory
@@ -320,8 +326,9 @@ export async function deployAztecL1Contracts(
   // Use foundry-artifacts from l1-artifacts package
   const l1ContractsPath = prepareL1ContractsForDeployment();
 
+  const forgeBin = resolveFoundryBinary('forge');
   const FORGE_SCRIPT = 'script/deploy/DeployAztecL1Contracts.s.sol';
-  await maybeForgeForceProductionBuild(l1ContractsPath, FORGE_SCRIPT, chainId);
+  await maybeForgeForceProductionBuild(forgeBin, l1ContractsPath, FORGE_SCRIPT, chainId);
 
   // Verify contracts on Etherscan when on mainnet/sepolia and ETHERSCAN_API_KEY is available.
   const isVerifiableChain = chainId === mainnet.id || chainId === sepolia.id;
@@ -346,6 +353,8 @@ export async function deployAztecL1Contracts(
     ...(shouldVerify ? ['--verify'] : []),
   ];
   const forgeEnv = {
+    // Resolved forge binary picked up by forge_broadcast.js, so it works without forge on PATH.
+    FORGE_BIN: forgeBin,
     // Env vars required by l1-contracts/script/deploy/DeploymentConfiguration.sol.
     NETWORK: getActiveNetworkName(),
     FOUNDRY_PROFILE: chainId === mainnet.id ? 'production' : undefined,
@@ -590,6 +599,11 @@ export function getDeployRollupForUpgradeEnvVars(
     AZTEC_SLASH_AMOUNT_SMALL: args.slashAmountSmall.toString(),
     AZTEC_SLASH_AMOUNT_MEDIUM: args.slashAmountMedium.toString(),
     AZTEC_SLASH_AMOUNT_LARGE: args.slashAmountLarge.toString(),
+    AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: args.entryQueueBootstrapValidatorSetSize.toString(),
+    AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: args.entryQueueBootstrapFlushSize.toString(),
+    AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: args.entryQueueFlushSizeMin.toString(),
+    AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: args.entryQueueFlushSizeQuotient.toString(),
+    AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: args.entryQueueMaxFlushSize.toString(),
   } as const;
 }
 
@@ -613,12 +627,15 @@ export const deployRollupForUpgrade = async (
   // Use foundry-artifacts from l1-artifacts package
   const l1ContractsPath = prepareL1ContractsForDeployment();
 
+  const forgeBin = resolveFoundryBinary('forge');
   const FORGE_SCRIPT = 'script/deploy/DeployRollupForUpgrade.s.sol';
-  await maybeForgeForceProductionBuild(l1ContractsPath, FORGE_SCRIPT, chainId);
+  await maybeForgeForceProductionBuild(forgeBin, l1ContractsPath, FORGE_SCRIPT, chainId);
 
   const scriptPath = join(getL1ContractsPath(), 'scripts', 'forge_broadcast.js');
   const forgeArgs = [FORGE_SCRIPT, '--sig', 'run()', '--private-key', privateKey, '--rpc-url', rpcUrl];
   const forgeEnv = {
+    // Resolved forge binary picked up by forge_broadcast.js, so it works without forge on PATH.
+    FORGE_BIN: forgeBin,
     FOUNDRY_PROFILE: chainId === mainnet.id ? 'production' : undefined,
     // Env vars required by l1-contracts/script/deploy/RollupConfiguration.sol.
     REGISTRY_ADDRESS: registryAddress.toString(),

package/src/foundry_binary.ts

@@ -0,0 +1,57 @@
+import { spawnSync } from 'child_process';
+import { accessSync, constants } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+function isExecutable(path: string): boolean {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Locate a Foundry binary (`anvil`, `forge`, ...) without relying on the caller's PATH. Order:
+ *   1. `$<NAME>_BIN` (e.g. `$ANVIL_BIN`, `$FORGE_BIN`) — explicit override, e.g. for CI with a pinned
+ *      version. Throws if set but not pointing at an executable, instead of silently falling back.
+ *   2. `~/.aztec/current/internal-bin/<name>` — where aztec-up installs it.
+ *   3. `~/.aztec/current/bin/aztec-<name>` — the publicly-exposed symlink.
+ *   4. `~/.foundry/bin/<name>` — standalone foundryup install.
+ *   5. `command -v <name>` — anything else on PATH.
+ *
+ * Throws with a directive message if none work.
+ */
+export function resolveFoundryBinary(name: string): string {
+  const envVar = `${name.toUpperCase()}_BIN`;
+  const envBin = process.env[envVar];
+  if (envBin) {
+    if (!isExecutable(envBin)) {
+      throw new Error(`$${envVar} is set to ${envBin}, which does not exist or is not executable.`);
+    }
+    return envBin;
+  }
+
+  const candidates = [
+    join(homedir(), '.aztec', 'current', 'internal-bin', name),
+    join(homedir(), '.aztec', 'current', 'bin', `aztec-${name}`),
+    join(homedir(), '.foundry', 'bin', name),
+  ];
+  for (const path of candidates) {
+    if (isExecutable(path)) {
+      return path;
+    }
+  }
+
+  const which = spawnSync('sh', ['-c', `command -v ${name}`], { encoding: 'utf8' });
+  if (which.status === 0 && which.stdout.trim()) {
+    return which.stdout.trim();
+  }
+
+  throw new Error(
+    `${name} binary not found. Tried $${envVar}, ~/.aztec/current/internal-bin/${name}, ` +
+      `~/.aztec/current/bin/aztec-${name}, ~/.foundry/bin/${name}, and $PATH. ` +
+      `Install via \`aztec-up\` or set ${envVar} to a working binary.`,
+  );
+}

package/src/l1_tx_utils/l1_fee_analyzer.ts

@@ -791,9 +791,6 @@ export class L1FeeAnalyzer {
     });
   }
 
-  /**
-   * Gets the minimum value from an array of bigints
-   */
   private minBigInt(values: bigint[]): bigint {
     if (values.length === 0) {
       return 0n;
@@ -801,3 +798,78 @@ export class L1FeeAnalyzer {
     return values.reduce((min, val) => (val < min ? val : min), values[0]);
   }
 }
+
+/** Per-block fee data for one mined L1 block, used to diagnose whether a tx was underpriced for it. */
+export interface WindowBlockFees {
+  blockNumber: bigint;
+  timestamp: bigint;
+  baseFeePerGas: bigint;
+  /** 75th percentile priority fee among the block's txs (gas-weighted, from eth_feeHistory). */
+  p75PriorityFee: bigint;
+  /** Minimum priority fee among all included txs — the inclusion bar for that block. */
+  minIncludedPriorityFee: bigint;
+  blockBlobsFull: boolean;
+  includedBlobCount: number;
+}
+
+/** Safety bound on how far back the window scan walks if the chain head is far ahead of the window. */
+const MAX_WINDOW_SCAN_BLOCKS = 64;
+
+/**
+ * Reads the already-mined L1 blocks whose timestamps fall in [windowStartS, windowEndS) — the L1
+ * inclusion window of an L2 slot — and extracts per-block fee data. Walks block headers to map the
+ * window to block numbers, then reads the priority-fee stats from a single eth_feeHistory call
+ * (percentile 0 is the cheapest included tx, i.e. the inclusion bar), so no transaction bodies are
+ * ever downloaded. Historical reads only, so it never waits on a future block. Returns the blocks in
+ * chronological order, [] on error, or the subset mined so far if the window is still in progress.
+ * Never throws.
+ */
+export async function captureWindowBlockFees(
+  client: ViemClient,
+  windowStartS: bigint,
+  windowEndS: bigint,
+): Promise<WindowBlockFees[]> {
+  try {
+    let current = await client.getBlock({ blockTag: 'latest' });
+    const inWindow: (typeof current)[] = [];
+    let scanned = 0;
+    // Walk back from the head, collecting blocks inside the window and skipping any past its end,
+    // until we cross below the window start (or hit the safety cap / genesis).
+    while (current.timestamp >= windowStartS && scanned < MAX_WINDOW_SCAN_BLOCKS) {
+      if (current.timestamp < windowEndS) {
+        inWindow.push(current);
+      }
+      if (current.number === 0n) {
+        break;
+      }
+      current = await client.getBlock({ blockNumber: current.number - 1n });
+      scanned++;
+    }
+    if (inWindow.length === 0) {
+      return [];
+    }
+    inWindow.reverse();
+    const newest = inWindow[inWindow.length - 1];
+    const feeHistory = await client.getFeeHistory({
+      blockCount: Number(newest.number - inWindow[0].number) + 1,
+      blockNumber: newest.number,
+      rewardPercentiles: [0, 75],
+    });
+    return inWindow.map(block => {
+      const idx = Number(block.number - feeHistory.oldestBlock);
+      const [minIncludedPriorityFee, p75PriorityFee] = feeHistory.reward?.[idx] ?? [0n, 0n];
+      const blobsInBlock = block.blobGasUsed ? Number(block.blobGasUsed / GAS_PER_BLOB) : 0;
+      return {
+        blockNumber: block.number,
+        timestamp: block.timestamp,
+        baseFeePerGas: block.baseFeePerGas ?? 0n,
+        p75PriorityFee,
+        minIncludedPriorityFee,
+        blockBlobsFull: blobsInBlock >= getMaxBlobCapacity(block.timestamp),
+        includedBlobCount: blobsInBlock,
+      };
+    });
+  } catch {
+    return [];
+  }
+}

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -36,6 +36,7 @@ import {
   type L1TxConfig,
   type L1TxRequest,
   type L1TxState,
+  L1TxTimeoutError,
   type SigningCallback,
   TerminalTxUtilsState,
   TxUtilsState,
@@ -306,6 +307,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         txConfigOverrides: gasConfigOverrides ?? {},
         sentAtL1Ts: now,
         lastSentAtL1Ts: now,
+        gasPriceHistory: [baseState.gasPrice],
       };
 
       // And persist it
@@ -504,6 +506,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         if (timePassed >= stallTimeMs && attempts <= maxSpeedUpAttempts) {
           const newGasPrice = await this.getGasPrice(gasConfig, isBlobTx, attempts, state.gasPrice);
           state.gasPrice = newGasPrice;
+          state.gasPriceHistory?.push(newGasPrice);
 
           this.logger.debug(
             `Tx ${currentTxHash} with nonce ${nonce} from ${account} appears stuck. ` +
@@ -672,8 +675,22 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     blobInputs?: L1BlobInputs,
   ): Promise<{ receipt: TransactionReceipt; state: L1TxState }> {
     const { state } = await this.sendTransaction(request, gasConfig, blobInputs);
-    const receipt = await this.monitorTransaction(state);
-    return { receipt, state };
+    try {
+      const receipt = await this.monitorTransaction(state);
+      return { receipt, state };
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        // Snapshot the ladder now: the fire-and-forget cancellation mutates state.gasPrice moments later.
+        throw new L1TxTimeoutError(err.message, {
+          gasPriceHistory: state.gasPriceHistory ? [...state.gasPriceHistory] : undefined,
+          finalGasPrice: state.gasPrice,
+          attempts: state.txHashes.length,
+          nonce: state.nonce,
+          gasLimit: state.gasLimit,
+        });
+      }
+      throw err;
+    }
   }
 
   public override async simulate(

package/src/l1_tx_utils/types.ts

@@ -1,4 +1,5 @@
 import type { BlobKzgInstance } from '@aztec/blob-lib/types';
+import { TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemTransactionSignature } from '@aztec/foundation/eth-signature';
 
@@ -55,6 +56,12 @@ export type L1TxState = {
   cancelTxHashes: Hex[];
   gasLimit: bigint;
   gasPrice: GasPrice;
+  /**
+   * Prices used for each attempt (initial send followed by each speed-up), in order. Always set on
+   * newly sent txs; optional because states restored from the state store predate the field.
+   * In-memory only — not persisted by the state store.
+   */
+  gasPriceHistory?: GasPrice[];
   txConfigOverrides: L1TxConfig;
   request: L1TxRequest;
   status: TxUtilsState;
@@ -83,3 +90,28 @@ export class DroppedTransactionError extends Error {
     this.name = 'DroppedTransactionError';
   }
 }
+
+/** Snapshot of what a timed-out L1 tx tried to pay, taken when the timeout is raised. */
+export type TimedOutTxState = {
+  /** Prices used across the initial send and each speed-up, in order (undefined only for restored states). */
+  gasPriceHistory?: GasPrice[];
+  /** The last price the tx was sent at before timing out. */
+  finalGasPrice: GasPrice;
+  /** Number of send attempts (initial + speed-ups). */
+  attempts: number;
+  nonce: number;
+  gasLimit: bigint;
+};
+
+/**
+ * Thrown by sendAndMonitorTransaction when a tx times out. Subclasses TimeoutError so existing
+ * `instanceof TimeoutError` checks keep working, while carrying the gas-price ladder for diagnostics.
+ */
+export class L1TxTimeoutError extends TimeoutError {
+  constructor(
+    message: string,
+    public readonly txState: TimedOutTxState,
+  ) {
+    super(message);
+  }
+}

package/src/queries.ts

@@ -186,5 +186,11 @@ export async function getL1ContractsConfig(
     slashAmountMedium: slashingAmounts[1],
     slashAmountLarge: slashingAmounts[2],
     initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
+    // Not exposed by the rollup contract; fall back to defaults like the other non-on-chain fields above.
+    entryQueueBootstrapValidatorSetSize: DefaultL1ContractsConfig.entryQueueBootstrapValidatorSetSize,
+    entryQueueBootstrapFlushSize: DefaultL1ContractsConfig.entryQueueBootstrapFlushSize,
+    entryQueueFlushSizeMin: DefaultL1ContractsConfig.entryQueueFlushSizeMin,
+    entryQueueFlushSizeQuotient: DefaultL1ContractsConfig.entryQueueFlushSizeQuotient,
+    entryQueueMaxFlushSize: DefaultL1ContractsConfig.entryQueueMaxFlushSize,
   };
 }

package/src/test/eth_cheat_codes.ts

@@ -505,19 +505,40 @@ export class EthCheatCodes {
    * reorg is needed because anvil applies a new gas limit only to future blocks: without it the just-mined
    * blocks would keep the tiny gas limit, and an `eth_call` against `latest` (whose gas is capped by the
    * block gas limit) would revert with "intrinsic gas too high".
+   *
+   * The replacement blocks advance L1 time. `anvil_reorg` stamps each replacement as `parent + N*interval`,
+   * so on its own it would freeze L1 time at the parent timestamp; callers that measure elapsed L1 time
+   * (L1TxUtils stall/timeout detection, `syncDateProvider`-driven slot advancement) rely on it moving
+   * forward. We reproduce the wall-clock advance the mine step just made (at least 1s per block) via a
+   * temporary block-timestamp interval, then restore any pre-existing interval.
    */
   public async mineEmptyBlock(blockCount: number = 1): Promise<void> {
     await this.execWithPausedAnvil(async () => {
       const originalGasLimit = await this.getBlockGasLimit();
+      const parentTimestamp = await this.lastBlockTimestamp();
+      // anvil has no getter for the block-timestamp interval, but the pending block is stamped
+      // `latest + interval`, so this delta is the standing interval (0 when none is set).
+      const priorInterval = (await this.nextBlockTimestamp()) - parentTimestamp;
       try {
         await this.setBlockGasLimit(1n);
         await this.doMine(blockCount);
       } finally {
         await this.setBlockGasLimit(originalGasLimit);
       }
+      const advance = (await this.lastBlockTimestamp()) - parentTimestamp;
+      const perBlockInterval = Math.max(1, Math.floor(advance / blockCount));
       // Replace the tiny-gas-limit blocks with empty blocks at the restored gas limit, keeping the same
-      // height and timestamps. The reorged-out blocks held no transactions, so nothing returns to the pool.
-      await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      // height. The reorged-out blocks held no transactions, so nothing returns to the pool.
+      await this.doRpcCall('anvil_setBlockTimestampInterval', [perBlockInterval]);
+      try {
+        await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      } finally {
+        if (priorInterval > 0) {
+          await this.doRpcCall('anvil_setBlockTimestampInterval', [priorInterval]);
+        } else {
+          await this.doRpcCall('anvil_removeBlockTimestampInterval', []);
+        }
+      }
     });
 
     this.logger.warn(`Mined ${blockCount} empty L1 ${pluralize('block', blockCount)}`);

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

@@ -235,18 +235,18 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
     // If decoding fails, we fall back to the original formatting
   }
 
-  // Strip ABI from the error object before formatting. We clone first to avoid mutating the
-  // caller's error, but structuredClone throws DataCloneError on values it cannot clone (e.g.
-  // viem RPC errors carrying function-valued request context). If cloning fails, fall back to
-  // formatting the original error untouched rather than letting the clone failure mask it.
+  // Strip ABI from the error object before formatting
   if (error && typeof error === 'object') {
-    try {
-      const errorClone = structuredClone(error);
-      stripAbis(errorClone);
-      error = errorClone;
-    } catch {
-      // Leave `error` as the original; we skip stripAbis to avoid mutating the caller's object.
-    }
+    // Create a clone to avoid modifying the original
+    const errorClone = structuredClone(error);
+
+    // Helper function to recursively remove ABI properties
+
+    // Strip ABIs from the clone
+    stripAbis(errorClone);
+
+    // Use the cleaned clone for further processing
+    error = errorClone;
   }
 
   // If it's a regular Error instance, return it with its message