@aztec/sequencer-client 3.0.0-devnet.6 → 3.0.0-devnet.6-patch.1

package/src/sequencer/sequencer.ts

@@ -1,12 +1,15 @@
 import { L2Block } from '@aztec/aztec.js/block';
-import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { getKzg } from '@aztec/blob-lib';
+import { BLOBS_PER_CHECKPOINT, 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 { NoCommitteeError, type RollupContract } from '@aztec/ethereum/contracts';
+import { FormattedViemError } from '@aztec/ethereum/utils';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { omit, pick } from '@aztec/foundation/collection';
-import { randomInt } from '@aztec/foundation/crypto';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 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 } from '@aztec/foundation/timer';
@@ -17,6 +20,7 @@ import {
   CommitteeAttestation,
   CommitteeAttestationsAndSigners,
   type L2BlockSource,
+  MaliciousCommitteeAttestationsAndSigners,
   type ValidateBlockResult,
 } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
@@ -60,7 +64,7 @@ export type SequencerEvents = {
     oldState: SequencerState;
     newState: SequencerState;
     secondsIntoSlot?: number;
-    slotNumber?: bigint;
+    slotNumber?: SlotNumber;
   }) => void;
   ['proposer-rollup-check-failed']: (args: { reason: string }) => void;
   ['tx-count-check-failed']: (args: { minTxs: number; availableTxs: number }) => void;
@@ -71,7 +75,7 @@ export type SequencerEvents = {
     sentActions?: Action[];
     expiredActions?: Action[];
   }) => void;
-  ['block-published']: (args: { blockNumber: number; slot: number }) => void;
+  ['block-published']: (args: { blockNumber: BlockNumber; slot: number }) => void;
 };
 
 /**
@@ -98,6 +102,12 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
 
   private governanceProposerPayload: EthAddress | undefined;
 
+  /** The last slot for which we attempted to vote when sync failed, to prevent duplicate attempts. */
+  private lastSlotForVoteWhenSyncFailed: SlotNumber | undefined;
+
+  /** The last slot for which we built a validation block in fisherman mode, to prevent duplicate attempts. */
+  private lastSlotForValidationBlock: SlotNumber | 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;
@@ -129,6 +139,11 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   ) {
     super();
 
+    // Add [FISHERMAN] prefix to logger if in fisherman mode
+    if (this.config.fishermanMode) {
+      this.log = log.createChild('[FISHERMAN]');
+    }
+
     this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
     // Initialize config
     this.updateConfig(this.config);
@@ -207,6 +222,8 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   }
 
   public async init() {
+    // Takes ~3s to precompute some tables.
+    getKzg();
     this.publisher = (await this.publisherFactory.create(undefined)).publisher;
   }
 
@@ -214,7 +231,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
    * Starts the sequencer and moves to IDLE state.
    */
   public start() {
-    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollingIntervalMs);
+    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('Started sequencer');
@@ -248,27 +265,28 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
    *          - Submit block
    *          - If our block for some reason is not included, revert the state
    */
-  protected async doRealWork() {
+  protected async work() {
     this.setState(SequencerState.SYNCHRONIZING, undefined);
+    const { slot, ts, now } = this.epochCache.getEpochAndSlotInNextL1Slot();
 
-    // Check all components are synced to latest as seen by the archiver
-    const syncedTo = await this.getChainTip();
+    // 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;
+    }
 
-    // Do not go forward with new block if the previous one has not been mined and processed
+    // 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 { slot, ts, now } = this.epochCache.getEpochAndSlotInNextL1Slot();
+    const newBlockNumber = BlockNumber(syncedTo.blockNumber + 1);
 
-    this.setState(SequencerState.PROPOSER_CHECK, slot);
-
-    // 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 syncLogData = {
       now,
       syncedToL1Ts: syncedTo.l1Timestamp,
@@ -280,84 +298,70 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       isPendingChainValid: pick(syncedTo.pendingChainValidationStatus, 'valid', 'reason', 'invalidIndex'),
     };
 
-    if (syncedTo.l1Timestamp + BigInt(this.l1Constants.ethereumSlotDuration) < ts) {
-      this.log.debug(
-        `Cannot propose block ${newBlockNumber} at next L2 slot ${slot} due to pending sync from L1`,
-        syncLogData,
-      );
-      return;
-    }
-
-    // Check that the slot is not taken by a block already
-    if (syncedTo.block && syncedTo.block.header.getSlot() >= slot) {
-      this.log.debug(
-        `Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`,
-        { ...syncLogData, block: syncedTo.block.header.toInspect() },
-      );
-      return;
-    }
+    // Check that we are a proposer for the next slot
+    this.setState(SequencerState.PROPOSER_CHECK, slot);
+    const [canPropose, proposer] = await this.checkCanPropose(slot);
 
-    // Or that we haven't published it ourselves
-    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}`,
-        { ...syncLogData, block: this.lastBlockPublished.header.toInspect() },
-      );
+    // 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 we are a proposer for the next slot
-    let proposerInNextSlot: EthAddress | undefined;
-    try {
-      proposerInNextSlot = await this.epochCache.getProposerAttesterAddressInNextSlot();
-    } catch (e) {
-      if (e instanceof NoCommitteeError) {
-        this.log.warn(
-          `Cannot propose block ${newBlockNumber} at next L2 slot ${slot} since the committee does not exist on L1`,
-        );
+    // In fisherman mode, check if we've already validated this slot to prevent duplicate attempts
+    if (this.config.fishermanMode) {
+      if (this.lastSlotForValidationBlock === slot) {
+        this.log.trace(`Already validated block building for slot ${slot} (skipping)`, { slot });
         return;
       }
+      this.log.debug(
+        `Building validation block for slot ${slot} (actual proposer: ${proposer?.toString() ?? 'none'})`,
+        { slot, proposer: proposer?.toString() },
+      );
+      // Mark this slot as being validated
+      this.lastSlotForValidationBlock = slot;
     }
 
-    // If get proposer in next slot is undefined, then the committee is empty and anyone may propose.
-    // If the committee is defined and not empty, but none of our validators are the proposer, then stop.
-    const validatorAddresses = this.validatorClient!.getValidatorAddresses();
-    if (proposerInNextSlot !== undefined && !validatorAddresses.some(addr => addr.equals(proposerInNextSlot))) {
-      this.log.debug(`Cannot propose block ${newBlockNumber} since we are not a proposer`, {
-        us: validatorAddresses,
-        proposer: proposerInNextSlot,
-        ...syncLogData,
-      });
-      // If the pending chain is invalid, we may need to invalidate the block if no one else is doing it.
-      if (!syncedTo.pendingChainValidationStatus.valid) {
-        // We pass i undefined here to get any available publisher.
-        const { publisher } = await this.publisherFactory.create(undefined);
-        await this.considerInvalidatingBlock(syncedTo, slot, validatorAddresses, publisher);
-      }
+    // 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() },
+      );
+      this.metrics.recordBlockProposalPrecheckFailed('slot_already_taken');
       return;
     }
 
-    // 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 proposerAddressInNextSlot = proposerInNextSlot ?? EthAddress.ZERO;
-
     // 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(proposerInNextSlot);
-
+    // In fisherman mode, pass undefined to use the fisherman's own keystore instead of the actual proposer's
+    const { attestorAddress, publisher } = await this.publisherFactory.create(
+      this.config.fishermanMode ? undefined : proposer,
+    );
     this.log.verbose(`Created publisher at address ${publisher.getSenderAddress()} for attestor ${attestorAddress}`);
-
     this.publisher = publisher;
 
+    // In fisherman mode, set the actual proposer's address for simulations
+    if (this.config.fishermanMode) {
+      if (proposer) {
+        publisher.setProposerAddressForSimulation(proposer);
+        this.log.debug(`Set proposer address ${proposer} for simulation in fisherman mode`);
+      }
+    }
+
+    // Get proposer credentials
     const coinbase = this.validatorClient!.getCoinbaseForAttestor(attestorAddress);
     const feeRecipient = this.validatorClient!.getFeeRecipientForAttestor(attestorAddress);
 
     // 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,
-      proposerAddressInNextSlot,
+      proposer ?? EthAddress.ZERO,
       invalidateBlock,
     );
 
@@ -367,6 +371,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         syncLogData,
       );
       this.emit('proposer-rollup-check-failed', { reason: 'Rollup contract check failed' });
+      this.metrics.recordBlockProposalPrecheckFailed('rollup_contract_check_failed');
       return;
     } else if (canProposeCheck.slot !== slot) {
       this.log.warn(
@@ -374,20 +379,19 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         { ...syncLogData, rollup: canProposeCheck, newBlockNumber, expectedSlot: slot },
       );
       this.emit('proposer-rollup-check-failed', { reason: 'Slot mismatch' });
+      this.metrics.recordBlockProposalPrecheckFailed('slot_mismatch');
       return;
-    } else if (canProposeCheck.blockNumber !== BigInt(newBlockNumber)) {
+    } else if (canProposeCheck.checkpointNumber !== CheckpointNumber.fromBlockNumber(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}.`,
+        `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.checkpointNumber}.`,
         { ...syncLogData, rollup: canProposeCheck, newBlockNumber, expectedSlot: slot },
       );
       this.emit('proposer-rollup-check-failed', { reason: 'Block mismatch' });
+      this.metrics.recordBlockProposalPrecheckFailed('block_number_mismatch');
       return;
     }
 
-    this.log.debug(
-      `Can propose block ${newBlockNumber} at slot ${slot}` + (proposerInNextSlot ? ` as ${proposerInNextSlot}` : ''),
-      { ...syncLogData, validatorAddresses },
-    );
+    this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot} as ${proposer}`, { ...syncLogData });
 
     const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(
       newBlockNumber,
@@ -396,53 +400,98 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       slot,
     );
 
-    const { timestamp } = newGlobalVariables;
-    const signerFn = (msg: TypedDataDefinition) =>
-      this.validatorClient!.signWithAddress(attestorAddress, msg).then(s => s.toString());
-
-    const enqueueGovernanceSignalPromise =
-      this.governanceProposerPayload && !this.governanceProposerPayload.isZero()
-        ? publisher
-            .enqueueGovernanceCastSignal(this.governanceProposerPayload, slot, timestamp, attestorAddress, signerFn)
-            .catch(err => {
-              this.log.error(`Error enqueuing governance vote`, err, { blockNumber: newBlockNumber, slot });
-              return false;
-            })
-        : Promise.resolve(false);
-
-    const enqueueSlashingActionsPromise = 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, { blockNumber: newBlockNumber, slot });
-            return false;
-          })
-      : Promise.resolve(false);
+    // Enqueue governance and slashing votes (returns promises that will be awaited later)
+    // In fisherman mode, we simulate slashing but don't actually publish to L1
+    const votesPromises = this.enqueueGovernanceAndSlashingVotes(
+      publisher,
+      attestorAddress,
+      slot,
+      newGlobalVariables.timestamp,
+    );
 
+    // Enqueues block invalidation
     if (invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
       publisher.enqueueInvalidateBlock(invalidateBlock);
     }
 
+    // Actual block building
     this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
+    this.metrics.incOpenSlot(slot, proposer?.toString() ?? 'unknown');
+    const block: L2Block | undefined = await this.tryBuildBlockAndEnqueuePublish(
+      slot,
+      proposer,
+      newBlockNumber,
+      publisher,
+      newGlobalVariables,
+      chainTipArchive,
+      invalidateBlock,
+    );
 
-    this.metrics.incOpenSlot(slot, proposerAddressInNextSlot.toString());
+    // Wait until the voting promises have resolved, so all requests are enqueued
+    await Promise.all(votesPromises);
+
+    // In fisherman mode, we don't publish to L1
+    if (this.config.fishermanMode) {
+      // Clear pending requests
+      publisher.clearPendingRequests();
+
+      if (block) {
+        this.log.info(`Validation block building SUCCEEDED for slot ${slot}`, {
+          blockNumber: newBlockNumber,
+          slot: Number(slot),
+          archive: block.archive.toString(),
+          txCount: block.body.txEffects.length,
+        });
+        this.lastBlockPublished = block;
+        this.metrics.recordBlockProposalSuccess();
+      } else {
+        // Block building failed in fisherman mode
+        this.log.warn(`Validation block building FAILED for slot ${slot}`, {
+          blockNumber: newBlockNumber,
+          slot: Number(slot),
+        });
+        this.metrics.recordBlockProposalFailed('block_build_failed');
+      }
+    } else {
+      // Normal mode: 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: SlotNumber,
+    proposer: EthAddress | undefined,
+    newBlockNumber: BlockNumber,
+    publisher: SequencerPublisher,
+    newGlobalVariables: GlobalVariables,
+    chainTipArchive: Fr,
+    invalidateBlock: InvalidateBlockRequest | undefined,
+  ) {
     this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-      proposer: proposerInNextSlot?.toString(),
-      coinbase,
+      proposer,
       publisher: publisher.getSenderAddress(),
-      feeRecipient,
       globalVariables: newGlobalVariables.toInspect(),
       chainTipArchive,
       blockNumber: newBlockNumber,
       slot,
     });
 
-    // If I created a "partial" header here that should make our job much easier.
     const proposalHeader = CheckpointHeader.from({
       ...newGlobalVariables,
       timestamp: newGlobalVariables.timestamp,
       lastArchiveRoot: chainTipArchive,
+      blockHeadersHash: Fr.ZERO,
       contentCommitment: ContentCommitment.empty(),
       totalManaUsed: Fr.ZERO,
     });
@@ -459,7 +508,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
           pendingTxs,
           proposalHeader,
           newGlobalVariables,
-          proposerInNextSlot,
+          proposer,
           invalidateBlock,
           publisher,
         );
@@ -470,6 +519,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         } else {
           this.log.error(`Error building/enqueuing block`, err, { blockNumber: newBlockNumber, slot });
         }
+        this.metrics.recordBlockProposalFailed(err.name || 'unknown_error');
       }
     } else {
       this.log.verbose(
@@ -477,27 +527,15 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         { chainTipArchive, blockNumber: newBlockNumber, slot },
       );
       this.emit('tx-count-check-failed', { minTxs: this.minTxsPerBlock, availableTxs: pendingTxCount });
+      this.metrics.recordBlockProposalFailed('insufficient_txs');
     }
-
-    await Promise.all([enqueueGovernanceSignalPromise, enqueueSlashingActionsPromise]);
-
-    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);
+    return block;
   }
 
   @trackSpan('Sequencer.work')
-  protected async work() {
+  protected async safeWork() {
     try {
-      await this.doRealWork();
+      await this.work();
     } catch (err) {
       if (err instanceof SequencerTooSlowError) {
         // Log as warn only if we had to abort halfway through the block proposal
@@ -520,13 +558,13 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
    * @param slotNumber - The current slot number.
    * @param force - Whether to force the transition even if the sequencer is stopped.
    */
-  setState(proposedState: SequencerStateWithSlot, slotNumber: bigint, opts?: { force?: boolean }): void;
+  setState(proposedState: SequencerStateWithSlot, slotNumber: SlotNumber, 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 {
+  setState(proposedState: SequencerState, slotNumber: SlotNumber | 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();
@@ -567,7 +605,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     await this.p2pClient.deleteTxs(failedTxHashes);
   }
 
-  protected getBlockBuilderOptions(slot: number): PublicProcessorLimits {
+  protected getBlockBuilderOptions(slot: SlotNumber): PublicProcessorLimits {
     // Deadline for processing depends on whether we're proposing a block
     const secondsIntoSlot = this.getSecondsIntoSlot(slot);
     const processingEndTimeWithinSlot = this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
@@ -580,7 +618,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       maxTransactions: this.maxTxsPerBlock,
       maxBlockSize: this.maxBlockSizeInBytes,
       maxBlockGas: this.maxBlockGas,
-      maxBlobFields: BLOBS_PER_BLOCK * FIELDS_PER_BLOB,
+      maxBlobFields: BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB,
       deadline,
     };
   }
@@ -610,14 +648,15 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     await publisher.validateBlockHeader(proposalHeader, invalidateBlock);
 
     const blockNumber = newGlobalVariables.blockNumber;
-    const slot = proposalHeader.slotNumber.toBigInt();
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
+    const checkpointNumber = CheckpointNumber.fromBlockNumber(blockNumber);
+    const slot = proposalHeader.slotNumber;
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
 
     const workTimer = new Timer();
     this.setState(SequencerState.CREATING_BLOCK, slot);
 
     try {
-      const blockBuilderOptions = this.getBlockBuilderOptions(Number(slot));
+      const blockBuilderOptions = this.getBlockBuilderOptions(slot);
       const buildBlockRes = await this.blockBuilder.buildBlock(
         pendingTxs,
         l1ToL2Messages,
@@ -665,19 +704,28 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         },
       );
 
-      this.log.debug('Collecting attestations');
-      const attestations = await this.collectAttestations(block, usedTxs, proposerAddress);
-      if (attestations !== undefined) {
-        this.log.verbose(`Collected ${attestations.length} attestations`, { blockHash, blockNumber });
+      // In fisherman mode, skip attestation collection
+      let attestationsAndSigners: CommitteeAttestationsAndSigners;
+      if (this.config.fishermanMode) {
+        this.log.debug('Skipping attestation collection');
+        attestationsAndSigners = CommitteeAttestationsAndSigners.empty();
+      } else {
+        this.log.debug('Collecting attestations');
+        attestationsAndSigners = await this.collectAttestations(block, usedTxs, proposerAddress);
+        this.log.verbose(
+          `Collected ${attestationsAndSigners.attestations.length} attestations for block ${blockNumber} at slot ${slot}`,
+          { blockHash, blockNumber, slot },
+        );
       }
 
-      const attestationsAndSigners = new CommitteeAttestationsAndSigners(attestations ?? []);
-      const attestationsAndSignersSignature = this.validatorClient
-        ? await this.validatorClient.signAttestationsAndSigners(
-            attestationsAndSigners,
-            proposerAddress ?? publisher.getSenderAddress(),
-          )
-        : Signature.empty();
+      // In fisherman mode, skip attestation signing
+      const attestationsAndSignersSignature =
+        this.config.fishermanMode || !this.validatorClient
+          ? Signature.empty()
+          : await this.validatorClient.signAttestationsAndSigners(
+              attestationsAndSigners,
+              proposerAddress ?? publisher.getSenderAddress(),
+            );
 
       await this.enqueuePublishL2Block(
         block,
@@ -703,8 +751,8 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     block: L2Block,
     txs: Tx[],
     proposerAddress: EthAddress | undefined,
-  ): Promise<CommitteeAttestation[] | undefined> {
-    const { committee } = await this.epochCache.getCommittee(block.header.getSlot());
+  ): Promise<CommitteeAttestationsAndSigners> {
+    const { committee, seed, epoch } = await this.epochCache.getCommittee(block.slot);
 
     // We checked above that the committee is defined, so this should never happen.
     if (!committee) {
@@ -713,20 +761,18 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
 
     if (committee.length === 0) {
       this.log.verbose(`Attesting committee is empty`);
-      return undefined;
+      return CommitteeAttestationsAndSigners.empty();
     } else {
       this.log.debug(`Attesting committee length is ${committee.length}`);
     }
 
     if (!this.validatorClient) {
-      const msg = 'Missing validator client: Cannot collect attestations';
-      this.log.error(msg);
-      throw new Error(msg);
+      throw new Error('Missing validator client: Cannot collect attestations');
     }
 
     const numberOfRequiredAttestations = Math.floor((committee.length * 2) / 3) + 1;
 
-    const slotNumber = block.header.globalVariables.slotNumber.toBigInt();
+    const slotNumber = block.header.globalVariables.slotNumber;
     this.setState(SequencerState.COLLECTING_ATTESTATIONS, slotNumber);
 
     this.log.debug('Creating block proposal for validators');
@@ -738,7 +784,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       block.header.globalVariables.blockNumber,
       block.getCheckpointHeader(),
       block.archive.root,
-      block.header.state,
       txs,
       proposerAddress,
       blockProposalOptions,
@@ -751,7 +796,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     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);
+      return new CommitteeAttestationsAndSigners(orderAttestations(attestations ?? [], committee));
     }
 
     this.log.debug('Broadcasting block proposal to validators');
@@ -777,13 +822,13 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
 
       // 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();
+
+      // manipulate the attestations if we've been configured to do so
+      if (this.config.injectFakeAttestation || this.config.shuffleAttestationOrdering) {
+        return this.manipulateAttestations(block, epoch, seed, committee, sorted);
       }
-      return sorted;
+
+      return new CommitteeAttestationsAndSigners(sorted);
     } catch (err) {
       if (err && err instanceof AttestationTimeoutError) {
         collectedAttestationsCount = err.collectedCount;
@@ -794,6 +839,53 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     }
   }
 
+  /** Breaks the attestations before publishing based on attack configs */
+  private manipulateAttestations(
+    block: L2Block,
+    epoch: EpochNumber,
+    seed: bigint,
+    committee: EthAddress[],
+    attestations: CommitteeAttestation[],
+  ) {
+    // Compute the proposer index in the committee, since we dont want to tweak it.
+    // Otherwise, the L1 rollup contract will reject the block outright.
+    const proposerIndex = Number(
+      this.epochCache.computeProposerIndex(block.slot, epoch, seed, BigInt(committee.length)),
+    );
+
+    if (this.config.injectFakeAttestation) {
+      // Find non-empty attestations that are not from the proposer
+      const nonProposerIndices: number[] = [];
+      for (let i = 0; i < attestations.length; i++) {
+        if (!attestations[i].signature.isEmpty() && i !== proposerIndex) {
+          nonProposerIndices.push(i);
+        }
+      }
+      if (nonProposerIndices.length > 0) {
+        const targetIndex = nonProposerIndices[randomInt(nonProposerIndices.length)];
+        this.log.warn(`Injecting fake attestation in block ${block.number} at index ${targetIndex}`);
+        unfreeze(attestations[targetIndex]).signature = Signature.random();
+      }
+      return new CommitteeAttestationsAndSigners(attestations);
+    }
+
+    if (this.config.shuffleAttestationOrdering) {
+      this.log.warn(`Shuffling attestation ordering in block ${block.number} (proposer index ${proposerIndex})`);
+
+      const shuffled = [...attestations];
+      const [i, j] = [(proposerIndex + 1) % shuffled.length, (proposerIndex + 2) % shuffled.length];
+      const valueI = shuffled[i];
+      const valueJ = shuffled[j];
+      shuffled[i] = valueJ;
+      shuffled[j] = valueI;
+
+      const signers = new CommitteeAttestationsAndSigners(attestations).getSigners();
+      return new MaliciousCommitteeAttestationsAndSigners(shuffled, signers);
+    }
+
+    return new CommitteeAttestationsAndSigners(attestations);
+  }
+
   /**
    * Publishes the L2Block to the rollup contract.
    * @param block - The L2Block to be published.
@@ -809,10 +901,10 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     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());
+    this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber);
 
     // Time out tx at the end of the slot
-    const slot = block.header.globalVariables.slotNumber.toNumber();
+    const slot = block.header.globalVariables.slotNumber;
     const txTimeoutAt = new Date((this.getSlotStartBuildTimestamp(slot) + this.aztecSlotDuration) * 1000);
 
     const enqueued = await publisher.enqueueProposeL2Block(
@@ -833,18 +925,31 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   /**
    * 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<
+  protected async checkSync(args: { ts: bigint; slot: SlotNumber }): Promise<
     | {
         block?: L2Block;
-        blockNumber: number;
+        blockNumber: BlockNumber;
         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(({ syncSummary }) => ({
         number: syncSummary.latestBlockNumber,
@@ -853,49 +958,203 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       this.l2BlockSource.getL2Tips().then(t => t.latest),
       this.p2pClient.getStatus().then(p2p => p2p.syncedToL2Block),
       this.l1ToL2MessageSource.getL2Tips().then(t => t.latest),
-      this.l2BlockSource.getL1Timestamp(),
       this.l2BlockSource.getPendingChainValidationStatus(),
     ] as const);
 
-    const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, l1Timestamp, pendingChainValidationStatus] =
-      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)
+    // Handle zero as a special case, since the block hash won't match across services if we're changing the prefilled data for the genesis block,
+    // as the world state can compute the new genesis block hash, but other components use the hardcoded constant.
     const result =
-      l2BlockSource.hash === undefined
-        ? worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0
-        : worldState.hash === l2BlockSource.hash &&
-          p2p.hash === l2BlockSource.hash &&
-          l1ToL2MessageSource.hash === l2BlockSource.hash;
-
-    const logData = { worldState, l2BlockSource, p2p, l1ToL2MessageSource };
-    this.log.debug(`Sequencer sync check ${result ? 'succeeded' : 'failed'}`, logData);
+      (l2BlockSource.number === 0 && 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;
     }
 
+    // Special case for genesis state
     const blockNumber = worldState.number;
-    if (blockNumber >= INITIAL_L2_BLOCK_NUM) {
-      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.warn(`Failed to get L2 block ${blockNumber} from the archiver with all components in sync`, logData);
-        return undefined;
+    if (blockNumber < INITIAL_L2_BLOCK_NUM) {
+      const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
+      return { blockNumber: 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: SlotNumber,
+    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 => {
+              // Record metrics for fisherman mode
+              if (this.config.fishermanMode && actions.length > 0) {
+                this.log.debug(`Fisherman mode: simulating ${actions.length} slashing action(s) for slot ${slot}`, {
+                  slot,
+                  actionCount: actions.length,
+                });
+                this.metrics.recordSlashingAttempt(actions.length);
+              }
+              // Enqueue the actions to fully simulate L1 tx building (they won't be sent in fisherman mode)
+              return 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: SlotNumber): 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];
+    }
 
-      return {
-        block,
-        blockNumber: block.number,
-        archive: block.archive.root,
-        l1Timestamp,
-        pendingChainValidationStatus,
-      };
-    } else {
-      const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
-      return { blockNumber: INITIAL_L2_BLOCK_NUM - 1, archive, l1Timestamp, pendingChainValidationStatus };
+    // If proposer is undefined, then the committee is empty and anyone may propose
+    if (proposer === undefined) {
+      return [true, undefined];
+    }
+    // In fisherman mode, just return the current proposer
+    if (this.config.fishermanMode) {
+      return [true, proposer];
+    }
+
+    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: SlotNumber; 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();
   }
 
   /**
@@ -905,10 +1164,8 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
    * and if they fail, any sequencer will try as well.
    */
   protected async considerInvalidatingBlock(
-    syncedTo: NonNullable<Awaited<ReturnType<Sequencer['getChainTip']>>>,
-    currentSlot: bigint,
-    ourValidatorAddresses: EthAddress[],
-    publisher: SequencerPublisher,
+    syncedTo: NonNullable<Awaited<ReturnType<Sequencer['checkSync']>>>,
+    currentSlot: SlotNumber,
   ): Promise<void> {
     const { pendingChainValidationStatus, l1Timestamp } = syncedTo;
     if (pendingChainValidationStatus.valid) {
@@ -918,6 +1175,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     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;
@@ -953,6 +1211,24 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       return;
     }
 
+    let validatorToUse: EthAddress;
+    if (invalidateAsCommitteeMember) {
+      // When invalidating as a committee member, use first validator that's actually in the committee
+      const { committee } = await this.epochCache.getCommittee(currentSlot);
+      if (committee) {
+        const committeeSet = new Set(committee.map(addr => addr.toString()));
+        validatorToUse =
+          ourValidatorAddresses.find(addr => committeeSet.has(addr.toString())) ?? ourValidatorAddresses[0];
+      } else {
+        validatorToUse = ourValidatorAddresses[0];
+      }
+    } else {
+      // When invalidating as a non-committee member, use the first validator
+      validatorToUse = ourValidatorAddresses[0];
+    }
+
+    const { publisher } = await this.publisherFactory.create(validatorToUse);
+
     const invalidateBlock = await publisher.simulateInvalidateBlock(pendingChainValidationStatus);
     if (!invalidateBlock) {
       this.log.warn(`Failed to simulate invalidate block`, logData);
@@ -967,14 +1243,20 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     );
 
     publisher.enqueueInvalidateBlock(invalidateBlock);
-    await publisher.sendRequests();
+
+    if (!this.config.fishermanMode) {
+      await publisher.sendRequests();
+    } else {
+      this.log.info('Invalidating block in fisherman mode, clearing pending requests');
+      publisher.clearPendingRequests();
+    }
   }
 
-  private getSlotStartBuildTimestamp(slotNumber: number | bigint): number {
+  private getSlotStartBuildTimestamp(slotNumber: SlotNumber): number {
     return getSlotStartBuildTimestamp(slotNumber, this.l1Constants);
   }
 
-  private getSecondsIntoSlot(slotNumber: number | bigint): number {
+  private getSecondsIntoSlot(slotNumber: SlotNumber): number {
     const slotStartTimestamp = this.getSlotStartBuildTimestamp(slotNumber);
     return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
   }