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

package/src/sequencer/sequencer.ts

@@ -1,55 +1,79 @@
-import type { L2Block } from '@aztec/aztec.js';
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { omit } from '@aztec/foundation/collection';
+import { L2Block } from '@aztec/aztec.js/block';
+import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import type { EpochCache } from '@aztec/epoch-cache';
+import { FormattedViemError, NoCommitteeError, type RollupContract } from '@aztec/ethereum';
+import { omit, pick } from '@aztec/foundation/collection';
+import { randomInt } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import type { Signature } from '@aztec/foundation/eth-signature';
+import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { type DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
+import { type DateProvider, Timer } from '@aztec/foundation/timer';
+import { type TypedEventEmitter, unfreeze } from '@aztec/foundation/types';
 import type { P2P } from '@aztec/p2p';
-import type { BlockBuilderFactory } from '@aztec/prover-client/block-builder';
-import type { PublicProcessorFactory } from '@aztec/simulator/server';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { SlasherClientInterface } from '@aztec/slasher';
+import {
+  CommitteeAttestation,
+  CommitteeAttestationsAndSigners,
+  type L2BlockSource,
+  type ValidateBlockResult,
+} from '@aztec/stdlib/block';
+import { type L1RollupConstants, getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import {
-  type AllowedElement,
+  type IFullNodeBlockBuilder,
+  type PublicProcessorLimits,
   SequencerConfigSchema,
   type WorldStateSynchronizer,
-  type WorldStateSynchronizerStatus,
 } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { BlockProposalOptions } from '@aztec/stdlib/p2p';
+import { orderAttestations } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
 import type { L2BlockBuiltStats } from '@aztec/stdlib/stats';
-import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import {
-  BlockHeader,
-  ContentCommitment,
-  type GlobalVariables,
-  StateReference,
-  Tx,
-  type TxHash,
-} from '@aztec/stdlib/tx';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { ContentCommitment, type FailedTx, GlobalVariables, Tx } from '@aztec/stdlib/tx';
+import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import type { ValidatorClient } from '@aztec/validator-client';
 
+import EventEmitter from 'node:events';
+import type { TypedDataDefinition } from 'viem';
+
 import type { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import { type SequencerPublisher, VoteType } from '../publisher/sequencer-publisher.js';
-import type { SlasherClient } from '../slasher/slasher_client.js';
-import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
-import { getDefaultAllowedSetupFunctions } from './allowed.js';
+import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
+import type { Action, InvalidateBlockRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
 import type { SequencerConfig } from './config.js';
+import { SequencerInterruptedError, SequencerTooSlowError } from './errors.js';
 import { SequencerMetrics } from './metrics.js';
-import { SequencerTimetable, SequencerTooSlowError } from './timetable.js';
-import { SequencerState, orderAttestations } from './utils.js';
+import { SequencerTimetable } from './timetable.js';
+import { SequencerState, type SequencerStateWithSlot } from './utils.js';
 
 export { SequencerState };
 
 type SequencerRollupConstants = Pick<L1RollupConstants, 'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration'>;
 
+export type SequencerEvents = {
+  ['state-changed']: (args: {
+    oldState: SequencerState;
+    newState: SequencerState;
+    secondsIntoSlot?: number;
+    slotNumber?: bigint;
+  }) => void;
+  ['proposer-rollup-check-failed']: (args: { reason: string }) => void;
+  ['tx-count-check-failed']: (args: { minTxs: number; availableTxs: number }) => void;
+  ['block-build-failed']: (args: { reason: string }) => void;
+  ['block-publish-failed']: (args: {
+    successfulActions?: Action[];
+    failedActions?: Action[];
+    sentActions?: Action[];
+    expiredActions?: Action[];
+  }) => void;
+  ['block-published']: (args: { blockNumber: number; slot: number }) => void;
+};
+
 /**
  * Sequencer client
  * - Wins a period of time to become the sequencer (depending on finalized protocol).
@@ -59,64 +83,81 @@ type SequencerRollupConstants = Pick<L1RollupConstants, 'ethereumSlotDuration' |
  * - Receives results to those proofs from the network (repeats as necessary) (not for this milestone).
  * - Publishes L1 tx(s) to the rollup contract via RollupPublisher.
  */
-export class Sequencer {
+export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<SequencerEvents>) {
   private runningPromise?: RunningPromise;
   private pollingIntervalMs: number = 1000;
   private maxTxsPerBlock = 32;
   private minTxsPerBlock = 1;
   private maxL1TxInclusionTimeIntoSlot = 0;
-  // TODO: zero values should not be allowed for the following 2 values in PROD
-  private _coinbase = EthAddress.ZERO;
-  private _feeRecipient = AztecAddress.ZERO;
   private state = SequencerState.STOPPED;
-  private allowedInSetup: AllowedElement[] = [];
   private maxBlockSizeInBytes: number = 1024 * 1024;
   private maxBlockGas: Gas = new Gas(100e9, 100e9);
   private metrics: SequencerMetrics;
-  private isFlushing: boolean = false;
+
+  private lastBlockPublished: L2Block | undefined;
+
+  private governanceProposerPayload: EthAddress | undefined;
+
+  /** The last slot for which we attempted to vote when sync failed, to prevent duplicate attempts. */
+  private lastSlotForVoteWhenSyncFailed: bigint | undefined;
 
   /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */
   protected timetable!: SequencerTimetable;
-
   protected enforceTimeTable: boolean = false;
 
+  // This shouldn't be here as this gets re-created each time we build/propose a block.
+  // But we have a number of tests that abuse/rely on this class having a permanent publisher.
+  // As long as those tests only configure a single publisher they will continue to work.
+  // This will get re-assigned every time the sequencer goes to build a new block to a publisher that is valid
+  // for the block proposer.
+  protected publisher: SequencerPublisher | undefined;
+
   constructor(
-    protected publisher: SequencerPublisher,
+    protected publisherFactory: SequencerPublisherFactory,
     protected validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
     protected globalsBuilder: GlobalVariableBuilder,
     protected p2pClient: P2P,
     protected worldState: WorldStateSynchronizer,
-    protected slasherClient: SlasherClient,
-    protected blockBuilderFactory: BlockBuilderFactory,
+    protected slasherClient: SlasherClientInterface | undefined,
     protected l2BlockSource: L2BlockSource,
     protected l1ToL2MessageSource: L1ToL2MessageSource,
-    protected publicProcessorFactory: PublicProcessorFactory,
-    protected contractDataSource: ContractDataSource,
+    protected blockBuilder: IFullNodeBlockBuilder,
     protected l1Constants: SequencerRollupConstants,
     protected dateProvider: DateProvider,
-    protected config: SequencerConfig = {},
-    telemetry: TelemetryClient = getTelemetryClient(),
+    protected epochCache: EpochCache,
+    protected rollupContract: RollupContract,
+    protected config: SequencerConfig,
+    protected telemetry: TelemetryClient = getTelemetryClient(),
     protected log = createLogger('sequencer'),
   ) {
-    this.metrics = new SequencerMetrics(telemetry, () => this.state, 'Sequencer');
+    super();
 
-    // Register the block builder with the validator client for re-execution
-    this.validatorClient?.registerBlockBuilder(this.buildBlock.bind(this));
-
-    // Register the slasher on the publisher to fetch slashing payloads
-    this.publisher.registerSlashPayloadGetter(this.slasherClient.getSlashPayload.bind(this.slasherClient));
+    this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
+    // Initialize config
+    this.updateConfig(this.config);
   }
 
   get tracer(): Tracer {
     return this.metrics.tracer;
   }
 
+  public getValidatorAddresses() {
+    return this.validatorClient?.getValidatorAddresses();
+  }
+
+  public getConfig() {
+    return this.config;
+  }
+
   /**
-   * Updates sequencer config.
+   * Updates sequencer config by the defined values in the config on input.
    * @param config - New parameters.
    */
-  public async updateConfig(config: SequencerConfig) {
-    this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'allowedInSetup'));
+  public updateConfig(config: SequencerConfig) {
+    this.log.info(
+      `Sequencer config set`,
+      omit(pickFromSchema(config, SequencerConfigSchema), 'txPublicSetupAllowList'),
+    );
 
     if (config.transactionPollingIntervalMS !== undefined) {
       this.pollingIntervalMs = config.transactionPollingIntervalMS;
@@ -133,22 +174,11 @@ export class Sequencer {
     if (config.maxL2BlockGas !== undefined) {
       this.maxBlockGas = new Gas(this.maxBlockGas.daGas, config.maxL2BlockGas);
     }
-    if (config.coinbase) {
-      this._coinbase = config.coinbase;
-    }
-    if (config.feeRecipient) {
-      this._feeRecipient = config.feeRecipient;
-    }
-    if (config.allowedInSetup) {
-      this.allowedInSetup = config.allowedInSetup;
-    } else {
-      this.allowedInSetup = await getDefaultAllowedSetupFunctions();
-    }
     if (config.maxBlockSizeInBytes !== undefined) {
       this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
     }
     if (config.governanceProposerPayload) {
-      this.publisher.setGovernancePayload(config.governanceProposerPayload);
+      this.governanceProposerPayload = config.governanceProposerPayload;
     }
     if (config.maxL1TxInclusionTimeIntoSlot !== undefined) {
       this.maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot;
@@ -160,55 +190,51 @@ export class Sequencer {
     this.setTimeTable();
 
     // TODO: Just read everything from the config object as needed instead of copying everything into local vars.
-    this.config = config;
+
+    // Update all values on this.config that are populated in the config object.
+    Object.assign(this.config, config);
   }
 
   private setTimeTable() {
     this.timetable = new SequencerTimetable(
-      this.l1Constants.ethereumSlotDuration,
-      this.aztecSlotDuration,
-      this.maxL1TxInclusionTimeIntoSlot,
-      this.enforceTimeTable,
+      {
+        ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
+        aztecSlotDuration: this.aztecSlotDuration,
+        maxL1TxInclusionTimeIntoSlot: this.maxL1TxInclusionTimeIntoSlot,
+        attestationPropagationTime: this.config.attestationPropagationTime,
+        enforce: this.enforceTimeTable,
+      },
       this.metrics,
       this.log,
     );
-    this.log.verbose(`Sequencer timetable updated`, { enforceTimeTable: this.enforceTimeTable });
+  }
+
+  public async init() {
+    this.publisher = (await this.publisherFactory.create(undefined)).publisher;
   }
 
   /**
    * Starts the sequencer and moves to IDLE state.
    */
-  public async start() {
-    await this.updateConfig(this.config);
-    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollingIntervalMs);
-    this.setState(SequencerState.IDLE, 0n, true /** force */);
+  public start() {
+    this.runningPromise = new RunningPromise(this.safeWork.bind(this), this.log, this.pollingIntervalMs);
+    this.setState(SequencerState.IDLE, undefined, { force: true });
     this.runningPromise.start();
-    this.log.info(`Sequencer started with address ${this.publisher.getSenderAddress().toString()}`);
+    this.log.info('Started sequencer');
   }
 
   /**
    * Stops the sequencer from processing txs and moves to STOPPED state.
    */
   public async stop(): Promise<void> {
-    this.log.debug(`Stopping sequencer`);
-    await this.validatorClient?.stop();
+    this.log.info(`Stopping sequencer`);
+    this.setState(SequencerState.STOPPING, undefined, { force: true });
+    this.publisher?.interrupt();
     await this.runningPromise?.stop();
-    this.slasherClient.stop();
-    this.publisher.interrupt();
-    this.setState(SequencerState.STOPPED, 0n, true /** force */);
+    this.setState(SequencerState.STOPPED, undefined, { force: true });
     this.log.info('Stopped sequencer');
   }
 
-  /**
-   * Starts a previously stopped sequencer.
-   */
-  public restart() {
-    this.log.info('Restarting sequencer');
-    this.publisher.restart();
-    this.runningPromise!.start();
-    this.setState(SequencerState.IDLE, 0n, true /** force */);
-  }
-
   /**
    * Returns the current state of the sequencer.
    * @returns An object with a state entry with one of SequencerState.
@@ -217,11 +243,6 @@ export class Sequencer {
     return { state: this.state };
   }
 
-  /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */
-  public flush() {
-    this.isFlushing = true;
-  }
-
   /**
    * @notice  Performs most of the sequencer duties:
    *          - Checks if we are up to date
@@ -230,300 +251,303 @@ export class Sequencer {
    *          - Submit block
    *          - If our block for some reason is not included, revert the state
    */
-  protected async doRealWork() {
-    this.setState(SequencerState.SYNCHRONIZING, 0n);
-    // Update state when the previous block has been synced
-    const chainTip = await this.getChainTip();
-    // Do not go forward with new block if the previous one has not been mined and processed
-    if (!chainTip) {
+  protected async work() {
+    this.setState(SequencerState.SYNCHRONIZING, undefined);
+    const { slot, ts, now } = this.epochCache.getEpochAndSlotInNextL1Slot();
+
+    // Check we have not already published a block for this slot (cheapest check)
+    if (this.lastBlockPublished && this.lastBlockPublished.header.getSlot() >= slot) {
+      this.log.debug(
+        `Cannot propose block at next L2 slot ${slot} since that slot was taken by our own block ${this.lastBlockPublished.number}`,
+      );
       return;
     }
 
-    this.setState(SequencerState.PROPOSER_CHECK, 0n);
+    // Check all components are synced to latest as seen by the archiver (queries all subsystems)
+    const syncedTo = await this.checkSync({ ts, slot });
+    if (!syncedTo) {
+      await this.tryVoteWhenSyncFails({ slot, ts });
+      return;
+    }
+
+    const chainTipArchive = syncedTo.archive;
+    const newBlockNumber = syncedTo.blockNumber + 1;
+
+    const syncLogData = {
+      now,
+      syncedToL1Ts: syncedTo.l1Timestamp,
+      syncedToL2Slot: getSlotAtTimestamp(syncedTo.l1Timestamp, this.l1Constants),
+      nextL2Slot: slot,
+      nextL2SlotTs: ts,
+      l1SlotDuration: this.l1Constants.ethereumSlotDuration,
+      newBlockNumber,
+      isPendingChainValid: pick(syncedTo.pendingChainValidationStatus, 'valid', 'reason', 'invalidIndex'),
+    };
+
+    // Check that we are a proposer for the next slot
+    this.setState(SequencerState.PROPOSER_CHECK, slot);
+    const [canPropose, proposer] = await this.checkCanPropose(slot);
+
+    // If we are not a proposer, check if we should invalidate a invalid block, and bail
+    if (!canPropose) {
+      await this.considerInvalidatingBlock(syncedTo, slot);
+      return;
+    }
+
+    // Check that the slot is not taken by a block already (should never happen, since only us can propose for this slot)
+    if (syncedTo.block && syncedTo.block.header.getSlot() >= slot) {
+      this.log.warn(
+        `Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`,
+        { ...syncLogData, block: syncedTo.block.header.toInspect() },
+      );
+      return;
+    }
 
-    const newBlockNumber = chainTip.blockNumber + 1;
+    // We now need to get ourselves a publisher.
+    // The returned attestor will be the one we provided if we provided one.
+    // Otherwise it will be a valid attestor for the returned publisher.
+    const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
+    this.log.verbose(`Created publisher at address ${publisher.getSenderAddress()} for attestor ${attestorAddress}`);
+    this.publisher = publisher;
 
-    // If we cannot find a tip archive, assume genesis.
-    const chainTipArchive = chainTip.archive;
+    const coinbase = this.validatorClient!.getCoinbaseForAttestor(attestorAddress);
+    const feeRecipient = this.validatorClient!.getFeeRecipientForAttestor(attestorAddress);
 
-    const slot = await this.slotForProposal(chainTipArchive.toBuffer(), BigInt(newBlockNumber));
-    if (!slot) {
-      this.log.debug(`Cannot propose block ${newBlockNumber}`);
+    // Prepare invalidation request if the pending chain is invalid (returns undefined if no need)
+    const invalidateBlock = await publisher.simulateInvalidateBlock(syncedTo.pendingChainValidationStatus);
+
+    // Check with the rollup if we can indeed propose at the next L2 slot. This check should not fail
+    // if all the previous checks are good, but we do it just in case.
+    const canProposeCheck = await publisher.canProposeAtNextEthBlock(
+      chainTipArchive,
+      proposer ?? EthAddress.ZERO,
+      invalidateBlock,
+    );
+
+    if (canProposeCheck === undefined) {
+      this.log.warn(
+        `Cannot propose block ${newBlockNumber} at slot ${slot} due to failed rollup contract check`,
+        syncLogData,
+      );
+      this.emit('proposer-rollup-check-failed', { reason: 'Rollup contract check failed' });
+      return;
+    } else if (canProposeCheck.slot !== slot) {
+      this.log.warn(
+        `Cannot propose block due to slot mismatch with rollup contract (this can be caused by a clock out of sync). Expected slot ${slot} but got ${canProposeCheck.slot}.`,
+        { ...syncLogData, rollup: canProposeCheck, newBlockNumber, expectedSlot: slot },
+      );
+      this.emit('proposer-rollup-check-failed', { reason: 'Slot mismatch' });
+      return;
+    } else if (canProposeCheck.blockNumber !== BigInt(newBlockNumber)) {
+      this.log.warn(
+        `Cannot propose block due to block mismatch with rollup contract (this can be caused by a pending archiver sync). Expected block ${newBlockNumber} but got ${canProposeCheck.blockNumber}.`,
+        { ...syncLogData, rollup: canProposeCheck, newBlockNumber, expectedSlot: slot },
+      );
+      this.emit('proposer-rollup-check-failed', { reason: 'Block mismatch' });
       return;
     }
 
-    this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot}`);
+    this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot} as ${proposer}`, { ...syncLogData });
 
     const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(
-      new Fr(newBlockNumber),
-      this._coinbase,
-      this._feeRecipient,
+      newBlockNumber,
+      coinbase,
+      feeRecipient,
       slot,
     );
 
-    const enqueueGovernanceVotePromise = this.publisher.enqueueCastVote(
+    // Enqueue governance and slashing votes (returns promises that will be awaited later)
+    const votesPromises = this.enqueueGovernanceAndSlashingVotes(
+      publisher,
+      attestorAddress,
       slot,
-      newGlobalVariables.timestamp.toBigInt(),
-      VoteType.GOVERNANCE,
+      newGlobalVariables.timestamp,
     );
-    const enqueueSlashingVotePromise = this.publisher.enqueueCastVote(
+
+    // Enqueues block invalidation
+    if (invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
+      publisher.enqueueInvalidateBlock(invalidateBlock);
+    }
+
+    // Actual block building
+    this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
+    const block: L2Block | undefined = await this.tryBuildBlockAndEnqueuePublish(
       slot,
-      newGlobalVariables.timestamp.toBigInt(),
-      VoteType.SLASHING,
+      proposer,
+      newBlockNumber,
+      publisher,
+      newGlobalVariables,
+      chainTipArchive,
+      invalidateBlock,
     );
 
-    this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
+    // Wait until the voting promises have resolved, so all requests are enqueued
+    await Promise.all(votesPromises);
+
+    // And send the tx to L1
+    const l1Response = await publisher.sendRequests();
+    const proposedBlock = l1Response?.successfulActions.find(a => a === 'propose');
+    if (proposedBlock) {
+      this.lastBlockPublished = block;
+      this.emit('block-published', { blockNumber: newBlockNumber, slot: Number(slot) });
+      await this.metrics.incFilledSlot(publisher.getSenderAddress().toString(), coinbase);
+    } else if (block) {
+      this.emit('block-publish-failed', l1Response ?? {});
+    }
+
+    this.setState(SequencerState.IDLE, undefined);
+  }
+
+  /** Tries building a block proposal, and if successful, enqueues it for publishing. */
+  private async tryBuildBlockAndEnqueuePublish(
+    slot: bigint,
+    proposer: EthAddress | undefined,
+    newBlockNumber: number,
+    publisher: SequencerPublisher,
+    newGlobalVariables: GlobalVariables,
+    chainTipArchive: Fr,
+    invalidateBlock: InvalidateBlockRequest | undefined,
+  ) {
     this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
+      proposer,
+      publisher: publisher.getSenderAddress(),
+      globalVariables: newGlobalVariables.toInspect(),
       chainTipArchive,
       blockNumber: newBlockNumber,
       slot,
     });
 
-    // If I created a "partial" header here that should make our job much easier.
-    const proposalHeader = new BlockHeader(
-      new AppendOnlyTreeSnapshot(chainTipArchive, 1),
-      ContentCommitment.empty(),
-      StateReference.empty(),
-      newGlobalVariables,
-      Fr.ZERO,
-      Fr.ZERO,
-    );
+    const proposalHeader = CheckpointHeader.from({
+      ...newGlobalVariables,
+      timestamp: newGlobalVariables.timestamp,
+      lastArchiveRoot: chainTipArchive,
+      contentCommitment: ContentCommitment.empty(),
+      totalManaUsed: Fr.ZERO,
+    });
+
+    let block: L2Block | undefined;
 
-    let finishedFlushing = false;
     const pendingTxCount = await this.p2pClient.getPendingTxCount();
-    if (pendingTxCount >= this.minTxsPerBlock || this.isFlushing) {
+    if (pendingTxCount >= this.minTxsPerBlock) {
       // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
       // and also we may need to fetch more if we don't have enough valid txs.
       const pendingTxs = this.p2pClient.iteratePendingTxs();
-
-      await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader).catch(err => {
-        this.log.error(`Error building/enqueuing block`, err, { blockNumber: newBlockNumber, slot });
-      });
-      finishedFlushing = true;
+      try {
+        block = await this.buildBlockAndEnqueuePublish(
+          pendingTxs,
+          proposalHeader,
+          newGlobalVariables,
+          proposer,
+          invalidateBlock,
+          publisher,
+        );
+      } catch (err: any) {
+        this.emit('block-build-failed', { reason: err.message });
+        if (err instanceof FormattedViemError) {
+          this.log.verbose(`Unable to build/enqueue block ${err.message}`);
+        } else {
+          this.log.error(`Error building/enqueuing block`, err, { blockNumber: newBlockNumber, slot });
+        }
+      }
     } else {
-      this.log.debug(
-        `Not enough txs to build block ${newBlockNumber} at slot ${slot}: got ${pendingTxCount} txs, need ${this.minTxsPerBlock}`,
+      this.log.verbose(
+        `Not enough txs to build block ${newBlockNumber} at slot ${slot} (got ${pendingTxCount} txs, need ${this.minTxsPerBlock})`,
+        { chainTipArchive, blockNumber: newBlockNumber, slot },
       );
+      this.emit('tx-count-check-failed', { minTxs: this.minTxsPerBlock, availableTxs: pendingTxCount });
     }
-
-    await enqueueGovernanceVotePromise.catch(err => {
-      this.log.error(`Error enqueuing governance vote`, err, { blockNumber: newBlockNumber, slot });
-    });
-    await enqueueSlashingVotePromise.catch(err => {
-      this.log.error(`Error enqueuing slashing vote`, err, { blockNumber: newBlockNumber, slot });
-    });
-
-    await this.publisher.sendRequests();
-
-    if (finishedFlushing) {
-      this.isFlushing = false;
-    }
-
-    this.setState(SequencerState.IDLE, 0n);
+    return block;
   }
 
   @trackSpan('Sequencer.work')
-  protected async work() {
+  protected async safeWork() {
     try {
-      await this.doRealWork();
+      await this.work();
     } catch (err) {
       if (err instanceof SequencerTooSlowError) {
-        this.log.warn(err.message);
+        // Log as warn only if we had to abort halfway through the block proposal
+        const logLvl = [SequencerState.INITIALIZING_PROPOSAL, SequencerState.PROPOSER_CHECK].includes(err.proposedState)
+          ? ('debug' as const)
+          : ('warn' as const);
+        this.log[logLvl](err.message, { now: this.dateProvider.nowInSeconds() });
       } else {
         // Re-throw other errors
         throw err;
       }
     } finally {
-      this.setState(SequencerState.IDLE, 0n);
+      this.setState(SequencerState.IDLE, undefined);
     }
   }
 
-  public getForwarderAddress() {
-    return this.publisher.getForwarderAddress();
-  }
-
-  /**
-   * Checks if we can propose at the next block and returns the slot number if we can.
-   * @param tipArchive - The archive of the previous block.
-   * @param proposalBlockNumber - The block number of the proposal.
-   * @returns The slot number if we can propose at the next block, otherwise undefined.
-   */
-  async slotForProposal(tipArchive: Buffer, proposalBlockNumber: bigint): Promise<bigint | undefined> {
-    const result = await this.publisher.canProposeAtNextEthBlock(tipArchive);
-
-    if (!result) {
-      return undefined;
-    }
-
-    const [slot, blockNumber] = result;
-
-    if (proposalBlockNumber !== blockNumber) {
-      const msg = `Sequencer block number mismatch. Expected ${proposalBlockNumber} but got ${blockNumber}.`;
-      this.log.warn(msg);
-      throw new Error(msg);
-    }
-    return slot;
-  }
-
   /**
    * Sets the sequencer state and checks if we have enough time left in the slot to transition to the new state.
    * @param proposedState - The new state to transition to.
-   * @param currentSlotNumber - The current slot number.
+   * @param slotNumber - The current slot number.
    * @param force - Whether to force the transition even if the sequencer is stopped.
-   *
-   * @dev If the `currentSlotNumber` doesn't matter (e.g. transitioning to IDLE), pass in `0n`;
-   * it is only used to check if we have enough time left in the slot to transition to the new state.
    */
-  setState(proposedState: SequencerState, currentSlotNumber: bigint, force: boolean = false) {
-    if (this.state === SequencerState.STOPPED && force !== true) {
+  setState(proposedState: SequencerStateWithSlot, slotNumber: bigint, opts?: { force?: boolean }): void;
+  setState(
+    proposedState: Exclude<SequencerState, SequencerStateWithSlot>,
+    slotNumber?: undefined,
+    opts?: { force?: boolean },
+  ): void;
+  setState(proposedState: SequencerState, slotNumber: bigint | undefined, opts: { force?: boolean } = {}): void {
+    if (this.state === SequencerState.STOPPING && proposedState !== SequencerState.STOPPED && !opts.force) {
+      this.log.warn(`Cannot set sequencer to ${proposedState} as it is stopping.`);
+      throw new SequencerInterruptedError();
+    }
+    if (this.state === SequencerState.STOPPED && !opts.force) {
       this.log.warn(`Cannot set sequencer from ${this.state} to ${proposedState} as it is stopped.`);
       return;
     }
-    const secondsIntoSlot = this.getSecondsIntoSlot(currentSlotNumber);
-    this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
-    this.log.debug(`Transitioning from ${this.state} to ${proposedState}`);
-    this.state = proposedState;
-  }
-
-  /**
-   * Build a block
-   *
-   * Shared between the sequencer and the validator for re-execution
-   *
-   * @param pendingTxs - The pending transactions to construct the block from
-   * @param newGlobalVariables - The global variables for the new block
-   * @param historicalHeader - The historical header of the parent
-   * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
-   */
-  protected async buildBlock(
-    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
-    newGlobalVariables: GlobalVariables,
-    opts: { validateOnly?: boolean } = {},
-  ) {
-    const blockNumber = newGlobalVariables.blockNumber.toNumber();
-    const slot = newGlobalVariables.slotNumber.toBigInt();
-    this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(blockNumber));
-    const msgCount = l1ToL2Messages.length;
+    let secondsIntoSlot = undefined;
+    if (slotNumber !== undefined) {
+      secondsIntoSlot = this.getSecondsIntoSlot(slotNumber);
+      this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
+    }
 
-    this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
-      slot,
-      blockNumber,
-      msgCount,
-      validator: opts.validateOnly,
+    const boringStates = [SequencerState.IDLE, SequencerState.SYNCHRONIZING];
+    const logLevel =
+      boringStates.includes(proposedState) && boringStates.includes(this.state)
+        ? ('trace' as const)
+        : ('debug' as const);
+    this.log[logLevel](`Transitioning from ${this.state} to ${proposedState}`, { slotNumber, secondsIntoSlot });
+
+    this.emit('state-changed', {
+      oldState: this.state,
+      newState: proposedState,
+      secondsIntoSlot,
+      slotNumber,
     });
+    this.state = proposedState;
+  }
 
-    // Sync to the previous block at least
-    await this.worldState.syncImmediate(blockNumber - 1);
-    this.log.debug(`Synced to previous block ${blockNumber - 1}`);
-
-    // NB: separating the dbs because both should update the state
-    const publicProcessorFork = await this.worldState.fork();
-    const orchestratorFork = await this.worldState.fork();
-
-    const previousBlockHeader =
-      (await this.l2BlockSource.getBlock(blockNumber - 1))?.header ?? orchestratorFork.getInitialHeader();
-
-    try {
-      const processor = this.publicProcessorFactory.create(publicProcessorFork, newGlobalVariables, true);
-      const blockBuildingTimer = new Timer();
-      const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
-      await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages, previousBlockHeader);
-
-      // Deadline for processing depends on whether we're proposing a block
-      const secondsIntoSlot = this.getSecondsIntoSlot(slot);
-      const processingEndTimeWithinSlot = opts.validateOnly
-        ? this.timetable.getValidatorReexecTimeEnd(secondsIntoSlot)
-        : this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
-
-      // Deadline is only set if enforceTimeTable is enabled.
-      const deadline = this.enforceTimeTable
-        ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000)
-        : undefined;
-
-      this.log.verbose(`Processing pending txs`, {
-        slot,
-        slotStart: new Date(this.getSlotStartTimestamp(slot) * 1000),
-        now: new Date(this.dateProvider.now()),
-        deadline,
-      });
-
-      const validators = createValidatorsForBlockBuilding(
-        publicProcessorFork,
-        this.contractDataSource,
-        newGlobalVariables,
-        this.allowedInSetup,
-      );
-
-      // TODO(#11000): Public processor should just handle processing, one tx at a time. It should be responsibility
-      // of the sequencer to update world state and iterate over txs. We should refactor this along with unifying the
-      // publicProcessorFork and orchestratorFork, to avoid doing tree insertions twice when building the block.
-      const proposerLimits = {
-        maxTransactions: this.maxTxsPerBlock,
-        maxBlockSize: this.maxBlockSizeInBytes,
-        maxBlockGas: this.maxBlockGas,
-      };
-      const limits = opts.validateOnly ? { deadline } : { deadline, ...proposerLimits };
-      const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-        processor.process(pendingTxs, limits, validators),
-      );
-
-      if (!opts.validateOnly && failedTxs.length > 0) {
-        const failedTxData = failedTxs.map(fail => fail.tx);
-        const failedTxHashes = await Tx.getHashes(failedTxData);
-        this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
-        await this.p2pClient.deleteTxs(failedTxHashes);
-      }
-
-      if (
-        !opts.validateOnly && // We check for minTxCount only if we are proposing a block, not if we are validating it
-        !this.isFlushing && // And we skip the check when flushing, since we want all pending txs to go out, no matter if too few
-        this.minTxsPerBlock !== undefined &&
-        processedTxs.length < this.minTxsPerBlock
-      ) {
-        this.log.warn(
-          `Block ${blockNumber} has too few txs to be proposed (got ${processedTxs.length} but required ${this.minTxsPerBlock})`,
-          { slot, blockNumber, processedTxCount: processedTxs.length },
-        );
-        throw new Error(`Block has too few successful txs to be proposed`);
-      }
-
-      const start = process.hrtime.bigint();
-      await blockBuilder.addTxs(processedTxs);
-      const end = process.hrtime.bigint();
-      const duration = Number(end - start) / 1_000;
-      this.metrics.recordBlockBuilderTreeInsertions(duration);
-
-      // All real transactions have been added, set the block as full and pad if needed
-      const block = await blockBuilder.setBlockCompleted();
-
-      // How much public gas was processed
-      const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
-
-      return {
-        block,
-        publicGas,
-        publicProcessorDuration,
-        numMsgs: l1ToL2Messages.length,
-        numTxs: processedTxs.length,
-        numFailedTxs: failedTxs.length,
-        blockBuildingTimer,
-      };
-    } finally {
-      // We create a fresh processor each time to reset any cached state (eg storage writes)
-      // We wait a bit to close the forks since the processor may still be working on a dangling tx
-      // which was interrupted due to the processingDeadline being hit.
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      setTimeout(async () => {
-        try {
-          await publicProcessorFork.close();
-          await orchestratorFork.close();
-        } catch (err) {
-          // This can happen if the sequencer is stopped before we hit this timeout.
-          this.log.warn(`Error closing forks for block processing`, err);
-        }
-      }, 5000);
+  private async dropFailedTxsFromP2P(failedTxs: FailedTx[]) {
+    if (failedTxs.length === 0) {
+      return;
     }
+    const failedTxData = failedTxs.map(fail => fail.tx);
+    const failedTxHashes = failedTxData.map(tx => tx.getTxHash());
+    this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
+    await this.p2pClient.deleteTxs(failedTxHashes);
+  }
+
+  protected getBlockBuilderOptions(slot: number): PublicProcessorLimits {
+    // Deadline for processing depends on whether we're proposing a block
+    const secondsIntoSlot = this.getSecondsIntoSlot(slot);
+    const processingEndTimeWithinSlot = this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
+
+    // Deadline is only set if enforceTimeTable is enabled.
+    const deadline = this.enforceTimeTable
+      ? new Date((this.getSlotStartBuildTimestamp(slot) + processingEndTimeWithinSlot) * 1000)
+      : undefined;
+    return {
+      maxTransactions: this.maxTxsPerBlock,
+      maxBlockSize: this.maxBlockSizeInBytes,
+      maxBlockGas: this.maxBlockGas,
+      maxBlobFields: BLOBS_PER_BLOCK * FIELDS_PER_BLOB,
+      deadline,
+    };
   }
 
   /**
@@ -534,36 +558,58 @@ export class Sequencer {
    *
    * @param pendingTxs - Iterable of pending transactions to construct the block from
    * @param proposalHeader - The partial header constructed for the proposal
+   * @param newGlobalVariables - The global variables for the new block
+   * @param proposerAddress - The address of the proposer
    */
-  @trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, proposalHeader) => ({
-    [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
+  @trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, _proposalHeader, newGlobalVariables) => ({
+    [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber,
   }))
   private async buildBlockAndEnqueuePublish(
     pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
-    proposalHeader: BlockHeader,
-  ): Promise<void> {
-    await this.publisher.validateBlockForSubmission(proposalHeader);
+    proposalHeader: CheckpointHeader,
+    newGlobalVariables: GlobalVariables,
+    proposerAddress: EthAddress | undefined,
+    invalidateBlock: InvalidateBlockRequest | undefined,
+    publisher: SequencerPublisher,
+  ): Promise<L2Block> {
+    await publisher.validateBlockHeader(proposalHeader, invalidateBlock);
 
-    const newGlobalVariables = proposalHeader.globalVariables;
-    const blockNumber = newGlobalVariables.blockNumber.toNumber();
-    const slot = newGlobalVariables.slotNumber.toBigInt();
+    const blockNumber = newGlobalVariables.blockNumber;
+    const slot = proposalHeader.slotNumber.toBigInt();
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
 
-    // this.metrics.recordNewBlock(blockNumber, validTxs.length);
     const workTimer = new Timer();
     this.setState(SequencerState.CREATING_BLOCK, slot);
 
     try {
-      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables);
-      const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
-      this.metrics.recordBuiltBlock(workTimer.ms(), publicGas.l2Gas);
+      const blockBuilderOptions = this.getBlockBuilderOptions(Number(slot));
+      const buildBlockRes = await this.blockBuilder.buildBlock(
+        pendingTxs,
+        l1ToL2Messages,
+        newGlobalVariables,
+        blockBuilderOptions,
+      );
+      const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer, usedTxs, failedTxs } =
+        buildBlockRes;
+      const blockBuildDuration = workTimer.ms();
+      await this.dropFailedTxsFromP2P(failedTxs);
+
+      const minTxsPerBlock = this.minTxsPerBlock;
+      if (numTxs < minTxsPerBlock) {
+        this.log.warn(
+          `Block ${blockNumber} has too few txs to be proposed (got ${numTxs} but required ${minTxsPerBlock})`,
+          { slot, blockNumber, numTxs },
+        );
+        throw new Error(`Block has too few successful txs to be proposed`);
+      }
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
       // block being published before ours instead of just waiting on our block
-      await this.publisher.validateBlockForSubmission(block.header);
+      await publisher.validateBlockHeader(block.getCheckpointHeader(), invalidateBlock);
 
       const blockStats: L2BlockBuiltStats = {
         eventName: 'l2-block-built',
-        creator: this.publisher.getSenderAddress().toString(),
+        creator: proposerAddress?.toString() ?? publisher.getSenderAddress().toString(),
         duration: workTimer.ms(),
         publicProcessDuration: publicProcessorDuration,
         rollupCircuitsDuration: blockBuildingTimer.ms(),
@@ -585,14 +631,28 @@ export class Sequencer {
       );
 
       this.log.debug('Collecting attestations');
-      const stopCollectingAttestationsTimer = this.metrics.startCollectingAttestationsTimer();
-      const attestations = await this.collectAttestations(block, txHashes);
+      const attestations = await this.collectAttestations(block, usedTxs, proposerAddress);
       if (attestations !== undefined) {
         this.log.verbose(`Collected ${attestations.length} attestations`, { blockHash, blockNumber });
       }
-      stopCollectingAttestationsTimer();
 
-      return this.enqueuePublishL2Block(block, attestations, txHashes);
+      const attestationsAndSigners = new CommitteeAttestationsAndSigners(attestations ?? []);
+      const attestationsAndSignersSignature = this.validatorClient
+        ? await this.validatorClient.signAttestationsAndSigners(
+            attestationsAndSigners,
+            proposerAddress ?? publisher.getSenderAddress(),
+          )
+        : Signature.empty();
+
+      await this.enqueuePublishL2Block(
+        block,
+        attestationsAndSigners,
+        attestationsAndSignersSignature,
+        invalidateBlock,
+        publisher,
+      );
+      this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
+      return block;
     } catch (err) {
       this.metrics.recordFailedBlock();
       throw err;
@@ -604,9 +664,17 @@ export class Sequencer {
     [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
     [Attributes.BLOCK_TXS_COUNT]: txHashes.length,
   }))
-  protected async collectAttestations(block: L2Block, txHashes: TxHash[]): Promise<Signature[] | undefined> {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962): inefficient to have a round trip in here - this should be cached
-    const committee = await this.publisher.getCurrentEpochCommittee();
+  protected async collectAttestations(
+    block: L2Block,
+    txs: Tx[],
+    proposerAddress: EthAddress | undefined,
+  ): Promise<CommitteeAttestation[] | undefined> {
+    const { committee } = await this.epochCache.getCommittee(block.header.getSlot());
+
+    // We checked above that the committee is defined, so this should never happen.
+    if (!committee) {
+      throw new Error('No committee when collecting attestations');
+    }
 
     if (committee.length === 0) {
       this.log.verbose(`Attesting committee is empty`);
@@ -622,31 +690,73 @@ export class Sequencer {
     }
 
     const numberOfRequiredAttestations = Math.floor((committee.length * 2) / 3) + 1;
+
     const slotNumber = block.header.globalVariables.slotNumber.toBigInt();
     this.setState(SequencerState.COLLECTING_ATTESTATIONS, slotNumber);
 
     this.log.debug('Creating block proposal for validators');
-    const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
+    const blockProposalOptions: BlockProposalOptions = {
+      publishFullTxs: !!this.config.publishTxsWithProposals,
+      broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal,
+    };
+    const proposal = await this.validatorClient.createBlockProposal(
+      block.header.globalVariables.blockNumber,
+      block.getCheckpointHeader(),
+      block.archive.root,
+      block.header.state,
+      txs,
+      proposerAddress,
+      blockProposalOptions,
+    );
+
     if (!proposal) {
-      const msg = `Failed to create block proposal`;
-      throw new Error(msg);
+      throw new Error(`Failed to create block proposal`);
+    }
+
+    if (this.config.skipCollectingAttestations) {
+      this.log.warn('Skipping attestation collection as per config (attesting with own keys only)');
+      const attestations = await this.validatorClient?.collectOwnAttestations(proposal);
+      return orderAttestations(attestations ?? [], committee);
     }
 
     this.log.debug('Broadcasting block proposal to validators');
-    this.validatorClient.broadcastBlockProposal(proposal);
+    await this.validatorClient.broadcastBlockProposal(proposal);
 
     const attestationTimeAllowed = this.enforceTimeTable
       ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_BLOCK)!
       : this.aztecSlotDuration;
-    const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
-    const attestations = await this.validatorClient.collectAttestations(
-      proposal,
-      numberOfRequiredAttestations,
-      attestationDeadline,
-    );
 
-    // note: the smart contract requires that the signatures are provided in the order of the committee
-    return orderAttestations(attestations, committee);
+    this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
+
+    const timer = new Timer();
+    let collectedAttestationsCount: number = 0;
+    try {
+      const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
+      const attestations = await this.validatorClient.collectAttestations(
+        proposal,
+        numberOfRequiredAttestations,
+        attestationDeadline,
+      );
+
+      collectedAttestationsCount = attestations.length;
+
+      // note: the smart contract requires that the signatures are provided in the order of the committee
+      const sorted = orderAttestations(attestations, committee);
+      if (this.config.injectFakeAttestation) {
+        const nonEmpty = sorted.filter(a => !a.signature.isEmpty());
+        const randomIndex = randomInt(nonEmpty.length);
+        this.log.warn(`Injecting fake attestation in block ${block.number}`);
+        unfreeze(nonEmpty[randomIndex]).signature = Signature.random();
+      }
+      return sorted;
+    } catch (err) {
+      if (err && err instanceof AttestationTimeoutError) {
+        collectedAttestationsCount = err.collectedCount;
+      }
+      throw err;
+    } finally {
+      this.metrics.recordCollectedAttestations(collectedAttestationsCount, timer.ms());
+    }
   }
 
   /**
@@ -658,19 +768,27 @@ export class Sequencer {
   }))
   protected async enqueuePublishL2Block(
     block: L2Block,
-    attestations?: Signature[],
-    txHashes?: TxHash[],
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    attestationsAndSignersSignature: Signature,
+    invalidateBlock: InvalidateBlockRequest | undefined,
+    publisher: SequencerPublisher,
   ): Promise<void> {
     // Publishes new block to the network and awaits the tx to be mined
     this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
 
     // Time out tx at the end of the slot
     const slot = block.header.globalVariables.slotNumber.toNumber();
-    const txTimeoutAt = new Date((this.getSlotStartTimestamp(slot) + this.aztecSlotDuration) * 1000);
-
-    const enqueued = await this.publisher.enqueueProposeL2Block(block, attestations, txHashes, {
-      txTimeoutAt,
-    });
+    const txTimeoutAt = new Date((this.getSlotStartBuildTimestamp(slot) + this.aztecSlotDuration) * 1000);
+
+    const enqueued = await publisher.enqueueProposeL2Block(
+      block,
+      attestationsAndSigners,
+      attestationsAndSignersSignature,
+      {
+        txTimeoutAt,
+        forcePendingBlockNumber: invalidateBlock?.forcePendingBlockNumber,
+      },
+    );
 
     if (!enqueued) {
       throw new Error(`Failed to enqueue publish of block ${block.number}`);
@@ -680,68 +798,301 @@ export class Sequencer {
   /**
    * Returns whether all dependencies have caught up.
    * We don't check against the previous block submitted since it may have been reorg'd out.
-   * @returns Boolean indicating if our dependencies are synced to the latest block.
    */
-  protected async getChainTip(): Promise<{ blockNumber: number; archive: Fr } | undefined> {
+  protected async checkSync(args: { ts: bigint; slot: bigint }): Promise<
+    | {
+        block?: L2Block;
+        blockNumber: number;
+        archive: Fr;
+        l1Timestamp: bigint;
+        pendingChainValidationStatus: ValidateBlockResult;
+      }
+    | undefined
+  > {
+    // Check that the archiver and dependencies have synced to the previous L1 slot at least
+    // TODO(#14766): Archiver reports L1 timestamp based on L1 blocks seen, which means that a missed L1 block will
+    // cause the archiver L1 timestamp to fall behind, and cause this sequencer to start processing one L1 slot later.
+    const l1Timestamp = await this.l2BlockSource.getL1Timestamp();
+    const { slot, ts } = args;
+    if (l1Timestamp === undefined || l1Timestamp + BigInt(this.l1Constants.ethereumSlotDuration) < ts) {
+      this.log.debug(`Cannot propose block at next L2 slot ${slot} due to pending sync from L1`, {
+        slot,
+        ts,
+        l1Timestamp,
+      });
+      return undefined;
+    }
+
     const syncedBlocks = await Promise.all([
-      this.worldState.status().then((s: WorldStateSynchronizerStatus) => {
-        return {
-          number: s.syncSummary.latestBlockNumber,
-          hash: s.syncSummary.latestBlockHash,
-        };
-      }),
+      this.worldState.status().then(({ syncSummary }) => ({
+        number: syncSummary.latestBlockNumber,
+        hash: syncSummary.latestBlockHash,
+      })),
       this.l2BlockSource.getL2Tips().then(t => t.latest),
       this.p2pClient.getStatus().then(p2p => p2p.syncedToL2Block),
-      this.l1ToL2MessageSource.getBlockNumber(),
+      this.l1ToL2MessageSource.getL2Tips().then(t => t.latest),
+      this.l2BlockSource.getPendingChainValidationStatus(),
     ] as const);
 
-    const [worldState, l2BlockSource, p2p, l1ToL2MessageSource] = syncedBlocks;
+    const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, pendingChainValidationStatus] = syncedBlocks;
 
+    // The archiver reports 'undefined' hash for the genesis block
+    // because it doesn't have access to world state to compute it (facepalm)
     const result =
-      // check that world state has caught up with archiver
-      // note that the archiver reports undefined hash for the genesis block
-      // because it doesn't have access to world state to compute it (facepalm)
-      (l2BlockSource.hash === undefined || worldState.hash === l2BlockSource.hash) &&
-      // and p2p client and message source are at least at the same block
-      // this should change to hashes once p2p client handles reorgs
-      // and once we stop pretending that the l1tol2message source is not
-      // just the archiver under a different name
-      (!l2BlockSource.hash || p2p.hash === l2BlockSource.hash) &&
-      l1ToL2MessageSource === l2BlockSource.number;
-
-    this.log.debug(`Sequencer sync check ${result ? 'succeeded' : 'failed'}`, {
-      worldStateNumber: worldState.number,
-      worldStateHash: worldState.hash,
-      l2BlockSourceNumber: l2BlockSource.number,
-      l2BlockSourceHash: l2BlockSource.hash,
-      p2pNumber: p2p.number,
-      p2pHash: p2p.hash,
-      l1ToL2MessageSourceNumber: l1ToL2MessageSource,
-    });
+      l2BlockSource.hash === undefined
+        ? worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0
+        : worldState.hash === l2BlockSource.hash &&
+          p2p.hash === l2BlockSource.hash &&
+          l1ToL2MessageSource.hash === l2BlockSource.hash;
 
     if (!result) {
+      this.log.debug(`Sequencer sync check failed`, { worldState, l2BlockSource, p2p, l1ToL2MessageSource });
       return undefined;
     }
-    if (worldState.number >= INITIAL_L2_BLOCK_NUM) {
-      const block = await this.l2BlockSource.getBlock(worldState.number);
-      if (!block) {
-        // this shouldn't really happen because a moment ago we checked that all components were in synch
-        return undefined;
-      }
 
-      return { blockNumber: block.number, archive: block.archive.root };
-    } else {
+    // Special case for genesis state
+    const blockNumber = worldState.number;
+    if (blockNumber < INITIAL_L2_BLOCK_NUM) {
       const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
-      return { blockNumber: INITIAL_L2_BLOCK_NUM - 1, archive };
+      return { blockNumber: INITIAL_L2_BLOCK_NUM - 1, archive, l1Timestamp, pendingChainValidationStatus };
+    }
+
+    const block = await this.l2BlockSource.getBlock(blockNumber);
+    if (!block) {
+      // this shouldn't really happen because a moment ago we checked that all components were in sync
+      this.log.error(`Failed to get L2 block ${blockNumber} from the archiver with all components in sync`);
+      return undefined;
     }
+
+    return {
+      block,
+      blockNumber: block.number,
+      archive: block.archive.root,
+      l1Timestamp,
+      pendingChainValidationStatus,
+    };
+  }
+
+  /**
+   * Enqueues governance and slashing votes with the publisher. Does not block.
+   * @param publisher - The publisher to enqueue votes with
+   * @param attestorAddress - The attestor address to use for signing
+   * @param slot - The slot number
+   * @param timestamp - The timestamp for the votes
+   * @param context - Optional context for logging (e.g., block number)
+   * @returns A tuple of [governanceEnqueued, slashingEnqueued]
+   */
+  protected enqueueGovernanceAndSlashingVotes(
+    publisher: SequencerPublisher,
+    attestorAddress: EthAddress,
+    slot: bigint,
+    timestamp: bigint,
+  ): [Promise<boolean> | undefined, Promise<boolean> | undefined] {
+    try {
+      const signerFn = (msg: TypedDataDefinition) =>
+        this.validatorClient!.signWithAddress(attestorAddress, msg).then(s => s.toString());
+
+      const enqueueGovernancePromise =
+        this.governanceProposerPayload && !this.governanceProposerPayload.isZero()
+          ? publisher
+              .enqueueGovernanceCastSignal(this.governanceProposerPayload, slot, timestamp, attestorAddress, signerFn)
+              .catch(err => {
+                this.log.error(`Error enqueuing governance vote`, err, { slot });
+                return false;
+              })
+          : undefined;
+
+      const enqueueSlashingPromise = this.slasherClient
+        ? this.slasherClient
+            .getProposerActions(slot)
+            .then(actions => publisher.enqueueSlashingActions(actions, slot, timestamp, attestorAddress, signerFn))
+            .catch(err => {
+              this.log.error(`Error enqueuing slashing actions`, err, { slot });
+              return false;
+            })
+        : undefined;
+
+      return [enqueueGovernancePromise, enqueueSlashingPromise];
+    } catch (err) {
+      this.log.error(`Error enqueueing governance and slashing votes`, err);
+      return [undefined, undefined];
+    }
+  }
+
+  /**
+   * Checks if we are the proposer for the next slot.
+   * @returns True if we can propose, and the proposer address (undefined if anyone can propose)
+   */
+  protected async checkCanPropose(slot: bigint): Promise<[boolean, EthAddress | undefined]> {
+    let proposer: EthAddress | undefined;
+    try {
+      proposer = await this.epochCache.getProposerAttesterAddressInSlot(slot);
+    } catch (e) {
+      if (e instanceof NoCommitteeError) {
+        this.log.warn(`Cannot propose at next L2 slot ${slot} since the committee does not exist on L1`);
+        return [false, undefined];
+      }
+      this.log.error(`Error getting proposer for slot ${slot}`, e);
+      return [false, undefined];
+    }
+
+    // If proposer is undefined, then the committee is empty and anyone may propose
+    if (proposer === undefined) {
+      return [true, undefined];
+    }
+
+    const validatorAddresses = this.validatorClient!.getValidatorAddresses();
+    const weAreProposer = validatorAddresses.some(addr => addr.equals(proposer));
+
+    if (!weAreProposer) {
+      this.log.debug(`Cannot propose at slot ${slot} since we are not a proposer`, { validatorAddresses, proposer });
+      return [false, proposer];
+    }
+
+    return [true, proposer];
+  }
+
+  /**
+   * Tries to vote on slashing actions and governance when the sync check fails but we're past the max time for initializing a proposal.
+   * This allows the sequencer to participate in governance/slashing votes even when it cannot build blocks.
+   */
+  protected async tryVoteWhenSyncFails(args: { slot: bigint; ts: bigint }): Promise<void> {
+    const { slot, ts } = args;
+
+    // Prevent duplicate attempts in the same slot
+    if (this.lastSlotForVoteWhenSyncFailed === slot) {
+      this.log.debug(`Already attempted to vote in slot ${slot} (skipping)`);
+      return;
+    }
+
+    // Check if we're past the max time for initializing a proposal
+    const secondsIntoSlot = this.getSecondsIntoSlot(slot);
+    const maxAllowedTime = this.timetable.getMaxAllowedTime(SequencerState.INITIALIZING_PROPOSAL);
+
+    // If we haven't exceeded the time limit for initializing a proposal, don't proceed with voting
+    // We use INITIALIZING_PROPOSAL time limit because if we're past that, we can't build a block anyway
+    if (maxAllowedTime === undefined || secondsIntoSlot <= maxAllowedTime) {
+      this.log.trace(`Not attempting to vote since there is still for block building`, {
+        secondsIntoSlot,
+        maxAllowedTime,
+      });
+      return;
+    }
+
+    this.log.debug(`Sync for slot ${slot} failed, checking for voting opportunities`, {
+      secondsIntoSlot,
+      maxAllowedTime,
+    });
+
+    // Check if we're a proposer or proposal is open
+    const [canPropose, proposer] = await this.checkCanPropose(slot);
+    if (!canPropose) {
+      this.log.debug(`Cannot vote in slot ${slot} since we are not a proposer`, { slot, proposer });
+      return;
+    }
+
+    // Mark this slot as attempted
+    this.lastSlotForVoteWhenSyncFailed = slot;
+
+    // Get a publisher for voting
+    const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
+
+    this.log.debug(`Attempting to vote despite sync failure at slot ${slot}`, {
+      attestorAddress,
+      slot,
+    });
+
+    // Enqueue governance and slashing votes using the shared helper method
+    const votesPromises = this.enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, ts);
+    await Promise.all(votesPromises);
+
+    if (votesPromises.every(p => !p)) {
+      this.log.debug(`No votes to enqueue for slot ${slot}`);
+      return;
+    }
+
+    this.log.info(`Voting in slot ${slot} despite sync failure`, { slot });
+    await publisher.sendRequests();
+  }
+
+  /**
+   * Considers invalidating a block if the pending chain is invalid. Depends on how long the invalid block
+   * has been there without being invalidated and whether the sequencer is in the committee or not. We always
+   * have the proposer try to invalidate, but if they fail, the sequencers in the committee are expected to try,
+   * and if they fail, any sequencer will try as well.
+   */
+  protected async considerInvalidatingBlock(
+    syncedTo: NonNullable<Awaited<ReturnType<Sequencer['checkSync']>>>,
+    currentSlot: bigint,
+  ): Promise<void> {
+    const { pendingChainValidationStatus, l1Timestamp } = syncedTo;
+    if (pendingChainValidationStatus.valid) {
+      return;
+    }
+
+    const { publisher } = await this.publisherFactory.create(undefined);
+    const invalidBlockNumber = pendingChainValidationStatus.block.blockNumber;
+    const invalidBlockTimestamp = pendingChainValidationStatus.block.timestamp;
+    const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidBlockTimestamp);
+    const ourValidatorAddresses = this.validatorClient!.getValidatorAddresses();
+
+    const { secondsBeforeInvalidatingBlockAsCommitteeMember, secondsBeforeInvalidatingBlockAsNonCommitteeMember } =
+      this.config;
+
+    const logData = {
+      invalidL1Timestamp: invalidBlockTimestamp,
+      l1Timestamp,
+      invalidBlock: pendingChainValidationStatus.block,
+      secondsBeforeInvalidatingBlockAsCommitteeMember,
+      secondsBeforeInvalidatingBlockAsNonCommitteeMember,
+      ourValidatorAddresses,
+      currentSlot,
+    };
+
+    const inCurrentCommittee = () =>
+      this.epochCache
+        .getCommittee(currentSlot)
+        .then(c => c?.committee?.some(member => ourValidatorAddresses.some(addr => addr.equals(member))));
+
+    const invalidateAsCommitteeMember =
+      secondsBeforeInvalidatingBlockAsCommitteeMember !== undefined &&
+      secondsBeforeInvalidatingBlockAsCommitteeMember > 0 &&
+      timeSinceChainInvalid > secondsBeforeInvalidatingBlockAsCommitteeMember &&
+      (await inCurrentCommittee());
+
+    const invalidateAsNonCommitteeMember =
+      secondsBeforeInvalidatingBlockAsNonCommitteeMember !== undefined &&
+      secondsBeforeInvalidatingBlockAsNonCommitteeMember > 0 &&
+      timeSinceChainInvalid > secondsBeforeInvalidatingBlockAsNonCommitteeMember;
+
+    if (!invalidateAsCommitteeMember && !invalidateAsNonCommitteeMember) {
+      this.log.debug(`Not invalidating pending chain`, logData);
+      return;
+    }
+
+    const invalidateBlock = await publisher.simulateInvalidateBlock(pendingChainValidationStatus);
+    if (!invalidateBlock) {
+      this.log.warn(`Failed to simulate invalidate block`, logData);
+      return;
+    }
+
+    this.log.info(
+      invalidateAsCommitteeMember
+        ? `Invalidating block ${invalidBlockNumber} as committee member`
+        : `Invalidating block ${invalidBlockNumber} as non-committee member`,
+      logData,
+    );
+
+    publisher.enqueueInvalidateBlock(invalidateBlock);
+    await publisher.sendRequests();
   }
 
-  private getSlotStartTimestamp(slotNumber: number | bigint): number {
-    return Number(this.l1Constants.l1GenesisTime) + Number(slotNumber) * this.l1Constants.slotDuration;
+  private getSlotStartBuildTimestamp(slotNumber: number | bigint): number {
+    return getSlotStartBuildTimestamp(slotNumber, this.l1Constants);
   }
 
   private getSecondsIntoSlot(slotNumber: number | bigint): number {
-    const slotStartTimestamp = this.getSlotStartTimestamp(slotNumber);
+    const slotStartTimestamp = this.getSlotStartBuildTimestamp(slotNumber);
     return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
   }
 
@@ -749,11 +1100,11 @@ export class Sequencer {
     return this.l1Constants.slotDuration;
   }
 
-  get coinbase(): EthAddress {
-    return this._coinbase;
+  get maxL2BlockGas(): number | undefined {
+    return this.config.maxL2BlockGas;
   }
 
-  get feeRecipient(): AztecAddress {
-    return this._feeRecipient;
+  public getSlasherClient(): SlasherClientInterface | undefined {
+    return this.slasherClient;
   }
 }