@aztec/sequencer-client 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/global_variable_builder/README.md

@@ -0,0 +1,44 @@
+# Fee Prediction
+
+The `FeePredictor` predicts min fees for upcoming L2 slots based on the current L1
+oracle state and an assumed mana usage pattern.
+
+## Prediction Window
+
+The prediction covers `LAG = 2` entries (the next available slot plus 1 more).
+A new oracle update can activate at `startSlot + LAG`, so only the first LAG entries
+are guaranteed stable. Beyond that, L1 fees could change unpredictably.
+
+Each entry uses:
+
+- The **actual L1 fees** the oracle would return for that slot's timestamp (pre or post,
+  depending on whether the slot is before or after `slotOfChange`).
+- A **configurable congestion assumption** (`ManaUsageEstimate`): none (0 mana), target
+  (steady state), or limit (worst case, 2x target).
+
+The client picks `max(predicted[0..LAG-1])` as their `maxFeesPerGas`.
+
+```
+predicted[0]  →  fee at next slot     (current oracle + current congestion)
+predicted[1]  →  fee at next slot + 1 (congestion may change based on usage estimate)
+```
+
+## Why LAG and not LIFETIME?
+
+The L1 gas oracle has two timing constants:
+
+- **LAG = 2 slots**: when new fees are queued, they activate LAG slots later
+- **LIFETIME = 5 slots**: after an oracle update, the next update is rejected until
+  `slotOfChange + (LIFETIME - LAG)` slots have passed
+
+If the oracle cooldown has already elapsed (i.e., no recent update), a new update can
+be enqueued at any moment. Its new values would activate LAG slots later. This means
+predictions beyond LAG slots could be invalidated by an oracle update that happens
+right after we query.
+
+With a LIFETIME-sized window, we'd give a false sense of coverage: the prediction
+would look like it covers 6 slots, but slots beyond LAG could be wrong if an update
+is enqueued after the prediction is computed.
+
+By limiting to LAG entries, we guarantee that all predicted L1 fees are the ones that
+will actually be used — no oracle update can change them within this window.

package/src/global_variable_builder/fee_predictor.ts

@@ -0,0 +1,172 @@
+import { type L1FeeData, MAX_FEE_ASSET_PRICE_MODIFIER_BPS, type RollupContract } from '@aztec/ethereum/contracts';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { times } from '@aztec/foundation/collection';
+import type { DateProvider } from '@aztec/foundation/timer';
+import { getSlotAtNextL1Block, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import {
+  FEE_ORACLE_LAG,
+  GasFees,
+  MIN_ETH_PER_FEE_ASSET,
+  ManaUsageEstimate,
+  computeExcessMana,
+  computeManaMinFee,
+} from '@aztec/stdlib/gas';
+
+/** Cached rollup state for fee prediction. Refreshed once per L1 block. */
+type FeeOracleState = {
+  lastSlot: SlotNumber;
+  excessMana: bigint;
+  ethPerFeeAsset: bigint;
+  manaTarget: bigint;
+  manaLimit: bigint;
+  provingCostPerManaEth: bigint;
+  epochDuration: bigint;
+  /** Pre-resolved L1 fees for each slot in the prediction window. */
+  l1FeesBySlot: L1FeeData[];
+};
+
+/**
+ * Predicts min fees for LAG upcoming slots based on the L1 oracle state.
+ * A new oracle update can activate at startSlot + LAG, so only the first LAG entries
+ * are guaranteed stable. Caches L1 queries per L1 block and recomputes predictions
+ * for each mana usage estimate.
+ */
+export class FeePredictor {
+  private cachedState: Promise<FeeOracleState> | undefined;
+  private cachedL1BlockNumber: bigint | undefined;
+
+  private readonly slotDuration: number;
+  private readonly l1GenesisTime: bigint;
+  private readonly ethereumSlotDuration: number;
+
+  constructor(
+    private readonly rollupContract: RollupContract,
+    private readonly publicClient: { getBlockNumber: (opts?: { cacheTime?: number }) => Promise<bigint> },
+    private readonly dateProvider: DateProvider,
+    config: { slotDuration: number; l1GenesisTime: bigint; ethereumSlotDuration: number },
+  ) {
+    this.slotDuration = config.slotDuration;
+    this.l1GenesisTime = config.l1GenesisTime;
+    this.ethereumSlotDuration = config.ethereumSlotDuration;
+  }
+
+  /** Returns predicted min fees for each slot in the prediction window. */
+  async getPredictedMinFees(manaUsage: ManaUsageEstimate): Promise<GasFees[]> {
+    const state = await this.getState();
+    return this.computePredictions(state, manaUsage);
+  }
+
+  /** Fetches and caches rollup state. Refreshes when L1 block number advances. */
+  private async getState(): Promise<FeeOracleState> {
+    const blockNumber = await this.publicClient.getBlockNumber({ cacheTime: 0 });
+    if (this.cachedL1BlockNumber === undefined || blockNumber > this.cachedL1BlockNumber) {
+      this.cachedL1BlockNumber = blockNumber;
+      this.cachedState = this.fetchState(blockNumber);
+    }
+    return this.cachedState!;
+  }
+
+  private async fetchState(blockNumber: bigint): Promise<FeeOracleState> {
+    // Pin all non-constant queries to this L1 block number for a consistent snapshot.
+    const opts = { blockNumber };
+
+    // Cached constants don't need pinning
+    const [manaTarget, manaLimit, provingCostPerManaEth, epochDuration] = await Promise.all([
+      this.rollupContract.getManaTarget(),
+      this.rollupContract.getManaLimit(),
+      this.rollupContract.getProvingCostPerMana(),
+      this.rollupContract.getEpochDuration(),
+    ]);
+
+    // First, compute the earliest possible nextSlot independently of the checkpoint, so we can
+    // evaluate pruneability at the prediction start timestamp instead of the current L1 block time.
+    // This avoids an epoch-boundary edge case where the effective parent differs between now and nextSlot.
+    const slotConfig = { slotDuration: this.slotDuration, l1GenesisTime: this.l1GenesisTime };
+    const currentSlot = await this.rollupContract.getSlotNumber(opts);
+
+    const slotAtNextL1Block = getSlotAtNextL1Block(BigInt(this.dateProvider.nowInSeconds()), {
+      l1GenesisTime: this.l1GenesisTime,
+      slotDuration: this.slotDuration,
+      ethereumSlotDuration: this.ethereumSlotDuration,
+    });
+    const preliminaryNextSlot = SlotNumber(Math.max(currentSlot, slotAtNextL1Block));
+    const nextSlotTimestamp = getTimestampForSlot(preliminaryNextSlot, slotConfig);
+
+    // Resolve the effective checkpoint at the prediction start timestamp
+    const lastCheckpoint = await this.rollupContract.getEffectivePendingCheckpoint(nextSlotTimestamp, opts);
+    const lastSlot = lastCheckpoint.slotNumber;
+    // Refine nextSlot: also account for the slot after the last checkpoint
+    const nextSlot = SlotNumber(Math.max(SlotNumber.add(lastSlot, 1), preliminaryNextSlot));
+    const feeHeader = lastCheckpoint.feeHeader;
+
+    const slotCount = FEE_ORACLE_LAG;
+    const timestamps = times(slotCount, i => getTimestampForSlot(SlotNumber.add(nextSlot, i), slotConfig));
+    const l1FeesBySlot = await Promise.all(timestamps.map(ts => this.rollupContract.getL1FeesAt(ts, opts)));
+
+    return {
+      lastSlot,
+      excessMana: computeExcessMana(feeHeader.excessMana, feeHeader.manaUsed, manaTarget),
+      ethPerFeeAsset: feeHeader.ethPerFeeAsset,
+      manaTarget,
+      manaLimit,
+      provingCostPerManaEth,
+      epochDuration: BigInt(epochDuration),
+      l1FeesBySlot,
+    };
+  }
+
+  /** Computes per-slot fee predictions given cached state and a mana usage assumption. */
+  private computePredictions(state: FeeOracleState, manaUsage: ManaUsageEstimate): GasFees[] {
+    const assumedManaUsed = this.getAssumedManaUsed(state, manaUsage);
+
+    const result: GasFees[] = [];
+    let { excessMana } = state;
+    let { ethPerFeeAsset } = state;
+
+    // Slot 0: current state (next available slot after last checkpoint)
+    result.push(this.computeGasFees(state, excessMana, ethPerFeeAsset, state.l1FeesBySlot[0]));
+
+    // Slots 1..LAG-1: advance excessMana with the assumed mana usage per checkpoint,
+    // and decay ethPerFeeAsset by MAX_FEE_ASSET_PRICE_MODIFIER_BPS per slot for conservative estimates.
+    // Lower ethPerFeeAsset means higher fees in fee asset terms.
+    for (let i = 1; i < state.l1FeesBySlot.length; i++) {
+      excessMana = computeExcessMana(excessMana, assumedManaUsed, state.manaTarget);
+      const decayed = (ethPerFeeAsset * (10000n - MAX_FEE_ASSET_PRICE_MODIFIER_BPS)) / 10000n;
+      ethPerFeeAsset = decayed < MIN_ETH_PER_FEE_ASSET ? MIN_ETH_PER_FEE_ASSET : decayed;
+      result.push(this.computeGasFees(state, excessMana, ethPerFeeAsset, state.l1FeesBySlot[i]));
+    }
+
+    return result;
+  }
+
+  private getAssumedManaUsed(state: FeeOracleState, manaUsage: ManaUsageEstimate): bigint {
+    switch (manaUsage) {
+      case ManaUsageEstimate.None:
+        return 0n;
+      case ManaUsageEstimate.Target:
+        return state.manaTarget;
+      case ManaUsageEstimate.Limit:
+        return state.manaLimit;
+    }
+  }
+
+  private computeGasFees(
+    state: FeeOracleState,
+    excessMana: bigint,
+    ethPerFeeAsset: bigint,
+    l1Fees: L1FeeData,
+  ): GasFees {
+    return new GasFees(
+      0,
+      computeManaMinFee({
+        l1BaseFee: l1Fees.baseFee,
+        l1BlobFee: l1Fees.blobFee,
+        manaTarget: state.manaTarget,
+        epochDuration: state.epochDuration,
+        provingCostPerManaEth: state.provingCostPerManaEth,
+        excessMana,
+        ethPerFeeAsset,
+      }),
+    );
+  }
+}

package/src/global_variable_builder/fee_provider.ts

@@ -0,0 +1,80 @@
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import type { DateProvider } from '@aztec/foundation/timer';
+import { getNextL1SlotTimestamp } from '@aztec/stdlib/epoch-helpers';
+import { GasFees, ManaUsageEstimate } from '@aztec/stdlib/gas';
+import type { FeeProvider } from '@aztec/stdlib/tx';
+
+import { FeePredictor } from './fee_predictor.js';
+import type { GlobalVariableBuilderConfig } from './global_builder.js';
+
+/** Provides current and predicted fee information based on on-chain state. */
+export class FeeProviderImpl implements FeeProvider {
+  private currentMinFees: Promise<GasFees> = Promise.resolve(new GasFees(0, 0));
+  private currentL1BlockNumber: bigint | undefined = undefined;
+
+  private readonly rollupContract: RollupContract;
+  private readonly feePredictor: FeePredictor;
+  private readonly ethereumSlotDuration: number;
+  private readonly l1GenesisTime: bigint;
+
+  constructor(
+    private readonly dateProvider: DateProvider,
+    private readonly publicClient: ViemPublicClient,
+    config: GlobalVariableBuilderConfig,
+  ) {
+    this.ethereumSlotDuration = config.ethereumSlotDuration;
+    this.l1GenesisTime = config.l1GenesisTime;
+
+    this.rollupContract = new RollupContract(this.publicClient, config.rollupAddress);
+    this.feePredictor = new FeePredictor(this.rollupContract, this.publicClient, this.dateProvider, {
+      slotDuration: config.slotDuration,
+      l1GenesisTime: config.l1GenesisTime,
+      ethereumSlotDuration: config.ethereumSlotDuration,
+    });
+  }
+
+  /**
+   * Computes the "current" min fees, e.g., the price that you currently should pay to get include in the next block
+   * @returns Min fees for the next block
+   */
+  private async computeCurrentMinFees(): Promise<GasFees> {
+    // Since this might be called in the middle of a slot where a block might have been published,
+    // we need to fetch the last block written, and estimate the earliest timestamp for the next block.
+    // The timestamp of that last block will act as a lower bound for the next block.
+
+    const lastCheckpoint = await this.rollupContract.getPendingCheckpoint();
+    const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
+      SlotNumber.fromBigInt(BigInt(lastCheckpoint.slotNumber) + 1n),
+    );
+    const nextEthTimestamp = getNextL1SlotTimestamp(this.dateProvider.nowInSeconds(), {
+      l1GenesisTime: this.l1GenesisTime,
+      ethereumSlotDuration: this.ethereumSlotDuration,
+    });
+    const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
+
+    return new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
+  }
+
+  public async getCurrentMinFees(): Promise<GasFees> {
+    // Get the current block number
+    const blockNumber = await this.publicClient.getBlockNumber({ cacheTime: 0 });
+
+    // If the L1 block number has changed then chain a new promise to get the current min fees
+    if (this.currentL1BlockNumber === undefined || blockNumber > this.currentL1BlockNumber) {
+      this.currentL1BlockNumber = blockNumber;
+      this.currentMinFees = this.currentMinFees.then(() => this.computeCurrentMinFees());
+    }
+    return this.currentMinFees;
+  }
+
+  public async getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]> {
+    const [currentMinFees, predictedMinFees] = await Promise.all([
+      this.getCurrentMinFees(),
+      this.feePredictor.getPredictedMinFees(manaUsage ?? ManaUsageEstimate.Target),
+    ]);
+
+    return [currentMinFees, ...predictedMinFees];
+  }
+}

package/src/global_variable_builder/global_builder.ts

@@ -1,13 +1,12 @@
-import { createEthereumChain } from '@aztec/ethereum/chain';
-import { makeL1HttpTransport } from '@aztec/ethereum/client';
-import type { L1ContractsConfig } from '@aztec/ethereum/config';
-import { RollupContract } from '@aztec/ethereum/contracts';
-import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import {
+  RollupContract,
+  type SimulationOverridesPlan,
+  buildSimulationOverridesStateOverride,
+} from '@aztec/ethereum/contracts';
 import type { ViemPublicClient } from '@aztec/ethereum/types';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type L1RollupConstants, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
@@ -15,21 +14,19 @@ import type {
   CheckpointGlobalVariables,
   GlobalVariableBuilder as GlobalVariableBuilderInterface,
 } from '@aztec/stdlib/tx';
-import { GlobalVariables } from '@aztec/stdlib/tx';
 
-import { createPublicClient } from 'viem';
+/** Configuration for the GlobalVariableBuilder (excludes L1 client config). */
+export type GlobalVariableBuilderConfig = {
+  rollupAddress: EthAddress;
+  ethereumSlotDuration: number;
+  rollupVersion: bigint;
+} & Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'>;
 
 /**
  * Simple global variables builder.
  */
 export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
-  private log = createLogger('sequencer:global_variable_builder');
-  private currentMinFees: Promise<GasFees> = Promise.resolve(new GasFees(0, 0));
-  private currentL1BlockNumber: bigint | undefined = undefined;
-
   private readonly rollupContract: RollupContract;
-  private readonly publicClient: ViemPublicClient;
-  private readonly ethereumSlotDuration: number;
   private readonly aztecSlotDuration: number;
   private readonly l1GenesisTime: bigint;
 
@@ -37,83 +34,16 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   private version: Fr;
 
   constructor(
-    config: L1ReaderConfig &
-      Pick<L1ContractsConfig, 'ethereumSlotDuration'> &
-      Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'> & { rollupVersion: bigint },
+    private readonly publicClient: ViemPublicClient,
+    config: GlobalVariableBuilderConfig,
   ) {
-    const { l1RpcUrls, l1ChainId: chainId, l1Contracts } = config;
-
-    const chain = createEthereumChain(l1RpcUrls, chainId);
-
     this.version = new Fr(config.rollupVersion);
-    this.chainId = new Fr(chainId);
+    this.chainId = new Fr(this.publicClient.chain!.id);
 
-    this.ethereumSlotDuration = config.ethereumSlotDuration;
     this.aztecSlotDuration = config.slotDuration;
     this.l1GenesisTime = config.l1GenesisTime;
 
-    this.publicClient = createPublicClient({
-      chain: chain.chainInfo,
-      transport: makeL1HttpTransport(chain.rpcUrls, { timeout: config.l1HttpTimeoutMS }),
-      pollingInterval: config.viemPollingIntervalMS,
-    });
-
-    this.rollupContract = new RollupContract(this.publicClient, l1Contracts.rollupAddress);
-  }
-
-  /**
-   * Computes the "current" min fees, e.g., the price that you currently should pay to get include in the next block
-   * @returns Min fees for the next block
-   */
-  private async computeCurrentMinFees(): Promise<GasFees> {
-    // Since this might be called in the middle of a slot where a block might have been published,
-    // we need to fetch the last block written, and estimate the earliest timestamp for the next block.
-    // The timestamp of that last block will act as a lower bound for the next block.
-
-    const lastCheckpoint = await this.rollupContract.getPendingCheckpoint();
-    const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
-      SlotNumber.fromBigInt(BigInt(lastCheckpoint.slotNumber) + 1n),
-    );
-    const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
-    const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
-
-    return new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
-  }
-
-  public async getCurrentMinFees(): Promise<GasFees> {
-    // Get the current block number
-    const blockNumber = await this.publicClient.getBlockNumber();
-
-    // If the L1 block number has changed then chain a new promise to get the current min fees
-    if (this.currentL1BlockNumber === undefined || blockNumber > this.currentL1BlockNumber) {
-      this.currentL1BlockNumber = blockNumber;
-      this.currentMinFees = this.currentMinFees.then(() => this.computeCurrentMinFees());
-    }
-    return this.currentMinFees;
-  }
-
-  /**
-   * Simple builder of global variables.
-   * @param blockNumber - The block number to build global variables for.
-   * @param coinbase - The address to receive block reward.
-   * @param feeRecipient - The address to receive fees.
-   * @param slotNumber - The slot number to use for the global variables, if undefined it will be calculated.
-   * @returns The global variables for the given block number.
-   */
-  public async buildGlobalVariables(
-    blockNumber: BlockNumber,
-    coinbase: EthAddress,
-    feeRecipient: AztecAddress,
-    maybeSlot?: SlotNumber,
-  ): Promise<GlobalVariables> {
-    const slot: SlotNumber =
-      maybeSlot ??
-      (await this.rollupContract.getSlotAt(
-        BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration)),
-      ));
-
-    const checkpointGlobalVariables = await this.buildCheckpointGlobalVariables(coinbase, feeRecipient, slot);
-    return GlobalVariables.from({ blockNumber, ...checkpointGlobalVariables });
+    this.rollupContract = new RollupContract(this.publicClient, config.rollupAddress);
   }
 
   /** Builds global variables that are constant throughout a checkpoint. */
@@ -121,6 +51,7 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber: SlotNumber,
+    simulationOverridesPlan?: SimulationOverridesPlan,
   ): Promise<CheckpointGlobalVariables> {
     const { chainId, version } = this;
 
@@ -129,9 +60,8 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
       l1GenesisTime: this.l1GenesisTime,
     });
 
-    // We can skip much of the logic in getCurrentMinFees since it we already check that we are not within a slot elsewhere.
-    // TODO(palla/mbps): Can we use a cached value here?
-    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
+    const stateOverride = await buildSimulationOverridesStateOverride(this.rollupContract, simulationOverridesPlan);
+    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true, stateOverride));
 
     return { chainId, version, slotNumber, timestamp, coinbase, feeRecipient, gasFees };
   }

package/src/global_variable_builder/index.ts

@@ -1 +1,3 @@
-export { GlobalVariableBuilder } from './global_builder.js';
+export { FeeProviderImpl } from './fee_provider.js';
+export { GlobalVariableBuilder, type GlobalVariableBuilderConfig } from './global_builder.js';
+export { FeePredictor } from './fee_predictor.js';

package/src/publisher/config.ts

@@ -1,9 +1,16 @@
 import { type BlobClientConfig, blobClientConfigMapping } from '@aztec/blob-client/client/config';
 import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from '@aztec/ethereum/l1-tx-utils/config';
-import { type ConfigMappingsType, SecretValue, booleanConfigHelper } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  SecretValue,
+  booleanConfigHelper,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
+import { parseEther } from 'viem';
+
 /** Configuration of the transaction publisher. */
 export type TxSenderConfig = L1ReaderConfig & {
   /** The private key to be used by the publisher. */
@@ -50,13 +57,37 @@ export type PublisherConfig = L1TxUtilsConfig &
     publisherForwarderAddress?: EthAddress;
     /** Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path */
     l1TxFailedStore?: string;
+    /** Min ETH balance below which a publisher gets funded. Undefined = funding disabled. */
+    publisherFundingThreshold?: bigint;
+    /** Amount of ETH to send when funding a publisher. Undefined = funding disabled. */
+    publisherFundingAmount?: bigint;
   };
 
+/** Shared config mappings for publisher funding, used by both sequencer and prover publisher configs. */
+const publisherFundingConfigMappings = {
+  publisherFundingThreshold: {
+    env: 'PUBLISHER_FUNDING_THRESHOLD' as const,
+    description:
+      'Min ETH balance below which a publisher gets funded. Specified in ether (e.g. 0.1). Unset = funding disabled.',
+    parseEnv: (val: string) => parseEther(val),
+  },
+  publisherFundingAmount: {
+    env: 'PUBLISHER_FUNDING_AMOUNT' as const,
+    description:
+      'Amount of ETH to send when funding a publisher. Specified in ether (e.g. 0.5). Unset = funding disabled.',
+    parseEnv: (val: string) => parseEther(val),
+  },
+};
+
 export type ProverPublisherConfig = L1TxUtilsConfig &
   BlobClientConfig & {
     fishermanMode?: boolean;
     proverPublisherAllowInvalidStates?: boolean;
     proverPublisherForwarderAddress?: EthAddress;
+    /** Min ETH balance below which a publisher gets funded. Undefined = funding disabled. */
+    publisherFundingThreshold?: bigint;
+    /** Amount of ETH to send when funding a publisher. Undefined = funding disabled. */
+    publisherFundingAmount?: bigint;
   };
 
 export type SequencerPublisherConfig = L1TxUtilsConfig &
@@ -64,8 +95,16 @@ export type SequencerPublisherConfig = L1TxUtilsConfig &
     fishermanMode?: boolean;
     sequencerPublisherAllowInvalidStates?: boolean;
     sequencerPublisherForwarderAddress?: EthAddress;
+    /** How long to wait for the previous L1 block before sending scheduled publisher txs anyway. */
+    sequencerPublisherPreviousL1BlockWaitTimeoutMs: number;
+    /** Poll interval while waiting for the previous L1 block before scheduled publisher txs. */
+    sequencerPublisherPreviousL1BlockWaitPollIntervalMs: number;
     /** Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path */
     l1TxFailedStore?: string;
+    /** Min ETH balance below which a publisher gets funded. Undefined = funding disabled. */
+    publisherFundingThreshold?: bigint;
+    /** Amount of ETH to send when funding a publisher. Undefined = funding disabled. */
+    publisherFundingAmount?: bigint;
   };
 
 export function getPublisherConfigFromProverConfig(config: ProverPublisherConfig): PublisherConfig {
@@ -85,12 +124,13 @@ export function getPublisherConfigFromSequencerConfig(config: SequencerPublisher
   };
 }
 
-export const proverTxSenderConfigMappings: ConfigMappingsType<Omit<ProverTxSenderConfig, 'l1Contracts'>> = {
+export const proverTxSenderConfigMappings: ConfigMappingsType<ProverTxSenderConfig> = {
   ...l1ReaderConfigMappings,
   proverPublisherPrivateKeys: {
     env: `PROVER_PUBLISHER_PRIVATE_KEYS`,
     description: 'The private keys to be used by the prover publisher.',
-    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+    parseEnv: (val: string) =>
+      val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}` as `0x${string}`)),
     defaultValue: [],
     fallback: [`PROVER_PUBLISHER_PRIVATE_KEY`],
   },
@@ -102,12 +142,13 @@ export const proverTxSenderConfigMappings: ConfigMappingsType<Omit<ProverTxSende
   },
 };
 
-export const sequencerTxSenderConfigMappings: ConfigMappingsType<Omit<SequencerTxSenderConfig, 'l1Contracts'>> = {
+export const sequencerTxSenderConfigMappings: ConfigMappingsType<SequencerTxSenderConfig> = {
   ...l1ReaderConfigMappings,
   sequencerPublisherPrivateKeys: {
     env: `SEQ_PUBLISHER_PRIVATE_KEYS`,
     description: 'The private keys to be used by the sequencer publisher.',
-    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+    parseEnv: (val: string) =>
+      val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}` as `0x${string}`)),
     defaultValue: [],
     fallback: [`SEQ_PUBLISHER_PRIVATE_KEY`],
   },
@@ -136,12 +177,25 @@ export const sequencerPublisherConfigMappings: ConfigMappingsType<SequencerPubli
   sequencerPublisherForwarderAddress: {
     env: `SEQ_PUBLISHER_FORWARDER_ADDRESS`,
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
-    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+    parseEnv: (val: string) => EthAddress.fromString(val),
+  },
+  sequencerPublisherPreviousL1BlockWaitTimeoutMs: {
+    env: `SEQ_PUBLISHER_PREVIOUS_L1_BLOCK_WAIT_TIMEOUT_MS`,
+    description:
+      'How long to wait for the previous L1 block before sending scheduled publisher txs anyway, in milliseconds.',
+    ...numberConfigHelper(8_000),
+  },
+  sequencerPublisherPreviousL1BlockWaitPollIntervalMs: {
+    env: `SEQ_PUBLISHER_PREVIOUS_L1_BLOCK_WAIT_POLL_INTERVAL_MS`,
+    description:
+      'Poll interval while waiting for the previous L1 block before scheduled publisher txs, in milliseconds.',
+    ...numberConfigHelper(500),
   },
   l1TxFailedStore: {
     env: 'L1_TX_FAILED_STORE',
     description: 'Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path',
   },
+  ...publisherFundingConfigMappings,
 };
 
 export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherConfig & L1TxUtilsConfig> = {
@@ -161,6 +215,7 @@ export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherCo
   proverPublisherForwarderAddress: {
     env: `PROVER_PUBLISHER_FORWARDER_ADDRESS`,
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
-    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+    parseEnv: (val: string) => EthAddress.fromString(val),
   },
+  ...publisherFundingConfigMappings,
 };

package/src/publisher/l1_tx_failed_store/failed_tx_store.ts

@@ -1,7 +1,9 @@
+import type { Branded } from '@aztec/foundation/branded-types';
+
 import type { Hex } from 'viem';
 
 /** URI pointing to a stored failed L1 transaction. */
-export type FailedL1TxUri = string & { __brand: 'FailedL1TxUri' };
+export type FailedL1TxUri = Branded<string, 'FailedL1TxUri'>;
 
 /** A failed L1 transaction captured for debugging and replay. */
 export type FailedL1Tx = {