@aztec/sequencer-client 0.0.1-commit.b655e406 → 0.0.1-commit.c0b82b2

package/dest/sequencer/sequencer.js

@@ -1,45 +1,411 @@
-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 { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { FormattedViemError, NoCommitteeError } from '@aztec/ethereum';
-import { omit, pick } from '@aztec/foundation/collection';
-import { randomInt } from '@aztec/foundation/crypto';
+var _dec, _dec1, _dec2, _dec3, _initProto;
+import { getKzg } from '@aztec/blob-lib';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+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 { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { Timer } from '@aztec/foundation/timer';
-import { unfreeze } from '@aztec/foundation/types';
-import { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
 import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
-import { Gas } from '@aztec/stdlib/gas';
 import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
-import { orderAttestations } from '@aztec/stdlib/p2p';
-import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { ContentCommitment } from '@aztec/stdlib/tx';
-import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import 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 } 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.
+ * - 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;
@@ -49,145 +415,166 @@ export { SequencerState };
     slasherClient;
     l2BlockSource;
     l1ToL2MessageSource;
-    blockBuilder;
+    checkpointsBuilder;
     l1Constants;
     dateProvider;
     epochCache;
     rollupContract;
-    config;
     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;
     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 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 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.
-    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;
-        this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
-        // Initialize config
-        this.updateConfig(this.config);
-    }
-    get tracer() {
-        return this.metrics.tracer;
-    }
-    getValidatorAddresses() {
-        return this.validatorClient?.getValidatorAddresses();
-    }
-    getConfig() {
-        return this.config;
-    }
-    /**
-   * Updates sequencer config 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;
+    /** 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]');
         }
-        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);
+        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() {
-        this.publisher = (await this.publisherFactory.create(undefined)).publisher;
+    /** Initializes the sequencer (precomputes tables). Takes about 3s. */ init() {
+        getKzg();
     }
-    /**
-   * Starts the sequencer and moves to IDLE state.
-   */ start() {
-        this.runningPromise = new RunningPromise(this.safeWork.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.setState(SequencerState.STOPPING, undefined, {
             force: true
         });
-        this.publisher?.interrupt();
+        this.publisherFactory.interruptAll();
         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() {
+    /** Main sequencer loop with a try/catch */ async safeWork() {
+        try {
+            await this.work();
+        } catch (err) {
+            this.emit('checkpoint-error', {
+                error: err
+            });
+            if (err instanceof SequencerTooSlowError) {
+                // 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
+   * 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, ts, now } = this.epochCache.getEpochAndSlotInNextL1Slot();
-        // Check we have not already published a block for this slot (cheapest check)
-        if (this.lastBlockPublished && this.lastBlockPublished.header.getSlot() >= slot) {
-            this.log.debug(`Cannot propose block at next L2 slot ${slot} since that slot was taken by our own block ${this.lastBlockPublished.number}`);
+        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(epoch, slot, ts, now);
+        if (!checkpointProposalJob) {
             return;
         }
+        // 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(epoch, 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,
@@ -198,180 +585,131 @@ export { SequencerState };
                 slot,
                 ts
             });
-            return;
+            return undefined;
+        }
+        // If escape hatch is open for this epoch, do not start checkpoint proposal work and do not attempt invalidations.
+        // Still perform governance/slashing voting (as proposer) once per slot.
+        const isEscapeHatchOpen = await this.epochCache.isEscapeHatchOpen(epoch);
+        if (isEscapeHatchOpen) {
+            this.setState(SequencerState.PROPOSER_CHECK, slot);
+            const [canPropose, proposer] = await this.checkCanPropose(slot);
+            if (canPropose) {
+                await this.tryVoteWhenEscapeHatchOpen({
+                    slot,
+                    proposer
+                });
+            } else {
+                this.log.trace(`Escape hatch open but we are not proposer, skipping vote-only actions`, {
+                    slot,
+                    epoch,
+                    proposer
+                });
+            }
+            return undefined;
         }
-        const chainTipArchive = syncedTo.archive;
-        const newBlockNumber = syncedTo.blockNumber + 1;
-        const syncLogData = {
+        // Next checkpoint follows from the last synced one
+        const checkpointNumber = CheckpointNumber(syncedTo.checkpointNumber + 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')
         };
         // 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 we are not a proposer check if we should invalidate an invalid checkpoint, and bail
         if (!canPropose) {
-            await this.considerInvalidatingBlock(syncedTo, slot);
-            return;
+            await this.considerInvalidatingCheckpoint(syncedTo, slot);
+            return undefined;
         }
         // 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) {
+        if (syncedTo.blockData && syncedTo.blockData.header.getSlot() >= slot) {
             this.log.warn(`Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`, {
-                ...syncLogData,
-                block: syncedTo.block.header.toInspect()
+                ...logCtx,
+                block: syncedTo.blockData.header.toInspect()
             });
-            return;
+            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.
-        const { attestorAddress, publisher } = await this.publisherFactory.create(proposer);
+        // 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);
+        // 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)
-        const invalidateBlock = await publisher.simulateInvalidateBlock(syncedTo.pendingChainValidationStatus);
-        // Check with the rollup if we can indeed propose at the next L2 slot. This check should not fail
+        const invalidateCheckpoint = await publisher.simulateInvalidateCheckpoint(syncedTo.pendingChainValidationStatus);
+        // 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(chainTipArchive, proposer ?? EthAddress.ZERO, invalidateBlock);
+        const canProposeCheck = await publisher.canProposeAtNextEthBlock(syncedTo.archive, proposer ?? EthAddress.ZERO, invalidateCheckpoint);
         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.recordCheckpointPrecheckFailed('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.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,
                 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} as ${proposer}`, {
-            ...syncLogData
-        });
-        const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(newBlockNumber, coinbase, feeRecipient, slot);
-        // Enqueue governance and slashing votes (returns promises that will be awaited later)
-        const votesPromises = this.enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, newGlobalVariables.timestamp);
-        // Enqueues block invalidation
-        if (invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
-            publisher.enqueueInvalidateBlock(invalidateBlock);
-        }
-        // Actual block building
-        this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
-        const block = await this.tryBuildBlockAndEnqueuePublish(slot, proposer, newBlockNumber, publisher, newGlobalVariables, chainTipArchive, invalidateBlock);
-        // Wait until the voting promises have resolved, so all requests are enqueued
-        await Promise.all(votesPromises);
-        // And send the tx to L1
-        const l1Response = await publisher.sendRequests();
-        const proposedBlock = l1Response?.successfulActions.find((a)=>a === 'propose');
-        if (proposedBlock) {
-            this.lastBlockPublished = block;
-            this.emit('block-published', {
-                blockNumber: newBlockNumber,
-                slot: Number(slot)
-            });
-            await this.metrics.incFilledSlot(publisher.getSenderAddress().toString(), coinbase);
-        } else if (block) {
-            this.emit('block-publish-failed', l1Response ?? {});
-        }
-        this.setState(SequencerState.IDLE, undefined);
-    }
-    /** Tries building a block proposal, and if successful, enqueues it for publishing. */ async tryBuildBlockAndEnqueuePublish(slot, proposer, newBlockNumber, publisher, newGlobalVariables, chainTipArchive, invalidateBlock) {
-        this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-            proposer,
-            publisher: publisher.getSenderAddress(),
-            globalVariables: newGlobalVariables.toInspect(),
-            chainTipArchive,
-            blockNumber: newBlockNumber,
-            slot
-        });
-        const proposalHeader = CheckpointHeader.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, proposer, 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
-            });
+            this.metrics.recordCheckpointPrecheckFailed('block_number_mismatch');
+            return undefined;
         }
-        return block;
+        this.lastSlotForCheckpointProposalJob = slot;
+        await this.p2pClient.prepareForSlot(slot);
+        this.log.info(`Preparing checkpoint proposal ${checkpointNumber} at slot ${slot}`, {
+            ...logCtx,
+            proposer
+        });
+        // Create and return the checkpoint proposal job
+        return this.createCheckpointProposalJob(epoch, slot, checkpointNumber, syncedTo.blockNumber, proposer, publisher, attestorAddress, invalidateCheckpoint);
     }
-    async safeWork() {
-        try {
-            await this.work();
-        } 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(epoch, slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateCheckpoint) {
+        return new CheckpointProposalJob(epoch, slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateCheckpoint, this.validatorClient, this.globalsBuilder, this.p2pClient, this.worldState, this.l1ToL2MessageSource, this.l2BlockSource, this.checkpointsBuilder, this.l2BlockSource, this.l1Constants, this.config, this.timetable, this.slasherClient, this.epochCache, this.dateProvider, this.metrics, this, this.setState.bind(this), this.tracer, this.log.getBindings());
     }
-    setState(proposedState, slotNumber, opts = {}) {
+    /**
+   * Returns the current sequencer state.
+   */ getState() {
+        return this.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 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();
@@ -398,181 +736,10 @@ 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,
-            maxBlobFields: BLOBS_PER_BLOCK * FIELDS_PER_BLOB,
-            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);
-        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.getCheckpointHeader(), 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
-            });
-            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
-                });
-            }
-            const attestationsAndSigners = new CommitteeAttestationsAndSigners(attestations ?? []);
-            const attestationsAndSignersSignature = this.validatorClient ? await this.validatorClient.signAttestationsAndSigners(attestationsAndSigners, proposerAddress ?? publisher.getSenderAddress()) : Signature.empty();
-            await this.enqueuePublishL2Block(block, attestationsAndSigners, attestationsAndSignersSignature, invalidateBlock, publisher);
-            this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
-            return block;
-        } catch (err) {
-            this.metrics.recordFailedBlock();
-            throw err;
-        }
-    }
-    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,
-            broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
-        };
-        const proposal = await this.validatorClient.createBlockProposal(block.header.globalVariables.blockNumber, block.getCheckpointHeader(), block.archive.root, block.header.state, txs, proposerAddress, blockProposalOptions);
-        if (!proposal) {
-            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 collectedAttestationsCount = 0;
-        try {
-            const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
-            const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations, attestationDeadline);
-            collectedAttestationsCount = attestations.length;
-            // note: the smart contract requires that the signatures are provided in the order of the committee
-            const sorted = orderAttestations(attestations, committee);
-            if (this.config.injectFakeAttestation) {
-                const nonEmpty = sorted.filter((a)=>!a.signature.isEmpty());
-                const randomIndex = randomInt(nonEmpty.length);
-                this.log.warn(`Injecting fake attestation in block ${block.number}`);
-                unfreeze(nonEmpty[randomIndex]).signature = Signature.random();
-            }
-            return sorted;
-        } catch (err) {
-            if (err && err instanceof AttestationTimeoutError) {
-                collectedAttestationsCount = err.collectedCount;
-            }
-            throw err;
-        } finally{
-            this.metrics.recordCollectedAttestations(collectedAttestationsCount, timer.ms());
-        }
-    }
-    /**
-   * Publishes the L2Block to the rollup contract.
-   * @param block - The L2Block to be published.
-   */ async enqueuePublishL2Block(block, attestationsAndSigners, attestationsAndSignersSignature, invalidateBlock, publisher) {
-        // Publishes new block to the network and awaits the tx to be mined
-        this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
-        // 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, attestationsAndSigners, attestationsAndSignersSignature, {
-            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.
@@ -595,15 +762,16 @@ export { SequencerState };
                     number: syncSummary.latestBlockNumber,
                     hash: syncSummary.latestBlockHash
                 })),
-            this.l2BlockSource.getL2Tips().then((t)=>t.latest),
+            this.l2BlockSource.getL2Tips().then((t)=>t.proposed),
             this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
-            this.l1ToL2MessageSource.getL2Tips().then((t)=>t.latest),
+            this.l1ToL2MessageSource.getL2Tips().then((t)=>t.proposed),
             this.l2BlockSource.getPendingChainValidationStatus()
         ]);
         const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, pendingChainValidationStatus] = syncedBlocks;
-        // The archiver reports 'undefined' hash for the genesis block
-        // because it doesn't have access to world state to compute it (facepalm)
-        const result = l2BlockSource.hash === undefined ? worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0 : worldState.hash === l2BlockSource.hash && p2p.hash === l2BlockSource.hash && l1ToL2MessageSource.hash === l2BlockSource.hash;
+        // 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.
+        // TODO(palla/mbps): Fix the above. All components should be able to handle dynamic genesis block hashes.
+        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,
@@ -618,62 +786,29 @@ export { SequencerState };
         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,
+                checkpointNumber: CheckpointNumber.ZERO,
+                blockNumber: BlockNumber.ZERO,
                 archive,
                 l1Timestamp,
                 pendingChainValidationStatus
             };
         }
-        const block = await this.l2BlockSource.getBlock(blockNumber);
-        if (!block) {
+        const blockData = await this.l2BlockSource.getBlockData(blockNumber);
+        if (!blockData) {
             // 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`);
+            this.log.error(`Failed to get L2 block data ${blockNumber} from the archiver with all components in sync`);
             return undefined;
         }
         return {
-            block,
-            blockNumber: block.number,
-            archive: block.archive.root,
+            blockData,
+            blockNumber: blockData.header.getBlockNumber(),
+            checkpointNumber: blockData.checkpointNumber,
+            archive: blockData.archive.root,
             l1Timestamp,
             pendingChainValidationStatus
         };
     }
     /**
-   * Enqueues governance and slashing votes with the publisher. Does not block.
-   * @param publisher - The publisher to enqueue votes with
-   * @param attestorAddress - The attestor address to use for signing
-   * @param slot - The slot number
-   * @param timestamp - The timestamp for the votes
-   * @param context - Optional context for logging (e.g., block number)
-   * @returns A tuple of [governanceEnqueued, slashingEnqueued]
-   */ enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, timestamp) {
-        try {
-            const signerFn = (msg)=>this.validatorClient.signWithAddress(attestorAddress, msg).then((s)=>s.toString());
-            const enqueueGovernancePromise = this.governanceProposerPayload && !this.governanceProposerPayload.isZero() ? publisher.enqueueGovernanceCastSignal(this.governanceProposerPayload, slot, timestamp, attestorAddress, signerFn).catch((err)=>{
-                this.log.error(`Error enqueuing governance vote`, err, {
-                    slot
-                });
-                return false;
-            }) : undefined;
-            const enqueueSlashingPromise = this.slasherClient ? this.slasherClient.getProposerActions(slot).then((actions)=>publisher.enqueueSlashingActions(actions, slot, timestamp, attestorAddress, signerFn)).catch((err)=>{
-                this.log.error(`Error enqueuing slashing actions`, err, {
-                    slot
-                });
-                return false;
-            }) : undefined;
-            return [
-                enqueueGovernancePromise,
-                enqueueSlashingPromise
-            ];
-        } catch (err) {
-            this.log.error(`Error enqueueing governance and slashing votes`, err);
-            return [
-                undefined,
-                undefined
-            ];
-        }
-    }
-    /**
    * Checks if we are the proposer for the next slot.
    * @returns True if we can propose, and the proposer address (undefined if anyone can propose)
    */ async checkCanPropose(slot) {
@@ -682,7 +817,10 @@ export { SequencerState };
             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`);
+                if (this.lastSlotForNoCommitteeWarning !== slot) {
+                    this.lastSlotForNoCommitteeWarning = slot;
+                    this.log.warn(`Cannot propose at next L2 slot ${slot} since the committee does not exist on L1`);
+                }
                 return [
                     false,
                     undefined
@@ -701,6 +839,13 @@ export { SequencerState };
                 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) {
@@ -722,49 +867,50 @@ export { SequencerState };
    * Tries to vote on slashing actions and governance when the sync check fails but we're past the max time for initializing a proposal.
    * This allows the sequencer to participate in governance/slashing votes even when it cannot build blocks.
    */ async tryVoteWhenSyncFails(args) {
-        const { slot, ts } = args;
+        const { slot } = args;
         // Prevent duplicate attempts in the same slot
-        if (this.lastSlotForVoteWhenSyncFailed === slot) {
-            this.log.debug(`Already attempted to vote in slot ${slot} (skipping)`);
+        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_PROPOSAL);
+        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 for block building`, {
+            this.log.trace(`Not attempting to vote since there is still time for block building`, {
                 secondsIntoSlot,
                 maxAllowedTime
             });
             return;
         }
-        this.log.debug(`Sync for slot ${slot} failed, checking for voting opportunities`, {
+        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.debug(`Cannot vote in slot ${slot} since we are not a proposer`, {
+            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;
+        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
         });
-        // Enqueue governance and slashing votes using the shared helper method
-        const votesPromises = this.enqueueGovernanceAndSlashingVotes(publisher, attestorAddress, slot, ts);
-        await Promise.all(votesPromises);
-        if (votesPromises.every((p)=>!p)) {
+        // 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;
         }
@@ -774,25 +920,53 @@ export { SequencerState };
         await publisher.sendRequests();
     }
     /**
+   * 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, 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,
+            attestorAddress
+        });
+        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} (escape hatch open)`);
+            return;
+        }
+        this.log.info(`Voting in slot ${slot} (escape hatch open)`, {
+            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) {
+   */ async considerInvalidatingCheckpoint(syncedTo, currentSlot) {
         const { pendingChainValidationStatus, l1Timestamp } = syncedTo;
         if (pendingChainValidationStatus.valid) {
             return;
         }
-        const { publisher } = await this.publisherFactory.create(undefined);
-        const invalidBlockNumber = pendingChainValidationStatus.block.blockNumber;
-        const invalidBlockTimestamp = pendingChainValidationStatus.block.timestamp;
-        const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidBlockTimestamp);
+        const 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: invalidBlockTimestamp,
+            invalidL1Timestamp: invalidCheckpointTimestamp,
             l1Timestamp,
-            invalidBlock: pendingChainValidationStatus.block,
+            invalidCheckpoint: pendingChainValidationStatus.checkpoint,
             secondsBeforeInvalidatingBlockAsCommitteeMember,
             secondsBeforeInvalidatingBlockAsNonCommitteeMember,
             ourValidatorAddresses,
@@ -805,14 +979,60 @@ export { SequencerState };
             this.log.debug(`Not invalidating pending chain`, logData);
             return;
         }
-        const invalidateBlock = await publisher.simulateInvalidateBlock(pendingChainValidationStatus);
-        if (!invalidateBlock) {
-            this.log.warn(`Failed to simulate invalidate block`, logData);
+        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 invalidateCheckpoint = await publisher.simulateInvalidateCheckpoint(pendingChainValidationStatus);
+        if (!invalidateCheckpoint) {
+            this.log.warn(`Failed to simulate invalidate checkpoint`, logData);
             return;
         }
-        this.log.info(invalidateAsCommitteeMember ? `Invalidating block ${invalidBlockNumber} as committee member` : `Invalidating block ${invalidBlockNumber} as non-committee member`, logData);
-        publisher.enqueueInvalidateBlock(invalidateBlock);
-        await publisher.sendRequests();
+        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();
+        }
+    }
+    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);
@@ -830,24 +1050,19 @@ export { SequencerState };
     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 l1PublishingTime() {
+        return this.config.l1PublishingTime ?? this.l1Constants.ethereumSlotDuration;
+    }
 }
-_ts_decorate([
-    trackSpan('Sequencer.work')
-], Sequencer.prototype, "safeWork", 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);