@aztec/sequencer-client 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/publisher/sequencer-publisher.ts

@@ -1,184 +1,429 @@
-import type { L2Block } from '@aztec/aztec.js';
-import { Blob } from '@aztec/blob-lib';
-import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
 import type { EpochCache } from '@aztec/epoch-cache';
+import type { L1ContractsConfig } from '@aztec/ethereum/config';
 import {
-  FormattedViemError,
-  type ForwarderContract,
-  type GasPrice,
+  FeeAssetPriceOracle,
   type GovernanceProposerContract,
-  type IEmpireBase,
+  MULTI_CALL_3_ADDRESS,
+  Multicall3,
+  MulticallForwarderRevertedError,
+  type RollupContract,
+  type SimulationOverridesPlan,
+  type SlashingProposerContract,
+  buildSimulationOverridesStateOverride,
+} from '@aztec/ethereum/contracts';
+import { type L1FeeAnalysisResult, L1FeeAnalyzer } from '@aztec/ethereum/l1-fee-analysis';
+import {
   type L1BlobInputs,
-  type L1ContractsConfig,
-  type L1GasConfig,
+  type L1TxConfig,
   type L1TxRequest,
-  RollupContract,
-  type SlashingProposerContract,
+  type L1TxUtils,
+  MAX_L1_TX_LIMIT,
   type TransactionStats,
+  WEI_CONST,
+} from '@aztec/ethereum/l1-tx-utils';
+import {
+  FormattedViemError,
   formatViemError,
-} from '@aztec/ethereum';
-import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
-import { toHex } from '@aztec/foundation/bigint-buffer';
+  mergeAbis,
+  tryDecodeRevertReason,
+  tryExtractEvent,
+} from '@aztec/ethereum/utils';
+import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { trimmedBytesLength } from '@aztec/foundation/buffer';
+import { pick } from '@aztec/foundation/collection';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import type { Signature } from '@aztec/foundation/eth-signature';
-import { createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { ForwarderAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayload } from '@aztec/stdlib/p2p';
-import type { L1PublishBlockStats } from '@aztec/stdlib/stats';
-import { type BlockHeader, TxHash } from '@aztec/stdlib/tx';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import pick from 'lodash.pick';
-import { type TransactionReceipt, encodeFunctionData } from 'viem';
-
-import type { PublisherConfig, TxSenderConfig } from './config.js';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
+import { bufferToHex } from '@aztec/foundation/string';
+import { type DateProvider, Timer } from '@aztec/foundation/timer';
+import { EmpireBaseAbi, ErrorsAbi, RollupAbi, SlashingProposerAbi } from '@aztec/l1-artifacts';
+import { type ProposerSlashAction, encodeSlashConsensusVotes } from '@aztec/slasher';
+import { CommitteeAttestationsAndSigners, type ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import {
+  getLastL1SlotTimestampForL2Slot,
+  getNextL1SlotTimestamp,
+  getTimestampForSlot,
+} from '@aztec/stdlib/epoch-helpers';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
+import type { L1PublishCheckpointStats } from '@aztec/stdlib/stats';
+import { type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+
+import {
+  type Abi,
+  type Hex,
+  type TransactionReceipt,
+  type TypedDataDefinition,
+  encodeFunctionData,
+  keccak256,
+  toHex,
+} from 'viem';
+
+import type { SequencerPublisherConfig } from './config.js';
+import { type FailedL1Tx, type L1TxFailedStore, createL1TxFailedStore } from './l1_tx_failed_store/index.js';
+import { type DroppedRequest, SequencerBundleSimulator } from './sequencer-bundle-simulator.js';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
 
+/**
+ * Returns true if the receipt indicates a successful send AND the expected event was emitted
+ * by the target contract. Both pieces are required: an aggregate3 entry that reverted will
+ * have receipt.status === 'success' but no event log.
+ */
+function extractEventSuccess(
+  receipt: TransactionReceipt | undefined,
+  opts: { address: string; abi: Abi; eventName: string },
+): boolean {
+  if (!receipt || receipt.status !== 'success') {
+    return false;
+  }
+  return !!tryExtractEvent(receipt.logs, opts.address.toString() as Hex, opts.abi, opts.eventName);
+}
+
+/** Result of a sendRequests call, returned by both sendRequests() and sendRequestsAt(). */
+export type SendRequestsResult = {
+  /** The L1 transaction receipt from the bundled multicall. */
+  result: { receipt: TransactionReceipt };
+  /** Actions that expired (past their deadline) before the request was sent. */
+  expiredActions: Action[];
+  /** Actions that were included in the sent L1 transaction. */
+  sentActions: Action[];
+  /** Actions whose L1 simulation succeeded (subset of sentActions). */
+  successfulActions: Action[];
+  /** Actions whose L1 simulation failed (subset of sentActions). */
+  failedActions: Action[];
+};
+
 /** Arguments to the process method of the rollup contract */
 type L1ProcessArgs = {
   /** The L2 block header. */
-  header: Buffer;
+  header: CheckpointHeader;
   /** A root of the archive tree after the L2 block is applied. */
   archive: Buffer;
-  /** The L2 block's leaf in the archive tree. */
-  blockHash: Buffer;
   /** L2 block blobs containing all tx effects. */
   blobs: Blob[];
-  /** L2 block tx hashes */
-  txHashes: TxHash[];
   /** Attestations */
-  attestations?: Signature[];
+  attestationsAndSigners: CommitteeAttestationsAndSigners;
+  /** Attestations and signers signature */
+  attestationsAndSignersSignature: Signature;
+  /** The fee asset price modifier in basis points (from oracle) */
+  feeAssetPriceModifier: bigint;
 };
 
-export enum VoteType {
-  GOVERNANCE,
-  SLASHING,
-}
+export const Actions = [
+  'invalidate-by-invalid-attestation',
+  'invalidate-by-insufficient-attestations',
+  'propose',
+  'governance-signal',
+  'vote-offenses',
+  'execute-slash',
+] as const;
+
+export type Action = (typeof Actions)[number];
+
+type GovernanceSignalAction = Extract<Action, 'governance-signal'>;
+
+// Sorting for actions such that invalidations go before proposals, and proposals go before votes
+export const compareActions = (a: Action, b: Action) => Actions.indexOf(a) - Actions.indexOf(b);
 
-type GetSlashPayloadCallBack = (slotNumber: bigint) => Promise<EthAddress | undefined>;
+export type InvalidateCheckpointRequest = {
+  request: L1TxRequest;
+  reason: 'invalid-attestation' | 'insufficient-attestations';
+  gasUsed: bigint;
+  checkpointNumber: CheckpointNumber;
+  forcePendingCheckpointNumber: CheckpointNumber;
+  /** Archive at the rollback target checkpoint (checkpoint N-1). */
+  lastArchive: Fr;
+};
 
-type Action = 'propose' | 'governance-vote' | 'slashing-vote';
-interface RequestWithExpiry {
+type EnqueueProposeCheckpointOpts = {
+  txTimeoutAt?: Date;
+};
+
+export interface RequestWithExpiry {
   action: Action;
   request: L1TxRequest;
-  lastValidL2Slot: bigint;
-  gasConfig?: L1GasConfig;
+  lastValidL2Slot: SlotNumber;
+  gasConfig?: Pick<L1TxConfig, 'txTimeoutAt' | 'gasLimit'>;
   blobConfig?: L1BlobInputs;
-  onResult?: (
+  /** Gas consumed by validateBlobs; stashed for the bundle simulate at send time. */
+  blobEvaluationGas?: bigint;
+  checkSuccess: (
     request: L1TxRequest,
-    result?: { receipt: TransactionReceipt; gasPrice: GasPrice; stats?: TransactionStats; errorMsg?: string },
-  ) => void;
+    result?: { receipt: TransactionReceipt; stats?: TransactionStats; errorMsg?: string },
+  ) => boolean;
 }
 
 export class SequencerPublisher {
   private interrupted = false;
   private metrics: SequencerPublisherMetrics;
-  private epochCache: EpochCache;
-  private forwarderContract: ForwarderContract;
-
-  protected governanceLog = createLogger('sequencer:publisher:governance');
-  protected governanceProposerAddress?: EthAddress;
-  private governancePayload: EthAddress = EthAddress.ZERO;
+  private bundleSimulator: SequencerBundleSimulator;
+  public epochCache: EpochCache;
+  private failedTxStore?: Promise<L1TxFailedStore | undefined>;
 
-  protected slashingLog = createLogger('sequencer:publisher:slashing');
-  protected slashingProposerAddress?: EthAddress;
-  private getSlashPayload?: GetSlashPayloadCallBack = undefined;
+  /**
+   * ABI used to decode raw revert payloads from dropped bundle entries when the original
+   * request did not carry an abi (e.g. the propose request). Merges every contract the
+   * publisher can route to so any of their custom errors decode against it.
+   */
+  private readonly revertDecoderAbi: Abi = mergeAbis([RollupAbi, SlashingProposerAbi, EmpireBaseAbi, ErrorsAbi]);
 
-  private myLastVotes: Record<VoteType, bigint> = {
-    [VoteType.GOVERNANCE]: 0n,
-    [VoteType.SLASHING]: 0n,
-  };
+  protected lastActions: Partial<Record<Action, SlotNumber>> = {};
 
-  protected log = createLogger('sequencer:publisher');
+  protected log: Logger;
   protected ethereumSlotDuration: bigint;
+  protected aztecSlotDuration: bigint;
+
+  /** Date provider for wall-clock time. */
+  private readonly dateProvider: DateProvider;
+
+  private blobClient: BlobClientInterface;
 
-  private blobSinkClient: BlobSinkClientInterface;
-  // @note - with blobs, the below estimate seems too large.
-  // Total used for full block from int_l1_pub e2e test: 1m (of which 86k is 1x blob)
-  // Total used for emptier block from above test: 429k (of which 84k is 1x blob)
-  public static PROPOSE_GAS_GUESS: bigint = 12_000_000n;
+  /** Optional callback to obtain a replacement publisher when the current one fails to send. */
+  private getNextPublisher?: (excludeAddresses: EthAddress[]) => Promise<L1TxUtils | undefined>;
 
-  public l1TxUtils: L1TxUtilsWithBlobs;
+  /** L1 fee analyzer for fisherman mode */
+  private l1FeeAnalyzer?: L1FeeAnalyzer;
+
+  /** Fee asset price oracle for computing price modifiers from Uniswap V4 */
+  private feeAssetPriceOracle: FeeAssetPriceOracle;
+
+  /** Interruptible sleep used by sendRequestsAt to wait until a target timestamp. */
+  private readonly interruptibleSleep = new InterruptibleSleep();
+
+  public l1TxUtils: L1TxUtils;
   public rollupContract: RollupContract;
   public govProposerContract: GovernanceProposerContract;
-  public slashingProposerContract: SlashingProposerContract;
+  public slashingProposerContract: SlashingProposerContract | undefined;
+
+  public readonly tracer: Tracer;
 
   protected requests: RequestWithExpiry[] = [];
 
   constructor(
-    config: TxSenderConfig & PublisherConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>,
+    private config: Pick<SequencerPublisherConfig, 'fishermanMode' | 'l1TxFailedStore'> &
+      Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration'> & { l1ChainId: number },
     deps: {
       telemetry?: TelemetryClient;
-      blobSinkClient?: BlobSinkClientInterface;
-      forwarderContract: ForwarderContract;
-      l1TxUtils: L1TxUtilsWithBlobs;
+      blobClient: BlobClientInterface;
+      l1TxUtils: L1TxUtils;
       rollupContract: RollupContract;
-      slashingProposerContract: SlashingProposerContract;
+      slashingProposerContract: SlashingProposerContract | undefined;
       governanceProposerContract: GovernanceProposerContract;
       epochCache: EpochCache;
+      dateProvider: DateProvider;
+      metrics: SequencerPublisherMetrics;
+      lastActions: Partial<Record<Action, SlotNumber>>;
+      log?: Logger;
+      getNextPublisher?: (excludeAddresses: EthAddress[]) => Promise<L1TxUtils | undefined>;
     },
   ) {
+    this.log = deps.log ?? createLogger('sequencer:publisher');
     this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
+    this.aztecSlotDuration = BigInt(config.aztecSlotDuration);
+    this.dateProvider = deps.dateProvider;
     this.epochCache = deps.epochCache;
+    this.lastActions = deps.lastActions;
 
-    this.blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
+    this.blobClient = deps.blobClient;
+    this.dateProvider = deps.dateProvider;
 
     const telemetry = deps.telemetry ?? getTelemetryClient();
-    this.metrics = new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
+    this.metrics = deps.metrics ?? new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
+    this.tracer = telemetry.getTracer('SequencerPublisher');
     this.l1TxUtils = deps.l1TxUtils;
+    this.getNextPublisher = deps.getNextPublisher;
 
     this.rollupContract = deps.rollupContract;
-    this.forwarderContract = deps.forwarderContract;
 
     this.govProposerContract = deps.governanceProposerContract;
     this.slashingProposerContract = deps.slashingProposerContract;
+
+    this.rollupContract.listenToSlasherChanged(async () => {
+      this.log.info('Slashing proposer changed');
+      const newSlashingProposer = await this.rollupContract.getSlashingProposer();
+      this.slashingProposerContract = newSlashingProposer;
+    });
+    // Initialize L1 fee analyzer for fisherman mode
+    if (config.fishermanMode) {
+      this.l1FeeAnalyzer = new L1FeeAnalyzer(
+        this.l1TxUtils.client,
+        deps.dateProvider,
+        this.log.createChild('fee-analyzer'),
+      );
+    }
+
+    // Initialize fee asset price oracle
+    this.feeAssetPriceOracle = new FeeAssetPriceOracle(
+      this.l1TxUtils.client,
+      this.rollupContract,
+      this.log.createChild('price-oracle'),
+    );
+
+    // Initialize failed L1 tx store (optional, for test networks)
+    this.failedTxStore = createL1TxFailedStore(config.l1TxFailedStore, this.log);
+
+    this.bundleSimulator = new SequencerBundleSimulator({
+      getL1TxUtils: () => this.l1TxUtils,
+      rollupContract: this.rollupContract,
+      epochCache: this.epochCache,
+      log: this.log.createChild('bundle-simulator'),
+    });
   }
 
-  public registerSlashPayloadGetter(callback: GetSlashPayloadCallBack) {
-    this.getSlashPayload = callback;
+  /**
+   * Backs up a failed L1 transaction to the configured store for debugging.
+   * Does nothing if no store is configured.
+   */
+  private backupFailedTx(failedTx: Omit<FailedL1Tx, 'timestamp'>): void {
+    if (!this.failedTxStore) {
+      return;
+    }
+
+    const tx: FailedL1Tx = {
+      ...failedTx,
+      timestamp: Date.now(),
+    };
+
+    // Fire and forget - don't block on backup
+    void this.failedTxStore
+      .then(store => store?.saveFailedTx(tx))
+      .catch(err => {
+        this.log.warn(`Failed to backup failed L1 tx to store`, err);
+      });
   }
 
-  public getForwarderAddress() {
-    return EthAddress.fromString(this.forwarderContract.getAddress());
+  public getRollupContract(): RollupContract {
+    return this.rollupContract;
   }
 
-  public getSenderAddress() {
-    return EthAddress.fromString(this.l1TxUtils.getSenderAddress());
+  /**
+   * Gets the fee asset price modifier from the oracle.
+   *
+   * @param predictedParentEthPerFeeAssetE12 - Optional predicted parent eth-per-fee-asset (E12).
+   *   Pipelined proposers should pass the value from the predicted parent fee header so the
+   *   modifier matches the parent L1 will use when applying it.
+   * @returns The fee asset price modifier in basis points, or 0n if the oracle query fails.
+   */
+  public getFeeAssetPriceModifier(predictedParentEthPerFeeAssetE12?: bigint): Promise<bigint> {
+    return this.feeAssetPriceOracle.computePriceModifier(predictedParentEthPerFeeAssetE12);
   }
 
-  public getGovernancePayload() {
-    return this.governancePayload;
+  public getSenderAddress() {
+    return this.l1TxUtils.getSenderAddress();
   }
 
-  public setGovernancePayload(payload: EthAddress) {
-    this.governancePayload = payload;
+  /**
+   * Gets the L1 fee analyzer instance (only available in fisherman mode)
+   */
+  public getL1FeeAnalyzer(): L1FeeAnalyzer | undefined {
+    return this.l1FeeAnalyzer;
   }
 
   public addRequest(request: RequestWithExpiry) {
     this.requests.push(request);
   }
 
-  public getCurrentL2Slot(): bigint {
-    return this.epochCache.getEpochAndSlotNow().slot;
+  public getCurrentL2Slot(): SlotNumber {
+    return this.epochCache.getSlotNow();
+  }
+
+  /**
+   * Clears all pending requests without sending them.
+   */
+  public clearPendingRequests(): void {
+    const count = this.requests.length;
+    this.requests = [];
+    if (count > 0) {
+      this.log.debug(`Cleared ${count} pending request(s)`);
+    }
+  }
+
+  /**
+   * Analyzes L1 fees for the pending requests without sending them.
+   * This is used in fisherman mode to validate fee calculations.
+   * @param l2SlotNumber - The L2 slot number for this analysis
+   * @param onComplete - Optional callback to invoke when analysis completes (after block is mined)
+   * @returns The analysis result (incomplete until block mines), or undefined if no requests
+   */
+  public async analyzeL1Fees(
+    l2SlotNumber: SlotNumber,
+    onComplete?: (analysis: L1FeeAnalysisResult) => void,
+  ): Promise<L1FeeAnalysisResult | undefined> {
+    if (!this.l1FeeAnalyzer) {
+      this.log.warn('L1 fee analyzer not available (not in fisherman mode)');
+      return undefined;
+    }
+
+    const requestsToAnalyze = [...this.requests];
+    if (requestsToAnalyze.length === 0) {
+      this.log.debug('No requests to analyze for L1 fees');
+      return undefined;
+    }
+
+    // Extract blob config from requests (if any)
+    const blobConfigs = requestsToAnalyze.filter(request => request.blobConfig).map(request => request.blobConfig);
+    const blobConfig = blobConfigs[0];
+
+    // Get gas configs
+    const gasConfigs = requestsToAnalyze.filter(request => request.gasConfig).map(request => request.gasConfig);
+    const gasLimits = gasConfigs.map(g => g?.gasLimit).filter((g): g is bigint => g !== undefined);
+    const gasLimit = gasLimits.length > 0 ? gasLimits.reduce((sum, g) => sum + g, 0n) : 0n;
+
+    // Get the transaction requests
+    const l1Requests = requestsToAnalyze.map(r => r.request);
+
+    // Start the analysis
+    const analysisId = await this.l1FeeAnalyzer.startAnalysis(
+      l2SlotNumber,
+      gasLimit > 0n ? gasLimit : MAX_L1_TX_LIMIT,
+      l1Requests,
+      blobConfig,
+      onComplete,
+    );
+
+    this.log.info('Started L1 fee analysis', {
+      analysisId,
+      l2SlotNumber: l2SlotNumber.toString(),
+      requestCount: requestsToAnalyze.length,
+      hasBlobConfig: !!blobConfig,
+      gasLimit: gasLimit.toString(),
+      actions: requestsToAnalyze.map(r => r.action),
+    });
+
+    // Return the analysis result (will be incomplete until block mines)
+    return this.l1FeeAnalyzer.getAnalysis(analysisId);
   }
 
   /**
    * Sends all requests that are still valid.
+   * @param targetSlot - The target L2 slot for this send. When provided (the production path, via
+   *   sendRequestsAt), it is threaded into bundleSimulate so the block.timestamp override matches
+   *   the slot the propose is built for. When omitted, falls back to getCurrentL2Slot() for the
+   *   AutomineSequencer, which publishes synchronously within the current slot.
    * @returns one of:
    * - A receipt and stats if the tx succeeded
    * - a receipt and errorMsg if it failed on L1
    * - undefined if no valid requests are found OR the tx failed to send.
    */
-  public async sendRequests() {
+  @trackSpan('SequencerPublisher.sendRequests')
+  public async sendRequests(targetSlot?: SlotNumber): Promise<SendRequestsResult | undefined> {
     const requestsToProcess = [...this.requests];
     this.requests = [];
-    if (this.interrupted) {
+
+    if (this.interrupted || requestsToProcess.length === 0) {
       return undefined;
     }
-    const currentL2Slot = this.getCurrentL2Slot();
-    this.log.debug(`Current L2 slot: ${currentL2Slot}`);
+    const currentL2Slot = targetSlot ?? this.getCurrentL2Slot();
+    this.log.debug(`Sending requests on L2 slot ${currentL2Slot}`);
     const validRequests = requestsToProcess.filter(request => request.lastValidL2Slot >= currentL2Slot);
+    const expiredActions = requestsToProcess
+      .filter(request => request.lastValidL2Slot < currentL2Slot)
+      .map(x => x.action);
 
     if (validRequests.length !== requestsToProcess.length) {
       this.log.warn(`Some requests were expired for slot ${currentL2Slot}`, {
@@ -198,69 +443,262 @@ export class SequencerPublisher {
       return undefined;
     }
 
-    // @note - we can only have one gas config and one blob config per bundle
-    // find requests with gas and blob configs
-    // See https://github.com/AztecProtocol/aztec-packages/issues/11513
-    const gasConfigs = requestsToProcess.filter(request => request.gasConfig);
-    const blobConfigs = requestsToProcess.filter(request => request.blobConfig);
+    // Collect earliest txTimeoutAt across all requests.
+    const gasConfigs = validRequests.filter(request => request.gasConfig).map(request => request.gasConfig);
+    const txTimeoutAts = gasConfigs.map(g => g?.txTimeoutAt).filter((g): g is Date => g !== undefined);
+    const txTimeoutAt = txTimeoutAts.length > 0 ? new Date(Math.min(...txTimeoutAts.map(g => g.getTime()))) : undefined;
 
-    if (gasConfigs.length > 1 || blobConfigs.length > 1) {
-      throw new Error('Multiple gas or blob configs found');
-    }
-
-    const gasConfig = gasConfigs[0]?.gasConfig;
-    const blobConfig = blobConfigs[0]?.blobConfig;
+    // Sort the requests so that proposals always go first
+    // This ensures the committee gets precomputed correctly
+    validRequests.sort((a, b) => compareActions(a.action, b.action));
 
     try {
+      // Bundle-level eth_simulateV1: filters out entries that revert and derives the gasLimit.
+      const bundleResult = await this.bundleSimulator.simulate(validRequests, currentL2Slot);
+
+      if (bundleResult.kind === 'aborted') {
+        this.logDroppedInSim(bundleResult.droppedRequests);
+        void this.backupDroppedInSim(bundleResult.droppedRequests);
+        return undefined;
+      }
+
+      const { requests, droppedRequests, gasLimit } =
+        bundleResult.kind === 'fallback'
+          ? {
+              requests: bundleResult.requests,
+              droppedRequests: bundleResult.droppedRequests,
+              gasLimit: MAX_L1_TX_LIMIT,
+            }
+          : bundleResult;
+
+      this.logDroppedInSim(droppedRequests);
+
+      // Compute blobConfig from survivors (not original validRequests) so that if the propose
+      // entry was dropped by bundleSimulate we don't attach a blob-typed config to a non-blob tx.
+      const [blobConfig] = requests.filter(r => r.blobConfig).map(r => r.blobConfig);
+      const txConfig: RequestWithExpiry['gasConfig'] = { gasLimit, txTimeoutAt };
+
       this.log.debug('Forwarding transactions', {
-        validRequests: validRequests.map(request => request.action),
+        requests: requests.map(request => request.action),
+        txConfig,
       });
-      const result = await this.forwarderContract.forward(
-        validRequests.map(request => request.request),
-        this.l1TxUtils,
-        gasConfig,
-        blobConfig,
-        this.log,
-      );
-      this.callbackBundledTransactions(validRequests, result);
-      return result;
+      const result = await this.forwardWithPublisherRotation(requests, txConfig, blobConfig);
+      if (result === undefined) {
+        return undefined;
+      }
+      const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(requests, result);
+      const allFailedActions = [...failedActions, ...droppedRequests.map(d => d.request.action)];
+      return {
+        result,
+        expiredActions,
+        sentActions: requests.map(x => x.action),
+        successfulActions,
+        failedActions: allFailedActions,
+      };
     } catch (err) {
       const viemError = formatViemError(err);
       this.log.error(`Failed to publish bundled transactions`, viemError);
       return undefined;
     } finally {
       try {
-        this.metrics.recordSenderBalance(await this.l1TxUtils.getSenderBalance(), this.l1TxUtils.getSenderAddress());
+        this.metrics.recordSenderBalance(
+          await this.l1TxUtils.getSenderBalance(),
+          this.l1TxUtils.getSenderAddress().toString(),
+        );
       } catch (err) {
         this.log.warn(`Failed to record balance after sending tx: ${err}`);
       }
     }
   }
 
+  /** Logs entries dropped by bundle simulation as warnings on the publisher's logger. */
+  private logDroppedInSim(dropped: DroppedRequest[]): void {
+    for (const drop of dropped) {
+      const revertReasonDecoded = drop.revertReason ?? tryDecodeRevertReason(drop.returnData, this.revertDecoderAbi);
+      this.log.warn('Bundle entry dropped: action reverted in sim', {
+        action: drop.request.action,
+        revertReason: revertReasonDecoded ?? drop.returnData,
+        revertReasonDecoded,
+        returnData: drop.returnData,
+      });
+    }
+  }
+
+  /** Backs up entries dropped by bundle simulation, one record per dropped action. */
+  private async backupDroppedInSim(dropped: DroppedRequest[]): Promise<void> {
+    if (dropped.length === 0) {
+      return;
+    }
+    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+    for (const { request: req } of dropped) {
+      this.backupFailedTx({
+        id: keccak256(req.request.data!),
+        failureType: 'simulation',
+        request: { to: req.request.to! as Hex, data: req.request.data! },
+        l1BlockNumber: l1BlockNumber.toString(),
+        error: { message: 'Bundle entry dropped: action reverted in sim' },
+        context: {
+          actions: [req.action],
+          sender: this.getSenderAddress().toString(),
+        },
+      });
+    }
+  }
+
+  /**
+   * Forwards transactions via Multicall3, rotating to the next available publisher if a send
+   * failure occurs (i.e. the tx never reached the chain).
+   * On-chain reverts and simulation errors are returned as-is without rotation.
+   */
+  private async forwardWithPublisherRotation(
+    validRequests: RequestWithExpiry[],
+    txConfig: RequestWithExpiry['gasConfig'],
+    blobConfig: L1BlobInputs | undefined,
+  ) {
+    if (!txConfig?.gasLimit) {
+      throw new Error('gasLimit is required for bundled transactions');
+    }
+    const txConfigWithGasLimit = txConfig as L1TxConfig & { gasLimit: bigint };
+
+    const triedAddresses: EthAddress[] = [];
+    let currentPublisher = this.l1TxUtils;
+
+    while (true) {
+      if (txConfig.txTimeoutAt && new Date() > txConfig.txTimeoutAt) {
+        this.log.warn(`Tx timeout (${txConfig.txTimeoutAt.toISOString()}) elapsed; stopping publisher rotation`, {
+          triedAddresses: triedAddresses.map(a => a.toString()),
+        });
+        return undefined;
+      }
+      triedAddresses.push(currentPublisher.getSenderAddress());
+
+      try {
+        const result = await Multicall3.forward(
+          validRequests.map(r => r.request),
+          currentPublisher,
+          txConfigWithGasLimit,
+          blobConfig,
+          { gasLimitRequired: true },
+        );
+        this.l1TxUtils = currentPublisher;
+        return result;
+      } catch (err) {
+        if (err instanceof TimeoutError) {
+          throw err;
+        }
+        if (err instanceof MulticallForwarderRevertedError) {
+          this.log.error('Forwarder transaction reverted on-chain; not rotating publisher', err, {
+            transactionHash: err.receipt.transactionHash,
+          });
+          return undefined;
+        }
+        const viemError = formatViemError(err);
+        if (!this.getNextPublisher) {
+          this.log.error('Failed to publish bundled transactions', viemError);
+          return undefined;
+        }
+        this.log.warn(
+          `Publisher ${currentPublisher.getSenderAddress()} failed to send, rotating to next publisher`,
+          viemError,
+        );
+        const nextPublisher = await this.getNextPublisher([...triedAddresses]);
+        if (!nextPublisher) {
+          this.log.error(
+            `All available publishers exhausted (tried ${triedAddresses.length}), failed to publish bundled transactions`,
+            viemError,
+            { triedAddresses: triedAddresses.map(a => a.toString()) },
+          );
+          return undefined;
+        }
+        currentPublisher = nextPublisher;
+      }
+    }
+  }
+
+  /*
+   * Schedules sending all enqueued requests at (or after) the start of the given L2 slot.
+   * Sleeps until one L1 slot before the L2 slot boundary so the tx has a chance of being
+   * picked up by the first L1 block of the L2 slot.
+   * NB: there is a known correctness risk — being included in the L1 block right before the
+   * L2 slot starts would revert propose with HeaderLib__InvalidSlotNumber.
+   * Uses InterruptibleSleep so it can be cancelled via interrupt().
+   */
+  public async sendRequestsAt(targetSlot: SlotNumber): Promise<SendRequestsResult | undefined> {
+    const l1Constants = this.epochCache.getL1Constants();
+    // Start of the target L2 slot, in ms (getTimestampForSlot returns seconds).
+    const startOfTargetSlotMs = Number(getTimestampForSlot(targetSlot, l1Constants)) * 1000;
+    // Aim to be in the mempool one L1 slot before the L2 slot starts, so we have a chance of
+    // being picked up by the first L1 block of the L2 slot.
+    const submitAfterMs = startOfTargetSlotMs - Number(this.ethereumSlotDuration) * 1000;
+    const sleepMs = submitAfterMs - this.dateProvider.now();
+    if (sleepMs > 0) {
+      this.log.debug(`Sleeping ${sleepMs}ms before sending requests`, {
+        targetSlot,
+        submitAfterMs,
+      });
+      await this.interruptibleSleep.sleep(sleepMs);
+    }
+    if (this.interrupted) {
+      return undefined;
+    }
+    return this.sendRequests(targetSlot);
+  }
+
   private callbackBundledTransactions(
     requests: RequestWithExpiry[],
-    result?: { receipt: TransactionReceipt; gasPrice: GasPrice },
+    result: { receipt: TransactionReceipt; multicallData: Hex },
   ) {
-    const success = result?.receipt.status === 'success';
-    const logger = success ? this.log.info : this.log.error;
+    const actionsListStr = requests.map(r => r.action).join(', ');
+    this.log.verbose(`Published bundled transactions (${actionsListStr})`, {
+      result,
+      requests: requests.map(r => ({
+        ...r,
+        // Avoid logging large blob data
+        blobConfig: r.blobConfig
+          ? { ...r.blobConfig, blobs: r.blobConfig.blobs.map(b => ({ size: trimmedBytesLength(b) })) }
+          : undefined,
+      })),
+    });
+    const successfulActions: Action[] = [];
+    const failedActions: Action[] = [];
     for (const request of requests) {
-      logger(`Bundled [${request.action}] transaction [${success ? 'succeeded' : 'failed'}]`);
-      request.onResult?.(request.request, result);
+      if (request.checkSuccess(request.request, result)) {
+        successfulActions.push(request.action);
+      } else {
+        failedActions.push(request.action);
+      }
     }
+    return { successfulActions, failedActions };
   }
 
   /**
-   * @notice  Will call `canProposeAtNextEthBlock` to make sure that it is possible to propose
+   * @notice  Will call `canProposeAt` to make sure that it is possible to propose
    * @param tipArchive - The archive to check
    * @returns The slot and block number if it is possible to propose, undefined otherwise
    */
-  public canProposeAtNextEthBlock(tipArchive: Buffer) {
-    const ignoredErrors = ['SlotAlreadyInChain', 'InvalidProposer', 'InvalidArchive'];
+  public async canProposeAt(tipArchive: Fr, msgSender: EthAddress, simulationOverridesPlan?: SimulationOverridesPlan) {
+    // TODO: #14291 - should loop through multiple keys to check if any of them can propose
+    // These errors are expected when we cannot actually propose right now — usually because our
+    // local view of the chain is ahead of L1 (proposed parent hasn't landed yet, or someone
+    // else has just landed the slot, or the archive override doesn't match). We log a warn and
+    // skip the proposal; we do NOT treat these as bugs.
+    const expectedErrors = ['SlotAlreadyInChain', 'InvalidProposer', 'InvalidArchive'];
+
+    const slotOffset = this.aztecSlotDuration;
+    const nextL1SlotTs = this.getNextL1SlotTimestamp() + slotOffset;
+
     return this.rollupContract
-      .canProposeAtNextEthBlock(tipArchive, this.getForwarderAddress().toString(), this.ethereumSlotDuration)
+      .canProposeAt(
+        tipArchive.toBuffer(),
+        msgSender.toString(),
+        nextL1SlotTs,
+        await buildSimulationOverridesStateOverride(this.rollupContract, simulationOverridesPlan),
+      )
       .catch(err => {
-        if (err instanceof FormattedViemError && ignoredErrors.find(e => err.message.includes(e))) {
-          this.log.debug(err.message);
+        if (err instanceof FormattedViemError && expectedErrors.find(e => err.message.includes(e))) {
+          this.log.warn(`Failed canProposeAtTime check with ${expectedErrors.find(e => err.message.includes(e))}`, {
+            error: err.message,
+          });
         } else {
           this.log.error(err.name, err);
         }
@@ -269,161 +707,484 @@ export class SequencerPublisher {
   }
 
   /**
-   * @notice  Will call `validateHeader` to make sure that it is possible to propose
-   *
-   * @dev     Throws if unable to propose
-   *
-   * @param header - The header to propose
-   * @param digest - The digest that attestations are signing over
-   *
+   * @notice  Will simulate `validateHeader` to make sure that the block header is valid
+   * @dev     This is a convenience function that can be used by the sequencer to validate a "partial" header.
+   *          It will throw if the block header is invalid.
+   * @param header - The block header to validate
    */
-  public async validateBlockForSubmission(
-    header: BlockHeader,
-    attestationData: { digest: Buffer; signatures: Signature[] } = {
-      digest: Buffer.alloc(32),
-      signatures: [],
-    },
-  ): Promise<bigint> {
-    const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
-
-    const formattedSignatures = attestationData.signatures.map(attest => attest.toViemSignature());
-    const flags = { ignoreDA: true, ignoreSignatures: formattedSignatures.length == 0 };
+  @trackSpan('SequencerPublisher.validateBlockHeader')
+  public async validateBlockHeader(
+    header: CheckpointHeader,
+    simulationOverridesPlan?: SimulationOverridesPlan,
+  ): Promise<void> {
+    const flags = { ignoreDA: true, ignoreSignatures: true };
 
     const args = [
-      `0x${header.toBuffer().toString('hex')}`,
-      formattedSignatures,
-      `0x${attestationData.digest.toString('hex')}`,
-      ts,
-      `0x${header.contentCommitment.blobsHash.toString('hex')}`,
+      header.toViem(),
+      CommitteeAttestationsAndSigners.packAttestations([]),
+      [], // no signers
+      Signature.empty().toViemSignature(),
+      `0x${'0'.repeat(64)}`, // 32 empty bytes
+      header.blobsHash.toString(),
       flags,
     ] as const;
 
-    await this.rollupContract.validateHeader(args, this.getForwarderAddress().toString());
-    return ts;
+    const l1Constants = this.epochCache.getL1Constants();
+    const ts = getLastL1SlotTimestampForL2Slot(header.slotNumber, l1Constants);
+    const stateOverrides = await buildSimulationOverridesStateOverride(this.rollupContract, simulationOverridesPlan);
+    let balance = 0n;
+    if (this.config.fishermanMode) {
+      // In fisherman mode, we can't know where the proposer is publishing from
+      // so we just add sufficient balance to the multicall3 address
+      balance = 10n * WEI_CONST * WEI_CONST; // 10 ETH
+    } else {
+      balance = await this.l1TxUtils.getSenderBalance();
+    }
+    stateOverrides.push({
+      address: MULTI_CALL_3_ADDRESS,
+      balance,
+    });
+
+    await this.l1TxUtils.simulate(
+      {
+        to: this.rollupContract.address,
+        data: encodeFunctionData({ abi: RollupAbi, functionName: 'validateHeaderWithAttestations', args }),
+        from: MULTI_CALL_3_ADDRESS,
+      },
+      { time: ts },
+      stateOverrides,
+    );
+    this.log.debug(`Simulated validateHeader`);
   }
 
-  public async getCurrentEpochCommittee(): Promise<EthAddress[]> {
-    const committee = await this.rollupContract.getCurrentEpochCommittee();
-    return committee.map(EthAddress.fromString);
+  /**
+   * Simulate making a call to invalidate a checkpoint with invalid attestations. Returns undefined if no need to invalidate.
+   * @param validationResult - The validation result indicating which checkpoint to invalidate (as returned by the archiver)
+   */
+  public async simulateInvalidateCheckpoint(
+    validationResult: ValidateCheckpointResult,
+  ): Promise<InvalidateCheckpointRequest | undefined> {
+    if (validationResult.valid) {
+      return undefined;
+    }
+
+    const { reason, checkpoint } = validationResult;
+    const checkpointNumber = checkpoint.checkpointNumber;
+    const logData = { ...checkpoint, reason };
+
+    const currentCheckpointNumber = await this.rollupContract.getCheckpointNumber();
+    if (currentCheckpointNumber < checkpointNumber) {
+      this.log.verbose(
+        `Skipping checkpoint ${checkpointNumber} invalidation since it has already been removed from the pending chain`,
+        { currentCheckpointNumber, ...logData },
+      );
+      return undefined;
+    }
+
+    const request = this.buildInvalidateCheckpointRequest(validationResult);
+    this.log.debug(`Simulating invalidate checkpoint ${checkpointNumber}`, { ...logData, request });
+
+    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+
+    try {
+      const { gasUsed } = await this.l1TxUtils.simulate(
+        request,
+        undefined,
+        undefined,
+        mergeAbis([request.abi ?? [], ErrorsAbi]),
+      );
+      this.log.verbose(`Simulation for invalidate checkpoint ${checkpointNumber} succeeded`, {
+        ...logData,
+        request,
+        gasUsed,
+      });
+
+      return {
+        request,
+        gasUsed,
+        checkpointNumber,
+        forcePendingCheckpointNumber: CheckpointNumber(checkpointNumber - 1),
+        lastArchive: validationResult.checkpoint.lastArchive,
+        reason,
+      };
+    } catch (err) {
+      const viemError = formatViemError(err);
+
+      // If the error is due to the checkpoint not being in the pending chain, and it was indeed removed by someone else,
+      // we can safely ignore it and return undefined so we go ahead with checkpoint building.
+      if (viemError.message?.includes('Rollup__CheckpointNotInPendingChain')) {
+        this.log.verbose(
+          `Simulation for invalidate checkpoint ${checkpointNumber} failed due to checkpoint not being in pending chain`,
+          { ...logData, request, error: viemError.message },
+        );
+        const latestProposedCheckpointNumber = await this.rollupContract.getCheckpointNumber();
+        if (latestProposedCheckpointNumber < checkpointNumber) {
+          this.log.verbose(`Checkpoint ${checkpointNumber} has already been invalidated`, { ...logData });
+          return undefined;
+        } else {
+          this.log.error(
+            `Simulation for invalidate checkpoint ${checkpointNumber} failed and it is still in pending chain`,
+            viemError,
+            logData,
+          );
+          throw new Error(
+            `Failed to simulate invalidate checkpoint ${checkpointNumber} while it is still in pending chain`,
+            {
+              cause: viemError,
+            },
+          );
+        }
+      }
+
+      // Otherwise, throw. We cannot build the next checkpoint if we cannot invalidate the previous one.
+      this.log.error(`Simulation for invalidate checkpoint ${checkpointNumber} failed`, viemError, logData);
+      this.backupFailedTx({
+        id: keccak256(request.data!),
+        failureType: 'simulation',
+        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
+        l1BlockNumber: l1BlockNumber.toString(),
+        error: { message: viemError.message, name: viemError.name },
+        context: {
+          actions: [`invalidate-${reason}`],
+          checkpointNumber,
+          sender: this.getSenderAddress().toString(),
+        },
+      });
+      throw new Error(`Failed to simulate invalidate checkpoint ${checkpointNumber}`, { cause: viemError });
+    }
+  }
+
+  private buildInvalidateCheckpointRequest(validationResult: ValidateCheckpointResult) {
+    if (validationResult.valid) {
+      throw new Error('Cannot invalidate a valid checkpoint');
+    }
+
+    const { checkpoint, committee, reason } = validationResult;
+    const logData = { ...checkpoint, reason };
+    this.log.debug(`Building invalidate checkpoint ${checkpoint.checkpointNumber} request`, logData);
+
+    const attestationsAndSigners = CommitteeAttestationsAndSigners.packAttestations(validationResult.attestations);
+
+    if (reason === 'invalid-attestation') {
+      return this.rollupContract.buildInvalidateBadAttestationRequest(
+        checkpoint.checkpointNumber,
+        attestationsAndSigners,
+        committee,
+        validationResult.invalidIndex,
+      );
+    } else if (reason === 'insufficient-attestations') {
+      return this.rollupContract.buildInvalidateInsufficientAttestationsRequest(
+        checkpoint.checkpointNumber,
+        attestationsAndSigners,
+        committee,
+      );
+    } else {
+      const _: never = reason;
+      throw new Error(`Unknown reason for invalidation`);
+    }
   }
 
-  private async enqueueCastVoteHelper(
-    slotNumber: bigint,
-    timestamp: bigint,
-    voteType: VoteType,
+  private async enqueueCastSignalHelper(
+    slotNumber: SlotNumber,
+    signalType: GovernanceSignalAction,
     payload: EthAddress,
-    base: IEmpireBase,
+    base: GovernanceProposerContract,
+    signerAddress: EthAddress,
+    signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>,
   ): Promise<boolean> {
-    if (this.myLastVotes[voteType] >= slotNumber) {
+    if (this.lastActions[signalType] && this.lastActions[signalType] === slotNumber) {
+      this.log.debug(`Skipping duplicate vote cast signal ${signalType} for slot ${slotNumber}`);
       return false;
     }
     if (payload.equals(EthAddress.ZERO)) {
       return false;
     }
+    if (signerAddress.equals(EthAddress.ZERO)) {
+      this.log.warn(`Cannot enqueue vote cast signal ${signalType} for address zero at slot ${slotNumber}`);
+      return false;
+    }
     const round = await base.computeRound(slotNumber);
-    const [proposer, roundInfo] = await Promise.all([
-      this.rollupContract.getProposerAt(timestamp),
-      base.getRoundInfo(this.rollupContract.address, round),
-    ]);
+    const roundInfo = await base.getRoundInfo(this.rollupContract.address, round);
+
+    if (roundInfo.quorumReached) {
+      return false;
+    }
 
-    if (proposer.toLowerCase() !== this.getForwarderAddress().toString().toLowerCase()) {
+    if (roundInfo.lastSignalSlot >= slotNumber) {
       return false;
     }
-    if (roundInfo.lastVote >= slotNumber) {
+
+    if (await base.isPayloadEmpty(payload)) {
+      this.log.warn(`Skipping vote cast for payload with empty code`);
       return false;
     }
 
-    const cachedLastVote = this.myLastVotes[voteType];
-    this.myLastVotes[voteType] = slotNumber;
+    // Skip signaling if there is already a live (non-terminal) Governance proposal for this
+    // payload. This is intentionally not cached: a previously-live proposal may transition to
+    // a terminal state (Dropped/Rejected/Expired/Executed), at which point we may want to re-signal
+    // the same payload in a future round.
+    let proposed = false;
+    try {
+      proposed = await base.hasActiveProposalWithPayload(payload.toString());
+    } catch (err) {
+      // We deliberately swallow the error and proceed to signal. Failing closed (skipping the
+      // signal) on transient RPC errors would let a flaky L1 endpoint silence governance
+      // participation entirely; failing open at worst produces a duplicate signal that the
+      // contract will simply count alongside others in the round.
+      this.log.error(`Failed to check if payload ${payload} was already proposed (signalling anyway)`, err);
+    }
+
+    if (proposed) {
+      this.log.info(`Payload ${payload} has a live governance proposal, stopping signals`);
+      return false;
+    }
+
+    const cachedLastVote = this.lastActions[signalType];
+    this.lastActions[signalType] = slotNumber;
+    const action = signalType;
+
+    const request = await base.createSignalRequestWithSignature(
+      payload.toString(),
+      slotNumber,
+      this.config.l1ChainId,
+      signerAddress.toString(),
+      signer,
+    );
+    this.log.debug(`Created ${action} request with signature`, {
+      request,
+      round,
+      signer: this.l1TxUtils.client.account?.address,
+      lastValidL2Slot: slotNumber,
+    });
 
+    // TODO(palla/slash): All votes (governance and slashing) should txTimeoutAt at the end of the slot.
     this.addRequest({
-      action: voteType === VoteType.GOVERNANCE ? 'governance-vote' : 'slashing-vote',
-      request: base.createVoteRequest(payload.toString()),
+      action,
+      request,
       lastValidL2Slot: slotNumber,
-      onResult: (_request, result) => {
-        if (!result || result.receipt.status !== 'success') {
-          this.myLastVotes[voteType] = cachedLastVote;
+      checkSuccess: (_request, result) => {
+        const success =
+          result &&
+          extractEventSuccess(result.receipt, {
+            address: base.address.toString(),
+            abi: EmpireBaseAbi,
+            eventName: 'SignalCast',
+          });
+
+        const logData = { ...result, slotNumber, round, payload: payload.toString() };
+        if (!success) {
+          this.log.error(
+            `Signaling in ${action} for ${payload} at slot ${slotNumber} in round ${round} failed`,
+            logData,
+          );
+          this.lastActions[signalType] = cachedLastVote;
+          return false;
         } else {
-          this.log.info(`Cast [${voteType}] vote for slot ${slotNumber}`);
+          this.log.info(
+            `Signaling in ${action} for ${payload} at slot ${slotNumber} in round ${round} succeeded`,
+            logData,
+          );
+          return true;
         }
       },
     });
     return true;
   }
 
-  private async getVoteConfig(
-    slotNumber: bigint,
-    voteType: VoteType,
-  ): Promise<{ payload: EthAddress; base: IEmpireBase } | undefined> {
-    if (voteType === VoteType.GOVERNANCE) {
-      return { payload: this.governancePayload, base: this.govProposerContract };
-    } else if (voteType === VoteType.SLASHING) {
-      if (!this.getSlashPayload) {
-        return undefined;
-      }
-      const slashPayload = await this.getSlashPayload(slotNumber);
-      if (!slashPayload) {
-        return undefined;
-      }
-      return { payload: slashPayload, base: this.slashingProposerContract };
-    }
-    throw new Error('Unreachable: Invalid vote type');
-  }
-
   /**
-   * Enqueues a castVote transaction to cast a vote for a given slot number.
-   * @param slotNumber - The slot number to cast a vote for.
-   * @param timestamp - The timestamp of the slot to cast a vote for.
-   * @param voteType - The type of vote to cast.
-   * @returns True if the vote was successfully enqueued, false otherwise.
+   * Enqueues a governance castSignal transaction to cast a signal for a given slot number.
+   * @param slotNumber - The slot number to cast a signal for.
+   * @returns True if the signal was successfully enqueued, false otherwise.
    */
-  public async enqueueCastVote(slotNumber: bigint, timestamp: bigint, voteType: VoteType): Promise<boolean> {
-    const voteConfig = await this.getVoteConfig(slotNumber, voteType);
-    if (!voteConfig) {
+  public enqueueGovernanceCastSignal(
+    governancePayload: EthAddress,
+    slotNumber: SlotNumber,
+    signerAddress: EthAddress,
+    signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>,
+  ): Promise<boolean> {
+    return this.enqueueCastSignalHelper(
+      slotNumber,
+      'governance-signal',
+      governancePayload,
+      this.govProposerContract,
+      signerAddress,
+      signer,
+    );
+  }
+
+  /** Enqueues all slashing actions as returned by the slasher client. */
+  public async enqueueSlashingActions(
+    actions: ProposerSlashAction[],
+    slotNumber: SlotNumber,
+    signerAddress: EthAddress,
+    signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>,
+  ): Promise<boolean> {
+    if (actions.length === 0) {
+      this.log.debug(`No slashing actions to enqueue for slot ${slotNumber}`);
       return false;
     }
-    const { payload, base } = voteConfig;
-    return this.enqueueCastVoteHelper(slotNumber, timestamp, voteType, payload, base);
+
+    for (const action of actions) {
+      switch (action.type) {
+        case 'vote-offenses': {
+          this.log.debug(`Enqueuing slashing vote for ${action.votes.length} votes at slot ${slotNumber}`, {
+            slotNumber,
+            round: action.round,
+            votesCount: action.votes.length,
+            signerAddress,
+          });
+          if (!this.slashingProposerContract) {
+            this.log.error('No slashing proposer contract available');
+            return false;
+          }
+          const votes = bufferToHex(encodeSlashConsensusVotes(action.votes));
+          const request = await this.slashingProposerContract.buildVoteRequestFromSigner(votes, slotNumber, signer);
+          this.enqueueRequest(
+            'vote-offenses',
+            request,
+            {
+              address: this.slashingProposerContract.address.toString(),
+              abi: SlashingProposerAbi,
+              eventName: 'VoteCast',
+            },
+            slotNumber,
+          );
+          break;
+        }
+
+        case 'execute-slash': {
+          this.log.debug(`Enqueuing slash execution for round ${action.round} at slot ${slotNumber}`, {
+            slotNumber,
+            round: action.round,
+            signerAddress,
+          });
+          if (!this.slashingProposerContract) {
+            this.log.error('No slashing proposer contract available');
+            return false;
+          }
+          const executeRequest = this.slashingProposerContract.buildExecuteRoundRequest(
+            action.round,
+            action.committees,
+          );
+          this.enqueueRequest(
+            'execute-slash',
+            executeRequest,
+            {
+              address: this.slashingProposerContract.address.toString(),
+              abi: SlashingProposerAbi,
+              eventName: 'RoundExecuted',
+            },
+            slotNumber,
+          );
+          break;
+        }
+
+        default: {
+          const _: never = action;
+          throw new Error(`Unknown slashing action type: ${(action as ProposerSlashAction).type}`);
+        }
+      }
+    }
+
+    return true;
   }
 
-  /**
-   * Proposes a L2 block on L1.
-   *
-   * @param block - L2 block to propose.
-   * @returns True if the tx has been enqueued, throws otherwise. See #9315
-   */
-  public async enqueueProposeL2Block(
-    block: L2Block,
-    attestations?: Signature[],
-    txHashes?: TxHash[],
-    opts: { txTimeoutAt?: Date } = {},
-  ): Promise<boolean> {
-    const consensusPayload = new ConsensusPayload(block.header, block.archive.root, txHashes ?? []);
+  /** Enqueues a proposal for a checkpoint on L1 */
+  public async enqueueProposeCheckpoint(
+    checkpoint: Checkpoint,
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    attestationsAndSignersSignature: Signature,
+    opts: EnqueueProposeCheckpointOpts = {},
+  ): Promise<void> {
+    const checkpointHeader = checkpoint.header;
 
-    const digest = await getHashedSignaturePayload(consensusPayload, SignatureDomainSeparator.blockAttestation);
+    const blobFields = checkpoint.toBlobFields();
+    const blobs = await getBlobsPerL1Block(blobFields);
 
-    const blobs = await Blob.getBlobs(block.body.toBlobFields());
-    const proposeTxArgs = {
-      header: block.header.toBuffer(),
-      archive: block.archive.root.toBuffer(),
-      blockHash: (await block.header.hash()).toBuffer(),
-      body: block.body.toBuffer(),
+    const proposeTxArgs: L1ProcessArgs = {
+      header: checkpointHeader,
+      archive: checkpoint.archive.root.toBuffer(),
       blobs,
-      attestations,
-      txHashes: txHashes ?? [],
+      attestationsAndSigners,
+      attestationsAndSignersSignature,
+      feeAssetPriceModifier: checkpoint.feeAssetPriceModifier,
     };
 
-    // @note  This will make sure that we are passing the checks for our header ASSUMING that the data is also made available
-    //        This means that we can avoid the simulation issues in later checks.
-    //        By simulation issue, I mean the fact that the block.timestamp is equal to the last block, not the next, which
-    //        make time consistency checks break.
-    const ts = await this.validateBlockForSubmission(block.header, {
-      digest: digest.toBuffer(),
-      signatures: attestations ?? [],
+    this.log.verbose(`Enqueuing checkpoint propose transaction`, {
+      ...checkpoint.toCheckpointInfo(),
+      txTimeoutAt: opts.txTimeoutAt,
+    });
+    await this.addProposeTx(checkpoint, proposeTxArgs, { txTimeoutAt: opts.txTimeoutAt });
+  }
+
+  public enqueueInvalidateCheckpoint(
+    request: InvalidateCheckpointRequest | undefined,
+    opts: { txTimeoutAt?: Date } = {},
+  ) {
+    if (!request) {
+      return;
+    }
+
+    const { gasUsed, checkpointNumber } = request;
+    const logData = { gasUsed, checkpointNumber, opts };
+    this.log.verbose(`Enqueuing invalidate checkpoint request`, logData);
+    this.addRequest({
+      action: `invalidate-by-${request.reason}`,
+      request: request.request,
+      gasConfig: opts.txTimeoutAt ? { txTimeoutAt: opts.txTimeoutAt } : undefined,
+      lastValidL2Slot: SlotNumber(this.getCurrentL2Slot() + 2),
+      checkSuccess: (_req, result) => {
+        const success =
+          result &&
+          extractEventSuccess(result.receipt, {
+            address: this.rollupContract.address,
+            abi: RollupAbi,
+            eventName: 'CheckpointInvalidated',
+          });
+        if (!success) {
+          this.log.warn(`Invalidate checkpoint ${request.checkpointNumber} failed`, { ...result, ...logData });
+        } else {
+          this.log.info(`Invalidate checkpoint ${request.checkpointNumber} succeeded`, { ...result, ...logData });
+        }
+        return !!success;
+      },
     });
+  }
+
+  /**
+   * Dedup-checked enqueue helper for actions that are simulated at bundle-send time rather
+   * than at enqueue time. Validates the (action, slot) dedup key, sets `lastActions`, and
+   * enqueues without a gasLimit so the bundle simulate sets the only gasLimit that matters.
+   */
+  private enqueueRequest(
+    action: Action,
+    request: L1TxRequest,
+    eventOpts: { address: string; abi: Abi; eventName: string },
+    slotNumber: SlotNumber,
+  ): boolean {
+    if (this.lastActions[action] && this.lastActions[action] === slotNumber) {
+      this.log.debug(`Skipping duplicate action ${action} for slot ${slotNumber}`);
+      return false;
+    }
+    const cachedLastActionSlot = this.lastActions[action];
+    this.lastActions[action] = slotNumber;
 
-    this.log.debug(`Submitting propose transaction`);
-    await this.addProposeTx(block, proposeTxArgs, opts, ts);
+    this.log.debug(`Enqueuing ${action}`, { slotNumber });
+    this.addRequest({
+      action,
+      request,
+      lastValidL2Slot: slotNumber,
+      checkSuccess: (_request, result) => {
+        const success = result && extractEventSuccess(result.receipt, eventOpts);
+        if (!success) {
+          this.log.warn(`Action ${action} at ${slotNumber} failed`, { ...result, slotNumber });
+          this.lastActions[action] = cachedLastActionSlot;
+        } else {
+          this.log.info(`Action ${action} at ${slotNumber} succeeded`, { ...result, slotNumber });
+        }
+        return !!success;
+      },
+    });
     return true;
   }
 
@@ -435,6 +1196,7 @@ export class SequencerPublisher {
    */
   public interrupt() {
     this.interrupted = true;
+    this.interruptibleSleep.interrupt();
     this.l1TxUtils.interrupt();
   }
 
@@ -444,114 +1206,104 @@ export class SequencerPublisher {
     this.l1TxUtils.restart();
   }
 
-  private async prepareProposeTx(encodedData: L1ProcessArgs, timestamp: bigint) {
+  private async prepareProposeTx(encodedData: L1ProcessArgs) {
     const kzg = Blob.getViemKzgInstance();
-    const blobInput = Blob.getEthBlobEvaluationInputs(encodedData.blobs);
+    const blobInput = getPrefixedEthBlobCommitments(encodedData.blobs);
     this.log.debug('Validating blob input', { blobInput });
-    const blobEvaluationGas = await this.l1TxUtils
-      .estimateGas(
-        this.l1TxUtils.walletClient.account,
-        {
-          to: this.rollupContract.address,
-          data: encodeFunctionData({
+
+    // Get blob evaluation gas
+    let blobEvaluationGas: bigint;
+    if (this.config.fishermanMode) {
+      // In fisherman mode, we can't estimate blob gas because estimateGas doesn't support state overrides
+      // Use a fixed estimate.
+      blobEvaluationGas = BigInt(encodedData.blobs.length) * 21_000n;
+      this.log.debug(`Using fixed blob evaluation gas estimate in fisherman mode: ${blobEvaluationGas}`);
+    } else {
+      // We call validateBlobs via estimateGas with real blob+kzg sidecars as a consistency check
+      // that our locally-built blob commitments match the blob data. The bundle simulate at send
+      // time uses eth_simulateV1, which cannot carry blob inputs, so the rollup's on-chain blob
+      // check is forced off there — making this the only pre-flight detector of a commitment/data
+      // mismatch. The returned gas estimate is stashed on the request for the bundle path to read.
+      blobEvaluationGas = await this.l1TxUtils
+        .estimateGas(
+          this.getSenderAddress().toString(),
+          {
+            to: this.rollupContract.address,
+            data: encodeFunctionData({
+              abi: RollupAbi,
+              functionName: 'validateBlobs',
+              args: [blobInput],
+            }),
+          },
+          {},
+          {
+            blobs: encodedData.blobs.map(b => b.data),
+            kzg,
+          },
+        )
+        .catch(async err => {
+          const viemError = formatViemError(err);
+          this.log.error(`Failed to validate blobs`, viemError.message, { metaMessages: viemError.metaMessages });
+          const validateBlobsData = encodeFunctionData({
             abi: RollupAbi,
             functionName: 'validateBlobs',
             args: [blobInput],
-          }),
-        },
-        {},
-        {
-          blobs: encodedData.blobs.map(b => b.data),
-          kzg,
-        },
-      )
-      .catch(err => {
-        const { message, metaMessages } = formatViemError(err);
-        this.log.error(`Failed to validate blobs`, message, { metaMessages });
-        throw new Error('Failed to validate blobs');
-      });
+          });
+          const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+          this.backupFailedTx({
+            id: keccak256(validateBlobsData),
+            failureType: 'simulation',
+            request: { to: this.rollupContract.address as Hex, data: validateBlobsData },
+            blobData: encodedData.blobs.map(b => toHex(b.data)) as Hex[],
+            l1BlockNumber: l1BlockNumber.toString(),
+            error: { message: viemError.message, name: viemError.name },
+            context: {
+              actions: ['validate-blobs'],
+              sender: this.getSenderAddress().toString(),
+            },
+          });
+          throw new Error('Failed to validate blobs');
+        });
+    }
+    const signers = encodedData.attestationsAndSigners.getSigners().map(signer => signer.toString());
 
-    const attestations = encodedData.attestations
-      ? encodedData.attestations.map(attest => attest.toViemSignature())
-      : [];
-    const txHashes = encodedData.txHashes ? encodedData.txHashes.map(txHash => txHash.toString()) : [];
     const args = [
       {
-        header: `0x${encodedData.header.toString('hex')}`,
-        archive: `0x${encodedData.archive.toString('hex')}`,
+        header: encodedData.header.toViem(),
+        archive: toHex(encodedData.archive),
         oracleInput: {
-          // We are currently not modifying these. See #9963
-          feeAssetPriceModifier: 0n,
+          feeAssetPriceModifier: encodedData.feeAssetPriceModifier,
         },
-        blockHash: `0x${encodedData.blockHash.toString('hex')}`,
-        txHashes,
       },
-      attestations,
+      encodedData.attestationsAndSigners.getPackedAttestations(),
+      signers,
+      encodedData.attestationsAndSignersSignature.toViemSignature(),
       blobInput,
     ] as const;
 
-    const rollupData = encodeFunctionData({
-      abi: RollupAbi,
-      functionName: 'propose',
-      args,
-    });
+    const rollupData = encodeFunctionData({ abi: RollupAbi, functionName: 'propose', args });
 
-    const forwarderData = encodeFunctionData({
-      abi: ForwarderAbi,
-      functionName: 'forward',
-      args: [[this.rollupContract.address], [rollupData]],
-    });
-
-    const simulationResult = await this.l1TxUtils
-      .simulateGasUsed(
-        {
-          to: this.getForwarderAddress().toString(),
-          data: forwarderData,
-          gas: SequencerPublisher.PROPOSE_GAS_GUESS,
-        },
-        {
-          // @note we add 1n to the timestamp because geth implementation doesn't like simulation timestamp to be equal to the current block timestamp
-          time: timestamp + 1n,
-          // @note reth should have a 30m gas limit per block but throws errors that this tx is beyond limit
-          gasLimit: SequencerPublisher.PROPOSE_GAS_GUESS * 2n,
-        },
-        [
-          {
-            address: this.rollupContract.address,
-            // @note we override checkBlob to false since blobs are not part simulate()
-            stateDiff: [
-              {
-                slot: toHex(RollupContract.checkBlobStorageSlot, true),
-                value: toHex(0n, true),
-              },
-            ],
-          },
-        ],
-        {
-          // @note fallback gas estimate to use if the node doesn't support simulation API
-          fallbackGasEstimate: SequencerPublisher.PROPOSE_GAS_GUESS,
-        },
-      )
-      .catch(err => {
-        const { message, metaMessages } = formatViemError(err);
-        this.log.error(`Failed to simulate gas used`, message, { metaMessages });
-        throw new Error('Failed to simulate gas used');
-      });
-
-    return { args, blobEvaluationGas, rollupData, simulationResult };
+    return { args, blobEvaluationGas, rollupData };
   }
 
   private async addProposeTx(
-    block: L2Block,
+    checkpoint: Checkpoint,
     encodedData: L1ProcessArgs,
-    opts: { txTimeoutAt?: Date } = {},
-    timestamp: bigint,
+    opts: EnqueueProposeCheckpointOpts = {},
   ): Promise<void> {
+    const slot = checkpoint.header.slotNumber;
     const timer = new Timer();
     const kzg = Blob.getViemKzgInstance();
-    const { rollupData, simulationResult, blobEvaluationGas } = await this.prepareProposeTx(encodedData, timestamp);
+    const { rollupData, blobEvaluationGas } = await this.prepareProposeTx(encodedData);
     const startBlock = await this.l1TxUtils.getBlockNumber();
-    const blockHash = await block.hash();
+
+    // Send the blobs to the blob client preemptively. This helps in tests where the sequencer mistakingly thinks that the propose
+    // tx fails but it does get mined. We make sure that the blobs are sent to the blob client regardless of the tx outcome.
+    void Promise.resolve().then(() =>
+      this.blobClient.sendBlobsToFilestore(encodedData.blobs).catch(_err => {
+        this.log.error('Failed to send blobs to blob client');
+      }),
+    );
 
     return this.addRequest({
       action: 'propose',
@@ -559,67 +1311,66 @@ export class SequencerPublisher {
         to: this.rollupContract.address,
         data: rollupData,
       },
-      lastValidL2Slot: block.header.globalVariables.slotNumber.toBigInt(),
-      gasConfig: {
-        ...opts,
-        gasLimit: this.l1TxUtils.bumpGasLimit(simulationResult + blobEvaluationGas),
-      },
+      lastValidL2Slot: checkpoint.header.slotNumber,
+      gasConfig: { txTimeoutAt: opts.txTimeoutAt, gasLimit: undefined },
+      blobEvaluationGas,
       blobConfig: {
         blobs: encodedData.blobs.map(b => b.data),
         kzg,
       },
-      onResult: (request, result) => {
+      checkSuccess: (_request, result) => {
         if (!result) {
-          return;
+          return false;
         }
         const { receipt, stats, errorMsg } = result;
-        if (receipt.status === 'success') {
+        const success = extractEventSuccess(receipt, {
+          address: this.rollupContract.address,
+          abi: RollupAbi,
+          eventName: 'CheckpointProposed',
+        });
+
+        if (success) {
           const endBlock = receipt.blockNumber;
           const inclusionBlocks = Number(endBlock - startBlock);
-          const publishStats: L1PublishBlockStats = {
+          const { calldataGas, calldataSize, sender } = stats!;
+          const publishStats: L1PublishCheckpointStats = {
             gasPrice: receipt.effectiveGasPrice,
             gasUsed: receipt.gasUsed,
             blobGasUsed: receipt.blobGasUsed ?? 0n,
             blobDataGas: receipt.blobGasPrice ?? 0n,
             transactionHash: receipt.transactionHash,
-            ...pick(stats!, 'calldataGas', 'calldataSize', 'sender'),
-            ...block.getStats(),
+            calldataGas,
+            calldataSize,
+            sender,
+            ...checkpoint.getStats(),
             eventName: 'rollup-published-to-l1',
             blobCount: encodedData.blobs.length,
             inclusionBlocks,
           };
-          this.log.verbose(`Published L2 block to L1 rollup contract`, { ...stats, ...block.getStats() });
-          this.metrics.recordProcessBlockTx(timer.ms(), publishStats);
-
-          // Send the blobs to the blob sink
-          this.sendBlobsToBlobSink(receipt.blockHash, encodedData.blobs).catch(_err => {
-            this.log.error('Failed to send blobs to blob sink');
+          this.log.info(`Published checkpoint ${checkpoint.number} at slot ${slot} to rollup contract`, {
+            ...stats,
+            ...checkpoint.getStats(),
+            ...pick(receipt, 'transactionHash', 'blockHash'),
           });
+          this.metrics.recordProcessBlockTx(timer.ms(), publishStats);
 
           return true;
         } else {
           this.metrics.recordFailedTx('process');
-
-          this.log.error(`Rollup process tx reverted. ${errorMsg ?? 'No error message'}`, undefined, {
-            ...block.getStats(),
-            txHash: receipt.transactionHash,
-            blockHash,
-            slotNumber: block.header.globalVariables.slotNumber.toBigInt(),
-          });
+          this.log.error(
+            `Publishing checkpoint at slot ${slot} failed with ${errorMsg ?? 'no error message'}`,
+            undefined,
+            { ...checkpoint.getStats(), ...receipt },
+          );
+          return false;
         }
       },
     });
   }
 
-  /**
-   * Send blobs to the blob sink
-   *
-   * If a blob sink url is configured, then we send blobs to the blob sink
-   * - for now we use the blockHash as the identifier for the blobs;
-   *   In the future this will move to be the beacon block id - which takes a bit more work
-   *   to calculate and will need to be mocked in e2e tests
-   */
-  protected sendBlobsToBlobSink(blockHash: string, blobs: Blob[]): Promise<boolean> {
-    return this.blobSinkClient.sendBlobsToBlobSink(blockHash, blobs);
+  /** Returns the timestamp of the next L1 slot boundary after now. */
+  private getNextL1SlotTimestamp(): bigint {
+    const l1Constants = this.epochCache.getL1Constants();
+    return getNextL1SlotTimestamp(this.dateProvider.nowInSeconds(), l1Constants);
   }
 }