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

package/dest/sequencer/sequencer.js

@@ -4,26 +4,33 @@ function _ts_decorate(decorators, target, key, desc) {
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { omit } from '@aztec/foundation/collection';
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { FormattedViemError, NoCommitteeError } from '@aztec/ethereum';
+import { omit, pick } from '@aztec/foundation/collection';
+import { randomInt } from '@aztec/foundation/crypto';
 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 { Timer, elapsed } from '@aztec/foundation/timer';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Timer } from '@aztec/foundation/timer';
+import { unfreeze } from '@aztec/foundation/types';
+import { CommitteeAttestationsAndSigners, MaliciousCommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
+import { orderAttestations } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
-import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import { BlockHeader, ContentCommitment, StateReference, Tx } from '@aztec/stdlib/tx';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { ContentCommitment } from '@aztec/stdlib/tx';
+import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { VoteType } from '../publisher/sequencer-publisher.js';
-import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
-import { getDefaultAllowedSetupFunctions } from './allowed.js';
+import EventEmitter from 'node:events';
+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 } from './utils.js';
 export { SequencerState };
 /**
  * Sequencer client
@@ -33,80 +40,68 @@ export { SequencerState };
  * - Adds proof requests to the request pool (not for this milestone).
  * - 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 {
-    publisher;
+ */ export class Sequencer extends EventEmitter {
+    publisherFactory;
     validatorClient;
     globalsBuilder;
     p2pClient;
     worldState;
     slasherClient;
-    blockBuilderFactory;
     l2BlockSource;
     l1ToL2MessageSource;
-    publicProcessorFactory;
-    contractDataSource;
+    blockBuilder;
     l1Constants;
     dateProvider;
+    epochCache;
+    rollupContract;
     config;
+    telemetry;
     log;
     runningPromise;
     pollingIntervalMs;
     maxTxsPerBlock;
     minTxsPerBlock;
     maxL1TxInclusionTimeIntoSlot;
-    // TODO: zero values should not be allowed for the following 2 values in PROD
-    _coinbase;
-    _feeRecipient;
     state;
-    allowedInSetup;
     maxBlockSizeInBytes;
     maxBlockGas;
     metrics;
-    isFlushing;
+    lastBlockPublished;
+    governanceProposerPayload;
+    /** The last slot for which we attempted to vote when sync failed, to prevent duplicate attempts. */ lastSlotForVoteWhenSyncFailed;
+    /** The last slot for which we built a validation block in fisherman mode, to prevent duplicate attempts. */ lastSlotForValidationBlock;
     /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */ timetable;
     enforceTimeTable;
-    constructor(publisher, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, blockBuilderFactory, l2BlockSource, l1ToL2MessageSource, publicProcessorFactory, contractDataSource, l1Constants, dateProvider, config = {}, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
-        this.publisher = publisher;
-        this.validatorClient = validatorClient;
-        this.globalsBuilder = globalsBuilder;
-        this.p2pClient = p2pClient;
-        this.worldState = worldState;
-        this.slasherClient = slasherClient;
-        this.blockBuilderFactory = blockBuilderFactory;
-        this.l2BlockSource = l2BlockSource;
-        this.l1ToL2MessageSource = l1ToL2MessageSource;
-        this.publicProcessorFactory = publicProcessorFactory;
-        this.contractDataSource = contractDataSource;
-        this.l1Constants = l1Constants;
-        this.dateProvider = dateProvider;
-        this.config = config;
-        this.log = log;
-        this.pollingIntervalMs = 1000;
-        this.maxTxsPerBlock = 32;
-        this.minTxsPerBlock = 1;
-        this.maxL1TxInclusionTimeIntoSlot = 0;
-        this._coinbase = EthAddress.ZERO;
-        this._feeRecipient = AztecAddress.ZERO;
-        this.state = SequencerState.STOPPED;
-        this.allowedInSetup = [];
-        this.maxBlockSizeInBytes = 1024 * 1024;
-        this.maxBlockGas = new Gas(100e9, 100e9);
-        this.isFlushing = false;
-        this.enforceTimeTable = false;
-        this.metrics = new SequencerMetrics(telemetry, ()=>this.state, 'Sequencer');
-        // 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 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.
+    publisher;
+    constructor(publisherFactory, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, l2BlockSource, l1ToL2MessageSource, blockBuilder, l1Constants, dateProvider, epochCache, rollupContract, config, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
+        super(), this.publisherFactory = publisherFactory, this.validatorClient = validatorClient, this.globalsBuilder = globalsBuilder, this.p2pClient = p2pClient, this.worldState = worldState, this.slasherClient = slasherClient, this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.blockBuilder = blockBuilder, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.epochCache = epochCache, this.rollupContract = rollupContract, this.config = config, this.telemetry = telemetry, this.log = log, this.pollingIntervalMs = 1000, this.maxTxsPerBlock = 32, this.minTxsPerBlock = 1, this.maxL1TxInclusionTimeIntoSlot = 0, this.state = SequencerState.STOPPED, this.maxBlockSizeInBytes = 1024 * 1024, this.maxBlockGas = new Gas(100e9, 100e9), this.enforceTimeTable = false;
+        // 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);
     }
     get tracer() {
         return this.metrics.tracer;
     }
+    getValidatorAddresses() {
+        return this.validatorClient?.getValidatorAddresses();
+    }
+    getConfig() {
+        return this.config;
+    }
     /**
-   * Updates sequencer config.
+   * Updates sequencer config by the defined values in the config on input.
    * @param config - New parameters.
-   */ async updateConfig(config) {
-        this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'allowedInSetup'));
+   */ updateConfig(config) {
+        this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'txPublicSetupAllowList'));
         if (config.transactionPollingIntervalMS !== undefined) {
             this.pollingIntervalMs = config.transactionPollingIntervalMS;
         }
@@ -122,22 +117,11 @@ export { SequencerState };
         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;
@@ -147,43 +131,46 @@ export { SequencerState };
         }
         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);
     }
     setTimeTable() {
-        this.timetable = new SequencerTimetable(this.l1Constants.ethereumSlotDuration, this.aztecSlotDuration, this.maxL1TxInclusionTimeIntoSlot, this.enforceTimeTable, this.metrics, this.log);
-        this.log.verbose(`Sequencer timetable updated`, {
-            enforceTimeTable: this.enforceTimeTable
-        });
+        this.timetable = new SequencerTimetable({
+            ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
+            aztecSlotDuration: this.aztecSlotDuration,
+            maxL1TxInclusionTimeIntoSlot: this.maxL1TxInclusionTimeIntoSlot,
+            attestationPropagationTime: this.config.attestationPropagationTime,
+            enforce: this.enforceTimeTable
+        }, this.metrics, this.log);
+    }
+    async init() {
+        this.publisher = (await this.publisherFactory.create(undefined)).publisher;
     }
     /**
    * Starts the sequencer and moves to IDLE state.
-   */ 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);
+   */ 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.
    */ async stop() {
-        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);
+        this.setState(SequencerState.STOPPED, undefined, {
+            force: true
+        });
         this.log.info('Stopped sequencer');
     }
     /**
-   * Starts a previously stopped sequencer.
-   */ restart() {
-        this.log.info('Restarting sequencer');
-        this.publisher.restart();
-        this.runningPromise.start();
-        this.setState(SequencerState.IDLE, 0n, true);
-    }
-    /**
    * Returns the current state of the sequencer.
    * @returns An object with a state entry with one of SequencerState.
    */ status() {
@@ -191,9 +178,6 @@ export { SequencerState };
             state: this.state
         };
     }
-    /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */ flush() {
-        this.isFlushing = true;
-    }
     /**
    * @notice  Performs most of the sequencer duties:
    *          - Checks if we are up to date
@@ -201,231 +185,306 @@ export { SequencerState };
    *          - Collect attestations for the block
    *          - Submit block
    *          - If our block for some reason is not included, revert the state
-   */ 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) {
+   */ 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);
-        const newBlockNumber = chainTip.blockNumber + 1;
-        // If we cannot find a tip archive, assume genesis.
-        const chainTipArchive = chainTip.archive;
-        const slot = await this.slotForProposal(chainTipArchive.toBuffer(), BigInt(newBlockNumber));
-        if (!slot) {
-            this.log.debug(`Cannot propose block ${newBlockNumber}`);
+        // 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;
         }
-        this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot}`);
-        const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(newBlockNumber), this._coinbase, this._feeRecipient, slot);
-        const enqueueGovernanceVotePromise = this.publisher.enqueueCastVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.GOVERNANCE);
-        const enqueueSlashingVotePromise = this.publisher.enqueueCastVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.SLASHING);
+        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;
+        }
+        // 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;
+        }
+        // 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;
+        }
+        // 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.
+        // 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, 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'
+            });
+            this.metrics.recordBlockProposalPrecheckFailed('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'
+            });
+            this.metrics.recordBlockProposalPrecheckFailed('slot_mismatch');
+            return;
+        } else if (canProposeCheck.checkpointNumber !== 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.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} as ${proposer}`, {
+            ...syncLogData
+        });
+        const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(newBlockNumber, coinbase, feeRecipient, slot);
+        // 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 = await this.tryBuildBlockAndEnqueuePublish(slot, proposer, newBlockNumber, publisher, newGlobalVariables, chainTipArchive, invalidateBlock);
+        // 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. */ async tryBuildBlockAndEnqueuePublish(slot, proposer, newBlockNumber, publisher, newGlobalVariables, chainTipArchive, invalidateBlock) {
         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);
-        let finishedFlushing = false;
+        const proposalHeader = CheckpointHeader.from({
+            ...newGlobalVariables,
+            timestamp: newGlobalVariables.timestamp,
+            lastArchiveRoot: chainTipArchive,
+            blockHeadersHash: Fr.ZERO,
+            contentCommitment: ContentCommitment.empty(),
+            totalManaUsed: Fr.ZERO
+        });
+        let block;
         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
+            try {
+                block = await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposer, invalidateBlock, publisher);
+            } catch (err) {
+                this.emit('block-build-failed', {
+                    reason: err.message
                 });
-            });
-            finishedFlushing = true;
+                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
+                    });
+                }
+                this.metrics.recordBlockProposalFailed(err.name || 'unknown_error');
+            }
         } else {
-            this.log.debug(`Not enough txs to build block ${newBlockNumber} at slot ${slot}: got ${pendingTxCount} txs, need ${this.minTxsPerBlock}`);
-        }
-        await enqueueGovernanceVotePromise.catch((err)=>{
-            this.log.error(`Error enqueuing governance vote`, err, {
+            this.log.verbose(`Not enough txs to build block ${newBlockNumber} at slot ${slot} (got ${pendingTxCount} txs, need ${this.minTxsPerBlock})`, {
+                chainTipArchive,
                 blockNumber: newBlockNumber,
                 slot
             });
-        });
-        await enqueueSlashingVotePromise.catch((err)=>{
-            this.log.error(`Error enqueuing slashing vote`, err, {
-                blockNumber: newBlockNumber,
-                slot
+            this.emit('tx-count-check-failed', {
+                minTxs: this.minTxsPerBlock,
+                availableTxs: pendingTxCount
             });
-        });
-        await this.publisher.sendRequests();
-        if (finishedFlushing) {
-            this.isFlushing = false;
+            this.metrics.recordBlockProposalFailed('insufficient_txs');
         }
-        this.setState(SequencerState.IDLE, 0n);
+        return block;
     }
-    async work() {
+    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' : 'warn';
+                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);
         }
     }
-    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, proposalBlockNumber) {
-        const result = await this.publisher.canProposeAtNextEthBlock(tipArchive);
-        if (!result) {
-            return undefined;
+    setState(proposedState, slotNumber, opts = {}) {
+        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();
         }
-        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 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, currentSlotNumber, force = false) {
-        if (this.state === SequencerState.STOPPED && force !== true) {
+        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}`);
+        let secondsIntoSlot = undefined;
+        if (slotNumber !== undefined) {
+            secondsIntoSlot = this.getSecondsIntoSlot(slotNumber);
+            this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
+        }
+        const boringStates = [
+            SequencerState.IDLE,
+            SequencerState.SYNCHRONIZING
+        ];
+        const logLevel = boringStates.includes(proposedState) && boringStates.includes(this.state) ? 'trace' : 'debug';
+        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;
     }
-    /**
-   * 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
-   */ async buildBlock(pendingTxs, newGlobalVariables, opts = {}) {
-        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;
-        this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
-            slot,
-            blockNumber,
-            msgCount,
-            validator: opts.validateOnly
-        });
-        // 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);
+    async dropFailedTxsFromP2P(failedTxs) {
+        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);
+    }
+    getBlockBuilderOptions(slot) {
+        // 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_CHECKPOINT * FIELDS_PER_BLOB,
+            deadline
+        };
     }
     /**
    * @notice  Build and propose a block to the chain
@@ -435,24 +494,36 @@ export { SequencerState };
    *
    * @param pendingTxs - Iterable of pending transactions to construct the block from
    * @param proposalHeader - The partial header constructed for the proposal
-   */ async buildBlockAndEnqueuePublish(pendingTxs, proposalHeader) {
-        await this.publisher.validateBlockForSubmission(proposalHeader);
-        const newGlobalVariables = proposalHeader.globalVariables;
-        const blockNumber = newGlobalVariables.blockNumber.toNumber();
-        const slot = newGlobalVariables.slotNumber.toBigInt();
-        // this.metrics.recordNewBlock(blockNumber, validTxs.length);
+   * @param newGlobalVariables - The global variables for the new block
+   * @param proposerAddress - The address of the proposer
+   */ async buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerAddress, invalidateBlock, publisher) {
+        await publisher.validateBlockHeader(proposalHeader, invalidateBlock);
+        const blockNumber = newGlobalVariables.blockNumber;
+        const slot = proposalHeader.slotNumber;
+        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
         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(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 = {
                 eventName: 'l2-block-built',
-                creator: this.publisher.getSenderAddress().toString(),
+                creator: proposerAddress?.toString() ?? publisher.getSenderAddress().toString(),
                 duration: workTimer.ms(),
                 publicProcessDuration: publicProcessorDuration,
                 rollupCircuitsDuration: blockBuildingTimer.ms(),
@@ -466,64 +537,137 @@ export { SequencerState };
                 txHashes,
                 ...blockStats
             });
-            this.log.debug('Collecting attestations');
-            const stopCollectingAttestationsTimer = this.metrics.startCollectingAttestationsTimer();
-            const attestations = await this.collectAttestations(block, txHashes);
-            if (attestations !== undefined) {
-                this.log.verbose(`Collected ${attestations.length} attestations`, {
+            // In fisherman mode, skip attestation collection
+            let attestationsAndSigners;
+            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
+                    blockNumber,
+                    slot
                 });
             }
-            stopCollectingAttestationsTimer();
-            return this.enqueuePublishL2Block(block, attestations, txHashes);
+            // 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, attestationsAndSigners, attestationsAndSignersSignature, invalidateBlock, publisher);
+            this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
+            return block;
         } catch (err) {
             this.metrics.recordFailedBlock();
             throw err;
         }
     }
-    async collectAttestations(block, txHashes) {
-        // 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();
+    async collectAttestations(block, txs, proposerAddress) {
+        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) {
+            throw new Error('No committee when collecting attestations');
+        }
         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');
-        const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
+        const blockProposalOptions = {
+            publishFullTxs: !!this.config.publishTxsWithProposals,
+            broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
+        };
+        const proposal = await this.validatorClient.createBlockProposal(block.header.globalVariables.blockNumber, block.getCheckpointHeader(), block.archive.root, 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 new CommitteeAttestationsAndSigners(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 = 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);
+            // 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 new CommitteeAttestationsAndSigners(sorted);
+        } catch (err) {
+            if (err && err instanceof AttestationTimeoutError) {
+                collectedAttestationsCount = err.collectedCount;
+            }
+            throw err;
+        } finally{
+            this.metrics.recordCollectedAttestations(collectedAttestationsCount, timer.ms());
+        }
+    }
+    /** Breaks the attestations before publishing based on attack configs */ manipulateAttestations(block, epoch, seed, committee, attestations) {
+        // 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 = [];
+            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.
-   */ async enqueuePublishL2Block(block, attestations, txHashes) {
+   */ async enqueuePublishL2Block(block, attestationsAndSigners, attestationsAndSignersSignature, invalidateBlock, publisher) {
         // 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 txTimeoutAt = new Date((this.getSlotStartTimestamp(slot) + this.aztecSlotDuration) * 1000);
-        const enqueued = await this.publisher.enqueueProposeL2Block(block, attestations, txHashes, {
-            txTimeoutAt
+        const slot = block.header.globalVariables.slotNumber;
+        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}`);
@@ -532,81 +676,290 @@ export { SequencerState };
     /**
    * 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.
-   */ async getChainTip() {
+   */ async checkSync(args) {
+        // 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)=>{
-                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()
         ]);
-        const [worldState, l2BlockSource, p2p, l1ToL2MessageSource] = syncedBlocks;
-        const result = // check that world state has caught up with archiver
-        // note that the archiver reports undefined hash for the genesis block
+        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)
-        (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
-        });
+        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;
         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
+                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]
+   */ enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, timestamp) {
+        try {
+            const signerFn = (msg)=>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)
+   */ async checkCanPropose(slot) {
+        let proposer;
+        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
+            ];
+        }
+        // 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.
+   */ async tryVoteWhenSyncFails(args) {
+        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.
+   */ async considerInvalidatingBlock(syncedTo, currentSlot) {
+        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);
+        if (!this.config.fishermanMode) {
+            await publisher.sendRequests();
+        } else {
+            this.log.info('Invalidating block in fisherman mode, clearing pending requests');
+            publisher.clearPendingRequests();
+        }
     }
-    getSlotStartTimestamp(slotNumber) {
-        return Number(this.l1Constants.l1GenesisTime) + Number(slotNumber) * this.l1Constants.slotDuration;
+    getSlotStartBuildTimestamp(slotNumber) {
+        return getSlotStartBuildTimestamp(slotNumber, this.l1Constants);
     }
     getSecondsIntoSlot(slotNumber) {
-        const slotStartTimestamp = this.getSlotStartTimestamp(slotNumber);
+        const slotStartTimestamp = this.getSlotStartBuildTimestamp(slotNumber);
         return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
     }
     get aztecSlotDuration() {
         return this.l1Constants.slotDuration;
     }
-    get coinbase() {
-        return this._coinbase;
+    get maxL2BlockGas() {
+        return this.config.maxL2BlockGas;
     }
-    get feeRecipient() {
-        return this._feeRecipient;
+    getSlasherClient() {
+        return this.slasherClient;
     }
 }
 _ts_decorate([
     trackSpan('Sequencer.work')
-], Sequencer.prototype, "work", null);
+], Sequencer.prototype, "safeWork", null);
 _ts_decorate([
-    trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, proposalHeader)=>({
-            [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber()
+    trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, _proposalHeader, newGlobalVariables)=>({
+            [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber
         }))
 ], Sequencer.prototype, "buildBlockAndEnqueuePublish", null);
 _ts_decorate([