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

package/dest/sequencer/sequencer.js

@@ -1,623 +1,1308 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.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;
+function applyDecs2203RFactory() {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function addInitializer(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1:
+                kindStr = "accessor";
+                break;
+            case 2:
+                kindStr = "method";
+                break;
+            case 3:
+                kindStr = "getter";
+                break;
+            case 4:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (kind === 0) {
+            if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
+                };
+            }
+        } else if (kind === 2) {
+            get = function() {
+                return desc.value;
+            };
+        } else {
+            if (kind === 1 || kind === 3) {
+                get = function() {
+                    return desc.get.call(this);
+                };
+            }
+            if (kind === 1 || kind === 4) {
+                set = function(v) {
+                    desc.set.call(this, v);
+                };
+            }
+        }
+        ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        try {
+            return dec(value, ctx);
+        } finally{
+            decoratorFinishedRef.v = true;
+        }
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) {
+            throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+    }
+    function assertCallable(fn, hint) {
+        if (typeof fn !== "function") {
+            throw new TypeError(hint + " must be a function");
+        }
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (kind === 1) {
+            if (type !== "object" || value === null) {
+                throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            }
+            if (value.get !== undefined) {
+                assertCallable(value.get, "accessor.get");
+            }
+            if (value.set !== undefined) {
+                assertCallable(value.set, "accessor.set");
+            }
+            if (value.init !== undefined) {
+                assertCallable(value.init, "accessor.init");
+            }
+        } else if (type !== "function") {
+            var hint;
+            if (kind === 0) {
+                hint = "field";
+            } else if (kind === 10) {
+                hint = "class";
+            } else {
+                hint = "method";
+            }
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) {
+            if (kind === 0 || kind === 1) {
+                desc = {
+                    get: decInfo[3],
+                    set: decInfo[4]
+                };
+            } else if (kind === 3) {
+                desc = {
+                    get: decInfo[3]
+                };
+            } else if (kind === 4) {
+                desc = {
+                    set: decInfo[3]
+                };
+            } else {
+                desc = {
+                    value: decInfo[3]
+                };
+            }
+        } else if (kind !== 0) {
+            desc = Object.getOwnPropertyDescriptor(base, name);
+        }
+        if (kind === 1) {
+            value = {
+                get: desc.get,
+                set: desc.set
+            };
+        } else if (kind === 2) {
+            value = desc.value;
+        } else if (kind === 3) {
+            value = desc.get;
+        } else if (kind === 4) {
+            value = desc.set;
+        }
+        var newValue, get, set;
+        if (typeof decs === "function") {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (newValue !== void 0) {
+                assertValidReturnValue(kind, newValue);
+                if (kind === 0) {
+                    init = newValue;
+                } else if (kind === 1) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else {
+                    value = newValue;
+                }
+            }
+        } else {
+            for(var i = decs.length - 1; i >= 0; i--){
+                var dec = decs[i];
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (newValue !== void 0) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+                    if (kind === 0) {
+                        newInit = newValue;
+                    } else if (kind === 1) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else {
+                        value = newValue;
+                    }
+                    if (newInit !== void 0) {
+                        if (init === void 0) {
+                            init = newInit;
+                        } else if (typeof init === "function") {
+                            init = [
+                                init,
+                                newInit
+                            ];
+                        } else {
+                            init.push(newInit);
+                        }
+                    }
+                }
+            }
+        }
+        if (kind === 0 || kind === 1) {
+            if (init === void 0) {
+                init = function(instance, init) {
+                    return init;
+                };
+            } else if (typeof init !== "function") {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++){
+                        value = ownInitializers[i].call(instance, value);
+                    }
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (kind !== 0) {
+            if (kind === 1) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (kind === 2) {
+                desc.value = value;
+            } else if (kind === 3) {
+                desc.get = value;
+            } else if (kind === 4) {
+                desc.set = value;
+            }
+            if (isPrivate) {
+                if (kind === 1) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (kind === 2) {
+                    ret.push(value);
+                } else {
+                    ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                }
+            } else {
+                Object.defineProperty(base, name, desc);
+            }
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            if (!Array.isArray(decInfo)) continue;
+            var kind = decInfo[1];
+            var name = decInfo[2];
+            var isPrivate = decInfo.length > 3;
+            var isStatic = kind >= 5;
+            var base;
+            var initializers;
+            if (isStatic) {
+                base = Class;
+                kind = kind - 5;
+                staticInitializers = staticInitializers || [];
+                initializers = staticInitializers;
+            } else {
+                base = Class.prototype;
+                protoInitializers = protoInitializers || [];
+                initializers = protoInitializers;
+            }
+            if (kind !== 0 && !isPrivate) {
+                var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                var existingKind = existingNonFields.get(name) || 0;
+                if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) {
+                    throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                } else if (!existingKind && kind > 2) {
+                    existingNonFields.set(name, kind);
+                } else {
+                    existingNonFields.set(name, true);
+                }
+            }
+            applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) {
+            ret.push(function(instance) {
+                for(var i = 0; i < initializers.length; i++){
+                    initializers[i].call(instance);
+                }
+                return instance;
+            });
+        }
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                try {
+                    var nextNewClass = classDecs[i](newClass, {
+                        kind: "class",
+                        name: name,
+                        addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                        metadata
+                    });
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+                if (nextNewClass !== undefined) {
+                    assertValidReturnValue(10, nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++){
+                        initializers[i].call(newClass);
+                    }
+                }
+            ];
+        }
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+        if (parentClass !== void 0) {
+            var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        }
+        var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { omit } from '@aztec/foundation/collection';
+var _dec, _dec1, _dec2, _dec3, _initProto;
+import { getKzg } from '@aztec/blob-lib';
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { merge, omit, pick } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
-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 { Gas } from '@aztec/stdlib/gas';
+import { getEpochAtSlot, getSlotStartBuildTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
-import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import { BlockHeader, ContentCommitment, StateReference, Tx } from '@aztec/stdlib/tx';
+import { MIN_EXECUTION_TIME } from '@aztec/stdlib/timetable';
 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 { DefaultSequencerConfig } from '../config.js';
+import { buildCheckpointSimulationOverridesPlan } from './chain_state_overrides.js';
+import { CheckpointProposalJob } from './checkpoint_proposal_job.js';
+import { CheckpointProposalJobMetrics } from './checkpoint_proposal_job_metrics.js';
+import { CheckpointVoter } from './checkpoint_voter.js';
+import { SequencerInterruptedError, SequencerTooSlowError } from './errors.js';
 import { SequencerMetrics } from './metrics.js';
-import { SequencerTimetable, SequencerTooSlowError } from './timetable.js';
-import { SequencerState, orderAttestations } from './utils.js';
+import { SequencerTimetable } from './timetable.js';
+import { SequencerState } from './utils.js';
 export { SequencerState };
+_dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpointProposal'), _dec2 = trackSpan('Seqeuencer.tryVoteWhenSyncFails', ({ slot })=>({
+        [Attributes.SLOT_NUMBER]: slot
+    })), _dec3 = trackSpan('Sequencer.tryVoteWhenEscapeHatchOpen', ({ slot })=>({
+        [Attributes.SLOT_NUMBER]: slot
+    }));
 /**
  * Sequencer client
- * - Wins a period of time to become the sequencer (depending on finalized protocol).
- * - Chooses a set of txs from the tx pool to be in the rollup.
- * - Simulate the rollup of txs.
- * - 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;
+ * - Checks whether it is elected as proposer for the next slot
+ * - Builds multiple blocks and broadcasts them
+ * - Collects attestations for the checkpoint
+ * - Publishes the checkpoint to L1
+ * - Votes for proposals and slashes on L1
+ */ export class Sequencer extends EventEmitter {
+    publisherFactory;
     validatorClient;
     globalsBuilder;
     p2pClient;
     worldState;
     slasherClient;
-    blockBuilderFactory;
     l2BlockSource;
     l1ToL2MessageSource;
-    publicProcessorFactory;
-    contractDataSource;
+    checkpointsBuilder;
     l1Constants;
     dateProvider;
-    config;
+    epochCache;
+    rollupContract;
+    telemetry;
     log;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "work"
+            ],
+            [
+                _dec1,
+                2,
+                "prepareCheckpointProposal"
+            ],
+            [
+                _dec2,
+                2,
+                "tryVoteWhenSyncFails"
+            ],
+            [
+                _dec3,
+                2,
+                "tryVoteWhenEscapeHatchOpen"
+            ]
+        ], []));
+    }
     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;
+    stateSlotNumber;
+    stateEnteredAtMs;
     metrics;
-    isFlushing;
+    checkpointProposalJobMetrics;
+    stateLog;
+    /** The last slot for which we attempted to perform our voting duties with degraded block production */ lastSlotForFallbackVote;
+    /** The last slot for which we logged "no committee" warning, to avoid spam */ lastSlotForNoCommitteeWarning;
+    /** The last slot for which we triggered a checkpoint proposal job, to prevent duplicate attempts. */ lastSlotForCheckpointProposalJob;
+    /** Last successful checkpoint proposed */ lastCheckpointProposed;
+    /** The last epoch for which we logged strategy comparison in fisherman mode. */ lastEpochForStrategyComparison;
+    /** The last checkpoint proposal job, tracked so we can await its pending L1 submission during shutdown. */ lastCheckpointProposalJob;
     /** 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));
+    /** Config for the sequencer */ config;
+    signatureContext;
+    constructor(publisherFactory, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, l2BlockSource, l1ToL2MessageSource, checkpointsBuilder, 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.checkpointsBuilder = checkpointsBuilder, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.epochCache = epochCache, this.rollupContract = rollupContract, this.telemetry = telemetry, this.log = log, this.state = (_initProto(this), SequencerState.STOPPED), this.stateEnteredAtMs = performance.now(), this.config = DefaultSequencerConfig;
+        this.stateLog = log.createChild('state');
+        // Add [FISHERMAN] prefix to logger if in fisherman mode
+        if (config.fishermanMode) {
+            this.log = log.createChild('[FISHERMAN]');
+        }
+        this.signatureContext = {
+            chainId: config.l1ChainId,
+            rollupAddress: config.rollupAddress
+        };
+        this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
+        this.checkpointProposalJobMetrics = new CheckpointProposalJobMetrics(telemetry);
+        this.updateConfig(config);
     }
-    get tracer() {
-        return this.metrics.tracer;
+    /** Updates sequencer config by the defined values and updates the timetable */ updateConfig(config) {
+        const filteredConfig = pickFromSchema(config, SequencerConfigSchema);
+        this.log.info(`Updated sequencer config`, omit(filteredConfig, 'txPublicSetupAllowListExtend'));
+        this.config = merge(this.config, filteredConfig);
+        const p2pPropagationTime = this.config.attestationPropagationTime;
+        this.timetable = new SequencerTimetable({
+            ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
+            aztecSlotDuration: this.aztecSlotDuration,
+            l1PublishingTime: this.l1PublishingTime,
+            p2pPropagationTime,
+            blockDurationMs: this.config.blockDurationMs,
+            enforce: this.config.enforceTimeTable
+        }, this.metrics, this.log);
     }
-    /**
-   * Updates sequencer config.
-   * @param config - New parameters.
-   */ async updateConfig(config) {
-        this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'allowedInSetup'));
-        if (config.transactionPollingIntervalMS !== undefined) {
-            this.pollingIntervalMs = config.transactionPollingIntervalMS;
-        }
-        if (config.maxTxsPerBlock !== undefined) {
-            this.maxTxsPerBlock = config.maxTxsPerBlock;
-        }
-        if (config.minTxsPerBlock !== undefined) {
-            this.minTxsPerBlock = config.minTxsPerBlock;
-        }
-        if (config.maxDABlockGas !== undefined) {
-            this.maxBlockGas = new Gas(config.maxDABlockGas, this.maxBlockGas.l2Gas);
-        }
-        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);
-        }
-        if (config.maxL1TxInclusionTimeIntoSlot !== undefined) {
-            this.maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot;
-        }
-        if (config.enforceTimeTable !== undefined) {
-            this.enforceTimeTable = config.enforceTimeTable;
-        }
-        this.setTimeTable();
-        // TODO: Just read everything from the config object as needed instead of copying everything into local vars.
-        this.config = config;
+    /** Initializes the sequencer (precomputes tables). Takes about 3s. */ init() {
+        getKzg();
     }
-    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
+    /** Starts the sequencer and moves to IDLE state. */ start() {
+        this.runningPromise = new RunningPromise(this.safeWork.bind(this), this.log, this.config.sequencerPollingIntervalMS);
+        this.setState(SequencerState.IDLE, undefined, {
+            force: true
         });
-    }
-    /**
-   * 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);
         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();
+    /** Triggers an immediate run of the sequencer, bypassing the polling interval. */ trigger() {
+        return this.runningPromise?.trigger();
+    }
+    /** Stops the sequencer from building blocks and moves to STOPPED state. */ async stop() {
+        this.log.info(`Stopping sequencer`);
+        this.setState(SequencerState.STOPPING, undefined, {
+            force: true
+        });
+        this.lastCheckpointProposalJob?.interrupt();
+        await this.publisherFactory.stopAll();
         await this.runningPromise?.stop();
-        this.slasherClient.stop();
-        this.publisher.interrupt();
-        this.setState(SequencerState.STOPPED, 0n, true);
+        await this.lastCheckpointProposalJob?.awaitPendingSubmission();
+        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);
+    /** Main sequencer loop with a try/catch */ async safeWork() {
+        try {
+            await this.work();
+        } catch (err) {
+            if (err instanceof SequencerTooSlowError && [
+                SequencerState.INITIALIZING_CHECKPOINT,
+                SequencerState.PROPOSER_CHECK
+            ].includes(err.proposedState)) {
+                // No need to alert if we just didn't get to start in time
+                this.log.debug(err.message, {
+                    now: this.dateProvider.nowInSeconds()
+                });
+            } else {
+                // Re-throw other errors
+                this.emit('checkpoint-error', {
+                    error: err
+                });
+                throw err;
+            }
+        } finally{
+            this.setState(SequencerState.IDLE, undefined);
+        }
     }
-    /**
-   * Returns the current state of the sequencer.
-   * @returns An object with a state entry with one of SequencerState.
-   */ status() {
+    /** Returns the current state of the sequencer. */ status() {
         return {
             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
-   *          - If we are and we are the sequencer, collect txs and build a block
-   *          - 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) {
+   * Main sequencer loop:
+   * - Checks if we are up to date
+   * - If we are and we are the sequencer, collect txs and build blocks
+   * - Build multiple blocks per slot when configured
+   * - Collect attestations for the final block
+   * - Submit checkpoint
+   */ async work() {
+        this.setState(SequencerState.SYNCHRONIZING, undefined);
+        const { slot, targetSlot, epoch, targetEpoch, ts, nowSeconds } = this.getSlotContextInNextL1Slot();
+        // Check if we are synced and it's our slot, grab a publisher, check previous block invalidation, etc
+        const checkpointProposalJob = await this.prepareCheckpointProposal(slot, targetSlot, epoch, targetEpoch, ts, nowSeconds);
+        if (!checkpointProposalJob) {
             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}`);
-            return;
+        // Track the job so we can await its pending L1 submission during shutdown
+        this.lastCheckpointProposalJob = checkpointProposalJob;
+        // Execute the checkpoint proposal job
+        const checkpoint = await checkpointProposalJob.execute();
+        // Update last checkpoint proposed (currently unused)
+        if (checkpoint) {
+            this.lastCheckpointProposed = checkpoint;
+        }
+        // Log fee strategy comparison if on fisherman (uses target epoch since we mirror the proposer's perspective)
+        if (this.config.fishermanMode && (this.lastEpochForStrategyComparison === undefined || targetEpoch > this.lastEpochForStrategyComparison)) {
+            this.logStrategyComparison(targetEpoch, checkpointProposalJob.getPublisher());
+            this.lastEpochForStrategyComparison = targetEpoch;
+        }
+        return checkpoint;
+    }
+    /** Returns slot and target slot from a single clock snapshot. */ getSlotContextInNextL1Slot() {
+        const { slot, ts, nowSeconds, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
+        const targetSlot = SlotNumber(slot + PROPOSER_PIPELINING_SLOT_OFFSET);
+        return {
+            slot,
+            targetSlot,
+            epoch,
+            targetEpoch: getEpochAtSlot(targetSlot, this.l1Constants),
+            ts,
+            nowSeconds
+        };
+    }
+    /**
+   * Prepares the checkpoint proposal by performing all necessary checks and setup.
+   * This is the initial step in the main loop.
+   * @returns CheckpointProposalJob if successful, undefined if we are not yet synced or are not the proposer.
+   */ async prepareCheckpointProposal(slot, targetSlot, epoch, targetEpoch, ts, nowSeconds) {
+        // Check we have not already processed this target slot (cheapest check)
+        // We only check this if enforce timetable is set, since we want to keep processing the same slot if we are not
+        // running against actual time (eg when we use sandbox-style automining)
+        if (this.lastSlotForCheckpointProposalJob && this.lastSlotForCheckpointProposalJob >= targetSlot && this.config.enforceTimeTable) {
+            this.log.trace(`Target slot ${targetSlot} has already been processed`);
+            return undefined;
+        }
+        // But if we have already proposed for this slot, then we definitely have to skip it, automining or not
+        if (this.lastCheckpointProposed && this.lastCheckpointProposed.header.slotNumber >= targetSlot) {
+            this.log.trace(`Slot ${targetSlot} has already been published as checkpoint ${this.lastCheckpointProposed.number}`);
+            return undefined;
         }
-        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);
-        this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
-        this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-            chainTipArchive,
-            blockNumber: newBlockNumber,
+        // Test-only: skip proposing for explicitly paused slots. Attestation paths run in the validator
+        // client and are not gated by this hook, so paused proposers still attest to others' proposals.
+        if (this.config.pauseProposingForSlots?.some((s)=>s === targetSlot)) {
+            this.log.warn(`Skipping proposal for paused slot ${targetSlot} (test-only pauseProposingForSlots hook)`, {
+                targetSlot
+            });
+            return undefined;
+        }
+        // Check all components are synced to latest as seen by the archiver (queries all subsystems)
+        const syncedTo = await this.checkSync({
+            ts,
             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 pendingTxCount = await this.p2pClient.getPendingTxCount();
-        if (pendingTxCount >= this.minTxsPerBlock || this.isFlushing) {
-            // 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
+        if (!syncedTo) {
+            await this.tryVoteWhenSyncFails({
+                slot,
+                targetSlot,
+                ts
+            });
+            return undefined;
+        }
+        // If escape hatch is open for the target epoch, do not start checkpoint proposal work and do not attempt invalidations.
+        // Still perform governance/slashing voting (as proposer) once per slot.
+        // When pipelining, we check the target epoch (slot+1's epoch) since that's the epoch we're building for.
+        const isEscapeHatchOpen = await this.epochCache.isEscapeHatchOpen(targetEpoch);
+        if (isEscapeHatchOpen) {
+            this.setState(SequencerState.PROPOSER_CHECK, slot);
+            const [canPropose, proposer] = await this.checkCanPropose(targetSlot);
+            if (canPropose) {
+                await this.tryVoteWhenEscapeHatchOpen({
+                    slot,
+                    targetSlot,
+                    proposer
                 });
+            } else {
+                this.log.trace(`Escape hatch open but we are not proposer, skipping vote-only actions`, {
+                    slot,
+                    epoch,
+                    proposer
+                });
+            }
+            return undefined;
+        }
+        // Next checkpoint follows from the last synced one
+        const checkpointNumber = CheckpointNumber(syncedTo.checkpointNumber + 1);
+        const logCtx = {
+            nowSeconds,
+            syncedToL2Slot: syncedTo.syncedL2Slot,
+            slot,
+            targetSlot,
+            slotTs: ts,
+            checkpointNumber,
+            isPendingChainValid: pick(syncedTo.pendingChainValidationStatus, 'valid', 'reason', 'invalidIndex')
+        };
+        // Check that we are a proposer for the target slot.
+        this.setState(SequencerState.PROPOSER_CHECK, slot);
+        const [canPropose, proposer] = await this.checkCanPropose(targetSlot);
+        // If we are not a proposer check if we should invalidate an invalid checkpoint, and bail
+        if (!canPropose) {
+            await this.considerInvalidatingCheckpoint(syncedTo, slot);
+            return undefined;
+        }
+        // Guard: don't exceed 1-deep pipeline. Without a proposed checkpoint, we can only build
+        // confirmed + 1. With a proposed checkpoint, we can build confirmed + 2.
+        const confirmedCkpt = syncedTo.checkpointedCheckpointNumber;
+        if (checkpointNumber > confirmedCkpt + 2) {
+            this.log.verbose(`Skipping slot ${targetSlot}: checkpoint ${checkpointNumber} exceeds max pipeline depth (confirmed=${confirmedCkpt})`);
+            return undefined;
+        }
+        // Check that the target slot is not taken by a block already (should never happen, since only us can propose for this slot)
+        if (syncedTo.blockData && syncedTo.blockData.header.getSlot() >= targetSlot) {
+            this.log.warn(`Cannot propose block at target slot ${targetSlot} since that slot was taken by block ${syncedTo.blockNumber}`, {
+                ...logCtx,
+                block: syncedTo.blockData.header.toInspect()
+            });
+            this.metrics.recordCheckpointPrecheckFailed('slot_already_taken');
+            return undefined;
+        }
+        // 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 proposerForPublisher = this.config.fishermanMode ? undefined : proposer;
+        const { attestorAddress, publisher } = await this.publisherFactory.create(proposerForPublisher);
+        this.log.verbose(`Created publisher at address ${publisher.getSenderAddress()} for attestor ${attestorAddress}`);
+        // Prepare invalidation request if the pending chain is invalid (returns undefined if no need).
+        // Only simulate invalidation when there's no proposed parent, since we assume the proposed parent
+        // will invalidate the currently invalid checkpoint on L1.
+        const invalidateCheckpoint = syncedTo.hasProposedCheckpoint || syncedTo.pendingChainValidationStatus.valid ? undefined : await publisher.simulateInvalidateCheckpoint(syncedTo.pendingChainValidationStatus);
+        // Determine the correct archive and L1 state overrides for the canProposeAt check.
+        // The L1 contract reads archives[proposedCheckpointNumber] and compares it with the provided archive.
+        // When invalidating or pipelining, the local archive may differ from L1's, so we adjust accordingly.
+        let archiveForCheck = syncedTo.archive;
+        if (syncedTo.hasProposedCheckpoint) {
+            this.metrics.recordPipelineDepth(syncedTo.checkpointNumber - syncedTo.checkpointedCheckpointNumber);
+            this.log.verbose(`Building on top of proposed checkpoint (pending=${syncedTo.proposedCheckpointData?.checkpointNumber}) for target slot ${targetSlot}`, {
+                targetSlot,
+                parentCheckpointNumber: CheckpointNumber(checkpointNumber - 1)
             });
-            finishedFlushing = true;
+            // Match what L1 will see at archives[pending] once the proposed parent lands: the parent's
+            // own archive root from the gossiped proposal. `syncedTo.archive` is the world-state-local
+            // view and can transiently diverge from the proposed parent (e.g. before the proposed
+            // parent's blocks have been applied locally); diverging here would cause the canProposeAt
+            // override to set archives[pending] to one value while we present another for comparison.
+            archiveForCheck = syncedTo.proposedCheckpointData.archive.root;
+        } else if (invalidateCheckpoint) {
+            // After invalidation, L1 will roll back to checkpoint N-1. The archive at N-1 already
+            // exists on L1, so we just pass the matching archive (the lastArchive of the invalid checkpoint).
+            archiveForCheck = invalidateCheckpoint.lastArchive;
+            this.metrics.recordPipelineDepth(0);
         } else {
-            this.log.debug(`Not enough txs to build block ${newBlockNumber} at slot ${slot}: got ${pendingTxCount} txs, need ${this.minTxsPerBlock}`);
+            this.metrics.recordPipelineDepth(0);
         }
-        await enqueueGovernanceVotePromise.catch((err)=>{
-            this.log.error(`Error enqueuing governance vote`, err, {
-                blockNumber: newBlockNumber,
-                slot
+        // Build the simulation plan: pending/proven override from pipelining or invalidation (or the
+        // current snapshot when neither applies, to short-circuit any pending prune in simulation),
+        // plus the parent checkpoint cell and fee header when pipelining.
+        const simulationOverridesPlan = await buildCheckpointSimulationOverridesPlan({
+            checkpointNumber,
+            proposedCheckpointData: syncedTo.hasProposedCheckpoint ? syncedTo.proposedCheckpointData : undefined,
+            invalidateToPendingCheckpointNumber: invalidateCheckpoint?.forcePendingCheckpointNumber,
+            checkpointedCheckpointNumber: syncedTo.checkpointedCheckpointNumber,
+            rollup: this.rollupContract,
+            signatureContext: this.signatureContext,
+            log: this.log
+        });
+        // The plan always pins both pending/proven (to short-circuit `canPruneAtTime` in simulation),
+        // so `provenOverride` always reflects the assumed proven checkpoint we are pinning the
+        // simulation to. We additionally warn when the pin is load-bearing — i.e. when a prune would
+        // actually fire at the target slot without it — so observers can spot "we are building
+        // optimistically across a pruning boundary" in the logs.
+        const provenOverride = simulationOverridesPlan?.chainTipsOverride?.proven;
+        if (provenOverride !== undefined && await this.l2BlockSource.isPruneDueAtSlot(targetSlot)) {
+            this.log.warn(`Assuming proof for epoch ending at checkpoint ${provenOverride} lands by target slot ${targetSlot}`, {
+                checkpointNumber,
+                slot,
+                targetSlot,
+                provenOverride
             });
+        }
+        this.emit('preparing-checkpoint', {
+            targetSlot,
+            checkpointNumber,
+            hadProposedParent: syncedTo.hasProposedCheckpoint,
+            provenOverride,
+            simulatedPending: simulationOverridesPlan?.chainTipsOverride?.pending
         });
-        await enqueueSlashingVotePromise.catch((err)=>{
-            this.log.error(`Error enqueuing slashing vote`, err, {
-                blockNumber: newBlockNumber,
+        const canProposeCheck = await publisher.canProposeAt(archiveForCheck, proposer ?? EthAddress.ZERO, simulationOverridesPlan);
+        const proposeContext = {
+            hasProposedCheckpoint: syncedTo.hasProposedCheckpoint,
+            proposedCheckpointNumber: syncedTo.proposedCheckpointData?.checkpointNumber,
+            checkpointedCheckpointNumber: syncedTo.checkpointedCheckpointNumber,
+            isInvalidating: !!invalidateCheckpoint,
+            invalidatingCheckpointNumber: invalidateCheckpoint?.checkpointNumber,
+            archiveForCheck: archiveForCheck.toString(),
+            overridePendingCheckpointNumber: simulationOverridesPlan?.chainTipsOverride?.pending,
+            overrideArchive: simulationOverridesPlan?.pendingCheckpointState?.archive,
+            overrideFeeHeader: simulationOverridesPlan?.pendingCheckpointState?.feeHeader
+        };
+        if (canProposeCheck === undefined) {
+            this.log.warn(`Cannot propose checkpoint ${checkpointNumber} at slot ${slot} due to failed rollup contract check`, {
+                ...logCtx,
+                ...proposeContext
+            });
+            this.emit('proposer-rollup-check-failed', {
+                reason: 'Rollup contract check failed',
                 slot
             });
-        });
-        await this.publisher.sendRequests();
-        if (finishedFlushing) {
-            this.isFlushing = false;
+            this.metrics.recordCheckpointPrecheckFailed('rollup_contract_check_failed');
+            return undefined;
         }
-        this.setState(SequencerState.IDLE, 0n);
-    }
-    async work() {
-        try {
-            await this.doRealWork();
-        } catch (err) {
-            if (err instanceof SequencerTooSlowError) {
-                this.log.warn(err.message);
-            } else {
-                // Re-throw other errors
-                throw err;
-            }
-        } finally{
-            this.setState(SequencerState.IDLE, 0n);
+        if (canProposeCheck.slot !== targetSlot) {
+            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 ${targetSlot} but got ${canProposeCheck.slot}.`, {
+                ...logCtx,
+                ...proposeContext,
+                rollup: canProposeCheck,
+                expectedSlot: targetSlot
+            });
+            this.emit('proposer-rollup-check-failed', {
+                reason: 'Slot mismatch',
+                slot
+            });
+            this.metrics.recordCheckpointPrecheckFailed('slot_mismatch');
+            return undefined;
+        }
+        if (canProposeCheck.checkpointNumber !== checkpointNumber) {
+            this.log.warn(`Cannot propose due to block mismatch with rollup contract (this can be caused by a pending archiver sync). Expected checkpoint ${checkpointNumber} but got ${canProposeCheck.checkpointNumber}.`, {
+                ...logCtx,
+                ...proposeContext,
+                rollup: canProposeCheck,
+                expectedSlot: slot
+            });
+            this.emit('proposer-rollup-check-failed', {
+                reason: 'Block mismatch',
+                slot
+            });
+            this.metrics.recordCheckpointPrecheckFailed('block_number_mismatch');
+            return undefined;
         }
+        this.lastSlotForCheckpointProposalJob = targetSlot;
+        await this.p2pClient.prepareForSlot(targetSlot);
+        this.log.info(`Preparing checkpoint proposal ${checkpointNumber} for target slot ${targetSlot} during wall-clock slot ${slot}`, {
+            ...logCtx,
+            ...proposeContext,
+            proposer
+        });
+        // Create and return the checkpoint proposal job
+        return this.createCheckpointProposalJob(slot, targetSlot, targetEpoch, checkpointNumber, syncedTo.blockNumber, syncedTo.checkpointedCheckpointNumber, proposer, publisher, attestorAddress, invalidateCheckpoint, syncedTo.proposedCheckpointData);
     }
-    getForwarderAddress() {
-        return this.publisher.getForwarderAddress();
+    createCheckpointProposalJob(slot, targetSlot, targetEpoch, checkpointNumber, syncedToBlockNumber, checkpointedCheckpointNumber, proposer, publisher, attestorAddress, invalidateCheckpoint, proposedCheckpointData) {
+        return new CheckpointProposalJob(slot, targetSlot, targetEpoch, checkpointNumber, syncedToBlockNumber, checkpointedCheckpointNumber, proposer, publisher, attestorAddress, invalidateCheckpoint, this.validatorClient, this.globalsBuilder, this.p2pClient, this.worldState, this.l1ToL2MessageSource, this.l2BlockSource, this.checkpointsBuilder, this.l2BlockSource, this.l1Constants, this.signatureContext, this.config, this.timetable, this.slasherClient, this.epochCache, this.dateProvider, this.metrics, this.checkpointProposalJobMetrics.createRecorder(), this, (state, slot, timeReferenceSlot)=>this.setState(state, slot, {
+                timeReferenceSlot
+            }), this.tracer, this.log.getBindings(), proposedCheckpointData);
     }
     /**
-   * 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;
-        }
-        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;
+   * Returns the current sequencer state.
+   */ getState() {
+        return this.state;
     }
     /**
-   * Sets the sequencer state and checks if we have enough time left in the slot to transition to the new state.
+   * Internal helper for setting the sequencer state and checks if we have enough time left in the slot to transition to the new state.
    * @param proposedState - The new state to transition to.
-   * @param currentSlotNumber - The current slot number.
+   * @param slotNumber - The logical slot associated with the new state.
    * @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) {
+   * @param timeReferenceSlot - The slot to use for deadline checks when it differs from the logical slot.
+   */ 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();
+        }
+        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;
+        const timeReferenceSlot = opts.timeReferenceSlot ?? slotNumber;
+        if (timeReferenceSlot !== undefined) {
+            secondsIntoSlot = this.getSecondsIntoSlot(timeReferenceSlot);
+            this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
+        }
+        const oldState = this.state;
+        const oldStateSlotNumber = this.stateSlotNumber;
+        const stateChanged = proposedState !== oldState;
+        const transitionAtMs = performance.now();
+        const stateDurationMs = transitionAtMs - this.stateEnteredAtMs;
+        const boringStates = [
+            SequencerState.IDLE,
+            SequencerState.SYNCHRONIZING
+        ];
+        const logLevel = boringStates.includes(proposedState) && boringStates.includes(oldState) ? 'trace' : 'debug';
+        this.stateLog[logLevel](`Transitioning from ${oldState} to ${proposedState}`, {
+            oldState,
+            newState: proposedState,
+            slotNumber,
+            timeReferenceSlot,
+            stateSlotNumber: oldStateSlotNumber,
+            secondsIntoSlot,
+            ...stateChanged && {
+                stateDurationMs: Math.ceil(stateDurationMs)
+            }
+        });
+        this.emit('state-changed', {
+            oldState,
+            newState: proposedState,
+            secondsIntoSlot,
+            slot: slotNumber,
+            timeReferenceSlot
+        });
+        if (stateChanged) {
+            this.metrics.recordStateDuration(stateDurationMs, oldState);
+            this.stateEnteredAtMs = transitionAtMs;
+            this.stateSlotNumber = 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`, {
+   * Returns whether all dependencies have caught up.
+   * We don't check against the previous block submitted since it may have been reorg'd out.
+   */ async checkSync(args) {
+        // Check that the archiver has fully synced the L2 slot before the one we want to propose in.
+        // The archiver reports sync progress via L1 block timestamps and synced checkpoint slots.
+        // See getSyncedL2SlotNumber for how missed L1 blocks are handled.
+        const syncedL2Slot = await this.l2BlockSource.getSyncedL2SlotNumber();
+        const { slot } = args;
+        if (syncedL2Slot === undefined || syncedL2Slot + 1 < slot) {
+            this.log.debug(`Cannot propose block at next L2 slot ${slot} due to pending sync from L1`, {
                 slot,
-                slotStart: new Date(this.getSlotStartTimestamp(slot) * 1000),
-                now: new Date(this.dateProvider.now()),
-                deadline
+                syncedL2Slot
             });
-            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
+            return undefined;
+        }
+        const syncedBlocks = await Promise.all([
+            this.worldState.status().then(({ syncSummary })=>({
+                    number: syncSummary.latestBlockNumber,
+                    hash: syncSummary.latestBlockHash
+                })),
+            this.l2BlockSource.getL2Tips().then((t)=>({
+                    proposed: t.proposed,
+                    checkpointed: t.checkpointed,
+                    proposedCheckpoint: t.proposedCheckpoint
+                })),
+            this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
+            this.l1ToL2MessageSource.getL2Tips().then((t)=>({
+                    proposed: t.proposed,
+                    checkpointed: t.checkpointed
+                })),
+            this.l2BlockSource.getPendingChainValidationStatus(),
+            this.l2BlockSource.getProposedCheckpointData()
+        ]);
+        const [worldState, l2Tips, p2p, l1ToL2MessageSourceTips, pendingChainValidationStatus, proposedCheckpointData] = syncedBlocks;
+        const result = worldState.hash === l2Tips.proposed.hash && p2p.hash === l2Tips.proposed.hash && l1ToL2MessageSourceTips.proposed.hash === l2Tips.proposed.hash && l1ToL2MessageSourceTips.checkpointed.block.hash === l2Tips.checkpointed.block.hash && l1ToL2MessageSourceTips.checkpointed.checkpoint.hash === l2Tips.checkpointed.checkpoint.hash;
+        if (!result) {
+            this.log.debug(`Sequencer sync check failed`, {
+                worldState,
+                l2BlockSource: l2Tips.proposed,
+                p2p,
+                l1ToL2MessageSourceTips
+            });
+            return undefined;
+        }
+        const blockNumber = worldState.number;
+        const blockData = await this.l2BlockSource.getBlockData({
+            number: blockNumber
+        });
+        if (!blockData) {
+            this.log.warn(`Sequencer sync check failed: failed to get L2 block data ${blockNumber} from the archiver`, {
+                blockNumber,
+                l2Tips,
+                syncedL2Slot,
+                ...args
+            });
+            return undefined;
+        }
+        // Refuse to build a checkpoint on top of a proposed block whose enclosing checkpoint was never
+        // proposed. Under pipelining we may have received and reexecuted such a block locally — advancing
+        // our world-state tip past the checkpointed tip — while the proposing node never published the
+        // matching proposed checkpoint (e.g. it crashed before assembling it). Building on this orphan block
+        // would fork the chain off a tip no other node can follow. The archiver prunes these orphan blocks
+        // once their build slot ends; this guard is the correctness barrier during the grace window before.
+        if (blockData.checkpointNumber > l2Tips.checkpointed.checkpoint.number && (l2Tips.proposedCheckpoint.checkpoint.number !== blockData.checkpointNumber || proposedCheckpointData?.checkpointNumber !== blockData.checkpointNumber)) {
+            const logCtx = {
+                blockCheckpointNumber: blockData.checkpointNumber,
+                checkpointedCheckpointNumber: l2Tips.checkpointed.checkpoint.number,
+                proposedCheckpointTipNumber: l2Tips.proposedCheckpoint.checkpoint.number,
+                proposedCheckpointDataNumber: proposedCheckpointData?.checkpointNumber,
+                blockNumber: blockData.header.getBlockNumber(),
+                blockSlot: blockData.header.getSlot(),
+                syncedL2Slot,
+                ...args
             };
-            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`);
+            // Under pipelining the block proposal for a checkpoint leads its checkpoint proposal by up to one
+            // slot, so a world-state tip sitting in an as-yet-unproposed checkpoint is the expected steady state
+            // until that checkpoint is due. Only treat it as abnormal — and warn — once the checkpoint is overdue
+            // by the same deadline the archiver uses to prune the orphan block (see pruneOrphanProposedBlocks).
+            // Before then this is normal pipelining and we wait it out quietly.
+            if (this.isProposedCheckpointOverdue(blockData.header.getSlot())) {
+                this.log.warn(`Sequencer sync check failed: proposed block has no matching proposed checkpoint`, logCtx);
+            } else {
+                this.log.debug(`Waiting for proposed checkpoint to catch up with reexecuted block`, logCtx);
             }
-            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);
+            return undefined;
         }
+        const hasProposedCheckpoint = l2Tips.proposedCheckpoint.checkpoint.number > l2Tips.checkpointed.checkpoint.number;
+        // The l2Tips and proposedCheckpointData reads above come from independent archiver snapshots
+        // (a JS-side tips cache vs. a direct store read on `#proposedCheckpoints`). A concurrent archiver
+        // write that mutates both can be observed split, leaving us with `hasProposedCheckpoint=true` but
+        // no proposedCheckpointData (or one whose number doesn't match the tip). Refuse to proceed in that
+        // window — the next checkSync tick will see a coherent snapshot.
+        if (hasProposedCheckpoint && (!proposedCheckpointData || proposedCheckpointData.checkpointNumber !== l2Tips.proposedCheckpoint.checkpoint.number)) {
+            this.log.warn(`Sequencer sync check failed: inconsistent proposed-checkpoint state`, {
+                proposedCheckpointTipNumber: l2Tips.proposedCheckpoint.checkpoint.number,
+                checkpointedTipNumber: l2Tips.checkpointed.checkpoint.number,
+                proposedCheckpointDataNumber: proposedCheckpointData?.checkpointNumber,
+                syncedL2Slot,
+                ...args
+            });
+            return undefined;
+        }
+        // Check that the proposed checkpoint is indeed the parent of the checkpoint we'll be building
+        // The checkpoint number to build is derived as blockData.checkpointNumber + 1
+        if (proposedCheckpointData && proposedCheckpointData.checkpointNumber !== blockData.checkpointNumber) {
+            this.log.warn(`Sequencer sync check failed: proposed checkpoint number mismatch`, {
+                proposedCheckpointNumber: proposedCheckpointData.checkpointNumber,
+                blockCheckpointNumber: blockData.checkpointNumber,
+                syncedL2Slot,
+                ...args
+            });
+            return undefined;
+        }
+        return {
+            blockData,
+            blockNumber: blockData.header.getBlockNumber(),
+            checkpointNumber: blockData.checkpointNumber,
+            checkpointedCheckpointNumber: l2Tips.checkpointed.checkpoint.number,
+            archive: blockData.archive.root,
+            hasProposedCheckpoint,
+            proposedCheckpointData,
+            syncedL2Slot,
+            pendingChainValidationStatus
+        };
     }
     /**
-   * @notice  Build and propose a block to the chain
-   *
-   * @dev     MUST throw instead of exiting early to ensure that world-state
-   *          is being rolled back if the block is dropped.
-   *
-   * @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);
-        const workTimer = new Timer();
-        this.setState(SequencerState.CREATING_BLOCK, slot);
+   * Whether the enclosing checkpoint of a reexecuted block is overdue: past the deadline by which a
+   * well-behaved proposer should have published it. Mirrors the archiver's orphan-prune deadline (the
+   * start of the slot after the block's build slot, plus a grace period) so the sequencer only warns
+   * about a missing proposed checkpoint once the archiver itself would prune the orphan block. The grace
+   * is derived from the block build duration the same way the archiver defaults it at node wiring.
+   */ isProposedCheckpointOverdue(blockSlot) {
+        const expectedBySlot = SlotNumber(Number(blockSlot) - PROPOSER_PIPELINING_SLOT_OFFSET + 1);
+        const graceSeconds = this.config.blockDurationMs !== undefined ? Math.ceil(this.config.blockDurationMs / 1000) : MIN_EXECUTION_TIME;
+        const expectedByTime = getTimestampForSlot(expectedBySlot, this.l1Constants) + BigInt(graceSeconds);
+        return BigInt(this.dateProvider.nowInSeconds()) >= expectedByTime;
+    }
+    /**
+   * 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(targetSlot) {
+        let proposer;
         try {
-            const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables);
-            const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
-            this.metrics.recordBuiltBlock(workTimer.ms(), publicGas.l2Gas);
-            // 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);
-            const blockStats = {
-                eventName: 'l2-block-built',
-                creator: this.publisher.getSenderAddress().toString(),
-                duration: workTimer.ms(),
-                publicProcessDuration: publicProcessorDuration,
-                rollupCircuitsDuration: blockBuildingTimer.ms(),
-                ...block.getStats()
-            };
-            const blockHash = await block.hash();
-            const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
-            this.log.info(`Built block ${block.number} for slot ${slot} with ${numTxs} txs and ${numMsgs} messages. ${publicGas.l2Gas / workTimer.s()} mana/s`, {
-                blockHash,
-                globalVariables: block.header.globalVariables.toInspect(),
-                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`, {
-                    blockHash,
-                    blockNumber
-                });
+            proposer = await this.epochCache.getProposerAttesterAddressInSlot(targetSlot);
+        } catch (e) {
+            if (e instanceof NoCommitteeError) {
+                if (this.lastSlotForNoCommitteeWarning !== targetSlot) {
+                    this.lastSlotForNoCommitteeWarning = targetSlot;
+                    this.log.warn(`Cannot propose at target slot ${targetSlot} since the committee does not exist on L1`);
+                }
+                return [
+                    false,
+                    undefined
+                ];
             }
-            stopCollectingAttestationsTimer();
-            return this.enqueuePublishL2Block(block, attestations, txHashes);
-        } catch (err) {
-            this.metrics.recordFailedBlock();
-            throw err;
+            this.log.error(`Error getting proposer for target slot ${targetSlot}`, e);
+            return [
+                false,
+                undefined
+            ];
         }
-    }
-    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();
-        if (committee.length === 0) {
-            this.log.verbose(`Attesting committee is empty`);
-            return undefined;
-        } 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);
-        }
-        const numberOfRequiredAttestations = Math.floor(committee.length * 2 / 3) + 1;
-        const slotNumber = block.header.globalVariables.slotNumber.toBigInt();
-        this.setState(SequencerState.COLLECTING_ATTESTATIONS, slotNumber);
-        this.log.debug('Creating block proposal for validators');
-        const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
-        if (!proposal) {
-            const msg = `Failed to create block proposal`;
-            throw new Error(msg);
-        }
-        this.log.debug('Broadcasting block proposal to validators');
-        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);
+        // 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 target slot ${targetSlot} since we are not a proposer`, {
+                targetSlot,
+                validatorAddresses,
+                proposer
+            });
+            return [
+                false,
+                proposer
+            ];
+        }
+        this.log.info(`We are the proposer for pipeline slot ${targetSlot}`, {
+            targetSlot,
+            proposer
+        });
+        return [
+            true,
+            proposer
+        ];
     }
     /**
-   * Publishes the L2Block to the rollup contract.
-   * @param block - The L2Block to be published.
-   */ async enqueuePublishL2Block(block, attestations, txHashes) {
-        // Publishes new block to the network and awaits the tx to be mined
-        this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
-        // Time out tx at the end of the slot
-        const slot = block.header.globalVariables.slotNumber.toNumber();
-        const txTimeoutAt = new Date((this.getSlotStartTimestamp(slot) + this.aztecSlotDuration) * 1000);
-        const enqueued = await this.publisher.enqueueProposeL2Block(block, attestations, txHashes, {
-            txTimeoutAt
+   * 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, targetSlot } = args;
+        // Prevent duplicate attempts in the same slot
+        if (this.lastSlotForFallbackVote === slot) {
+            this.log.trace(`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_CHECKPOINT);
+        // 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 time for block building`, {
+                secondsIntoSlot,
+                maxAllowedTime
+            });
+            return;
+        }
+        this.log.trace(`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(targetSlot);
+        if (!canPropose) {
+            this.log.trace(`Cannot vote in slot ${slot} since we are not a proposer`, {
+                slot,
+                proposer
+            });
+            return;
+        }
+        // Mark this slot as attempted
+        this.lastSlotForFallbackVote = 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
         });
-        if (!enqueued) {
-            throw new Error(`Failed to enqueue publish of block ${block.number}`);
+        // Enqueue governance and slashing votes (voter uses the target slot for L1 submission)
+        const voter = new CheckpointVoter(targetSlot, publisher, attestorAddress, this.validatorClient, this.slasherClient, this.l1Constants, this.config, this.metrics, this.log);
+        const votesPromises = voter.enqueueVotes();
+        const votes = await Promise.all(votesPromises);
+        if (votes.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
+        });
+        // Votes are EIP-712-signed for `targetSlot` (the pipelined slot in which the multicall is
+        // expected to mine). Delay submission to the start of `targetSlot` so the tx mines in the
+        // slot the votes were signed for. We fire-and-forget so we don't block the sequencer's
+        // work loop while waiting for the target slot to start.
+        void publisher.sendRequestsAt(targetSlot).catch((err)=>{
+            this.log.error(`Failed to publish votes despite sync failure for slot ${slot}`, err, {
+                slot
+            });
+        });
     }
     /**
-   * 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() {
-        const syncedBlocks = await Promise.all([
-            this.worldState.status().then((s)=>{
-                return {
-                    number: s.syncSummary.latestBlockNumber,
-                    hash: s.syncSummary.latestBlockHash
-                };
-            }),
-            this.l2BlockSource.getL2Tips().then((t)=>t.latest),
-            this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
-            this.l1ToL2MessageSource.getBlockNumber()
-        ]);
-        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
-        // 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
+   * Tries to vote on slashing actions and governance proposals when escape hatch is open.
+   * This allows the sequencer to participate in voting without performing checkpoint proposal work.
+   */ async tryVoteWhenEscapeHatchOpen(args) {
+        const { slot, targetSlot, proposer } = args;
+        // Prevent duplicate attempts in the same slot
+        if (this.lastSlotForFallbackVote === slot) {
+            this.log.trace(`Already attempted to vote in slot ${slot} (escape hatch open, skipping)`);
+            return;
+        }
+        // Mark this slot as attempted
+        this.lastSlotForFallbackVote = slot;
+        const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
+        this.log.debug(`Escape hatch open for slot ${slot}, attempting vote-only actions`, {
+            slot,
+            targetSlot,
+            attestorAddress
         });
-        if (!result) {
-            return undefined;
+        // Under proposer pipelining, the multicall is expected to mine in `targetSlot` (slot + 1).
+        // Governance and slashing votes are EIP-712-signed against the slot they will mine in, and the
+        // L1 contract checks `msg.sender == getCurrentProposer()` using the mining slot. So we must
+        // sign for `targetSlot` and delay submission to the start of `targetSlot`.
+        const voter = new CheckpointVoter(targetSlot, publisher, attestorAddress, this.validatorClient, this.slasherClient, this.l1Constants, this.config, this.metrics, this.log);
+        const votesPromises = voter.enqueueVotes();
+        const votes = await Promise.all(votesPromises);
+        if (votes.every((p)=>!p)) {
+            this.log.debug(`No votes to enqueue for slot ${slot} (escape hatch open)`);
+            return;
         }
-        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;
+        this.log.info(`Voting in slot ${slot} (escape hatch open)`, {
+            slot,
+            targetSlot
+        });
+        // Votes are EIP-712-signed for `targetSlot`. Delay submission to the start of `targetSlot` so
+        // the multicall mines in the slot the votes were signed for; otherwise the L1 contract reads
+        // `signaler = getCurrentProposer()` against the wrong slot and signature verification fails
+        // silently inside Multicall3. Fire-and-forget so we don't block the sequencer's work loop while
+        // waiting for the target slot to start, mirroring tryVoteWhenSyncFails.
+        void publisher.sendRequestsAt(targetSlot).catch((err)=>{
+            this.log.error(`Failed to publish escape-hatch votes for slot ${slot}`, err, {
+                slot,
+                targetSlot
+            });
+        });
+    }
+    /**
+   * 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 considerInvalidatingCheckpoint(syncedTo, currentSlot) {
+        const { pendingChainValidationStatus, syncedL2Slot } = syncedTo;
+        if (pendingChainValidationStatus.valid) {
+            return;
+        }
+        const invalidCheckpointNumber = pendingChainValidationStatus.checkpoint.checkpointNumber;
+        const invalidCheckpointTimestamp = pendingChainValidationStatus.checkpoint.timestamp;
+        const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidCheckpointTimestamp);
+        const ourValidatorAddresses = this.validatorClient.getValidatorAddresses();
+        const { secondsBeforeInvalidatingBlockAsCommitteeMember, secondsBeforeInvalidatingBlockAsNonCommitteeMember } = this.config;
+        const logData = {
+            invalidL1Timestamp: invalidCheckpointTimestamp,
+            syncedL2Slot,
+            invalidCheckpoint: pendingChainValidationStatus.checkpoint,
+            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;
+        }
+        let validatorToUse;
+        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];
             }
-            return {
-                blockNumber: block.number,
-                archive: block.archive.root
-            };
         } else {
-            const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
-            return {
-                blockNumber: INITIAL_L2_BLOCK_NUM - 1,
-                archive
-            };
+            // When invalidating as a non-committee member, use the first validator
+            validatorToUse = ourValidatorAddresses[0];
+        }
+        const { publisher } = await this.publisherFactory.create(validatorToUse);
+        const invalidateCheckpoint = await publisher.simulateInvalidateCheckpoint(pendingChainValidationStatus);
+        if (!invalidateCheckpoint) {
+            this.log.warn(`Failed to simulate invalidate checkpoint`, logData);
+            return;
+        }
+        this.log.info(invalidateAsCommitteeMember ? `Invalidating checkpoint ${invalidCheckpointNumber} as committee member` : `Invalidating checkpoint ${invalidCheckpointNumber} as non-committee member`, logData);
+        publisher.enqueueInvalidateCheckpoint(invalidateCheckpoint);
+        if (!this.config.fishermanMode) {
+            await publisher.sendRequests();
+        } else {
+            this.log.info('Invalidating checkpoint in fisherman mode, clearing pending requests');
+            publisher.clearPendingRequests();
         }
     }
-    getSlotStartTimestamp(slotNumber) {
-        return Number(this.l1Constants.l1GenesisTime) + Number(slotNumber) * this.l1Constants.slotDuration;
+    logStrategyComparison(epoch, publisher) {
+        const feeAnalyzer = publisher.getL1FeeAnalyzer();
+        if (!feeAnalyzer) {
+            return;
+        }
+        const comparison = feeAnalyzer.getStrategyComparison();
+        if (comparison.length === 0) {
+            this.log.debug(`No strategy data available yet for epoch ${epoch}`);
+            return;
+        }
+        this.log.info(`L1 Fee Strategy Performance Report - End of Epoch ${epoch}`, {
+            epoch: Number(epoch),
+            totalAnalyses: comparison[0]?.totalAnalyses,
+            strategies: comparison.map((s)=>({
+                    id: s.strategyId,
+                    name: s.strategyName,
+                    inclusionRate: `${(s.inclusionRate * 100).toFixed(1)}%`,
+                    inclusionCount: `${s.inclusionCount}/${s.totalAnalyses}`,
+                    avgCostEth: s.avgEstimatedCostEth.toFixed(6),
+                    totalCostEth: s.totalEstimatedCostEth.toFixed(6),
+                    avgOverpaymentEth: s.avgOverpaymentEth.toFixed(6),
+                    totalOverpaymentEth: s.totalOverpaymentEth.toFixed(6),
+                    avgPriorityFeeDeltaGwei: s.avgPriorityFeeDeltaGwei.toFixed(2)
+                }))
+        });
+    }
+    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;
+    }
+    getSlasherClient() {
+        return this.slasherClient;
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    getValidatorAddresses() {
+        return this.validatorClient?.getValidatorAddresses();
+    }
+    /** Updates the publisher factory's node keystore adapter after a keystore reload. */ updatePublisherNodeKeyStore(adapter) {
+        this.publisherFactory.updateNodeKeyStore(adapter);
+    }
+    getConfig() {
+        return this.config;
     }
-    get feeRecipient() {
-        return this._feeRecipient;
+    get l1PublishingTime() {
+        return this.config.l1PublishingTime ?? this.l1Constants.ethereumSlotDuration;
     }
 }
-_ts_decorate([
-    trackSpan('Sequencer.work')
-], Sequencer.prototype, "work", null);
-_ts_decorate([
-    trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, proposalHeader)=>({
-            [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber()
-        }))
-], Sequencer.prototype, "buildBlockAndEnqueuePublish", null);
-_ts_decorate([
-    trackSpan('Sequencer.collectAttestations', (block, txHashes)=>({
-            [Attributes.BLOCK_NUMBER]: block.number,
-            [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
-            [Attributes.BLOCK_TXS_COUNT]: txHashes.length
-        }))
-], Sequencer.prototype, "collectAttestations", null);
-_ts_decorate([
-    trackSpan('Sequencer.enqueuePublishL2Block', (block)=>({
-            [Attributes.BLOCK_NUMBER]: block.number
-        }))
-], Sequencer.prototype, "enqueuePublishL2Block", null);