@aztec/ethereum 0.0.1-commit.4d3c002 → 0.0.1-commit.4d9804df

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

@@ -5,7 +5,7 @@ import { InterruptError, TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { Semaphore } from '@aztec/foundation/queue';
-import { retryUntil } from '@aztec/foundation/retry';
+import { makeBackoff, retry, retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
@@ -36,6 +36,7 @@ import {
   type L1TxConfig,
   type L1TxRequest,
   type L1TxState,
+  L1TxTimeoutError,
   type SigningCallback,
   TerminalTxUtilsState,
   TxUtilsState,
@@ -44,6 +45,11 @@ import {
 
 const MAX_L1_TX_STATES = 32;
 
+// Backoff (in seconds) for retrying the read-only RPC calls that prepare a tx cancellation. A
+// cancellation is fired in the background after a tx times out and is important (it frees the stuck
+// nonce), so a transient RPC failure while reading the pending nonce or gas price must not abandon it.
+const CANCELLATION_PREP_RETRY_BACKOFF_S = [1, 2, 4, 8];
+
 export class L1TxUtils extends ReadOnlyL1TxUtils {
   protected txs: L1TxState[] = [];
   /** Last nonce successfully sent to the chain. Used as a lower bound when a fallback RPC node returns a stale count. */
@@ -131,6 +137,14 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     );
   }
 
+  /**
+   * Clears the cached `lastSentNonce` so the next `sendTransaction` call fetches the real
+   * nonce from the chain. Call this after an L1 reorg to prevent stale nonce references.
+   */
+  public resetNonce(): void {
+    this.lastSentNonce = undefined;
+  }
+
   public getSenderAddress() {
     return this.address;
   }
@@ -213,6 +227,19 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     return await this.signTransaction(txRequest as TransactionSerializable);
   }
 
+  private async checkInterruptedOrTimedOut(gasConfig: Pick<L1TxConfig, 'txTimeoutAt'>): Promise<Date> {
+    if (this.interrupted) {
+      throw new InterruptError(`Transaction sending is interrupted`);
+    }
+    const now = new Date(await this.getL1Timestamp());
+    if (gasConfig.txTimeoutAt && now > gasConfig.txTimeoutAt) {
+      throw new TimeoutError(
+        `Transaction timed out before sending (now ${now.toISOString()} > timeoutAt ${gasConfig.txTimeoutAt.toISOString()})`,
+      );
+    }
+    return now;
+  }
+
   /**
    * Sends a transaction with gas estimation and pricing
    * @param request - The transaction request (to, data, value)
@@ -225,14 +252,15 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     blobInputs?: L1BlobInputs,
     stateChange: TxUtilsState = TxUtilsState.SENT,
   ): Promise<{ txHash: Hex; state: L1TxState }> {
-    if (this.interrupted) {
-      throw new InterruptError(`Transaction sending is interrupted`);
-    }
-
     try {
       const gasConfig = merge(this.config, gasConfigOverrides);
       const account = this.getSenderAddress().toString();
 
+      // Fail fast before doing any work (gas estimation, balance check) if we've been interrupted
+      // or if the caller's deadline has already passed. The same check is repeated after gas
+      // estimation in case it took long enough to push us past the deadline.
+      await this.checkInterruptedOrTimedOut(gasConfig);
+
       let gasLimit: bigint;
       if (this.debugMaxGasLimit) {
         gasLimit = MAX_L1_TX_LIMIT;
@@ -245,16 +273,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
       const gasPrice = await this.getGasPrice(gasConfig, !!blobInputs);
 
-      if (this.interrupted) {
-        throw new InterruptError(`Transaction sending is interrupted`);
-      }
-
-      const now = new Date(await this.getL1Timestamp());
-      if (gasConfig.txTimeoutAt && now > gasConfig.txTimeoutAt) {
-        throw new TimeoutError(
-          `Transaction timed out before sending (now ${now.toISOString()} > timeoutAt ${gasConfig.txTimeoutAt.toISOString()})`,
-        );
-      }
+      const now = await this.checkInterruptedOrTimedOut(gasConfig);
 
       let txHash: Hex;
       let nonce: number;
@@ -288,6 +307,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         txConfigOverrides: gasConfigOverrides ?? {},
         sentAtL1Ts: now,
         lastSentAtL1Ts: now,
+        gasPriceHistory: [baseState.gasPrice],
       };
 
       // And persist it
@@ -418,10 +438,23 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
     const initialTxHash = txHashes[0];
     let currentTxHash = txHashes.at(-1)!;
-    let l1Timestamp: number;
+    let l1Timestamp = 0;
 
     while (true) {
-      l1Timestamp = await this.getL1Timestamp();
+      try {
+        l1Timestamp = await this.getL1Timestamp();
+      } catch (err) {
+        // A transient RPC failure here must not abort monitoring with a rejection: callers that
+        // fire this loop in the background would surface it as an unhandled rejection (e.g. when a
+        // test tears down its L1 node while a monitor iteration is in flight). Exit quietly if we
+        // are shutting down, otherwise retry on the next interval.
+        if (this.interrupted) {
+          break;
+        }
+        this.logger.error(`Error fetching L1 timestamp while monitoring tx ${currentTxHash}`, err, { nonce, account });
+        await sleep(gasConfig.checkIntervalMs!);
+        continue;
+      }
 
       try {
         const timePassed = l1Timestamp - state.lastSentAtL1Ts.getTime();
@@ -473,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. ` +
@@ -641,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(
@@ -693,9 +741,37 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       return;
     }
 
-    // Check if the original tx is still pending
-    const currentNonce = await this.client.getTransactionCount({ address: account, blockTag: 'pending' });
-    if (currentNonce < nonce) {
+    // Resolve the pending nonce and cancellation gas price up front. These are read-only RPC calls, so
+    // they are safe to retry; a transient RPC failure here must not permanently abandon the cancellation
+    // (which would leave the nonce stuck and the tx state stranded short of CANCELLED). We retry with a
+    // real backoff before giving up, unlike getGasPrice's tight internal retry which can be exhausted by
+    // a brief node hiccup. The retried block performs no state-changing send, so retrying cannot
+    // double-send the cancellation tx.
+    const { currentNonce, cancelGasPrice } = await retry(
+      async () => {
+        const currentNonce = await this.client.getTransactionCount({ address: account, blockTag: 'pending' });
+        if (currentNonce >= nonce) {
+          // Get gas price with higher priority fee for cancellation
+          const cancelGasPrice = await this.getGasPrice(
+            {
+              ...this.config,
+              // Use high bump for cancellation to ensure it replaces the original tx
+              priorityFeeRetryBumpPercentage: 150, // 150% bump should be enough to replace any tx
+            },
+            isBlobTx,
+            state.txHashes.length,
+            previousGasPrice,
+          );
+          return { currentNonce, cancelGasPrice };
+        }
+        return { currentNonce, cancelGasPrice: undefined };
+      },
+      `Preparing cancellation for L1 tx from account ${account} with nonce ${nonce}`,
+      makeBackoff(CANCELLATION_PREP_RETRY_BACKOFF_S),
+      this.logger,
+    );
+
+    if (cancelGasPrice === undefined) {
       this.logger.verbose(
         `Not sending cancellation for L1 tx from account ${account} with nonce ${nonce} as it is dropped`,
         { nonce, account, currentNonce },
@@ -704,18 +780,6 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       return;
     }
 
-    // Get gas price with higher priority fee for cancellation
-    const cancelGasPrice = await this.getGasPrice(
-      {
-        ...this.config,
-        // Use high bump for cancellation to ensure it replaces the original tx
-        priorityFeeRetryBumpPercentage: 150, // 150% bump should be enough to replace any tx
-      },
-      isBlobTx,
-      state.txHashes.length,
-      previousGasPrice,
-    );
-
     const { maxFeePerGas, maxPriorityFeePerGas, maxFeePerBlobGas } = cancelGasPrice;
     this.logger.verbose(
       `Attempting to cancel L1 ${isBlobTx ? 'blob' : 'vanilla'} transaction from account ${account} with nonce ${nonce} after time out`,

package/src/l1_tx_utils/readonly_l1_tx_utils.ts

@@ -3,6 +3,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
+import { getErrorCause } from '@aztec/foundation/types';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
 import pickBy from 'lodash.pickby';
@@ -395,7 +396,7 @@ export class ReadOnlyL1TxUtils {
       this.logger?.debug(`L1 transaction simulation succeeded`, { ...result[0].calls[0] });
       return { gasUsed: result[0].gasUsed, result: result[0].calls[0].data as `0x${string}` };
     } catch (err) {
-      if (err instanceof MethodNotFoundRpcError || err instanceof MethodNotSupportedRpcError) {
+      if (getErrorCause(err, MethodNotFoundRpcError) || getErrorCause(err, MethodNotSupportedRpcError)) {
         if (gasConfig.fallbackGasEstimate) {
           this.logger?.warn(
             `Node does not support eth_simulateV1 API. Using fallback gas estimate: ${gasConfig.fallbackGasEstimate}`,

package/src/l1_tx_utils/tx_delayer.ts

@@ -81,7 +81,11 @@ export class Delayer {
 
   public maxInclusionTimeIntoSlot: number | undefined = undefined;
   public ethereumSlotDuration: bigint;
-  public nextWait: { l1Timestamp: bigint } | { l1BlockNumber: bigint } | { indefinitely: true } | undefined = undefined;
+  public nextWait:
+    | { l1Timestamp: bigint; timeoutSeconds?: number }
+    | { l1BlockNumber: bigint; timeoutSeconds?: number }
+    | { indefinitely: true }
+    | undefined = undefined;
   public sentTxHashes: Hex[] = [];
   public cancelledTxs: Hex[] = [];
 
@@ -110,13 +114,13 @@ export class Delayer {
   }
 
   /** Delays the next tx to be sent so it lands on the given L1 block number. */
-  pauseNextTxUntilBlock(l1BlockNumber: number | bigint) {
-    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber) };
+  pauseNextTxUntilBlock(l1BlockNumber: number | bigint, timeoutSeconds?: number) {
+    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber), timeoutSeconds };
   }
 
   /** Delays the next tx to be sent so it lands on the given timestamp. */
-  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint) {
-    this.nextWait = { l1Timestamp: BigInt(l1Timestamp) };
+  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint, timeoutSeconds?: number) {
+    this.nextWait = { l1Timestamp: BigInt(l1Timestamp), timeoutSeconds };
   }
 
   /** Delays the next tx to be sent indefinitely. */
@@ -198,9 +202,14 @@ export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer:
           // Or wait until the desired block number or timestamp
           wait =
             'l1BlockNumber' in waitUntil
-              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger)
+              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger, waitUntil.timeoutSeconds)
               : 'l1Timestamp' in waitUntil
-                ? waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger)
+                ? waitUntilL1Timestamp(
+                    publicClient,
+                    waitUntil.l1Timestamp - delayer.ethereumSlotDuration,
+                    logger,
+                    waitUntil.timeoutSeconds,
+                  )
                 : undefined;
 
           logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {

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/publisher_manager.ts

@@ -40,11 +40,12 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
   private log: Logger;
   private config: PublisherManagerConfig;
   private static readonly FUNDING_CHECK_INTERVAL_MS = 2 * 60 * 1000;
-  private funder?: UtilsType;
-  private fundingPromise?: RunningPromise;
+  protected funder?: UtilsType;
+  protected readonly fundingPromise?: RunningPromise;
+  private started = false;
 
   constructor(
-    private publishers: UtilsType[],
+    protected publishers: UtilsType[],
     config: PublisherManagerConfig,
     opts?: { bindings?: LoggerBindings; funder?: UtilsType },
   ) {
@@ -67,34 +68,60 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
         this.funder = undefined;
       }
     }
+
+    if (this.funder && hasThreshold && hasAmount) {
+      this.fundingPromise = new RunningPromise(
+        () => this.triggerFundingIfNeeded(),
+        this.log,
+        PublisherManager.FUNDING_CHECK_INTERVAL_MS,
+      );
+    }
   }
 
-  /** Loads the state of all publishers and the funder, and starts periodic funding checks. */
+  /**
+   * Clears any interrupted flag left by a previous {@link stop} so publishing works again after a restart,
+   * loads the state of all publishers and the funder, and starts periodic funding checks. Idempotent: a
+   * start while already started is a no-op, so it never re-runs `loadStateAndResumeMonitoring` (which
+   * would spawn a duplicate background monitor per pending nonce). Lifecycle calls are expected to be
+   * serialized by the caller.
+   */
   public async start(): Promise<void> {
+    if (this.started) {
+      this.log.debug('PublisherManager already started, ignoring start');
+      return;
+    }
+
+    // Clear the interrupted flag set by a previous stop() so a restarted manager can publish again.
+    // On a first start this is a no-op (the flag is already clear).
+    this.publishers.forEach(pub => pub.restart());
+    this.funder?.restart();
+
     await Promise.all([
       ...this.publishers.map(pub => pub.loadStateAndResumeMonitoring()),
       this.funder?.loadStateAndResumeMonitoring(),
     ]);
 
-    if (
-      this.funder &&
-      this.config.publisherFundingThreshold !== undefined &&
-      this.config.publisherFundingAmount !== undefined
-    ) {
-      this.fundingPromise = new RunningPromise(
-        () => this.triggerFundingIfNeeded(),
-        this.log,
-        PublisherManager.FUNDING_CHECK_INTERVAL_MS,
-      );
-      this.fundingPromise.start();
-    }
+    this.fundingPromise?.start();
+    // Marked started only once fully up, so a start that failed to load state can be retried.
+    this.started = true;
   }
 
-  /** Stops the funding loop and interrupts all publishers. */
+  /**
+   * Stops the funding loop, interrupts all publishers so no further L1 txs are sent, and waits (bounded)
+   * for their in-flight tx monitor loops to wind down. Idempotent, and the manager may be restarted
+   * afterwards via {@link start}, which clears the interrupted flag.
+   */
   public async stop(): Promise<void> {
+    this.started = false;
     await this.fundingPromise?.stop();
     this.publishers.forEach(pub => pub.interrupt());
     this.funder?.interrupt();
+    // Wait for in-flight tx monitor loops to observe the interrupt, so no L1 requests are still
+    // being issued after shutdown (e.g. against an anvil instance a test is about to tear down).
+    await Promise.all([
+      ...this.publishers.map(pub => pub.waitMonitoringStopped()),
+      this.funder?.waitMonitoringStopped(),
+    ]);
   }
 
   // Finds and prioritises available publishers based on
@@ -133,8 +160,17 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
       }),
     );
 
+    // Discount unfunded publishers: a publisher with no ETH cannot send a tx, so it must never win
+    // selection regardless of how favourable its state or last-used time is. Fall back to the full
+    // set only if every candidate is unfunded, so behaviour is no worse than before.
+    let fundedPublishers = publishersWithBalance.filter(p => p.balance > 0n);
+    if (fundedPublishers.length === 0) {
+      this.log.warn(`All candidate publishers have zero balance; selecting from unfunded publishers.`);
+      fundedPublishers = publishersWithBalance;
+    }
+
     // Sort based on state, then balance, then time since last use
-    const sortedPublishers = publishersWithBalance.sort((a, b) => {
+    const sortedPublishers = fundedPublishers.sort((a, b) => {
       const stateComparison = sortOrder.indexOf(a.publisher.state) - sortOrder.indexOf(b.publisher.state);
       if (stateComparison !== 0) {
         return stateComparison;

package/src/queries.ts

@@ -1,11 +1,77 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 
+import { BaseError, type Block } from 'viem';
+
 import { DefaultL1ContractsConfig, type L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
 import { GovernanceProposerContract } from './contracts/governance_proposer.js';
 import { InboxContract } from './contracts/inbox.js';
 import { RollupContract } from './contracts/rollup.js';
-import type { ViemPublicClient } from './types.js';
+import type { ViemClient, ViemPublicClient } from './types.js';
+
+/**
+ * Returns the L1 finalized block, or `undefined` if the chain does not yet have one
+ * (common on freshly started devnets). Rethrows any other RPC error.
+ */
+export async function getFinalizedL1Block(client: ViemClient): Promise<Block<bigint, false, 'finalized'> | undefined> {
+  try {
+    return await client.getBlock({ blockTag: 'finalized', includeTransactions: false });
+  } catch (err) {
+    if (isFinalizedBlockTagNotFoundError(err)) {
+      return undefined;
+    }
+    throw err;
+  }
+}
+
+// Error messages returned by popular Ethereum execution clients when
+// eth_getBlockByNumber / eth_call is called with blockTag "finalized" or
+// "safe" and no such block has been produced yet:
+//
+//   geth       "finalized block not found"
+//              "safe block not found"
+//   reth       "block not found: finalized"
+//              "block not found: safe"
+//   nethermind "Unknown block error"           (same for both tags)
+//   besu       "Unknown block"
+//   erigon     'block "finalized" not available (head block: N)'
+//              'block "safe" not available (head block: N)'
+//
+// A combined regex covers all five:
+const FINALIZED_BLOCK_TAG_NOT_FOUND_MESSAGE_RE =
+  /(finalized|safe) block not found|block not found: (finalized|safe)|unknown block|block "(finalized|safe)" not available/i;
+
+/**
+ * Returns true if the error originates from an RPC call that failed because
+ * the "finalized" (or "safe") block tag is not yet available on the chain.
+ */
+export function isFinalizedBlockTagNotFoundError(err: unknown): boolean {
+  if (!err) {
+    return false;
+  }
+
+  if (err instanceof BaseError) {
+    const hit = err.walk((e: any) => matchesFinalizedBlockTagNotFound(e));
+    if (hit) {
+      return true;
+    }
+  }
+
+  for (let cur: any = err, i = 0; cur && i < 10; cur = cur.cause, i++) {
+    if (matchesFinalizedBlockTagNotFound(cur)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function matchesFinalizedBlockTagNotFound(e: any): boolean {
+  if (!e) {
+    return false;
+  }
+  const text = `${e.details ?? ''} ${e.message ?? ''} ${e.shortMessage ?? ''}`;
+  return FINALIZED_BLOCK_TAG_NOT_FOUND_MESSAGE_RE.test(text);
+}
 
 /** Reads the L1ContractsConfig from L1 contracts. */
 export async function getL1ContractsConfig(
@@ -76,8 +142,8 @@ export async function getL1ContractsConfig(
     slasherProposer?.getRoundSize() ?? 0n,
     slasherProposer?.getLifetimeInRounds() ?? 0n,
     slasherProposer?.getExecutionDelayInRounds() ?? 0n,
-    slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
-    slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
+    slasherProposer?.getSlashOffsetInRounds() ?? 0n,
+    slasherProposer?.getSlashingAmounts() ?? [0n, 0n, 0n],
     slasher?.getVetoer() ?? EthAddress.ZERO,
     slasher?.getSlashingDisableDuration() ?? 0,
     rollup.getManaTarget(),
@@ -114,11 +180,17 @@ export async function getL1ContractsConfig(
     rollupVersion: Number(rollupVersion),
     genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
     exitDelaySeconds: Number(exitDelay),
-    slasherFlavor: slasherProposer?.type ?? 'tally',
+    slasherEnabled: !!slasherProposer,
     slashingOffsetInRounds: Number(slashingOffsetInRounds),
     slashAmountSmall: slashingAmounts[0],
     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,
   };
 }