@aztec/sequencer-client 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/src/client/sequencer-client.ts

@@ -1,32 +1,25 @@
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec/constants';
 import { EpochCache } from '@aztec/epoch-cache';
-import {
-  GovernanceProposerContract,
-  PublisherManager,
-  RollupContract,
-  getPublicClient,
-  isAnvilTestChain,
-} from '@aztec/ethereum';
-import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import { isAnvilTestChain } from '@aztec/ethereum/chain';
+import { getPublicClient } from '@aztec/ethereum/client';
+import { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
+import { type Delayer, L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
+import { PublisherManager } from '@aztec/ethereum/publisher-manager';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { KeystoreManager } from '@aztec/node-keystore';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type {
-  IFullNodeBlockBuilder,
-  ValidatorClientFullConfig,
-  WorldStateSynchronizer,
-} from '@aztec/stdlib/interfaces/server';
-import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
+import type { L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { L1Metrics, type TelemetryClient } from '@aztec/telemetry-client';
-import { NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
+import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
 
-import type { SequencerClientConfig } from '../config.js';
-import { GlobalVariableBuilder } from '../global_variable_builder/index.js';
+import { type SequencerClientConfig, getPublisherConfigFromSequencerConfig } from '../config.js';
+import type { GlobalVariableBuilder } from '../global_variable_builder/index.js';
 import { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
 import { Sequencer, type SequencerConfig } from '../sequencer/index.js';
 
@@ -35,11 +28,12 @@ import { Sequencer, type SequencerConfig } from '../sequencer/index.js';
  */
 export class SequencerClient {
   constructor(
-    protected publisherManager: PublisherManager<L1TxUtilsWithBlobs>,
+    protected publisherManager: PublisherManager<L1TxUtils>,
     protected sequencer: Sequencer,
-    protected blockBuilder: IFullNodeBlockBuilder,
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder,
     protected validatorClient?: ValidatorClient,
     private l1Metrics?: L1Metrics,
+    private delayer_?: Delayer,
   ) {}
 
   /**
@@ -57,20 +51,22 @@ export class SequencerClient {
   public static async new(
     config: SequencerClientConfig,
     deps: {
-      validatorClient: ValidatorClient | undefined; // allowed to be undefined while we migrate
+      validatorClient: ValidatorClient;
       p2pClient: P2P;
       worldStateSynchronizer: WorldStateSynchronizer;
       slasherClient: SlasherClientInterface | undefined;
-      blockBuilder: IFullNodeBlockBuilder;
-      l2BlockSource: L2BlockSource;
+      checkpointsBuilder: FullNodeCheckpointsBuilder;
+      l2BlockSource: L2BlockSource & L2BlockSink;
       l1ToL2MessageSource: L1ToL2MessageSource;
       telemetry: TelemetryClient;
       publisherFactory?: SequencerPublisherFactory;
-      blobSinkClient?: BlobSinkClientInterface;
+      blobClient: BlobClientInterface;
       dateProvider: DateProvider;
       epochCache?: EpochCache;
-      l1TxUtils: L1TxUtilsWithBlobs[];
+      l1TxUtils: L1TxUtils[];
+      funderL1TxUtils?: L1TxUtils;
       nodeKeyStore: KeystoreManager;
+      globalVariableBuilder: GlobalVariableBuilder;
     },
   ) {
     const {
@@ -78,7 +74,7 @@ export class SequencerClient {
       p2pClient,
       worldStateSynchronizer,
       slasherClient,
-      blockBuilder,
+      checkpointsBuilder,
       l2BlockSource,
       l1ToL2MessageSource,
       telemetry: telemetryClient,
@@ -92,11 +88,15 @@ export class SequencerClient {
       publicClient,
       l1TxUtils.map(x => x.getSenderAddress()),
     );
-    const publisherManager = new PublisherManager(l1TxUtils, config);
+    const publisherManager = new PublisherManager(l1TxUtils, getPublisherConfigFromSequencerConfig(config), {
+      bindings: log.getBindings(),
+      funder: deps.funderL1TxUtils,
+    });
     const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
-    const [l1GenesisTime, slotDuration] = await Promise.all([
+    const [l1GenesisTime, slotDuration, rollupManaLimit] = await Promise.all([
       rollupContract.getL1GenesisTime(),
       rollupContract.getSlotDuration(),
+      rollupContract.getManaLimit().then(Number),
     ] as const);
 
     const governanceProposerContract = new GovernanceProposerContract(
@@ -112,56 +112,40 @@ export class SequencerClient {
           l1ChainId: chainId,
           viemPollingIntervalMS: config.viemPollingIntervalMS,
           ethereumSlotDuration: config.ethereumSlotDuration,
+          enableProposerPipelining: config.enableProposerPipelining,
         },
         { dateProvider: deps.dateProvider },
       ));
 
-    const slashFactoryContract = new SlashFactoryContract(
-      publicClient,
-      config.l1Contracts.slashFactoryAddress?.toString() ?? EthAddress.ZERO.toString(),
-    );
-
     const publisherFactory =
       deps.publisherFactory ??
       new SequencerPublisherFactory(config, {
         telemetry: telemetryClient,
-        blobSinkClient: deps.blobSinkClient,
+        blobClient: deps.blobClient,
         epochCache,
         governanceProposerContract,
-        slashFactoryContract,
         rollupContract,
         dateProvider: deps.dateProvider,
         publisherManager,
         nodeKeyStore: NodeKeystoreAdapter.fromKeyStoreManager(deps.nodeKeyStore),
         logger: log,
       });
-    const globalsBuilder = new GlobalVariableBuilder(config);
 
     const ethereumSlotDuration = config.ethereumSlotDuration;
 
-    const rollupManaLimit = Number(await rollupContract.getManaLimit());
-    let sequencerManaLimit = config.maxL2BlockGas ?? rollupManaLimit;
-    if (sequencerManaLimit > rollupManaLimit) {
-      log.warn(
-        `Provided maxL2BlockGas of ${sequencerManaLimit} is greater than the maximum allowed by the L1 (${rollupManaLimit}), setting limit to ${rollupManaLimit}`,
-      );
-      sequencerManaLimit = rollupManaLimit;
-    }
+    const globalsBuilder = deps.globalVariableBuilder;
 
     // When running in anvil, assume we can post a tx up until one second before the end of an L1 slot.
-    // Otherwise, assume we must have broadcasted the tx before the slot started (we use a default
-    // maxL1TxInclusionTimeIntoSlot of zero) to get the tx into that L1 slot.
+    // Otherwise, we need the full L1 slot duration for publishing to ensure inclusion.
     // In theory, the L1 slot has an initial 4s phase where the block is propagated, so we could
-    // make it with a propagation time into slot equal to 4s. However, we prefer being conservative.
+    // reduce the publishing time allowance. However, we prefer being conservative.
     // See https://www.blocknative.com/blog/anatomy-of-a-slot#7 for more info.
-    const maxInclusionBasedOnChain = isAnvilTestChain(config.l1ChainId) ? ethereumSlotDuration - 1 : 0;
-    const maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot ?? maxInclusionBasedOnChain;
+    const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
+    const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
 
-    const l1Constants = {
-      l1GenesisTime,
-      slotDuration: Number(slotDuration),
-      ethereumSlotDuration,
-    };
+    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = capPerBlockLimits(config, rollupManaLimit, log);
+
+    const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration, rollupManaLimit };
 
     const sequencer = new Sequencer(
       publisherFactory,
@@ -172,19 +156,22 @@ export class SequencerClient {
       slasherClient,
       l2BlockSource,
       l1ToL2MessageSource,
-      blockBuilder,
+      checkpointsBuilder,
       l1Constants,
       deps.dateProvider,
       epochCache,
       rollupContract,
-      { ...config, maxL1TxInclusionTimeIntoSlot, maxL2BlockGas: sequencerManaLimit },
+      { ...config, l1PublishingTime, maxL2BlockGas, maxDABlockGas, maxTxsPerBlock },
       telemetryClient,
       log,
     );
 
-    await sequencer.init();
+    sequencer.init();
+
+    // Extract the shared delayer from the first L1TxUtils instance (all instances share the same delayer)
+    const delayer = l1TxUtils[0]?.delayer;
 
-    return new SequencerClient(publisherManager, sequencer, blockBuilder, validatorClient, l1Metrics);
+    return new SequencerClient(publisherManager, sequencer, checkpointsBuilder, validatorClient, l1Metrics, delayer);
   }
 
   /**
@@ -193,7 +180,7 @@ export class SequencerClient {
    */
   public updateConfig(config: SequencerConfig & Partial<ValidatorClientFullConfig>) {
     this.sequencer.updateConfig(config);
-    this.blockBuilder.updateConfig(config);
+    this.checkpointsBuilder.updateConfig(config);
     this.validatorClient?.updateConfig(config);
   }
 
@@ -202,7 +189,7 @@ export class SequencerClient {
     await this.validatorClient?.start();
     this.sequencer.start();
     this.l1Metrics?.start();
-    await this.publisherManager.loadState();
+    await this.publisherManager.start();
   }
 
   /**
@@ -211,14 +198,29 @@ export class SequencerClient {
   public async stop() {
     await this.sequencer.stop();
     await this.validatorClient?.stop();
-    this.publisherManager.interrupt();
+    await this.publisherManager.stop();
     this.l1Metrics?.stop();
   }
 
+  /** Triggers an immediate run of the sequencer, bypassing the polling interval. */
+  public trigger() {
+    return this.sequencer.trigger();
+  }
+
   public getSequencer(): Sequencer {
     return this.sequencer;
   }
 
+  /** Updates the publisher factory's node keystore adapter after a keystore reload. */
+  public updatePublisherNodeKeyStore(adapter: NodeKeystoreAdapter): void {
+    this.sequencer.updatePublisherNodeKeyStore(adapter);
+  }
+
+  /** Returns the shared tx delayer for sequencer L1 txs, if enabled. Test-only. */
+  getDelayer(): Delayer | undefined {
+    return this.delayer_;
+  }
+
   get validatorAddresses(): EthAddress[] | undefined {
     return this.sequencer.getValidatorAddresses();
   }
@@ -227,3 +229,41 @@ export class SequencerClient {
     return this.sequencer.maxL2BlockGas;
   }
 }
+
+/**
+ * Caps operator-provided per-block limits at checkpoint-level limits.
+ * Returns undefined for any limit the operator didn't set — the checkpoint builder handles redistribution.
+ */
+function capPerBlockLimits(
+  config: SequencerClientConfig,
+  rollupManaLimit: number,
+  log: ReturnType<typeof createLogger>,
+): { maxL2BlockGas: number | undefined; maxDABlockGas: number | undefined; maxTxsPerBlock: number | undefined } {
+  let maxL2BlockGas = config.maxL2BlockGas;
+  if (maxL2BlockGas !== undefined && maxL2BlockGas > rollupManaLimit) {
+    log.warn(`Provided MAX_L2_BLOCK_GAS ${maxL2BlockGas} exceeds rollup mana limit ${rollupManaLimit} (capping)`);
+    maxL2BlockGas = rollupManaLimit;
+  }
+
+  let maxDABlockGas = config.maxDABlockGas;
+  if (maxDABlockGas !== undefined && maxDABlockGas > MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT) {
+    log.warn(
+      `Provided MAX_DA_BLOCK_GAS ${maxDABlockGas} exceeds DA checkpoint limit ${MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT} (capping)`,
+    );
+    maxDABlockGas = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+  }
+
+  let maxTxsPerBlock = config.maxTxsPerBlock;
+  if (
+    maxTxsPerBlock !== undefined &&
+    config.maxTxsPerCheckpoint !== undefined &&
+    maxTxsPerBlock > config.maxTxsPerCheckpoint
+  ) {
+    log.warn(
+      `Provided MAX_TX_PER_BLOCK ${maxTxsPerBlock} exceeds MAX_TX_PER_CHECKPOINT ${config.maxTxsPerCheckpoint} (capping)`,
+    );
+    maxTxsPerBlock = config.maxTxsPerCheckpoint;
+  }
+
+  return { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock };
+}

package/src/config.ts

@@ -1,9 +1,5 @@
-import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  l1ContractsConfigMappings,
-  l1ReaderConfigMappings,
-} from '@aztec/ethereum';
+import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec/ethereum/config';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -12,71 +8,123 @@ import {
   pickConfigMappings,
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { type KeyStoreConfig, keyStoreConfigMappings } from '@aztec/node-keystore';
-import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p';
+import { type KeyStoreConfig, keyStoreConfigMappings } from '@aztec/node-keystore/config';
+import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p/config';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type ChainConfig, type SequencerConfig, chainConfigMappings } from '@aztec/stdlib/config';
-import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec/validator-client';
+import {
+  type ChainConfig,
+  type PipelineConfig,
+  type SequencerConfig,
+  chainConfigMappings,
+  pipelineConfigMappings,
+  sharedSequencerConfigMappings,
+} from '@aztec/stdlib/config';
+import type { ResolvedSequencerConfig } from '@aztec/stdlib/interfaces/server';
+import { DEFAULT_P2P_PROPAGATION_TIME } from '@aztec/stdlib/timetable';
+import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec/validator-client/config';
 
 import {
-  type PublisherConfig,
-  type TxSenderConfig,
-  getPublisherConfigMappings,
-  getTxSenderConfigMappings,
+  type SequencerPublisherConfig,
+  type SequencerTxSenderConfig,
+  sequencerPublisherConfigMappings,
+  sequencerTxSenderConfigMappings,
 } from './publisher/config.js';
 
 export * from './publisher/config.js';
 export type { SequencerConfig };
 
-export const DEFAULT_ATTESTATION_PROPAGATION_TIME = 2;
+/**
+ * Default values for SequencerConfig.
+ * Centralized location for all sequencer configuration defaults.
+ */
+export const DefaultSequencerConfig = {
+  sequencerPollingIntervalMS: 500,
+  minTxsPerBlock: 1,
+  buildCheckpointIfEmpty: false,
+  publishTxsWithProposals: false,
+  perBlockAllocationMultiplier: 1.2,
+  redistributeCheckpointBudget: true,
+  enforceTimeTable: true,
+  attestationPropagationTime: DEFAULT_P2P_PROPAGATION_TIME,
+  secondsBeforeInvalidatingBlockAsCommitteeMember: 144, // 12 L1 blocks
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember: 432, // 36 L1 blocks
+  skipCollectingAttestations: false,
+  skipInvalidateBlockAsProposer: false,
+  broadcastInvalidBlockProposal: false,
+  injectFakeAttestation: false,
+  injectHighSValueAttestation: false,
+  injectUnrecoverableSignatureAttestation: false,
+  fishermanMode: false,
+  shuffleAttestationOrdering: false,
+  skipPushProposedBlocksToArchiver: false,
+  skipPublishingCheckpointsPercent: 0,
+} satisfies ResolvedSequencerConfig;
 
 /**
  * Configuration settings for the SequencerClient.
  */
-export type SequencerClientConfig = PublisherConfig &
+export type SequencerClientConfig = SequencerPublisherConfig &
   KeyStoreConfig &
   ValidatorClientConfig &
-  TxSenderConfig &
+  SequencerTxSenderConfig &
   SequencerConfig &
   L1ReaderConfig &
   ChainConfig &
-  Pick<P2PConfig, 'txPublicSetupAllowList'> &
+  PipelineConfig &
+  Pick<P2PConfig, 'txPublicSetupAllowListExtend'> &
   Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration' | 'aztecEpochDuration'>;
 
 export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
-  transactionPollingIntervalMS: {
-    env: 'SEQ_TX_POLLING_INTERVAL_MS',
-    description: 'The number of ms to wait between polling for pending txs.',
-    ...numberConfigHelper(500),
+  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),
   },
-  maxTxsPerBlock: {
-    env: 'SEQ_MAX_TX_PER_BLOCK',
-    description: 'The maximum number of txs to include in a block.',
-    ...numberConfigHelper(32),
+  maxTxsPerCheckpoint: {
+    env: 'SEQ_MAX_TX_PER_CHECKPOINT',
+    description: 'The maximum number of txs across all blocks in a checkpoint.',
+    parseEnv: (val: string) => parseInt(val, 10),
   },
   minTxsPerBlock: {
     env: 'SEQ_MIN_TX_PER_BLOCK',
     description: 'The minimum number of txs to include in a block.',
-    ...numberConfigHelper(1),
+    ...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(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.publishTxsWithProposals),
   },
   maxL2BlockGas: {
     env: 'SEQ_MAX_L2_BLOCK_GAS',
     description: 'The maximum L2 block gas.',
-    ...numberConfigHelper(10e9),
+    parseEnv: (val: string) => parseInt(val, 10),
   },
   maxDABlockGas: {
     env: 'SEQ_MAX_DA_BLOCK_GAS',
     description: 'The maximum DA block gas.',
-    ...numberConfigHelper(10e9),
+    parseEnv: (val: string) => parseInt(val, 10),
+  },
+  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.',
+    ...numberConfigHelper(DefaultSequencerConfig.perBlockAllocationMultiplier),
+  },
+  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) => (val ? EthAddress.fromString(val) : undefined),
+    parseEnv: (val: string) => EthAddress.fromString(val),
     description: 'Recipient of block reward.',
   },
   feeRecipient: {
@@ -92,88 +140,108 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
     env: 'ACVM_BINARY_PATH',
     description: 'The path to the ACVM binary',
   },
-  maxBlockSizeInBytes: {
-    env: 'SEQ_MAX_BLOCK_SIZE_IN_BYTES',
-    description: 'Max block size',
-    ...numberConfigHelper(1024 * 1024),
-  },
   enforceTimeTable: {
     env: 'SEQ_ENFORCE_TIME_TABLE',
     description: 'Whether to enforce the time table when building blocks',
-    ...booleanConfigHelper(),
-    defaultValue: true,
+    ...booleanConfigHelper(DefaultSequencerConfig.enforceTimeTable),
   },
   governanceProposerPayload: {
     env: 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS',
     description: 'The address of the payload for the governanceProposer',
     parseEnv: (val: string) => EthAddress.fromString(val),
-    defaultValue: EthAddress.ZERO,
-  },
-  maxL1TxInclusionTimeIntoSlot: {
-    env: 'SEQ_MAX_L1_TX_INCLUSION_TIME_INTO_SLOT',
-    description: 'How many seconds into an L1 slot we can still send a tx and get it mined.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
   },
-  attestationPropagationTime: {
-    env: 'SEQ_ATTESTATION_PROPAGATION_TIME',
-    description: 'How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way)',
-    ...numberConfigHelper(DEFAULT_ATTESTATION_PROPAGATION_TIME),
+  l1PublishingTime: {
+    env: 'SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT',
+    description: 'How much time (in seconds) we allow in the slot for publishing the L1 tx (defaults to 1 L1 slot).',
+    parseEnv: (val: string) => parseInt(val, 10),
   },
   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(144), // 12 L1 blocks
+    ...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(432), // 36 L1 blocks
+    ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsNonCommitteeMember),
   },
   skipCollectingAttestations: {
     description:
       'Whether to skip collecting attestations from validators and only use self-attestations (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.skipCollectingAttestations),
   },
   skipInvalidateBlockAsProposer: {
     description: 'Do not invalidate the previous block if invalid when we are the proposer (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.skipInvalidateBlockAsProposer),
   },
   broadcastInvalidBlockProposal: {
     description: 'Broadcast invalid block proposals with corrupted state (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.broadcastInvalidBlockProposal),
   },
   injectFakeAttestation: {
     description: 'Inject a fake attestation (for testing only)',
-    ...booleanConfigHelper(false),
+    ...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),
   },
   fishermanMode: {
     env: 'FISHERMAN_MODE',
     description:
       'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.fishermanMode),
   },
   shuffleAttestationOrdering: {
     description: 'Shuffle attestation ordering to create invalid ordering (for testing only)',
-    ...booleanConfigHelper(false),
+    ...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),
   },
-  ...pickConfigMappings(p2pConfigMappings, ['txPublicSetupAllowList']),
+  skipPushProposedBlocksToArchiver: {
+    description: 'Skip pushing proposed blocks to archiver (default: true)',
+    ...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),
+  },
+  ...pickConfigMappings(p2pConfigMappings, ['txPublicSetupAllowListExtend']),
 };
 
 export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig> = {
+  // chainConfigMappings must come first: its l1Contracts only maps rollupAddress,
+  // while l1ReaderConfigMappings (spread later) maps all L1 contract addresses.
+  ...chainConfigMappings,
   ...validatorClientConfigMappings,
   ...sequencerConfigMappings,
   ...keyStoreConfigMappings,
   ...l1ReaderConfigMappings,
-  ...getTxSenderConfigMappings('SEQ'),
-  ...getPublisherConfigMappings('SEQ'),
-  ...chainConfigMappings,
+  ...sequencerTxSenderConfigMappings,
+  ...sequencerPublisherConfigMappings,
+  ...pipelineConfigMappings,
   ...pickConfigMappings(l1ContractsConfigMappings, ['ethereumSlotDuration', 'aztecSlotDuration', 'aztecEpochDuration']),
 };
 

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.