@aztec-labs/ethereum 6.0.0-rc.3 → 6.0.0

package/src/publisher_manager.ts

@@ -1,23 +1,31 @@
-import { pick } from '@aztec-labs/foundation/collection';
+import { maxBy, pick } from '@aztec-labs/foundation/collection';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec-labs/foundation/log';
 import { RunningPromise } from '@aztec-labs/foundation/running-promise';
+import { formatEther } from 'viem';
 
 import { Multicall3 } from './contracts/multicall.js';
-import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
-
-// Defines the order in which we prioritise publishers based on their state (first is better)
-const sortOrder = [
-  // Always prefer sending from idle publishers
-  TxUtilsState.IDLE,
-  // Then from publishers that have sent a tx and it got mined
-  TxUtilsState.MINED,
-  // Then from publishers that have sent a tx but it's in-flight
-  TxUtilsState.SPEED_UP,
-  TxUtilsState.SENT,
-  // We leave cancelled and not-mined states for last, since these represent failures to mines and could be problematic
-  TxUtilsState.CANCELLED,
-  TxUtilsState.NOT_MINED,
-];
+import {
+  type FeesPerGas,
+  INSUFFICIENT_FUNDS_BACKOFF_MS,
+  L1TxUtils,
+  type SendCostRequirement,
+  TxUtilsState,
+  computeSendCost,
+} from './l1_tx_utils/index.js';
+
+/**
+ * Selection rank per publisher state (lower is better). IDLE and MINED rank equally: a publisher whose sends keep
+ * failing (e.g. for lack of funds) never leaves IDLE, so ranking IDLE above MINED would let it beat a working one.
+ * In-flight states come next, and cancelled or not-mined states last since they represent failures to mine.
+ */
+const stateRank: Record<TxUtilsState, number> = {
+  [TxUtilsState.IDLE]: 0,
+  [TxUtilsState.MINED]: 0,
+  [TxUtilsState.SPEED_UP]: 1,
+  [TxUtilsState.SENT]: 1,
+  [TxUtilsState.CANCELLED]: 2,
+  [TxUtilsState.NOT_MINED]: 2,
+};
 
 // Which states represent a busy publisher that we should avoid if possible
 const busyStates: TxUtilsState[] = [
@@ -27,6 +35,10 @@ const busyStates: TxUtilsState[] = [
   TxUtilsState.NOT_MINED,
 ];
 
+const LOW_BALANCE_WARNING_INTERVAL_MS = 10 * 60 * 1000;
+const DEFAULT_LOW_BALANCE_WARNING_MULTIPLIER = 4;
+const NO_AFFORDABLE_PUBLISHER_WARNING_KEY = 'no-affordable-publisher';
+
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
 
 /** Config accepted by PublisherManager. */
@@ -34,26 +46,156 @@ type PublisherManagerConfig = {
   publisherAllowInvalidStates?: boolean;
   publisherFundingThreshold?: bigint;
   publisherFundingAmount?: bigint;
+  /** Warn when a publisher balance is below this multiple of the ETH required for the reference send. */
+  publisherLowBalanceWarningMultiplier?: number;
+};
+
+/** A send the periodic balance check prices at current fees, to report whether publishers can afford it. */
+export type ReferenceSend = {
+  /** Short name of the send for logs, such as "proposal" or "epoch proof". */
+  name: string;
+  requirement: SendCostRequirement;
+};
+
+/** Balances read by a periodic balance check, and how many reference sends each publisher can afford. */
+export type PublisherBalanceSnapshot = {
+  /** Publishers whose balance could be read. */
+  publishers: {
+    address: string;
+    balance: bigint;
+    /**
+     * Number of reference sends the balance covers at current fees, 0 while backed off after an insufficient funds
+     * rejection. Unset without a reference send or if fees could not be read.
+     */
+    sendsAffordable?: number;
+  }[];
+  funder?: { address: string; balance: bigint };
+  /** ETH needed for the reference send at current fees. Unset without a reference send or if fees could not be read. */
+  required?: bigint;
+};
+
+/** Metrics emitted by the PublisherManager from its periodic balance check. */
+export interface IPublisherManagerMetrics {
+  /** Records the latest balance snapshot, replacing the previous one. Undefined clears it once the manager stops. */
+  recordBalanceSnapshot(snapshot: PublisherBalanceSnapshot | undefined): void;
+}
+
+/** Balance snapshot of a publisher considered for an L1 send. */
+export type PublisherBalanceInfo = {
+  address: string;
+  balance: bigint;
+  state: string;
+  /** Balance at which a previous send was rejected for insufficient funds, if the publisher is backed off. */
+  insufficientFundsAtBalance?: bigint;
 };
 
+/** Thrown when publishers are available but none holds enough ETH to afford the requested L1 send. */
+export class NoAffordablePublisherError extends Error {
+  constructor(
+    public readonly required: bigint,
+    public readonly requirement: SendCostRequirement,
+    public readonly fees: FeesPerGas,
+    public readonly publishers: PublisherBalanceInfo[],
+  ) {
+    super(
+      `No publisher can afford the L1 send: requires ${formatEther(required)} ETH ` +
+        `(balances: ${publishers.map(p => `${p.address}=${formatEther(p.balance)}`).join(', ') || 'none'})`,
+    );
+    this.name = 'NoAffordablePublisherError';
+  }
+
+  /**
+   * ETH the best funded publisher that is not backed off after an insufficient funds rejection is missing to afford the
+   * send. Undefined if every publisher is backed off.
+   */
+  public shortfall(): bigint | undefined {
+    const richest = this.getRichestNotBackedOff();
+    return richest === undefined ? undefined : this.required - richest.balance;
+  }
+
+  /** Tells the operator which publisher to fund and with how much ETH for the send to become affordable. */
+  public describeFunding(): string {
+    const richest = this.getRichestNotBackedOff();
+    if (richest === undefined || this.required <= richest.balance) {
+      const minutes = INSUFFICIENT_FUNDS_BACKOFF_MS / 60_000;
+      return (
+        `every publisher is backed off after an insufficient funds rejection ` +
+        `until its balance increases or ${minutes} minutes pass`
+      );
+    }
+    const shortfall = formatEther(this.required - richest.balance);
+    const others = this.publishers.filter(p => p.address !== richest.address);
+    const alternative =
+      others.length === 0
+        ? ''
+        : `, or top up any of ${others.map(p => p.address).join(', ')} to ${formatEther(this.required)} ETH`;
+    return `fund ${richest.address} with ${shortfall} ETH more${alternative}`;
+  }
+
+  /** Structured context for logging. */
+  public toLogContext() {
+    return {
+      required: this.required,
+      shortfall: this.shortfall(),
+      gasLimit: this.requirement.gasLimit,
+      blobCount: this.requirement.blobCount,
+      maxFeePerGas: this.fees.maxFeePerGas,
+      maxFeePerBlobGas: this.fees.maxFeePerBlobGas,
+      publishers: this.publishers,
+    };
+  }
+
+  private getRichestNotBackedOff(): PublisherBalanceInfo | undefined {
+    return maxBy(
+      this.publishers.filter(p => p.insufficientFundsAtBalance === undefined),
+      p => p.balance,
+    );
+  }
+}
+
+type PublisherWithBalance<UtilsType> = { publisher: UtilsType; balance: bigint };
+
 export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
-  private log: Logger;
+  private static readonly BALANCE_CHECK_INTERVAL_MS = 60 * 1000;
+  protected log: Logger;
   private config: PublisherManagerConfig;
-  private static readonly FUNDING_CHECK_INTERVAL_MS = 2 * 60 * 1000;
   protected funder?: UtilsType;
-  protected readonly fundingPromise?: RunningPromise;
+  protected readonly balanceCheckPromise: RunningPromise;
   private started = false;
+  private readonly metrics?: IPublisherManagerMetrics;
+  private readonly referenceSend?: ReferenceSend;
+  /** Whether the balance check has run since the last start, so the first one logs a summary of all balances. */
+  private loggedBalanceSummary = false;
+  /** Last time a balance warning was logged, per publisher address or per kind of warning. */
+  private readonly lastLowBalanceWarningAt = new Map<string, number>();
 
   constructor(
     protected publishers: UtilsType[],
     config: PublisherManagerConfig,
-    opts?: { bindings?: LoggerBindings; funder?: UtilsType },
+    opts?: {
+      bindings?: LoggerBindings;
+      funder?: UtilsType;
+      metrics?: IPublisherManagerMetrics;
+      /**
+       * Send the balance check prices to report whether publishers can afford it. Without one, balances are still
+       * recorded, but affordability is neither recorded nor warned about.
+       */
+      referenceSend?: ReferenceSend;
+    },
   ) {
     this.funder = opts?.funder;
+    this.metrics = opts?.metrics;
+    this.referenceSend = opts?.referenceSend;
     this.log = createLogger('publisher:manager', opts?.bindings);
     this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
     this.publishers = publishers;
-    this.config = pick(config, 'publisherAllowInvalidStates', 'publisherFundingThreshold', 'publisherFundingAmount');
+    this.config = pick(
+      config,
+      'publisherAllowInvalidStates',
+      'publisherFundingThreshold',
+      'publisherFundingAmount',
+      'publisherLowBalanceWarningMultiplier',
+    );
 
     const hasThreshold = this.config.publisherFundingThreshold !== undefined;
     const hasAmount = this.config.publisherFundingAmount !== undefined;
@@ -69,21 +211,19 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
       }
     }
 
-    if (this.funder && hasThreshold && hasAmount) {
-      this.fundingPromise = new RunningPromise(
-        () => this.triggerFundingIfNeeded(),
-        this.log,
-        PublisherManager.FUNDING_CHECK_INTERVAL_MS,
-      );
-    }
+    this.balanceCheckPromise = new RunningPromise(
+      () => this.checkBalances(),
+      this.log,
+      PublisherManager.BALANCE_CHECK_INTERVAL_MS,
+    );
   }
 
   /**
    * 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.
+   * loads the state of all publishers and the funder, and starts the periodic balance check, which also tops up
+   * publishers if funding is configured. 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) {
@@ -101,19 +241,22 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
       this.funder?.loadStateAndResumeMonitoring(),
     ]);
 
-    this.fundingPromise?.start();
+    this.loggedBalanceSummary = false;
+    this.lastLowBalanceWarningAt.delete(NO_AFFORDABLE_PUBLISHER_WARNING_KEY);
+    this.balanceCheckPromise.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, interrupts all publishers so no further L1 txs are sent, and waits (bounded)
+   * Stops the balance check 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();
+    await this.balanceCheckPromise.stop();
+    this.metrics?.recordBalanceSnapshot(undefined);
     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
@@ -124,60 +267,62 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
     ]);
   }
 
-  // Finds and prioritises available publishers based on
-  // 1. Validity as per the provided filter function
-  // 2. Validity based on the state the publisher is in
-  // 3. Priority based on state as defined by sortOrder
-  // 4. Then priority based on highest balance
-  // 5. Then priority based on least recently used
-  public async getAvailablePublisher(filter: PublisherFilter<UtilsType> = () => true): Promise<UtilsType> {
+  /**
+   * Finds and prioritises an available publisher. Candidates must pass the filter and not be busy (unless
+   * `publisherAllowInvalidStates` is set and no idle publisher remains), and are ranked by state (see `stateRank`), then
+   * highest balance, then least recently used. Publishers backed off after an insufficient funds rejection are skipped
+   * until their balance increases or the backoff expires.
+   *
+   * With a `requirement`, only publishers whose balance covers the worst-case cost of that send are eligible, and a
+   * {@link NoAffordablePublisherError} is thrown if there are none. Without one, selection is lenient: it prefers funded
+   * publishers but falls back to unfunded ones rather than failing, for sends that are fine to attempt and lose.
+   */
+  public async getAvailablePublisher(
+    filter: PublisherFilter<UtilsType> = () => true,
+    opts?: { requirement?: SendCostRequirement },
+  ): Promise<UtilsType> {
     this.log.debug(`Getting available publisher`, {
       publishers: this.publishers.map(p => ({
         address: p.getSenderAddress(),
         state: p.state,
         lastMined: p.lastMinedAtBlockNumber,
       })),
+      requirement: opts?.requirement,
     });
 
-    // Extract the valid publishers
-    let validPublishers = this.publishers.filter((pub: UtilsType) => !busyStates.includes(pub.state) && filter(pub));
+    const filtered = this.publishers.filter(pub => filter(pub));
+    let validPublishers = filtered.filter(pub => !busyStates.includes(pub.state));
 
-    // If none found but we allow invalid (busy) states, try again including them
-    if (validPublishers.length === 0 && this.config.publisherAllowInvalidStates) {
-      this.log.warn(`No valid publishers found. Trying again including invalid states.`);
-      validPublishers = this.publishers.filter(pub => filter(pub));
+    // If none found but we allow invalid (busy) states, try again including them. When the send has a requirement we
+    // also consider busy ones, so that an idle but unaffordable publisher does not hide a busy affordable one. Busy
+    // publishers still rank below idle ones.
+    if (this.config.publisherAllowInvalidStates && (validPublishers.length === 0 || opts?.requirement)) {
+      if (validPublishers.length === 0) {
+        this.log.warn(`No valid publishers found. Trying again including invalid states.`);
+      }
+      validPublishers = filtered;
     }
 
-    // Error if none found
     if (validPublishers.length === 0) {
       throw new Error(`Failed to find an available publisher.`);
     }
 
-    // Get the balances
-    const publishersWithBalance = await Promise.all(
-      validPublishers.map(async pub => {
-        return { balance: await pub.getSenderBalance(), publisher: pub };
-      }),
-    );
+    const withBalance = await this.getBalances(validPublishers);
 
-    // 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;
+    let candidates: PublisherWithBalance<UtilsType>[];
+    if (opts?.requirement) {
+      candidates = await this.getAffordable(withBalance, opts.requirement);
+    } else {
+      candidates = this.getLenientCandidates(withBalance);
     }
 
-    // Sort based on state, then balance, then time since last use
-    const sortedPublishers = fundedPublishers.sort((a, b) => {
-      const stateComparison = sortOrder.indexOf(a.publisher.state) - sortOrder.indexOf(b.publisher.state);
+    const sortedPublishers = candidates.sort((a, b) => {
+      const stateComparison = stateRank[a.publisher.state] - stateRank[b.publisher.state];
       if (stateComparison !== 0) {
         return stateComparison;
       }
-      const balanceComparison = Number(b.balance - a.balance);
-      if (balanceComparison !== 0) {
-        return balanceComparison;
+      if (a.balance !== b.balance) {
+        return b.balance > a.balance ? 1 : -1;
       }
       const lastUsedComparison = Number(
         (a.publisher.lastMinedAtBlockNumber ?? 0n) - (b.publisher.lastMinedAtBlockNumber ?? 0n),
@@ -188,23 +333,254 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
     return sortedPublishers[0].publisher;
   }
 
-  /** Check all publisher balances and fund those below threshold. */
-  private async triggerFundingIfNeeded(): Promise<void> {
-    const { funder, config } = this;
-    if (!funder || config.publisherFundingThreshold === undefined || config.publisherFundingAmount === undefined) {
-      return;
+  /**
+   * Reads the balance of every publisher and the funder, prices the reference send at current fees, records metrics,
+   * logs balances that are low or cannot afford the reference send, and tops up publishers below the funding threshold
+   * if funding is configured. Runs once a minute while started.
+   */
+  protected async checkBalances(): Promise<void> {
+    const funder = this.funder;
+    const [publisherBalances, funderBalance] = await Promise.all([
+      Promise.all(this.publishers.map(publisher => this.tryGetBalance(publisher))),
+      funder ? this.tryGetBalance(funder) : undefined,
+    ]);
+    const withBalance = this.publishers.flatMap((publisher, i) => {
+      const balance = publisherBalances[i];
+      return balance === undefined ? [] : [{ publisher, balance }];
+    });
+    const cost = await this.tryGetReferenceCost();
+    const required = cost !== undefined && cost.required > 0n ? cost.required : undefined;
+
+    const snapshot: PublisherBalanceSnapshot = {
+      publishers: withBalance.map(({ publisher, balance }) => ({
+        address: publisher.getSenderAddress().toString(),
+        balance,
+        sendsAffordable:
+          required === undefined
+            ? undefined
+            : publisher.hasActiveInsufficientFundsBackoff(balance)
+              ? 0
+              : Number(balance / required),
+      })),
+      funder:
+        funder && funderBalance !== undefined
+          ? { address: funder.getSenderAddress().toString(), balance: funderBalance }
+          : undefined,
+      required,
+    };
+    this.metrics?.recordBalanceSnapshot(snapshot);
+
+    this.logBalances(withBalance, snapshot, cost?.fees);
+    if (required !== undefined) {
+      this.warnOnLowBalances(withBalance, required);
     }
 
-    const allBalances = await Promise.all(
-      this.publishers.map(async pub => ({ balance: await pub.getSenderBalance(), publisher: pub })),
+    await this.fundIfNeeded(withBalance, funderBalance);
+  }
+
+  private getBalances(publishers: UtilsType[]): Promise<PublisherWithBalance<UtilsType>[]> {
+    return Promise.all(publishers.map(async publisher => ({ publisher, balance: await publisher.getSenderBalance() })));
+  }
+
+  /** Returns the publishers that can afford the requirement, or throws NoAffordablePublisherError if none. */
+  private async getAffordable(
+    publishers: PublisherWithBalance<UtilsType>[],
+    requirement: SendCostRequirement,
+  ): Promise<PublisherWithBalance<UtilsType>[]> {
+    if (publishers.length === 0) {
+      throw new Error(`Failed to find an available publisher.`);
+    }
+    // All publishers share the L1 network, so fees are fetched once rather than per publisher.
+    const fees = await publishers[0].publisher.getFeesPerGas(undefined, requirement.blobCount > 0, 0);
+    const required = computeSendCost(fees, requirement);
+
+    const affordable = publishers.filter(
+      p => p.balance >= required && !p.publisher.isBackedOffForInsufficientFunds(p.balance),
     );
-    const lowBalance = allBalances.filter(p => p.balance < config.publisherFundingThreshold!);
-    if (lowBalance.length === 0) {
+    if (affordable.length === 0) {
+      throw new NoAffordablePublisherError(required, requirement, fees, this.toBalanceInfo(publishers));
+    }
+    return affordable;
+  }
+
+  private toBalanceInfo(publishers: PublisherWithBalance<UtilsType>[]): PublisherBalanceInfo[] {
+    return publishers.map(({ publisher, balance }) => ({
+      address: publisher.getSenderAddress().toString(),
+      balance,
+      state: TxUtilsState[publisher.state],
+      insufficientFundsAtBalance: publisher.hasActiveInsufficientFundsBackoff(balance)
+        ? publisher.getInsufficientFundsAtBalance()
+        : undefined,
+    }));
+  }
+
+  /**
+   * Prefers publishers that are funded and not backed off after an insufficient funds rejection, but never returns an
+   * empty list: if every candidate is excluded, falls back to the full set so lenient sends still have something to try.
+   */
+  private getLenientCandidates(publishers: PublisherWithBalance<UtilsType>[]): PublisherWithBalance<UtilsType>[] {
+    const usable = publishers.filter(p => p.balance > 0n && !p.publisher.isBackedOffForInsufficientFunds(p.balance));
+    if (usable.length > 0) {
+      return usable;
+    }
+    const funded = publishers.filter(p => p.balance > 0n);
+    if (funded.length > 0) {
+      return funded;
+    }
+    this.log.warn(`All candidate publishers have zero balance; selecting from unfunded publishers.`);
+    return publishers;
+  }
+
+  private async tryGetBalance(utils: UtilsType): Promise<bigint | undefined> {
+    try {
+      return await utils.getSenderBalance();
+    } catch (err) {
+      const address = utils.getSenderAddress().toString();
+      if (this.shouldWarn(`balance-read:${address}`)) {
+        this.log.warn(`Failed to read L1 balance of account`, { address, err });
+      }
+      return undefined;
+    }
+  }
+
+  private async tryGetReferenceCost(): Promise<{ fees: FeesPerGas; required: bigint } | undefined> {
+    const { referenceSend } = this;
+    if (referenceSend === undefined || this.publishers.length === 0) {
+      return undefined;
+    }
+    try {
+      // All publishers share the L1 network, so fees are fetched once rather than per publisher.
+      const fees = await this.publishers[0].getFeesPerGas(undefined, referenceSend.requirement.blobCount > 0, 0);
+      return { fees, required: computeSendCost(fees, referenceSend.requirement) };
+    } catch (err) {
+      if (this.shouldWarn('fee-read')) {
+        this.log.warn(`Failed to read L1 fees to check whether publishers can afford a ${referenceSend.name}`, { err });
+      }
+      return undefined;
+    }
+  }
+
+  /**
+   * Logs a summary of all balances on the first check after a start, and an error (at most once per interval) while no
+   * publisher can afford the reference send.
+   */
+  private logBalances(
+    publishers: PublisherWithBalance<UtilsType>[],
+    snapshot: PublisherBalanceSnapshot,
+    fees: FeesPerGas | undefined,
+  ): void {
+    const firstCheck = !this.loggedBalanceSummary;
+    this.loggedBalanceSummary = true;
+    const { referenceSend } = this;
+    const { required } = snapshot;
+    const context = {
+      publishers: snapshot.publishers.map(p => ({
+        address: p.address,
+        balance: formatEther(p.balance),
+        sendsAffordable: p.sendsAffordable,
+      })),
+      referenceSend: referenceSend?.name,
+      required: required === undefined ? undefined : formatEther(required),
+      funder: snapshot.funder && { address: snapshot.funder.address, balance: formatEther(snapshot.funder.balance) },
+    };
+
+    const allRead = publishers.length === this.publishers.length;
+    const noneAffordable =
+      referenceSend !== undefined &&
+      required !== undefined &&
+      fees !== undefined &&
+      allRead &&
+      snapshot.publishers.length > 0 &&
+      snapshot.publishers.every(p => (p.sendsAffordable ?? 0) < 1);
+
+    if (!noneAffordable) {
+      // Only a publisher seen affording the send ends an episode. A check that could not tell (failed reads) must not
+      // reset the rate limit, or alternating failed and empty checks would log the error on every empty one.
+      if (snapshot.publishers.some(p => (p.sendsAffordable ?? 0) >= 1)) {
+        this.lastLowBalanceWarningAt.delete(NO_AFFORDABLE_PUBLISHER_WARNING_KEY);
+      }
+      if (firstCheck) {
+        this.log.info(`Publisher balances`, context);
+      }
       return;
     }
 
-    const fundingAmount = config.publisherFundingAmount!;
-    const funderBalance = await funder.getSenderBalance();
+    if (this.shouldWarn(NO_AFFORDABLE_PUBLISHER_WARNING_KEY)) {
+      const err = new NoAffordablePublisherError(
+        required,
+        referenceSend.requirement,
+        fees,
+        this.toBalanceInfo(publishers),
+      );
+      this.log.error(`No publisher can afford a ${referenceSend.name} at current L1 fees: ${err.describeFunding()}`, {
+        ...context,
+        shortfall: err.shortfall(),
+      });
+    }
+  }
+
+  /** Warns at most once per interval for every publisher below the low-balance level. */
+  private warnOnLowBalances(publishers: PublisherWithBalance<UtilsType>[], required: bigint): void {
+    const multiplier = this.config.publisherLowBalanceWarningMultiplier ?? DEFAULT_LOW_BALANCE_WARNING_MULTIPLIER;
+    const warningLevel = (required * BigInt(Math.round(multiplier * 1000))) / 1000n;
+
+    for (const { publisher, balance } of publishers) {
+      if (balance >= warningLevel) {
+        continue;
+      }
+      const address = publisher.getSenderAddress().toString();
+      if (this.shouldWarn(address)) {
+        this.log.warn(`Publisher balance is low relative to the ETH required for an L1 send`, {
+          address,
+          balance,
+          required,
+          multiplier,
+          warningLevel,
+        });
+      }
+    }
+
+    const { publisherFundingThreshold } = this.config;
+    if (
+      this.funder &&
+      publisherFundingThreshold !== undefined &&
+      publisherFundingThreshold < warningLevel &&
+      this.shouldWarn('funding-threshold')
+    ) {
+      this.log.warn(`Publisher funding threshold is below the low-balance warning level`, {
+        publisherFundingThreshold,
+        warningLevel,
+        required,
+        multiplier,
+      });
+    }
+  }
+
+  private shouldWarn(key: string): boolean {
+    const now = Date.now();
+    const last = this.lastLowBalanceWarningAt.get(key);
+    if (last !== undefined && now - last < LOW_BALANCE_WARNING_INTERVAL_MS) {
+      return false;
+    }
+    this.lastLowBalanceWarningAt.set(key, now);
+    return true;
+  }
+
+  /** Funds the publishers below the funding threshold, using the balances read in the same balance check. */
+  private async fundIfNeeded(
+    publishers: PublisherWithBalance<UtilsType>[],
+    funderBalance: bigint | undefined,
+  ): Promise<void> {
+    const { funder, config } = this;
+    const { publisherFundingThreshold, publisherFundingAmount: fundingAmount } = config;
+    if (!funder || publisherFundingThreshold === undefined || fundingAmount === undefined) {
+      return;
+    }
+
+    const lowBalance = publishers.filter(p => p.balance < publisherFundingThreshold);
+    if (lowBalance.length === 0 || funderBalance === undefined) {
+      return;
+    }
 
     if (funderBalance < 10n * fundingAmount) {
       this.log.warn(`Funding account balance is low`, { funderBalance, threshold: 10n * fundingAmount });
@@ -222,18 +598,17 @@ export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
     }
 
     const toFund = lowBalance.slice(0, affordableCount).map(p => p.publisher);
-    await this.fundPublishers(toFund);
+    await this.fundPublishers(funder, toFund, fundingAmount);
   }
 
   /** Fund publishers via a single Multicall3 aggregate3Value transaction. */
-  private async fundPublishers(publishers: UtilsType[]): Promise<void> {
-    const fundingAmount = this.config.publisherFundingAmount!;
+  private async fundPublishers(funder: UtilsType, publishers: UtilsType[], fundingAmount: bigint): Promise<void> {
     const calls = publishers.map(pub => ({
       to: pub.getSenderAddress().toString(),
       value: fundingAmount,
     }));
 
-    await Multicall3.forwardValue(calls, this.funder!, this.log);
+    await Multicall3.forwardValue(calls, funder, this.log);
     this.log.info(`Funded ${publishers.length} publishers`);
   }
 }