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

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/contracts/outbox.ts

@@ -89,9 +89,13 @@ export class OutboxContract {
    * Returns every root stored for `epoch`. Slot `i` of the returned array holds the root inserted
    * for `numCheckpointsInEpoch = i + 1`, or `Fr.ZERO` if no proof of that depth has been inserted
    * yet. The array length is always `MAX_CHECKPOINTS_PER_EPOCH`.
+   *
+   * @param opts - Optional viem read options. Pass `blockNumber` to pin the read to a specific L1
+   *   block, which is important for callers that want a consistent snapshot across multiple reads
+   *   (e.g. the archiver's outbox-trees resolver, which pins to the node's synced L1 block).
    */
-  public async getRoots(epoch: EpochNumber): Promise<Fr[]> {
-    const raw = await this.outbox.read.getRoots([BigInt(epoch)]);
+  public async getRoots(epoch: EpochNumber, opts?: { blockNumber?: bigint }): Promise<Fr[]> {
+    const raw = await this.outbox.read.getRoots([BigInt(epoch)], opts);
     return raw.map(hex => Fr.fromString(hex));
   }
 

package/src/contracts/rollup.ts

@@ -6,6 +6,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
 import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { getErrorCause } from '@aztec/foundation/types';
 import { EscapeHatchAbi } from '@aztec/l1-artifacts/EscapeHatchAbi';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 import { RollupStorage } from '@aztec/l1-artifacts/RollupStorage';
@@ -13,11 +14,14 @@ import { RollupStorage } from '@aztec/l1-artifacts/RollupStorage';
 import chunk from 'lodash.chunk';
 import {
   type Account,
+  ContractFunctionRevertedError,
   type GetContractReturnType,
   type Hex,
   type Log,
+  RpcRequestError,
   type StateOverride,
   type WatchContractEventReturnType,
+  decodeErrorResult,
   encodeAbiParameters,
   encodeFunctionData,
   getContract,
@@ -79,6 +83,7 @@ export type ViemHeader = {
   feeRecipient: `0x${string}`;
   gasFees: ViemGasFees;
   totalManaUsed: bigint;
+  accumulatedFees: bigint;
 };
 
 export type ViemGasFees = {
@@ -230,6 +235,32 @@ export type CheckpointProposedArgs = {
 /** Log type for CheckpointProposed events. */
 export type CheckpointProposedLog = L1EventLog<CheckpointProposedArgs>;
 
+const INSUFFICIENT_VALIDATOR_SET_SIZE_ERROR = 'ValidatorSelection__InsufficientValidatorSetSize';
+
+function isValidatorSelectionError(err: unknown, errorName: string): boolean {
+  return (
+    getErrorCause(err, ContractFunctionRevertedError)?.data?.errorName === errorName ||
+    decodeRpcRequestErrorName(err) === errorName
+  );
+}
+
+function decodeRpcRequestErrorName(err: unknown): string | undefined {
+  const data = getErrorCause(err, RpcRequestError)?.data;
+  if (!isHexString(data)) {
+    return undefined;
+  }
+
+  try {
+    return decodeErrorResult({ abi: RollupAbi, data }).errorName;
+  } catch {
+    return undefined;
+  }
+}
+
+function isHexString(value: unknown): value is Hex {
+  return typeof value === 'string' && value.startsWith('0x');
+}
+
 export class RollupContract {
   private readonly rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
   private readonly logger = createLogger('ethereum:rollup');
@@ -524,8 +555,19 @@ export class RollupContract {
     return EthAddress.fromString(await this.rollup.read.owner());
   }
 
-  async getActiveAttesterCount(): Promise<number> {
-    return Number(await this.rollup.read.getActiveAttesterCount());
+  async getActiveAttesterCount(options?: { blockNumber?: bigint }): Promise<number> {
+    await checkBlockTag(options?.blockNumber, this.client);
+    return Number(await this.rollup.read.getActiveAttesterCount(options));
+  }
+
+  /**
+   * Number of attesters that were staked at the given (historical) L1 timestamp. This is the count that
+   * validator-set sampling uses to decide whether an epoch gets a committee, and the historical counterpart
+   * of {@link getActiveAttesterCount} (which reads at the latest L1 block).
+   */
+  async getAttesterCountAtTime(timestamp: bigint, options?: { blockNumber?: bigint }): Promise<number> {
+    const gse = new GSEContract(this.client, await this.getGSE());
+    return gse.getAttesterCountAtTime(this.address, timestamp, options);
   }
 
   public async getSlashingProposerAddress() {
@@ -588,7 +630,7 @@ export class RollupContract {
         args: [timestamp],
       })
       .catch(e => {
-        if (e instanceof Error && e.message.includes('ValidatorSelection__InsufficientValidatorSetSize')) {
+        if (isValidatorSelectionError(e, INSUFFICIENT_VALIDATOR_SET_SIZE_ERROR)) {
           return { result: undefined };
         }
         throw e;
@@ -618,7 +660,7 @@ export class RollupContract {
         args: [],
       })
       .catch(e => {
-        if (e instanceof Error && e.message.includes('ValidatorSelection__InsufficientValidatorSetSize')) {
+        if (isValidatorSelectionError(e, INSUFFICIENT_VALIDATOR_SET_SIZE_ERROR)) {
           return { result: undefined };
         }
         throw e;
@@ -782,7 +824,7 @@ export class RollupContract {
   }
 
   async getEpochProofPublicInputs(
-    args: readonly [bigint, bigint, EpochProofPublicInputArgs, readonly `0x${string}`[], `0x${string}`],
+    args: readonly [bigint, bigint, EpochProofPublicInputArgs, readonly ViemHeader[], `0x${string}`],
   ): Promise<Fr[]> {
     const result = await this.rollup.read.getEpochProofPublicInputs(args);
     return result.map(Fr.fromString);
@@ -1160,13 +1202,20 @@ export class RollupContract {
   }
 
   async getAttesters(timestamp?: bigint): Promise<EthAddress[]> {
-    const attesterSize = await this.getActiveAttesterCount();
+    // Pin every read to a single L1 block so the attester count and the chunked index reads
+    // observe a consistent set. Without this, the count and each chunk default to `latest` and
+    // can straddle a block boundary (or reorg), yielding an inconsistent or truncated set.
+    const block = await this.client.getBlock();
+    const blockNumber = block.number ?? undefined;
+    const ts = timestamp ?? block.timestamp;
+    const attesterSize = await this.getActiveAttesterCount({ blockNumber });
     const gse = new GSEContract(this.client, await this.getGSE());
-    const ts = timestamp ?? (await this.client.getBlock()).timestamp;
     const indices = Array.from({ length: attesterSize }, (_, i) => BigInt(i));
     const chunks = chunk(indices, 1000);
 
-    const results = await Promise.all(chunks.map(chunk => gse.getAttestersFromIndicesAtTime(this.address, ts, chunk)));
+    const results = await Promise.all(
+      chunks.map(chunk => gse.getAttestersFromIndicesAtTime(this.address, ts, chunk, { blockNumber })),
+    );
     return results.flat().map(addr => EthAddress.fromString(addr));
   }
 

package/src/contracts/slashing_proposer.ts

@@ -3,6 +3,7 @@ import type { ViemClient } from '@aztec/ethereum/types';
 import { mergeAbis, tryExtractEvent } from '@aztec/ethereum/utils';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
+import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { hexToBuffer } from '@aztec/foundation/string';
@@ -25,6 +26,14 @@ import {
 export class SlashingProposerContract {
   private readonly contract: GetContractReturnType<typeof SlashingProposerAbi, ViemClient>;
 
+  /**
+   * Slash target validators of the last round asked for. Safe to cache because a round's targets are the committees
+   * of epochs that had already ended when the round opened (see SLASH_OFFSET_IN_ROUNDS), and those committees are
+   * sampled from validator set and randao snapshots taken before the epoch started, so they cannot change while the
+   * round is live. The promise is cached rather than the result, so concurrent callers share one in-flight read.
+   */
+  private slashTargetValidators: { round: bigint; validators: Promise<EthAddress[]> } | undefined;
+
   constructor(
     public readonly client: ViemClient,
     address: Hex | EthAddress,
@@ -64,6 +73,8 @@ export class SlashingProposerContract {
     return this.contract.read.EXECUTION_DELAY_IN_ROUNDS();
   }
 
+  /** Returns the slash amounts for the three slash unit levels. Immutable on the contract, so memoized. */
+  @memoize
   public getSlashingAmounts(): Promise<[bigint, bigint, bigint]> {
     return Promise.all([
       this.contract.read.SLASH_AMOUNT_SMALL(),
@@ -234,35 +245,70 @@ export class SlashingProposerContract {
     };
   }
 
+  /**
+   * Returns the validators eligible to be voted against in a round, in the order votes encode them. Cached for the
+   * last round asked for: reading them runs a committee sampling simulation on L1, and every vote of a round decodes
+   * against the same list, so a caller walking a round's votes would otherwise repeat that call per vote. Only the
+   * last round is kept since callers move forward round by round.
+   */
+  public getSlashTargetValidators(round: bigint): Promise<EthAddress[]> {
+    const cached = this.slashTargetValidators;
+    if (cached?.round === round) {
+      return cached.validators;
+    }
+
+    const entry = { round, validators: this.fetchSlashTargetValidators(round) };
+    this.slashTargetValidators = entry;
+    // A failed read must not stay cached, or every later vote of the round would replay the same rejection
+    entry.validators.catch(() => {
+      if (this.slashTargetValidators === entry) {
+        this.slashTargetValidators = undefined;
+      }
+    });
+    return entry.validators;
+  }
+
+  private async fetchSlashTargetValidators(round: bigint): Promise<EthAddress[]> {
+    const { result } = await this.contract.simulate.getSlashTargetCommittees([round]);
+    return result.flat().map(validator => EthAddress.fromString(validator));
+  }
+
+  /**
+   * Returns the slash amount voted for each target validator by a single vote of a round.
+   * @param index - Position of the vote within the round, from 0 (inclusive) to the round's vote count (exclusive)
+   */
+  public async getVoteAt(round: bigint, index: bigint): Promise<SlashVoteTarget[]> {
+    const [validators, vote, slashAmounts] = await Promise.all([
+      this.getSlashTargetValidators(round),
+      this.contract.read.getVotes([round, index]),
+      this.getSlashingAmounts(),
+    ]);
+    return decodeVote(vote, validators, slashAmounts);
+  }
+
   /** Returns the last vote emitted for a given round  */
   public async getLastVote(round: bigint) {
     const { voteCount } = await this.getRound(round);
-    const validators = (await this.contract.simulate.getSlashTargetCommittees([round])).result.flat();
-    const vote = await this.contract.read.getVotes([round, voteCount - 1n]);
-    const decoded = decodeSlashConsensusVotes(hexToBuffer(vote));
-    const slashAmounts = await this.getSlashingAmounts();
-    return decoded
-      .map((units, i) => ({
-        validator: EthAddress.fromString(validators[i]),
-        slashAmount: slashAmounts[units - 1] ?? 0n,
-      }))
-      .filter(v => v.slashAmount > 0n);
+    return await this.getVoteAt(round, voteCount - 1n);
   }
 
   /**
    * Listen for VoteCast events
-   * @param callback - Callback function to handle vote cast events
+   * @param callback - Callback receiving the round, the vote's index within the round as accepted by `getVoteAt`,
+   * and the proposer that cast it
    * @returns Unwatch function
    */
-  public listenToVoteCast(callback: (args: { round: bigint; proposer: string }) => void): () => void {
+  public listenToVoteCast(
+    callback: (args: { round: bigint; voteIndex: bigint; proposer: string }) => void,
+  ): () => void {
     return this.contract.watchEvent.VoteCast(
       {},
       {
         onLogs: logs => {
           for (const log of logs) {
-            const { round, proposer } = log.args;
-            if (round !== undefined && proposer) {
-              callback({ round, proposer });
+            const { round, voteIndex, proposer } = log.args;
+            if (round !== undefined && voteIndex !== undefined && proposer) {
+              callback({ round, voteIndex, proposer });
             }
           }
         },
@@ -294,6 +340,23 @@ export class SlashingProposerContract {
   }
 }
 
+/**
+ * A validator targeted by a slashing vote, with the amount voted. The position is the validator's index in the
+ * round's flattened slash target committees — the unit the contract tallies quorum by. A validator sitting in
+ * several of the round's committees holds several positions, each with its own tally.
+ */
+export type SlashVoteTarget = { validator: EthAddress; slashAmount: bigint; position: number };
+
+function decodeVote(vote: Hex, validators: EthAddress[], slashAmounts: [bigint, bigint, bigint]): SlashVoteTarget[] {
+  return decodeSlashConsensusVotes(hexToBuffer(vote))
+    .map((units, position) => ({
+      validator: validators[position],
+      slashAmount: slashAmounts[units - 1] ?? 0n,
+      position,
+    }))
+    .filter(v => v.slashAmount > 0n);
+}
+
 /**
  * Decodes a Buffer containing slash votes back into an array of numbers.
  * Each vote is represented as a 2-bit value (0, 1, 2, or 3) representing slashing units.

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';
@@ -19,14 +19,17 @@ import { mainnet, sepolia } from 'viem/chains';
 
 import { createEthereumChain, isAnvilTestChain } from './chain.js';
 import { createExtendedL1Client } from './client.js';
-import type { L1ContractsConfig } from './config.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
@@ -282,6 +288,7 @@ export async function deployAztecL1Contracts(
   args: DeployAztecL1ContractsArgs,
 ): Promise<DeployAztecL1ContractsReturnType> {
   logger.info(`Deploying L1 contracts with config: ${jsonStringify(args)}`);
+  assertValidSlotDurations(args);
   if (args.initialValidators && args.initialValidators.length > 0 && args.existingTokenAddress) {
     throw new Error(
       'Cannot deploy with both initialValidators and existingTokenAddress. ' +
@@ -319,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;
@@ -345,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,
@@ -589,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;
 }
 
@@ -612,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/config.ts

@@ -73,7 +73,7 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   gasLimitBufferPercentage: {
     description: 'How much to increase calculated gas limit by (percentage)',
     env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
-    ...numberConfigHelper(20),
+    ...floatConfigHelper(20),
   },
   maxGwei: {
     description: 'Maximum gas price in gwei to be used for transactions.',
@@ -90,12 +90,12 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   priorityFeeBumpPercentage: {
     description: 'How much to increase priority fee by each attempt (percentage)',
     env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
-    ...numberConfigHelper(20),
+    ...floatConfigHelper(20),
   },
   priorityFeeRetryBumpPercentage: {
     description: 'How much to increase priority fee by each retry attempt (percentage)',
     env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
-    ...numberConfigHelper(50),
+    ...floatConfigHelper(50),
   },
   minimumPriorityFeePerGas: {
     description:

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 [];
+  }
+}