@aztec/sequencer-client 0.0.1-commit.381b1a9 → 0.0.1-commit.3a4ae741b

package/src/client/sequencer-client.ts

@@ -19,15 +19,10 @@ import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { L1Metrics, type TelemetryClient } from '@aztec/telemetry-client';
 import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
 
-import {
-  DefaultSequencerConfig,
-  type SequencerClientConfig,
-  getPublisherConfigFromSequencerConfig,
-} 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';
-import { SequencerTimetable } from '../sequencer/timetable.js';
 
 /**
  * Encapsulates the full sequencer and publisher.
@@ -70,7 +65,9 @@ export class SequencerClient {
       dateProvider: DateProvider;
       epochCache?: EpochCache;
       l1TxUtils: L1TxUtils[];
+      funderL1TxUtils?: L1TxUtils;
       nodeKeyStore: KeystoreManager;
+      globalVariableBuilder: GlobalVariableBuilder;
     },
   ) {
     const {
@@ -92,16 +89,14 @@ export class SequencerClient {
       publicClient,
       l1TxUtils.map(x => x.getSenderAddress()),
     );
-    const publisherManager = new PublisherManager(
-      l1TxUtils,
-      getPublisherConfigFromSequencerConfig(config),
-      log.getBindings(),
-    );
+    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, rollupVersion, rollupManaLimit] = await Promise.all([
+    const [l1GenesisTime, slotDuration, rollupManaLimit] = await Promise.all([
       rollupContract.getL1GenesisTime(),
       rollupContract.getSlotDuration(),
-      rollupContract.getVersion(),
       rollupContract.getManaLimit().then(Number),
     ] as const);
 
@@ -118,6 +113,7 @@ export class SequencerClient {
           l1ChainId: chainId,
           viemPollingIntervalMS: config.viemPollingIntervalMS,
           ethereumSlotDuration: config.ethereumSlotDuration,
+          enableProposerPipelining: config.enableProposerPipelining,
         },
         { dateProvider: deps.dateProvider },
       ));
@@ -144,13 +140,7 @@ export class SequencerClient {
 
     const ethereumSlotDuration = config.ethereumSlotDuration;
 
-    const globalsBuilder = new GlobalVariableBuilder({
-      ...config,
-      l1GenesisTime,
-      slotDuration: Number(slotDuration),
-      ethereumSlotDuration,
-      rollupVersion,
-    });
+    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, we need the full L1 slot duration for publishing to ensure inclusion.
@@ -160,12 +150,7 @@ export class SequencerClient {
     const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
     const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
 
-    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = computeBlockLimits(
-      config,
-      rollupManaLimit,
-      l1PublishingTime,
-      log,
-    );
+    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = capPerBlockLimits(config, rollupManaLimit, log);
 
     const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration, rollupManaLimit };
 
@@ -211,7 +196,7 @@ export class SequencerClient {
     await this.validatorClient?.start();
     this.sequencer.start();
     this.l1Metrics?.start();
-    await this.publisherManager.loadState();
+    await this.publisherManager.start();
   }
 
   /**
@@ -220,7 +205,7 @@ export class SequencerClient {
   public async stop() {
     await this.sequencer.stop();
     await this.validatorClient?.stop();
-    this.publisherManager.interrupt();
+    await this.publisherManager.stop();
     this.l1Metrics?.stop();
   }
 
@@ -248,88 +233,39 @@ export class SequencerClient {
 }
 
 /**
- * Computes per-block L2 gas, DA gas, and TX count budgets based on the L1 rollup limits and the timetable.
- * If the user explicitly set a limit, it is capped at the corresponding checkpoint limit.
- * Otherwise, derives it as (checkpointLimit / maxBlocks) * multiplier, capped at the checkpoint limit.
+ * 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.
  */
-export function computeBlockLimits(
+function capPerBlockLimits(
   config: SequencerClientConfig,
   rollupManaLimit: number,
-  l1PublishingTime: number,
   log: ReturnType<typeof createLogger>,
-): { maxL2BlockGas: number; maxDABlockGas: number; maxTxsPerBlock: number } {
-  const maxNumberOfBlocks = new SequencerTimetable({
-    ethereumSlotDuration: config.ethereumSlotDuration,
-    aztecSlotDuration: config.aztecSlotDuration,
-    l1PublishingTime,
-    p2pPropagationTime: config.attestationPropagationTime,
-    blockDurationMs: config.blockDurationMs,
-    enforce: config.enforceTimeTable ?? DefaultSequencerConfig.enforceTimeTable,
-  }).maxNumberOfBlocks;
-
-  const multiplier = config.perBlockAllocationMultiplier ?? DefaultSequencerConfig.perBlockAllocationMultiplier;
-
-  // Compute maxL2BlockGas
-  let maxL2BlockGas: number;
-  if (config.maxL2BlockGas !== undefined) {
-    if (config.maxL2BlockGas > rollupManaLimit) {
-      log.warn(
-        `Provided MAX_L2_BLOCK_GAS ${config.maxL2BlockGas} exceeds L1 rollup mana limit ${rollupManaLimit} (capping)`,
-      );
-      maxL2BlockGas = rollupManaLimit;
-    } else {
-      maxL2BlockGas = config.maxL2BlockGas;
-    }
-  } else {
-    maxL2BlockGas = Math.min(rollupManaLimit, Math.ceil((rollupManaLimit / maxNumberOfBlocks) * multiplier));
+): { 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;
   }
 
-  // Compute maxDABlockGas
-  const daCheckpointLimit = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
-  let maxDABlockGas: number;
-  if (config.maxDABlockGas !== undefined) {
-    if (config.maxDABlockGas > daCheckpointLimit) {
-      log.warn(
-        `Provided MAX_DA_BLOCK_GAS ${config.maxDABlockGas} exceeds DA checkpoint limit ${daCheckpointLimit} (capping)`,
-      );
-      maxDABlockGas = daCheckpointLimit;
-    } else {
-      maxDABlockGas = config.maxDABlockGas;
-    }
-  } else {
-    maxDABlockGas = Math.min(daCheckpointLimit, Math.ceil((daCheckpointLimit / maxNumberOfBlocks) * multiplier));
+  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;
   }
 
-  // Compute maxTxsPerBlock
-  const defaultMaxTxsPerBlock = 32;
-  let maxTxsPerBlock: number;
-  if (config.maxTxsPerBlock !== undefined) {
-    if (config.maxTxsPerCheckpoint !== undefined && config.maxTxsPerBlock > config.maxTxsPerCheckpoint) {
-      log.warn(
-        `Provided MAX_TX_PER_BLOCK ${config.maxTxsPerBlock} exceeds MAX_TX_PER_CHECKPOINT ${config.maxTxsPerCheckpoint} (capping)`,
-      );
-      maxTxsPerBlock = config.maxTxsPerCheckpoint;
-    } else {
-      maxTxsPerBlock = config.maxTxsPerBlock;
-    }
-  } else if (config.maxTxsPerCheckpoint !== undefined) {
-    maxTxsPerBlock = Math.min(
-      config.maxTxsPerCheckpoint,
-      Math.ceil((config.maxTxsPerCheckpoint / maxNumberOfBlocks) * multiplier),
+  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)`,
     );
-  } else {
-    maxTxsPerBlock = defaultMaxTxsPerBlock;
+    maxTxsPerBlock = config.maxTxsPerCheckpoint;
   }
 
-  log.info(`Computed block limits L2=${maxL2BlockGas} DA=${maxDABlockGas} maxTxs=${maxTxsPerBlock}`, {
-    maxL2BlockGas,
-    maxDABlockGas,
-    maxTxsPerBlock,
-    rollupManaLimit,
-    daCheckpointLimit,
-    maxNumberOfBlocks,
-    multiplier,
-  });
-
   return { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock };
 }

package/src/config.ts

@@ -13,8 +13,10 @@ import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p/config';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   type ChainConfig,
+  type PipelineConfig,
   type SequencerConfig,
   chainConfigMappings,
+  pipelineConfigMappings,
   sharedSequencerConfigMappings,
 } from '@aztec/stdlib/config';
 import type { ResolvedSequencerConfig } from '@aztec/stdlib/interfaces/server';
@@ -41,6 +43,7 @@ export const DefaultSequencerConfig = {
   buildCheckpointIfEmpty: false,
   publishTxsWithProposals: false,
   perBlockAllocationMultiplier: 1.2,
+  redistributeCheckpointBudget: true,
   enforceTimeTable: true,
   attestationPropagationTime: DEFAULT_P2P_PROPAGATION_TIME,
   secondsBeforeInvalidatingBlockAsCommitteeMember: 144, // 12 L1 blocks
@@ -67,6 +70,7 @@ export type SequencerClientConfig = SequencerPublisherConfig &
   SequencerConfig &
   L1ReaderConfig &
   ChainConfig &
+  PipelineConfig &
   Pick<P2PConfig, 'txPublicSetupAllowListExtend'> &
   Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration' | 'aztecEpochDuration'>;
 
@@ -112,6 +116,12 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
       ' 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),
@@ -234,6 +244,7 @@ export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientCo
   ...sequencerTxSenderConfigMappings,
   ...sequencerPublisherConfigMappings,
   ...chainConfigMappings,
+  ...pipelineConfigMappings,
   ...pickConfigMappings(l1ContractsConfigMappings, ['ethereumSlotDuration', 'aztecSlotDuration', 'aztecEpochDuration']),
 };
 

package/src/global_variable_builder/global_builder.ts

@@ -1,14 +1,13 @@
-import { createEthereumChain } from '@aztec/ethereum/chain';
-import type { L1ContractsConfig } from '@aztec/ethereum/config';
 import { RollupContract } from '@aztec/ethereum/contracts';
-import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import type { ViemPublicClient } from '@aztec/ethereum/types';
 import { BlockNumber, 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 { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type L1RollupConstants, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { type L1RollupConstants, getNextL1SlotTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
 import type {
   CheckpointGlobalVariables,
@@ -16,7 +15,12 @@ import type {
 } from '@aztec/stdlib/tx';
 import { GlobalVariables } from '@aztec/stdlib/tx';
 
-import { createPublicClient, fallback, http } from 'viem';
+/** Configuration for the GlobalVariableBuilder (excludes L1 client config). */
+export type GlobalVariableBuilderConfig = {
+  l1Contracts: Pick<L1ContractAddresses, 'rollupAddress'>;
+  ethereumSlotDuration: number;
+  rollupVersion: bigint;
+} & Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'>;
 
 /**
  * Simple global variables builder.
@@ -27,7 +31,6 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   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;
@@ -36,28 +39,18 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   private version: Fr;
 
   constructor(
-    config: L1ReaderConfig &
-      Pick<L1ContractsConfig, 'ethereumSlotDuration'> &
-      Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'> & { rollupVersion: bigint },
+    private readonly dateProvider: DateProvider,
+    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: fallback(chain.rpcUrls.map(url => http(url, { batch: false }))),
-      pollingInterval: config.viemPollingIntervalMS,
-    });
-
-    this.rollupContract = new RollupContract(this.publicClient, l1Contracts.rollupAddress);
+    this.rollupContract = new RollupContract(this.publicClient, config.l1Contracts.rollupAddress);
   }
 
   /**
@@ -73,7 +66,10 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
       SlotNumber.fromBigInt(BigInt(lastCheckpoint.slotNumber) + 1n),
     );
-    const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
+    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));
@@ -108,7 +104,10 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     const slot: SlotNumber =
       maybeSlot ??
       (await this.rollupContract.getSlotAt(
-        BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration)),
+        getNextL1SlotTimestamp(this.dateProvider.nowInSeconds(), {
+          l1GenesisTime: this.l1GenesisTime,
+          ethereumSlotDuration: this.ethereumSlotDuration,
+        }),
       ));
 
     const checkpointGlobalVariables = await this.buildCheckpointGlobalVariables(coinbase, feeRecipient, slot);

package/src/global_variable_builder/index.ts

@@ -1 +1 @@
-export { GlobalVariableBuilder } from './global_builder.js';
+export { GlobalVariableBuilder, type GlobalVariableBuilderConfig } from './global_builder.js';

package/src/publisher/config.ts

@@ -4,6 +4,8 @@ import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from '@aztec/ethereum/l
 import { type ConfigMappingsType, SecretValue, booleanConfigHelper } 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. */
@@ -48,13 +50,39 @@ export type PublisherConfig = L1TxUtilsConfig &
     fishermanMode?: boolean;
     /** Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only) */
     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 &
@@ -62,6 +90,12 @@ export type SequencerPublisherConfig = L1TxUtilsConfig &
     fishermanMode?: boolean;
     sequencerPublisherAllowInvalidStates?: boolean;
     sequencerPublisherForwarderAddress?: 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;
   };
 
 export function getPublisherConfigFromProverConfig(config: ProverPublisherConfig): PublisherConfig {
@@ -77,6 +111,7 @@ export function getPublisherConfigFromSequencerConfig(config: SequencerPublisher
     ...config,
     publisherAllowInvalidStates: config.sequencerPublisherAllowInvalidStates,
     publisherForwarderAddress: config.sequencerPublisherForwarderAddress,
+    l1TxFailedStore: config.l1TxFailedStore,
   };
 }
 
@@ -133,6 +168,11 @@ export const sequencerPublisherConfigMappings: ConfigMappingsType<SequencerPubli
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
     parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
   },
+  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> = {
@@ -154,4 +194,5 @@ export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherCo
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
     parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
   },
+  ...publisherFundingConfigMappings,
 };

package/src/publisher/index.ts

@@ -3,3 +3,6 @@ export { SequencerPublisherFactory } from './sequencer-publisher-factory.js';
 
 // Used for tests
 export { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
+
+// Failed L1 tx store (optional, for test networks)
+export { type FailedL1Tx, type FailedL1TxUri, type L1TxFailedStore } from './l1_tx_failed_store/index.js';

package/src/publisher/l1_tx_failed_store/factory.ts

@@ -0,0 +1,32 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { createFileStore } from '@aztec/stdlib/file-store';
+
+import type { L1TxFailedStore } from './failed_tx_store.js';
+import { FileStoreL1TxFailedStore } from './file_store_failed_tx_store.js';
+
+/**
+ * Creates an L1TxFailedStore from a config string.
+ * Supports any backend that FileStore supports (GCS, S3, R2, local filesystem).
+ * @param config - Config string (e.g., 'gs://bucket/path', 's3://bucket/path', 'file:///path'). If undefined, returns undefined.
+ * @param logger - Optional logger.
+ * @returns The store instance, or undefined if config is not provided.
+ */
+export async function createL1TxFailedStore(
+  config: string | undefined,
+  logger: Logger = createLogger('sequencer:l1-tx-failed-store'),
+): Promise<L1TxFailedStore | undefined> {
+  if (!config) {
+    return undefined;
+  }
+
+  const fileStore = await createFileStore(config, logger);
+  if (!fileStore) {
+    throw new Error(
+      `Failed to create file store from config: '${config}'. ` +
+        `Supported formats: 'gs://bucket/path', 's3://bucket/path', 'file:///path'.`,
+    );
+  }
+
+  logger.info(`Created L1 tx failed store`, { config });
+  return new FileStoreL1TxFailedStore(fileStore, logger);
+}

package/src/publisher/l1_tx_failed_store/failed_tx_store.ts

@@ -0,0 +1,55 @@
+import type { Hex } from 'viem';
+
+/** URI pointing to a stored failed L1 transaction. */
+export type FailedL1TxUri = string & { __brand: 'FailedL1TxUri' };
+
+/** A failed L1 transaction captured for debugging and replay. */
+export type FailedL1Tx = {
+  /** Tx hash (for reverts) or keccak256(request.data) (for simulation/send failures). */
+  id: Hex;
+  /** Unix timestamp (ms) when failure occurred. */
+  timestamp: number;
+  /** Whether the failure was during simulation or after sending. */
+  failureType: 'simulation' | 'revert' | 'send-error';
+  /** The actual L1 transaction for replay (multicall-encoded for bundled txs). */
+  request: {
+    to: Hex;
+    data: Hex;
+    value?: string; // bigint as string
+  };
+  /** Raw blob data as hex for replay. */
+  blobData?: Hex[];
+  /** L1 block number at time of failure (simulation target or receipt block). */
+  l1BlockNumber: string; // bigint as string
+  /** Receipt info (present only for on-chain reverts). */
+  receipt?: {
+    transactionHash: Hex;
+    blockNumber: string; // bigint as string
+    gasUsed: string; // bigint as string
+    status: 'reverted';
+  };
+  /** Error information. */
+  error: {
+    message: string;
+    /** Decoded error name (e.g., 'Rollup__InvalidProposer'). */
+    name?: string;
+  };
+  /** Context metadata. */
+  context: {
+    /** Actions involved (e.g., ['propose', 'governance-signal']). */
+    actions: string[];
+    /** Individual request data for each action (metadata, not used for replay). */
+    requests?: Array<{ action: string; to: Hex; data: Hex }>;
+    checkpointNumber?: number;
+    slot?: number;
+    sender: Hex;
+  };
+};
+
+/** Store for failed L1 transactions for debugging purposes. */
+export interface L1TxFailedStore {
+  /** Saves a failed transaction and returns its URI. */
+  saveFailedTx(tx: FailedL1Tx): Promise<FailedL1TxUri>;
+  /** Retrieves a failed transaction by its URI. */
+  getFailedTx(uri: FailedL1TxUri): Promise<FailedL1Tx>;
+}

package/src/publisher/l1_tx_failed_store/file_store_failed_tx_store.ts

@@ -0,0 +1,46 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { FileStore } from '@aztec/stdlib/file-store';
+
+import type { FailedL1Tx, FailedL1TxUri, L1TxFailedStore } from './failed_tx_store.js';
+
+/**
+ * L1TxFailedStore implementation using the FileStore abstraction.
+ * Supports any backend that FileStore supports (GCS, S3, R2, local filesystem).
+ */
+export class FileStoreL1TxFailedStore implements L1TxFailedStore {
+  private readonly log: Logger;
+
+  constructor(
+    private readonly fileStore: FileStore,
+    logger?: Logger,
+  ) {
+    this.log = logger ?? createLogger('sequencer:l1-tx-failed-store');
+  }
+
+  public async saveFailedTx(tx: FailedL1Tx): Promise<FailedL1TxUri> {
+    const prefix = tx.receipt ? 'tx' : 'data';
+    const path = `${tx.failureType}/${prefix}-${tx.id}.json`;
+    const json = JSON.stringify(tx, null, 2);
+
+    const uri = await this.fileStore.save(path, Buffer.from(json), {
+      metadata: {
+        'content-type': 'application/json',
+        actions: tx.context.actions.join(','),
+        'failure-type': tx.failureType,
+      },
+    });
+
+    this.log.info(`Saved failed L1 tx to ${uri}`, {
+      id: tx.id,
+      failureType: tx.failureType,
+      actions: tx.context.actions.join(','),
+    });
+
+    return uri as FailedL1TxUri;
+  }
+
+  public async getFailedTx(uri: FailedL1TxUri): Promise<FailedL1Tx> {
+    const data = await this.fileStore.read(uri);
+    return JSON.parse(data.toString()) as FailedL1Tx;
+  }
+}

package/src/publisher/l1_tx_failed_store/index.ts

@@ -0,0 +1,3 @@
+export { type FailedL1Tx, type FailedL1TxUri, type L1TxFailedStore } from './failed_tx_store.js';
+export { createL1TxFailedStore } from './factory.js';
+export { FileStoreL1TxFailedStore } from './file_store_failed_tx_store.js';

package/src/publisher/sequencer-publisher-factory.ts

@@ -81,8 +81,23 @@ export class SequencerPublisherFactory {
     const rollup = this.deps.rollupContract;
     const slashingProposerContract = await rollup.getSlashingProposer();
 
+    const getNextPublisher = async (excludeAddresses: EthAddress[]): Promise<L1TxUtils | undefined> => {
+      const exclusionFilter: PublisherFilter<L1TxUtils> = (utils: L1TxUtils) => {
+        if (excludeAddresses.some(addr => addr.equals(utils.getSenderAddress()))) {
+          return false;
+        }
+        return filter(utils);
+      };
+      try {
+        return await this.deps.publisherManager.getAvailablePublisher(exclusionFilter);
+      } catch {
+        return undefined;
+      }
+    };
+
     const publisher = new SequencerPublisher(this.sequencerConfig, {
       l1TxUtils: l1Publisher,
+      getNextPublisher,
       telemetry: this.deps.telemetry,
       blobClient: this.deps.blobClient,
       rollupContract: this.deps.rollupContract,
@@ -102,8 +117,8 @@ export class SequencerPublisherFactory {
     };
   }
 
-  /** Interrupts all publishers managed by this factory. Used during sequencer shutdown. */
-  public interruptAll(): void {
-    this.deps.publisherManager.interrupt();
+  /** Stops all publishers managed by this factory. Used during sequencer shutdown. */
+  public async stopAll(): Promise<void> {
+    await this.deps.publisherManager.stop();
   }
 }