@aztec-labs/sequencer-client 6.0.0-nightly.20260829

package/src/config.ts

@@ -0,0 +1,309 @@
+import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec-labs/ethereum/config';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec-labs/ethereum/l1-reader';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  floatConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+  pickConfigMappings,
+} from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type KeyStoreConfig, keyStoreConfigMappings } from '@aztec-labs/node-keystore/config';
+import { type P2PConfig, p2pConfigMappings } from '@aztec-labs/p2p/config';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import {
+  type ChainConfig,
+  DEFAULT_BLOCK_DURATION_MS,
+  DEFAULT_MAX_BLOCKS_PER_CHECKPOINT,
+  type SequencerConfig,
+  chainConfigMappings,
+  sharedSequencerConfigMappings,
+} from '@aztec-labs/stdlib/config';
+import { MIN_PER_BLOCK_ALLOCATION_MULTIPLIER, MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER } from '@aztec-labs/stdlib/gas';
+import type { ResolvedSequencerConfig } from '@aztec-labs/stdlib/interfaces/server';
+import { DEFAULT_P2P_PROPAGATION_TIME } from '@aztec-labs/stdlib/timetable';
+import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec-labs/validator-client/config';
+
+import {
+  type SequencerPublisherConfig,
+  type SequencerTxSenderConfig,
+  sequencerPublisherConfigMappings,
+  sequencerTxSenderConfigMappings,
+} from './publisher/config.js';
+
+export * from './publisher/config.js';
+export type { SequencerConfig };
+
+/**
+ * Default values for SequencerConfig.
+ * Centralized location for all sequencer configuration defaults.
+ */
+export const DefaultSequencerConfig = {
+  sequencerPollingIntervalMS: 500,
+  minTxsPerBlock: 1,
+  buildCheckpointIfEmpty: false,
+  publishTxsWithProposals: false,
+  perBlockAllocationMultiplier: MIN_PER_BLOCK_ALLOCATION_MULTIPLIER,
+  perBlockDAAllocationMultiplier: MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER,
+  redistributeCheckpointBudget: true,
+  blockDurationMs: DEFAULT_BLOCK_DURATION_MS,
+  l1PublishingTime: 12,
+  checkpointProposalSyncGraceSeconds: 2 * (DEFAULT_BLOCK_DURATION_MS / 1000),
+  attestationPropagationTime: DEFAULT_P2P_PROPAGATION_TIME,
+  secondsBeforeInvalidatingBlockAsCommitteeMember: 144, // 12 L1 blocks
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember: 432, // 36 L1 blocks
+  skipCollectingAttestations: false,
+  skipInvalidateBlockAsProposer: false,
+  skipWaitForValidParentCheckpointOnL1: false,
+  broadcastInvalidBlockProposal: false,
+  broadcastInvalidCheckpointProposalOnly: false,
+  injectFakeAttestation: false,
+  injectHighSValueAttestation: false,
+  injectUnrecoverableSignatureAttestation: false,
+  injectYParityAttestation: false,
+  fishermanMode: false,
+  governanceProposerForcePayloadVote: false,
+  shuffleAttestationOrdering: false,
+  skipPushProposedBlocksToArchiver: false,
+  skipPublishingCheckpointsPercent: 0,
+  maxBlocksPerCheckpoint: DEFAULT_MAX_BLOCKS_PER_CHECKPOINT,
+  minPeersToPropose: 1,
+} satisfies ResolvedSequencerConfig;
+
+/**
+ * Configuration settings for the SequencerClient.
+ */
+export type SequencerClientConfig = SequencerPublisherConfig &
+  KeyStoreConfig &
+  ValidatorClientConfig &
+  SequencerTxSenderConfig &
+  SequencerConfig &
+  L1ReaderConfig &
+  ChainConfig &
+  Pick<P2PConfig, 'txPublicSetupAllowListExtend'> &
+  Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration' | 'aztecEpochDuration'>;
+
+export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
+  sequencerPollingIntervalMS: {
+    env: 'SEQ_POLLING_INTERVAL_MS',
+    description: 'The number of ms to wait between polling for checking to build on the next slot.',
+    ...numberConfigHelper(DefaultSequencerConfig.sequencerPollingIntervalMS),
+  },
+  maxTxsPerCheckpoint: {
+    env: 'SEQ_MAX_TX_PER_CHECKPOINT',
+    description: 'The maximum number of txs across all blocks in a checkpoint.',
+    ...optionalNumberConfigHelper(),
+  },
+  minTxsPerBlock: {
+    env: 'SEQ_MIN_TX_PER_BLOCK',
+    description: 'The minimum number of txs to include in a block.',
+    ...numberConfigHelper(DefaultSequencerConfig.minTxsPerBlock),
+  },
+  minValidTxsPerBlock: {
+    description:
+      'The minimum number of valid txs (after execution) to include in a block. If not set, falls back to minTxsPerBlock.',
+  },
+  publishTxsWithProposals: {
+    env: 'SEQ_PUBLISH_TXS_WITH_PROPOSALS',
+    description: 'Whether to publish txs with proposals.',
+    ...booleanConfigHelper(DefaultSequencerConfig.publishTxsWithProposals),
+  },
+  maxL2BlockGas: {
+    env: 'SEQ_MAX_L2_BLOCK_GAS',
+    description: 'The maximum L2 block gas.',
+    ...optionalNumberConfigHelper(),
+  },
+  maxDABlockGas: {
+    env: 'SEQ_MAX_DA_BLOCK_GAS',
+    description: 'The maximum DA block gas.',
+    ...optionalNumberConfigHelper(),
+  },
+  perBlockAllocationMultiplier: {
+    env: 'SEQ_PER_BLOCK_ALLOCATION_MULTIPLIER',
+    description:
+      'Per-block gas budget multiplier for both L2 and DA gas. Budget per block is (checkpointLimit / maxBlocks) * multiplier.' +
+      ' Values greater than one allow early blocks to use more than their even share, relying on checkpoint-level capping for later blocks.',
+    ...floatConfigHelper(DefaultSequencerConfig.perBlockAllocationMultiplier),
+  },
+  perBlockDAAllocationMultiplier: {
+    env: 'SEQ_PER_BLOCK_DA_ALLOCATION_MULTIPLIER',
+    description:
+      'Per-block budget multiplier applied to DA gas and blob fields in place of perBlockAllocationMultiplier.' +
+      ' Defaults higher than the general multiplier so the largest contract class deploy fits a single block.',
+    ...floatConfigHelper(DefaultSequencerConfig.perBlockDAAllocationMultiplier),
+  },
+  redistributeCheckpointBudget: {
+    env: 'SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET',
+    description:
+      'Redistribute remaining checkpoint budget evenly across remaining blocks instead of allowing a single block to consume the entire remaining budget.',
+    ...booleanConfigHelper(DefaultSequencerConfig.redistributeCheckpointBudget),
+  },
+  coinbase: {
+    env: 'COINBASE',
+    parseEnv: (val: string) => EthAddress.fromString(val),
+    description: 'Recipient of block reward.',
+  },
+  feeRecipient: {
+    env: 'FEE_RECIPIENT',
+    parseEnv: (val: string) => AztecAddress.fromStringUnsafe(val),
+    description: 'Address to receive fees.',
+  },
+  acvmWorkingDirectory: {
+    env: 'ACVM_WORKING_DIRECTORY',
+    description: 'The working directory to use for simulation/proving',
+  },
+  acvmBinaryPath: {
+    env: 'ACVM_BINARY_PATH',
+    description: 'The path to the ACVM binary',
+  },
+  governanceProposerPayload: {
+    env: 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS',
+    description: 'The address of the payload for the governanceProposer',
+    parseEnv: (val: string) => EthAddress.fromString(val),
+  },
+  governanceProposerForcePayloadVote: {
+    env: 'GOVERNANCE_PROPOSER_FORCE_PAYLOAD_VOTE',
+    description:
+      'Keep signalling the configured governance payload even if a proposal referencing it was already executed.',
+    ...booleanConfigHelper(DefaultSequencerConfig.governanceProposerForcePayloadVote),
+  },
+  l1PublishingTime: {
+    env: 'SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT',
+    description: 'How much time in seconds to allow in the slot for publishing the L1 transaction.',
+    ...numberConfigHelper(DefaultSequencerConfig.l1PublishingTime),
+  },
+  fakeProcessingDelayPerTxMs: {
+    description: 'Used for testing to introduce a fake delay after processing each tx',
+  },
+  fakeThrowAfterProcessingTxCount: {
+    description: 'Used for testing to throw an error after processing N txs',
+  },
+  secondsBeforeInvalidatingBlockAsCommitteeMember: {
+    env: 'SEQ_SECONDS_BEFORE_INVALIDATING_BLOCK_AS_COMMITTEE_MEMBER',
+    description:
+      'How many seconds to wait before trying to invalidate a block from the pending chain as a committee member (zero to never invalidate).' +
+      ' The next proposer is expected to invalidate, so the committee acts as a fallback.',
+    ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsCommitteeMember),
+  },
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember: {
+    env: 'SEQ_SECONDS_BEFORE_INVALIDATING_BLOCK_AS_NON_COMMITTEE_MEMBER',
+    description:
+      'How many seconds to wait before trying to invalidate a block from the pending chain as a non-committee member (zero to never invalidate).' +
+      ' The next proposer is expected to invalidate, then the committee, so other sequencers act as a fallback.',
+    ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsNonCommitteeMember),
+  },
+  skipCollectingAttestations: {
+    description:
+      'Whether to skip collecting attestations from validators and only use self-attestations (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.skipCollectingAttestations),
+  },
+  skipInvalidateBlockAsProposer: {
+    description: 'Do not invalidate the previous block if invalid when we are the proposer (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.skipInvalidateBlockAsProposer),
+  },
+  skipWaitForValidParentCheckpointOnL1: {
+    description:
+      'Bypass the parent checkpoint validity check before submitting a pipelined checkpoint, ' +
+      'allowing the proposer to publish even when the parent landed on L1 with invalid attestations (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.skipWaitForValidParentCheckpointOnL1),
+  },
+  broadcastInvalidBlockProposal: {
+    description: 'Broadcast invalid block proposals with corrupted state (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.broadcastInvalidBlockProposal),
+  },
+  invalidBlockProposalIndexWithinCheckpoint: {
+    description: 'Broadcast an invalid block proposal only at this indexWithinCheckpoint (for testing only)',
+    ...optionalNumberConfigHelper(),
+  },
+  broadcastInvalidCheckpointProposalOnly: {
+    description:
+      'Broadcast invalid checkpoint proposals while keeping the underlying block proposals valid (for testing only). When unset, the checkpoint follows broadcastInvalidBlockProposal.',
+    ...booleanConfigHelper(DefaultSequencerConfig.broadcastInvalidCheckpointProposalOnly),
+  },
+  injectFakeAttestation: {
+    description: 'Inject a fake attestation (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.injectFakeAttestation),
+  },
+  injectHighSValueAttestation: {
+    description: 'Inject a malleable attestation with a high-s value (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.injectHighSValueAttestation),
+  },
+  injectUnrecoverableSignatureAttestation: {
+    description: 'Inject an attestation with an unrecoverable signature (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.injectUnrecoverableSignatureAttestation),
+  },
+  injectYParityAttestation: {
+    description: 'Inject a non-proposer attestation slot in yParity form in the packed L1 tuple (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.injectYParityAttestation),
+  },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
+    ...booleanConfigHelper(DefaultSequencerConfig.fishermanMode),
+  },
+  shuffleAttestationOrdering: {
+    description: 'Shuffle attestation ordering to create invalid ordering (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.shuffleAttestationOrdering),
+  },
+  ...sharedSequencerConfigMappings,
+  buildCheckpointIfEmpty: {
+    env: 'SEQ_BUILD_CHECKPOINT_IF_EMPTY',
+    description: 'Have sequencer build and publish an empty checkpoint if there are no txs',
+    ...booleanConfigHelper(DefaultSequencerConfig.buildCheckpointIfEmpty),
+  },
+  skipPushProposedBlocksToArchiver: {
+    description: 'Skip pushing proposed blocks to archiver (test only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.skipPushProposedBlocksToArchiver),
+  },
+  minBlocksForCheckpoint: {
+    description: 'Minimum number of blocks required for a checkpoint proposal (test only)',
+  },
+  skipPublishingCheckpointsPercent: {
+    env: 'SEQ_SKIP_CHECKPOINT_PUBLISH_PERCENT',
+    description: 'Percent probability (0 - 100) of sequencer skipping checkpoint publishing (testing only)',
+    ...numberConfigHelper(DefaultSequencerConfig.skipPublishingCheckpointsPercent),
+  },
+  skipBroadcastProposals: {
+    description: 'Skip broadcasting checkpoint and block proposals via gossipsub when proposer (for testing only)',
+    ...booleanConfigHelper(false),
+  },
+  skipBroadcastCheckpointProposal: {
+    description:
+      'Skip broadcasting only the CheckpointProposal via gossipsub when proposer; the held last block is broadcast ' +
+      'standalone instead so peers still receive it as a proposed-but-uncheckpointed tip (for testing only)',
+    ...booleanConfigHelper(false),
+  },
+  pauseProposingForSlots: {
+    description:
+      'List of slots for which the sequencer will not produce a proposal (for testing only). Attestation paths are unaffected.',
+  },
+  minPeersToPropose: {
+    env: 'SEQ_MIN_PEERS_TO_PROPOSE',
+    description:
+      'Minimum number of connected p2p peers required to build and propose a checkpoint (zero to disable the check).' +
+      ' Ignored when p2p is disabled by config.',
+    ...numberConfigHelper(DefaultSequencerConfig.minPeersToPropose),
+  },
+  ...pickConfigMappings(p2pConfigMappings, ['txPublicSetupAllowListExtend']),
+};
+
+export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig> = {
+  ...chainConfigMappings,
+  ...validatorClientConfigMappings,
+  ...sequencerConfigMappings,
+  ...keyStoreConfigMappings,
+  ...l1ReaderConfigMappings,
+  ...sequencerTxSenderConfigMappings,
+  ...sequencerPublisherConfigMappings,
+  ...pickConfigMappings(l1ContractsConfigMappings, ['ethereumSlotDuration', 'aztecSlotDuration', 'aztecEpochDuration']),
+};
+
+/**
+ * Creates an instance of SequencerClientConfig out of environment variables using sensible defaults for integration testing if not set.
+ */
+export function getConfigEnvVars(): SequencerClientConfig {
+  return getConfigFromMappings<SequencerClientConfig>(sequencerClientConfigMappings);
+}

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,176 @@
+import { type L1FeeData, MAX_FEE_ASSET_PRICE_MODIFIER_BPS, type RollupContract } from '@aztec-labs/ethereum/contracts';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { times } from '@aztec-labs/foundation/collection';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import { getSlotAtNextL1Block, getTimestampForSlot } from '@aztec-labs/stdlib/epoch-helpers';
+import {
+  FEE_ORACLE_LAG,
+  GasFees,
+  MIN_ETH_PER_FEE_ASSET,
+  ManaUsageEstimate,
+  computeExcessMana,
+  computeManaMinFee,
+} from '@aztec-labs/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.
+ */
+export class FeePredictor {
+  private cachedState: FeeOracleState | undefined;
+
+  private readonly slotDuration: number;
+  private readonly l1GenesisTime: bigint;
+  private readonly ethereumSlotDuration: number;
+
+  constructor(
+    private readonly rollupContract: RollupContract,
+    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, from the cached state. */
+  getPredictedMinFees(manaUsage: ManaUsageEstimate): GasFees[] {
+    const state = this.getState();
+    if (state === undefined) {
+      throw new Error('FeePredictor.refreshState() must be called before getPredictedMinFees()');
+    }
+    return this.computePredictions(state, manaUsage);
+  }
+
+  /** Returns whatever rollup state is currently cached, or undefined if refreshState() has never been called. */
+  getState(): FeeOracleState | undefined {
+    return this.cachedState;
+  }
+
+  /**
+   * Fetches and caches rollup state for the given L1 block.
+   */
+  async refreshState(blockNumber: bigint): Promise<FeeOracleState> {
+    const state = await this.fetchState(blockNumber);
+    this.cachedState = state;
+    return state;
+  }
+
+  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,104 @@
+import { RollupContract } from '@aztec-labs/ethereum/contracts';
+import type { ViemPublicClient } from '@aztec-labs/ethereum/types';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { RunningPromise } from '@aztec-labs/foundation/running-promise';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import { getNextL1SlotTimestamp } from '@aztec-labs/stdlib/epoch-helpers';
+import { GasFees, ManaUsageEstimate } from '@aztec-labs/stdlib/gas';
+import type { FeeProvider } from '@aztec-labs/stdlib/tx';
+
+import { FeePredictor } from './fee_predictor.js';
+import type { GlobalVariableBuilderConfig } from './global_builder.js';
+
+/** Default interval for the background L1 refresh loop, well below L1's block time. */
+const DEFAULT_REFRESH_POLLING_INTERVAL_MS = 1000;
+
+/**
+ * Provides current and predicted fee information based on on-chain state.
+ */
+export class FeeProviderImpl implements FeeProvider {
+  private currentMinFees = new GasFees(0, 0);
+  private currentL1BlockNumber: bigint | undefined = undefined;
+  private refreshLoop: RunningPromise | undefined;
+
+  private readonly rollupContract: RollupContract;
+  private readonly feePredictor: FeePredictor;
+  private readonly ethereumSlotDuration: number;
+  private readonly l1GenesisTime: bigint;
+  private readonly log: Logger = createLogger('sequencer-client:fee-provider');
+
+  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.dateProvider, {
+      slotDuration: config.slotDuration,
+      l1GenesisTime: config.l1GenesisTime,
+      ethereumSlotDuration: config.ethereumSlotDuration,
+    });
+  }
+
+  public async start(pollingIntervalMs = DEFAULT_REFRESH_POLLING_INTERVAL_MS): Promise<void> {
+    await this.refreshFromL1();
+    this.refreshLoop = new RunningPromise(() => this.refreshFromL1(), this.log, pollingIntervalMs);
+    this.refreshLoop.start();
+  }
+
+  public async stop(): Promise<void> {
+    await this.refreshLoop?.stop();
+  }
+
+  /**
+   * Checks the current L1 block number and, if it has advanced, refreshes both the current and
+   * predicted min fees for that block.
+   */
+  private async refreshFromL1(): Promise<void> {
+    const blockNumber = await this.publicClient.getBlockNumber({ cacheTime: 0 });
+    if (this.currentL1BlockNumber !== undefined && blockNumber <= this.currentL1BlockNumber) {
+      return;
+    }
+
+    const currentMinFees = await this.computeCurrentMinFees();
+    await this.feePredictor.refreshState(blockNumber);
+    this.currentMinFees = currentMinFees;
+    this.currentL1BlockNumber = blockNumber;
+  }
+
+  /**
+   * 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 getCurrentMinFees(): Promise<GasFees> {
+    return Promise.resolve(this.currentMinFees);
+  }
+
+  public getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]> {
+    const currentMinFees = this.currentMinFees;
+    const predictedMinFees = this.feePredictor.getPredictedMinFees(manaUsage ?? ManaUsageEstimate.Target);
+    return Promise.resolve([currentMinFees, ...predictedMinFees]);
+  }
+}