@aztec/sequencer-client 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/dest/sequencer/sequencer.js

@@ -1,39 +1,407 @@
-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);
+}
+var _dec, _initProto;
+import { getKzg } from '@aztec/blob-lib';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { FormattedViemError, NoCommitteeError } from '@aztec/ethereum';
-import { omit, pick } from '@aztec/foundation/collection';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { merge, omit, pick } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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 } from '@aztec/foundation/timer';
-import { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
-import { Gas } from '@aztec/stdlib/gas';
+import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
-import { orderAttestations } from '@aztec/stdlib/p2p';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { ContentCommitment, ProposedBlockHeader } from '@aztec/stdlib/tx';
-import { AttestationTimeoutError } from '@aztec/stdlib/validators';
-import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import EventEmitter from 'node:events';
+import { DefaultSequencerConfig } from '../config.js';
+import { CheckpointProposalJob } from './checkpoint_proposal_job.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 { SequencerTimetable } from './timetable.js';
 import { SequencerState } from './utils.js';
 export { SequencerState };
+_dec = trackSpan('Sequencer.work');
 /**
  * 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.
+ * - 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;
@@ -43,370 +411,274 @@ export { SequencerState };
     slasherClient;
     l2BlockSource;
     l1ToL2MessageSource;
-    blockBuilder;
+    checkpointsBuilder;
     l1Constants;
     dateProvider;
     epochCache;
     rollupContract;
-    config;
     telemetry;
     log;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "safeWork"
+            ]
+        ], []));
+    }
     runningPromise;
-    pollingIntervalMs;
-    maxTxsPerBlock;
-    minTxsPerBlock;
-    maxL1TxInclusionTimeIntoSlot;
     state;
-    maxBlockSizeInBytes;
-    maxBlockGas;
     metrics;
-    lastBlockPublished;
-    governanceProposerPayload;
+    /** The last slot for which we attempted to vote when sync failed, to prevent duplicate attempts. */ lastSlotForVoteWhenSyncFailed;
+    /** The last slot for which we 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 maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */ timetable;
-    enforceTimeTable;
     // This shouldn't be here as this gets re-created each time we build/propose a block.
     // But we have a number of tests that abuse/rely on this class having a permanent publisher.
     // As long as those tests only configure a single publisher they will continue to work.
     // This will get re-assigned every time the sequencer goes to build a new block to a publisher that is valid
     // for the block proposer.
+    // TODO(palla/mbps): Remove this field and fix tests
     publisher;
-    constructor(publisherFactory, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, l2BlockSource, l1ToL2MessageSource, blockBuilder, l1Constants, dateProvider, epochCache, rollupContract, config, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
-        super(), this.publisherFactory = publisherFactory, this.validatorClient = validatorClient, this.globalsBuilder = globalsBuilder, this.p2pClient = p2pClient, this.worldState = worldState, this.slasherClient = slasherClient, this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.blockBuilder = blockBuilder, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.epochCache = epochCache, this.rollupContract = rollupContract, this.config = config, this.telemetry = telemetry, this.log = log, this.pollingIntervalMs = 1000, this.maxTxsPerBlock = 32, this.minTxsPerBlock = 1, this.maxL1TxInclusionTimeIntoSlot = 0, this.state = SequencerState.STOPPED, this.maxBlockSizeInBytes = 1024 * 1024, this.maxBlockGas = new Gas(100e9, 100e9), this.enforceTimeTable = false;
-        // Set an initial coinbase for metrics purposes, but this will potentially change with each block.
-        const validatorAddresses = this.validatorClient?.getValidatorAddresses() ?? [];
-        const coinbase = validatorAddresses.length === 0 ? EthAddress.ZERO : this.validatorClient?.getCoinbaseForAttestor(validatorAddresses[0]) ?? EthAddress.ZERO;
-        this.metrics = new SequencerMetrics(telemetry, ()=>this.state, coinbase, this.rollupContract, 'Sequencer');
-        // Initialize config
-        this.updateConfig(this.config);
-    }
-    get tracer() {
-        return this.metrics.tracer;
-    }
-    getValidatorAddresses() {
-        return this.validatorClient?.getValidatorAddresses();
-    }
-    getConfig() {
-        return this.config;
-    }
-    /**
-   * Updates sequencer config by the defined values in the config on input.
-   * @param config - New parameters.
-   */ updateConfig(config) {
-        this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'txPublicSetupAllowList'));
-        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.maxBlockSizeInBytes !== undefined) {
-            this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
-        }
-        if (config.governanceProposerPayload) {
-            this.governanceProposerPayload = 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.
-        // Update all values on this.config that are populated in the config object.
-        Object.assign(this.config, config);
+    /** Config for the sequencer */ config;
+    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.config = DefaultSequencerConfig;
+        // Add [FISHERMAN] prefix to logger if in fisherman mode
+        if (config.fishermanMode) {
+            this.log = log.createChild('[FISHERMAN]');
+        }
+        this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
+        this.updateConfig(config);
     }
-    setTimeTable() {
+    /** 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, 'txPublicSetupAllowList'));
+        this.config = merge(this.config, filteredConfig);
         this.timetable = new SequencerTimetable({
             ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
             aztecSlotDuration: this.aztecSlotDuration,
-            maxL1TxInclusionTimeIntoSlot: this.maxL1TxInclusionTimeIntoSlot,
-            attestationPropagationTime: this.config.attestationPropagationTime,
-            enforce: this.enforceTimeTable
+            l1PublishingTime: this.l1PublishingTime,
+            p2pPropagationTime: this.config.attestationPropagationTime,
+            blockDurationMs: this.config.blockDurationMs,
+            enforce: this.config.enforceTimeTable
         }, this.metrics, this.log);
     }
-    async init() {
+    /** Initializes the sequencer (precomputes tables and creates a publisher). Takes about 3s. */ async init() {
+        getKzg();
         this.publisher = (await this.publisherFactory.create(undefined)).publisher;
     }
-    /**
-   * Starts the sequencer and moves to IDLE state.
-   */ start() {
-        this.metrics.start();
-        this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollingIntervalMs);
+    /** 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
         });
         this.runningPromise.start();
         this.log.info('Started sequencer');
     }
-    /**
-   * Stops the sequencer from processing txs and moves to STOPPED state.
-   */ async stop() {
+    /** Stops the sequencer from building blocks and moves to STOPPED state. */ async stop() {
         this.log.info(`Stopping sequencer`);
-        this.metrics.stop();
+        this.setState(SequencerState.STOPPING, undefined, {
+            force: true
+        });
         this.publisher?.interrupt();
-        await this.validatorClient?.stop();
         await this.runningPromise?.stop();
         this.setState(SequencerState.STOPPED, undefined, {
             force: true
         });
         this.log.info('Stopped sequencer');
     }
-    /**
-   * Returns the current state of the sequencer.
-   * @returns An object with a state entry with one of SequencerState.
-   */ status() {
+    async safeWork() {
+        try {
+            await this.work();
+        } catch (err) {
+            this.emit('checkpoint-error', {
+                error: err
+            });
+            if (err instanceof SequencerTooSlowError) {
+                // TODO(palla/mbps): Add missing states
+                // Log as warn only if we had to abort halfway through the block proposal
+                const logLvl = [
+                    SequencerState.INITIALIZING_CHECKPOINT,
+                    SequencerState.PROPOSER_CHECK
+                ].includes(err.proposedState) ? 'debug' : 'warn';
+                this.log[logLvl](err.message, {
+                    now: this.dateProvider.nowInSeconds()
+                });
+            } else {
+                // Re-throw other errors
+                throw err;
+            }
+        } finally{
+            this.setState(SequencerState.IDLE, undefined);
+        }
+    }
+    /** Returns the current state of the sequencer. */ status() {
         return {
             state: this.state
         };
     }
     /**
-   * @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() {
+   * 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);
-        // Check all components are synced to latest as seen by the archiver
-        const syncedTo = await this.getChainTip();
-        // Do not go forward with new block if the previous one has not been mined and processed
-        if (!syncedTo) {
+        const { slot, ts, now, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
+        // Check if we are synced and it's our slot, grab a publisher, check previous block invalidation, etc
+        const checkpointProposalJob = await this.prepareCheckpointProposal(slot, ts, now);
+        if (!checkpointProposalJob) {
             return;
         }
-        const chainTipArchive = syncedTo.archive;
-        const newBlockNumber = syncedTo.blockNumber + 1;
-        const { slot, ts, now } = this.epochCache.getEpochAndSlotInNextL1Slot();
-        this.setState(SequencerState.PROPOSER_CHECK, slot);
-        // Check that the archiver and dependencies have synced to the previous L1 slot at least
-        // TODO(#14766): Archiver reports L1 timestamp based on L1 blocks seen, which means that a missed L1 block will
-        // cause the archiver L1 timestamp to fall behind, and cause this sequencer to start processing one L1 slot later.
-        const syncLogData = {
+        // 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
+        if (this.config.fishermanMode && (this.lastEpochForStrategyComparison === undefined || epoch > this.lastEpochForStrategyComparison)) {
+            this.logStrategyComparison(epoch, checkpointProposalJob.getPublisher());
+            this.lastEpochForStrategyComparison = epoch;
+        }
+        return checkpoint;
+    }
+    /**
+   * 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, ts, now) {
+        // Check we have not already processed this 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 >= slot && this.config.enforceTimeTable) {
+            this.log.trace(`Slot ${slot} has already been processed`);
+            return undefined;
+        }
+        // But if we have already proposed for this slot, the we definitely have to skip it, automining or not
+        if (this.lastCheckpointProposed && this.lastCheckpointProposed.header.slotNumber >= slot) {
+            this.log.trace(`Slot ${slot} has already been published as checkpoint ${this.lastCheckpointProposed.number}`);
+            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 (!syncedTo) {
+            await this.tryVoteWhenSyncFails({
+                slot,
+                ts
+            });
+            return undefined;
+        }
+        // TODO(palla/mbps): Compute proper checkpoint number
+        const checkpointNumber = CheckpointNumber.fromBlockNumber(BlockNumber(syncedTo.blockNumber + 1));
+        const logCtx = {
             now,
             syncedToL1Ts: syncedTo.l1Timestamp,
             syncedToL2Slot: getSlotAtTimestamp(syncedTo.l1Timestamp, this.l1Constants),
-            nextL2Slot: slot,
-            nextL2SlotTs: ts,
-            l1SlotDuration: this.l1Constants.ethereumSlotDuration,
-            newBlockNumber,
+            slot,
+            slotTs: ts,
+            checkpointNumber,
             isPendingChainValid: pick(syncedTo.pendingChainValidationStatus, 'valid', 'reason', 'invalidIndex')
         };
-        if (syncedTo.l1Timestamp + BigInt(this.l1Constants.ethereumSlotDuration) < ts) {
-            this.log.debug(`Cannot propose block ${newBlockNumber} at next L2 slot ${slot} due to pending sync from L1`, syncLogData);
-            return;
+        // Check that we are a proposer for the next slot
+        this.setState(SequencerState.PROPOSER_CHECK, slot);
+        const [canPropose, proposer] = await this.checkCanPropose(slot);
+        // If we are not a proposer check if we should invalidate a invalid block, and bail
+        if (!canPropose) {
+            await this.considerInvalidatingBlock(syncedTo, slot);
+            return undefined;
         }
-        // Check that the slot is not taken by a block already
+        // Check that the slot is not taken by a block already (should never happen, since only us can propose for this slot)
         if (syncedTo.block && syncedTo.block.header.getSlot() >= slot) {
-            this.log.debug(`Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`, {
-                ...syncLogData,
+            this.log.warn(`Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`, {
+                ...logCtx,
                 block: syncedTo.block.header.toInspect()
             });
-            return;
-        }
-        // Or that we haven't published it ourselves
-        if (this.lastBlockPublished && this.lastBlockPublished.header.getSlot() >= slot) {
-            this.log.debug(`Cannot propose block at next L2 slot ${slot} since that slot was taken by our own block ${this.lastBlockPublished.number}`, {
-                ...syncLogData,
-                block: this.lastBlockPublished.header.toInspect()
-            });
-            return;
-        }
-        // Check that we are a proposer for the next slot
-        let proposerInNextSlot;
-        try {
-            proposerInNextSlot = await this.epochCache.getProposerAttesterAddressInNextSlot();
-        } catch (e) {
-            if (e instanceof NoCommitteeError) {
-                this.log.warn(`Cannot propose block ${newBlockNumber} at next L2 slot ${slot} since the committee does not exist on L1`);
-                return;
-            }
-        }
-        // If get proposer in next slot is undefined, then the committee is empty and anyone may propose.
-        // If the committee is defined and not empty, but none of our validators are the proposer, then stop.
-        const validatorAddresses = this.validatorClient.getValidatorAddresses();
-        if (proposerInNextSlot !== undefined && !validatorAddresses.some((addr)=>addr.equals(proposerInNextSlot))) {
-            this.log.debug(`Cannot propose block ${newBlockNumber} since we are not a proposer`, {
-                us: validatorAddresses,
-                proposer: proposerInNextSlot,
-                ...syncLogData
-            });
-            // If the pending chain is invalid, we may need to invalidate the block if no one else is doing it.
-            if (!syncedTo.pendingChainValidationStatus.valid) {
-                // We pass i undefined here to get any available publisher.
-                const { publisher } = await this.publisherFactory.create(undefined);
-                await this.considerInvalidatingBlock(syncedTo, slot, validatorAddresses, publisher);
-            }
-            return;
+            this.metrics.recordBlockProposalPrecheckFailed('slot_already_taken');
+            return undefined;
         }
-        // Check with the rollup if we can indeed propose at the next L2 slot. This check should not fail
-        // if all the previous checks are good, but we do it just in case.
-        const proposerAddressInNextSlot = proposerInNextSlot ?? EthAddress.ZERO;
         // We now need to get ourselves a publisher.
         // The returned attestor will be the one we provided if we provided one.
         // Otherwise it will be a valid attestor for the returned publisher.
-        const { attestorAddress, publisher } = await this.publisherFactory.create(proposerInNextSlot);
+        // In fisherman mode, pass undefined to use the fisherman's own keystore instead of the actual proposer's
+        const 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}`);
         this.publisher = publisher;
-        const coinbase = this.validatorClient.getCoinbaseForAttestor(attestorAddress);
-        const feeRecipient = this.validatorClient.getFeeRecipientForAttestor(attestorAddress);
-        this.metrics.setCoinbase(coinbase);
+        // In fisherman mode, set the actual proposer's address for simulations
+        if (this.config.fishermanMode && proposer) {
+            publisher.setProposerAddressForSimulation(proposer);
+            this.log.debug(`Set proposer address ${proposer} for simulation in fisherman mode`);
+        }
         // Prepare invalidation request if the pending chain is invalid (returns undefined if no need)
+        // TODO(palla/mbps): We need to invalidate checkpoints, not blocks
         const invalidateBlock = await publisher.simulateInvalidateBlock(syncedTo.pendingChainValidationStatus);
-        const canProposeCheck = await publisher.canProposeAtNextEthBlock(chainTipArchive, proposerAddressInNextSlot, invalidateBlock);
+        // Check with the rollup contract if we can indeed propose at the next L2 slot. This check should not fail
+        // if all the previous checks are good, but we do it just in case.
+        const canProposeCheck = await publisher.canProposeAtNextEthBlock(syncedTo.archive, proposer ?? EthAddress.ZERO, invalidateBlock);
         if (canProposeCheck === undefined) {
-            this.log.warn(`Cannot propose block ${newBlockNumber} at slot ${slot} due to failed rollup contract check`, syncLogData);
+            this.log.warn(`Cannot propose checkpoint ${checkpointNumber} at slot ${slot} due to failed rollup contract check`, logCtx);
             this.emit('proposer-rollup-check-failed', {
-                reason: 'Rollup contract check failed'
+                reason: 'Rollup contract check failed',
+                slot
             });
-            return;
-        } else if (canProposeCheck.slot !== slot) {
+            this.metrics.recordBlockProposalPrecheckFailed('rollup_contract_check_failed');
+            return undefined;
+        }
+        if (canProposeCheck.slot !== slot) {
             this.log.warn(`Cannot propose block due to slot mismatch with rollup contract (this can be caused by a clock out of sync). Expected slot ${slot} but got ${canProposeCheck.slot}.`, {
-                ...syncLogData,
+                ...logCtx,
                 rollup: canProposeCheck,
-                newBlockNumber,
                 expectedSlot: slot
             });
             this.emit('proposer-rollup-check-failed', {
-                reason: 'Slot mismatch'
+                reason: 'Slot mismatch',
+                slot
             });
-            return;
-        } else if (canProposeCheck.blockNumber !== BigInt(newBlockNumber)) {
-            this.log.warn(`Cannot propose block due to block mismatch with rollup contract (this can be caused by a pending archiver sync). Expected block ${newBlockNumber} but got ${canProposeCheck.blockNumber}.`, {
-                ...syncLogData,
+            this.metrics.recordBlockProposalPrecheckFailed('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,
                 rollup: canProposeCheck,
-                newBlockNumber,
                 expectedSlot: slot
             });
             this.emit('proposer-rollup-check-failed', {
-                reason: 'Block mismatch'
-            });
-            return;
-        }
-        this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot}` + (proposerInNextSlot ? ` as ${proposerInNextSlot}` : ''), {
-            ...syncLogData,
-            validatorAddresses
-        });
-        const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(newBlockNumber, coinbase, feeRecipient, slot);
-        const { timestamp } = newGlobalVariables;
-        const signerFn = (msg)=>this.validatorClient.signWithAddress(attestorAddress, msg).then((s)=>s.toString());
-        const enqueueGovernanceSignalPromise = this.governanceProposerPayload && !this.governanceProposerPayload.isZero() ? publisher.enqueueGovernanceCastSignal(this.governanceProposerPayload, slot, timestamp, attestorAddress, signerFn).catch((err)=>{
-            this.log.error(`Error enqueuing governance vote`, err, {
-                blockNumber: newBlockNumber,
-                slot
-            });
-            return false;
-        }) : Promise.resolve(false);
-        const enqueueSlashingActionsPromise = this.slasherClient ? this.slasherClient.getProposerActions(slot).then((actions)=>publisher.enqueueSlashingActions(actions, slot, timestamp, attestorAddress, signerFn)).catch((err)=>{
-            this.log.error(`Error enqueuing slashing actions`, err, {
-                blockNumber: newBlockNumber,
-                slot
-            });
-            return false;
-        }) : Promise.resolve(false);
-        if (invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
-            publisher.enqueueInvalidateBlock(invalidateBlock);
-        }
-        this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
-        this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-            proposer: proposerInNextSlot?.toString(),
-            coinbase,
-            publisher: publisher.getSenderAddress(),
-            feeRecipient,
-            globalVariables: newGlobalVariables.toInspect(),
-            chainTipArchive,
-            blockNumber: newBlockNumber,
-            slot
-        });
-        // If I created a "partial" header here that should make our job much easier.
-        const proposalHeader = ProposedBlockHeader.from({
-            ...newGlobalVariables,
-            timestamp: newGlobalVariables.timestamp,
-            lastArchiveRoot: chainTipArchive,
-            contentCommitment: ContentCommitment.empty(),
-            totalManaUsed: Fr.ZERO
-        });
-        let block;
-        const pendingTxCount = await this.p2pClient.getPendingTxCount();
-        if (pendingTxCount >= this.minTxsPerBlock) {
-            // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
-            // and also we may need to fetch more if we don't have enough valid txs.
-            const pendingTxs = this.p2pClient.iteratePendingTxs();
-            try {
-                block = await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerInNextSlot, invalidateBlock, publisher);
-            } catch (err) {
-                this.emit('block-build-failed', {
-                    reason: err.message
-                });
-                if (err instanceof FormattedViemError) {
-                    this.log.verbose(`Unable to build/enqueue block ${err.message}`);
-                } else {
-                    this.log.error(`Error building/enqueuing block`, err, {
-                        blockNumber: newBlockNumber,
-                        slot
-                    });
-                }
-            }
-        } else {
-            this.log.verbose(`Not enough txs to build block ${newBlockNumber} at slot ${slot} (got ${pendingTxCount} txs, need ${this.minTxsPerBlock})`, {
-                chainTipArchive,
-                blockNumber: newBlockNumber,
+                reason: 'Block mismatch',
                 slot
             });
-            this.emit('tx-count-check-failed', {
-                minTxs: this.minTxsPerBlock,
-                availableTxs: pendingTxCount
-            });
-        }
-        await Promise.all([
-            enqueueGovernanceSignalPromise,
-            enqueueSlashingActionsPromise
-        ]);
-        const l1Response = await publisher.sendRequests();
-        const proposedBlock = l1Response?.successfulActions.find((a)=>a === 'propose');
-        if (proposedBlock) {
-            this.lastBlockPublished = block;
-            this.emit('block-published', {
-                blockNumber: newBlockNumber,
-                slot: Number(slot)
-            });
-            this.metrics.incFilledSlot(publisher.getSenderAddress().toString());
-        } else if (block) {
-            this.emit('block-publish-failed', l1Response ?? {});
+            this.metrics.recordBlockProposalPrecheckFailed('block_number_mismatch');
+            return undefined;
         }
-        this.setState(SequencerState.IDLE, undefined);
+        this.lastSlotForCheckpointProposalJob = slot;
+        this.log.info(`Preparing checkpoint proposal ${checkpointNumber} at slot ${slot}`, {
+            ...logCtx,
+            proposer
+        });
+        // Create and return the checkpoint proposal job
+        return this.createCheckpointProposalJob(slot, checkpointNumber, syncedTo.blockNumber, proposer, publisher, attestorAddress, invalidateBlock);
     }
-    async work() {
-        try {
-            await this.doRealWork();
-        } catch (err) {
-            if (err instanceof SequencerTooSlowError) {
-                // Log as warn only if we had to abort halfway through the block proposal
-                const logLvl = [
-                    SequencerState.INITIALIZING_PROPOSAL,
-                    SequencerState.PROPOSER_CHECK
-                ].includes(err.proposedState) ? 'debug' : 'warn';
-                this.log[logLvl](err.message, {
-                    now: this.dateProvider.nowInSeconds()
-                });
-            } else {
-                // Re-throw other errors
-                throw err;
-            }
-        } finally{
-            this.setState(SequencerState.IDLE, undefined);
-        }
+    createCheckpointProposalJob(slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateBlock) {
+        return new CheckpointProposalJob(slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateBlock, this.validatorClient, this.globalsBuilder, this.p2pClient, this.worldState, this.l1ToL2MessageSource, this.checkpointsBuilder, this.l1Constants, this.config, this.timetable, this.slasherClient, this.epochCache, this.dateProvider, this.metrics, this, this.setState.bind(this), this.log);
     }
-    setState(proposedState, slotNumber, opts = {}) {
+    /**
+   * 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 slotNumber - The current slot number.
+   * @param force - Whether to force the transition even if the sequencer is stopped.
+   */ 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;
@@ -416,7 +688,12 @@ export { SequencerState };
             secondsIntoSlot = this.getSecondsIntoSlot(slotNumber);
             this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
         }
-        this.log.debug(`Transitioning from ${this.state} to ${proposedState}`, {
+        const boringStates = [
+            SequencerState.IDLE,
+            SequencerState.SYNCHRONIZING
+        ];
+        const logLevel = boringStates.includes(proposedState) && boringStates.includes(this.state) ? 'trace' : 'debug';
+        this.log[logLevel](`Transitioning from ${this.state} to ${proposedState}`, {
             slotNumber,
             secondsIntoSlot
         });
@@ -424,176 +701,27 @@ export { SequencerState };
             oldState: this.state,
             newState: proposedState,
             secondsIntoSlot,
-            slotNumber
+            slot: slotNumber
         });
         this.state = proposedState;
     }
-    async dropFailedTxsFromP2P(failedTxs) {
-        if (failedTxs.length === 0) {
-            return;
-        }
-        const failedTxData = failedTxs.map((fail)=>fail.tx);
-        const failedTxHashes = failedTxData.map((tx)=>tx.getTxHash());
-        this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
-        await this.p2pClient.deleteTxs(failedTxHashes);
-    }
-    getBlockBuilderOptions(slot) {
-        // Deadline for processing depends on whether we're proposing a block
-        const secondsIntoSlot = this.getSecondsIntoSlot(slot);
-        const processingEndTimeWithinSlot = this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
-        // Deadline is only set if enforceTimeTable is enabled.
-        const deadline = this.enforceTimeTable ? new Date((this.getSlotStartBuildTimestamp(slot) + processingEndTimeWithinSlot) * 1000) : undefined;
-        return {
-            maxTransactions: this.maxTxsPerBlock,
-            maxBlockSize: this.maxBlockSizeInBytes,
-            maxBlockGas: this.maxBlockGas,
-            deadline
-        };
-    }
     /**
-   * @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
-   * @param newGlobalVariables - The global variables for the new block
-   * @param proposerAddress - The address of the proposer
-   */ async buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerAddress, invalidateBlock, publisher) {
-        await publisher.validateBlockHeader(proposalHeader, invalidateBlock);
-        const blockNumber = newGlobalVariables.blockNumber;
-        const slot = proposalHeader.slotNumber.toBigInt();
-        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
-        // this.metrics.recordNewBlock(blockNumber, validTxs.length);
-        const workTimer = new Timer();
-        this.setState(SequencerState.CREATING_BLOCK, slot);
-        try {
-            const blockBuilderOptions = this.getBlockBuilderOptions(Number(slot));
-            const buildBlockRes = await this.blockBuilder.buildBlock(pendingTxs, l1ToL2Messages, newGlobalVariables, blockBuilderOptions);
-            const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer, usedTxs, failedTxs } = buildBlockRes;
-            const blockBuildDuration = workTimer.ms();
-            await this.dropFailedTxsFromP2P(failedTxs);
-            const minTxsPerBlock = this.minTxsPerBlock;
-            if (numTxs < minTxsPerBlock) {
-                this.log.warn(`Block ${blockNumber} has too few txs to be proposed (got ${numTxs} but required ${minTxsPerBlock})`, {
-                    slot,
-                    blockNumber,
-                    numTxs
-                });
-                throw new Error(`Block has too few successful txs to be proposed`);
-            }
-            // TODO(@PhilWindle) We should probably periodically check for things like another
-            // block being published before ours instead of just waiting on our block
-            await publisher.validateBlockHeader(block.header.toPropose(), invalidateBlock);
-            const blockStats = {
-                eventName: 'l2-block-built',
-                creator: proposerAddress?.toString() ?? 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
+   * 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 and dependencies have synced to the previous L1 slot at least
+        // TODO(#14766): Archiver reports L1 timestamp based on L1 blocks seen, which means that a missed L1 block will
+        // cause the archiver L1 timestamp to fall behind, and cause this sequencer to start processing one L1 slot later.
+        const l1Timestamp = await this.l2BlockSource.getL1Timestamp();
+        const { slot, ts } = args;
+        if (l1Timestamp === undefined || l1Timestamp + BigInt(this.l1Constants.ethereumSlotDuration) < ts) {
+            this.log.debug(`Cannot propose block at next L2 slot ${slot} due to pending sync from L1`, {
+                slot,
+                ts,
+                l1Timestamp
             });
-            this.log.debug('Collecting attestations');
-            const attestations = await this.collectAttestations(block, usedTxs, proposerAddress);
-            if (attestations !== undefined) {
-                this.log.verbose(`Collected ${attestations.length} attestations`, {
-                    blockHash,
-                    blockNumber
-                });
-            }
-            await this.enqueuePublishL2Block(block, attestations, txHashes, invalidateBlock, publisher);
-            this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
-            return block;
-        } catch (err) {
-            this.metrics.recordFailedBlock();
-            throw err;
-        }
-    }
-    async collectAttestations(block, txs, proposerAddress) {
-        const { committee } = await this.epochCache.getCommittee(block.header.getSlot());
-        // We checked above that the committee is defined, so this should never happen.
-        if (!committee) {
-            throw new Error('No committee when collecting attestations');
-        }
-        if (committee.length === 0) {
-            this.log.verbose(`Attesting committee is empty`);
             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 blockProposalOptions = {
-            publishFullTxs: !!this.config.publishTxsWithProposals
-        };
-        const proposal = await this.validatorClient.createBlockProposal(block.header.globalVariables.blockNumber, block.header.toPropose(), block.archive.root, block.header.state, txs, proposerAddress, blockProposalOptions);
-        if (!proposal) {
-            throw new Error(`Failed to create block proposal`);
-        }
-        if (this.config.skipCollectingAttestations) {
-            this.log.warn('Skipping attestation collection as per config (attesting with own keys only)');
-            const attestations = await this.validatorClient?.collectOwnAttestations(proposal);
-            return orderAttestations(attestations ?? [], committee);
-        }
-        this.log.debug('Broadcasting block proposal to validators');
-        await this.validatorClient.broadcastBlockProposal(proposal);
-        const attestationTimeAllowed = this.enforceTimeTable ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_BLOCK) : this.aztecSlotDuration;
-        this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
-        const timer = new Timer();
-        let collectedAttestionsCount = 0;
-        try {
-            const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
-            const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations, attestationDeadline);
-            collectedAttestionsCount = attestations.length;
-            // note: the smart contract requires that the signatures are provided in the order of the committee
-            return orderAttestations(attestations, committee);
-        } catch (err) {
-            if (err && err instanceof AttestationTimeoutError) {
-                collectedAttestionsCount = err.collectedCount;
-            }
-            throw err;
-        } finally{
-            this.metrics.recordCollectedAttestations(collectedAttestionsCount, timer.ms());
-        }
-    }
-    /**
-   * Publishes the L2Block to the rollup contract.
-   * @param block - The L2Block to be published.
-   */ async enqueuePublishL2Block(block, attestations, txHashes, invalidateBlock, publisher) {
-        // Publishes new block to the network and awaits the tx to be mined
-        this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
-        // Time out tx at the end of the slot
-        const slot = block.header.globalVariables.slotNumber.toNumber();
-        const txTimeoutAt = new Date((this.getSlotStartBuildTimestamp(slot) + this.aztecSlotDuration) * 1000);
-        const enqueued = await publisher.enqueueProposeL2Block(block, attestations, txHashes, {
-            txTimeoutAt,
-            forcePendingBlockNumber: invalidateBlock?.forcePendingBlockNumber
-        });
-        if (!enqueued) {
-            throw new Error(`Failed to enqueue publish of block ${block.number}`);
         }
-    }
-    /**
-   * 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(({ syncSummary })=>({
                     number: syncSummary.latestBlockNumber,
@@ -602,66 +730,173 @@ export { SequencerState };
             this.l2BlockSource.getL2Tips().then((t)=>t.latest),
             this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
             this.l1ToL2MessageSource.getL2Tips().then((t)=>t.latest),
-            this.l2BlockSource.getL1Timestamp(),
             this.l2BlockSource.getPendingChainValidationStatus()
         ]);
-        const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, l1Timestamp, pendingChainValidationStatus] = syncedBlocks;
-        // The archiver reports 'undefined' hash for the genesis block
-        // because it doesn't have access to world state to compute it (facepalm)
-        const result = l2BlockSource.hash === undefined ? worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0 : worldState.hash === l2BlockSource.hash && p2p.hash === l2BlockSource.hash && l1ToL2MessageSource.hash === l2BlockSource.hash;
-        const logData = {
-            worldState,
-            l2BlockSource,
-            p2p,
-            l1ToL2MessageSource
-        };
-        this.log.debug(`Sequencer sync check ${result ? 'succeeded' : 'failed'}`, logData);
+        const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, pendingChainValidationStatus] = syncedBlocks;
+        // Handle zero as a special case, since the block hash won't match across services if we're changing the prefilled data for the genesis block,
+        // as the world state can compute the new genesis block hash, but other components use the hardcoded constant.
+        const result = l2BlockSource.number === 0 && worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0 || worldState.hash === l2BlockSource.hash && p2p.hash === l2BlockSource.hash && l1ToL2MessageSource.hash === l2BlockSource.hash;
         if (!result) {
+            this.log.debug(`Sequencer sync check failed`, {
+                worldState,
+                l2BlockSource,
+                p2p,
+                l1ToL2MessageSource
+            });
             return undefined;
         }
+        // Special case for genesis state
         const blockNumber = worldState.number;
-        if (blockNumber >= INITIAL_L2_BLOCK_NUM) {
-            const block = await this.l2BlockSource.getBlock(blockNumber);
-            if (!block) {
-                // this shouldn't really happen because a moment ago we checked that all components were in sync
-                this.log.warn(`Failed to get L2 block ${blockNumber} from the archiver with all components in sync`, logData);
-                return undefined;
-            }
-            return {
-                block,
-                blockNumber: block.number,
-                archive: block.archive.root,
-                l1Timestamp,
-                pendingChainValidationStatus
-            };
-        } else {
+        if (blockNumber < INITIAL_L2_BLOCK_NUM) {
             const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
             return {
-                blockNumber: INITIAL_L2_BLOCK_NUM - 1,
+                blockNumber: BlockNumber(INITIAL_L2_BLOCK_NUM - 1),
                 archive,
                 l1Timestamp,
                 pendingChainValidationStatus
             };
         }
+        const block = await this.l2BlockSource.getL2BlockNew(blockNumber);
+        if (!block) {
+            // this shouldn't really happen because a moment ago we checked that all components were in sync
+            this.log.error(`Failed to get L2 block ${blockNumber} from the archiver with all components in sync`);
+            return undefined;
+        }
+        return {
+            block,
+            blockNumber: block.number,
+            archive: block.archive.root,
+            l1Timestamp,
+            pendingChainValidationStatus
+        };
+    }
+    /**
+   * Checks if we are the proposer for the next slot.
+   * @returns True if we can propose, and the proposer address (undefined if anyone can propose)
+   */ async checkCanPropose(slot) {
+        let proposer;
+        try {
+            proposer = await this.epochCache.getProposerAttesterAddressInSlot(slot);
+        } catch (e) {
+            if (e instanceof NoCommitteeError) {
+                this.log.warn(`Cannot propose at next L2 slot ${slot} since the committee does not exist on L1`);
+                return [
+                    false,
+                    undefined
+                ];
+            }
+            this.log.error(`Error getting proposer for slot ${slot}`, e);
+            return [
+                false,
+                undefined
+            ];
+        }
+        // If proposer is undefined, then the committee is empty and anyone may propose
+        if (proposer === undefined) {
+            return [
+                true,
+                undefined
+            ];
+        }
+        // In fisherman mode, just return the current proposer
+        if (this.config.fishermanMode) {
+            return [
+                true,
+                proposer
+            ];
+        }
+        const validatorAddresses = this.validatorClient.getValidatorAddresses();
+        const weAreProposer = validatorAddresses.some((addr)=>addr.equals(proposer));
+        if (!weAreProposer) {
+            this.log.debug(`Cannot propose at slot ${slot} since we are not a proposer`, {
+                validatorAddresses,
+                proposer
+            });
+            return [
+                false,
+                proposer
+            ];
+        }
+        return [
+            true,
+            proposer
+        ];
+    }
+    /**
+   * Tries to vote on slashing actions and governance when the sync check fails but we're past the max time for initializing a proposal.
+   * This allows the sequencer to participate in governance/slashing votes even when it cannot build blocks.
+   */ async tryVoteWhenSyncFails(args) {
+        const { slot } = args;
+        // Prevent duplicate attempts in the same slot
+        if (this.lastSlotForVoteWhenSyncFailed === 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(slot);
+        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.lastSlotForVoteWhenSyncFailed = slot;
+        // Get a publisher for voting
+        const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
+        this.log.debug(`Attempting to vote despite sync failure at slot ${slot}`, {
+            attestorAddress,
+            slot
+        });
+        // Enqueue governance and slashing votes
+        const voter = new CheckpointVoter(slot, 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
+        });
+        await publisher.sendRequests();
     }
     /**
    * Considers invalidating a block if the pending chain is invalid. Depends on how long the invalid block
    * has been there without being invalidated and whether the sequencer is in the committee or not. We always
    * have the proposer try to invalidate, but if they fail, the sequencers in the committee are expected to try,
    * and if they fail, any sequencer will try as well.
-   */ async considerInvalidatingBlock(syncedTo, currentSlot, ourValidatorAddresses, publisher) {
+   */ async considerInvalidatingBlock(syncedTo, currentSlot) {
         const { pendingChainValidationStatus, l1Timestamp } = syncedTo;
         if (pendingChainValidationStatus.valid) {
             return;
         }
-        const invalidL1Timestamp = pendingChainValidationStatus.block.l1.timestamp;
-        const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidL1Timestamp);
-        const invalidBlockNumber = pendingChainValidationStatus.block.block.number;
+        const invalidBlockNumber = pendingChainValidationStatus.block.blockNumber;
+        const invalidBlockTimestamp = pendingChainValidationStatus.block.timestamp;
+        const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidBlockTimestamp);
+        const ourValidatorAddresses = this.validatorClient.getValidatorAddresses();
         const { secondsBeforeInvalidatingBlockAsCommitteeMember, secondsBeforeInvalidatingBlockAsNonCommitteeMember } = this.config;
         const logData = {
-            invalidL1Timestamp,
+            invalidL1Timestamp: invalidBlockTimestamp,
             l1Timestamp,
-            invalidBlock: pendingChainValidationStatus.block.block.toBlockInfo(),
+            invalidBlock: pendingChainValidationStatus.block,
             secondsBeforeInvalidatingBlockAsCommitteeMember,
             secondsBeforeInvalidatingBlockAsNonCommitteeMember,
             ourValidatorAddresses,
@@ -674,6 +909,21 @@ export { SequencerState };
             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];
+            }
+        } else {
+            // When invalidating as a non-committee member, use the first validator
+            validatorToUse = ourValidatorAddresses[0];
+        }
+        const { publisher } = await this.publisherFactory.create(validatorToUse);
         const invalidateBlock = await publisher.simulateInvalidateBlock(pendingChainValidationStatus);
         if (!invalidateBlock) {
             this.log.warn(`Failed to simulate invalidate block`, logData);
@@ -681,10 +931,41 @@ export { SequencerState };
         }
         this.log.info(invalidateAsCommitteeMember ? `Invalidating block ${invalidBlockNumber} as committee member` : `Invalidating block ${invalidBlockNumber} as non-committee member`, logData);
         publisher.enqueueInvalidateBlock(invalidateBlock);
-        await publisher.sendRequests();
+        if (!this.config.fishermanMode) {
+            await publisher.sendRequests();
+        } else {
+            this.log.info('Invalidating block in fisherman mode, clearing pending requests');
+            publisher.clearPendingRequests();
+        }
+    }
+    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 Number(this.l1Constants.l1GenesisTime) + Number(slotNumber) * this.l1Constants.slotDuration - this.l1Constants.ethereumSlotDuration;
+        return getSlotStartBuildTimestamp(slotNumber, this.l1Constants);
     }
     getSecondsIntoSlot(slotNumber) {
         const slotStartTimestamp = this.getSlotStartBuildTimestamp(slotNumber);
@@ -699,24 +980,16 @@ export { SequencerState };
     getSlasherClient() {
         return this.slasherClient;
     }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    getValidatorAddresses() {
+        return this.validatorClient?.getValidatorAddresses();
+    }
+    getConfig() {
+        return this.config;
+    }
+    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, newGlobalVariables)=>({
-            [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber
-        }))
-], 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);