@aztec/sequencer-client 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/dest/sequencer/sequencer.js

@@ -1,623 +1,1009 @@
-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, _dec1, _dec2, _initProto;
+import { getKzg } from '@aztec/blob-lib';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { omit } 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, elapsed } from '@aztec/foundation/timer';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Gas } from '@aztec/stdlib/gas';
+import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
-import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import { BlockHeader, ContentCommitment, StateReference, Tx } from '@aztec/stdlib/tx';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { VoteType } from '../publisher/sequencer-publisher.js';
-import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
-import { getDefaultAllowedSetupFunctions } from './allowed.js';
+import EventEmitter from 'node:events';
+import { DefaultSequencerConfig } from '../config.js';
+import { 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 { SequencerState, orderAttestations } from './utils.js';
+import { SequencerTimetable } from './timetable.js';
+import { SequencerState } from './utils.js';
 export { SequencerState };
+_dec = trackSpan('Sequencer.work'), _dec1 = trackSpan('Sequencer.prepareCheckpointProposal'), _dec2 = trackSpan('Seqeuencer.tryVoteWhenSyncFails', ({ slot })=>({
+        [Attributes.SLOT_NUMBER]: slot
+    }));
 /**
  * Sequencer client
- * - Wins a period of time to become the sequencer (depending on finalized protocol).
- * - Chooses a set of txs from the tx pool to be in the rollup.
- * - Simulate the rollup of txs.
- * - Adds proof requests to the request pool (not for this milestone).
- * - Receives results to those proofs from the network (repeats as necessary) (not for this milestone).
- * - Publishes L1 tx(s) to the rollup contract via RollupPublisher.
- */ export class Sequencer {
-    publisher;
+ * - Checks whether it is elected as proposer for the next slot
+ * - Builds multiple blocks and broadcasts them
+ * - Collects attestations for the checkpoint
+ * - Publishes the checkpoint to L1
+ * - Votes for proposals and slashes on L1
+ */ export class Sequencer extends EventEmitter {
+    publisherFactory;
     validatorClient;
     globalsBuilder;
     p2pClient;
     worldState;
     slasherClient;
-    blockBuilderFactory;
     l2BlockSource;
     l1ToL2MessageSource;
-    publicProcessorFactory;
-    contractDataSource;
+    checkpointsBuilder;
     l1Constants;
     dateProvider;
-    config;
+    epochCache;
+    rollupContract;
+    telemetry;
     log;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "work"
+            ],
+            [
+                _dec1,
+                2,
+                "prepareCheckpointProposal"
+            ],
+            [
+                _dec2,
+                2,
+                "tryVoteWhenSyncFails"
+            ]
+        ], []));
+    }
     runningPromise;
-    pollingIntervalMs;
-    maxTxsPerBlock;
-    minTxsPerBlock;
-    maxL1TxInclusionTimeIntoSlot;
-    // TODO: zero values should not be allowed for the following 2 values in PROD
-    _coinbase;
-    _feeRecipient;
     state;
-    allowedInSetup;
-    maxBlockSizeInBytes;
-    maxBlockGas;
     metrics;
-    isFlushing;
+    /** 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;
-    constructor(publisher, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, blockBuilderFactory, l2BlockSource, l1ToL2MessageSource, publicProcessorFactory, contractDataSource, l1Constants, dateProvider, config = {}, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
-        this.publisher = publisher;
-        this.validatorClient = validatorClient;
-        this.globalsBuilder = globalsBuilder;
-        this.p2pClient = p2pClient;
-        this.worldState = worldState;
-        this.slasherClient = slasherClient;
-        this.blockBuilderFactory = blockBuilderFactory;
-        this.l2BlockSource = l2BlockSource;
-        this.l1ToL2MessageSource = l1ToL2MessageSource;
-        this.publicProcessorFactory = publicProcessorFactory;
-        this.contractDataSource = contractDataSource;
-        this.l1Constants = l1Constants;
-        this.dateProvider = dateProvider;
-        this.config = config;
-        this.log = log;
-        this.pollingIntervalMs = 1000;
-        this.maxTxsPerBlock = 32;
-        this.minTxsPerBlock = 1;
-        this.maxL1TxInclusionTimeIntoSlot = 0;
-        this._coinbase = EthAddress.ZERO;
-        this._feeRecipient = AztecAddress.ZERO;
-        this.state = SequencerState.STOPPED;
-        this.allowedInSetup = [];
-        this.maxBlockSizeInBytes = 1024 * 1024;
-        this.maxBlockGas = new Gas(100e9, 100e9);
-        this.isFlushing = false;
-        this.enforceTimeTable = false;
-        this.metrics = new SequencerMetrics(telemetry, ()=>this.state, 'Sequencer');
-        // Register the block builder with the validator client for re-execution
-        this.validatorClient?.registerBlockBuilder(this.buildBlock.bind(this));
-        // Register the slasher on the publisher to fetch slashing payloads
-        this.publisher.registerSlashPayloadGetter(this.slasherClient.getSlashPayload.bind(this.slasherClient));
+    // This shouldn't be here as this gets re-created each time we build/propose a block.
+    // But we have a number of tests that abuse/rely on this class having a permanent publisher.
+    // As long as those tests only configure a single publisher they will continue to work.
+    // This will get re-assigned every time the sequencer goes to build a new block to a publisher that is valid
+    // for the block proposer.
+    // TODO(palla/mbps): Remove this field and fix tests
+    publisher;
+    /** 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);
     }
-    get tracer() {
-        return this.metrics.tracer;
+    /** Updates sequencer config by the defined values and updates the timetable */ updateConfig(config) {
+        const filteredConfig = pickFromSchema(config, SequencerConfigSchema);
+        this.log.info(`Updated sequencer config`, omit(filteredConfig, 'txPublicSetupAllowList'));
+        this.config = merge(this.config, filteredConfig);
+        this.timetable = new SequencerTimetable({
+            ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
+            aztecSlotDuration: this.aztecSlotDuration,
+            l1PublishingTime: this.l1PublishingTime,
+            p2pPropagationTime: this.config.attestationPropagationTime,
+            blockDurationMs: this.config.blockDurationMs,
+            enforce: this.config.enforceTimeTable
+        }, this.metrics, this.log);
     }
-    /**
-   * Updates sequencer config.
-   * @param config - New parameters.
-   */ async updateConfig(config) {
-        this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'allowedInSetup'));
-        if (config.transactionPollingIntervalMS !== undefined) {
-            this.pollingIntervalMs = config.transactionPollingIntervalMS;
-        }
-        if (config.maxTxsPerBlock !== undefined) {
-            this.maxTxsPerBlock = config.maxTxsPerBlock;
-        }
-        if (config.minTxsPerBlock !== undefined) {
-            this.minTxsPerBlock = config.minTxsPerBlock;
-        }
-        if (config.maxDABlockGas !== undefined) {
-            this.maxBlockGas = new Gas(config.maxDABlockGas, this.maxBlockGas.l2Gas);
-        }
-        if (config.maxL2BlockGas !== undefined) {
-            this.maxBlockGas = new Gas(this.maxBlockGas.daGas, config.maxL2BlockGas);
-        }
-        if (config.coinbase) {
-            this._coinbase = config.coinbase;
-        }
-        if (config.feeRecipient) {
-            this._feeRecipient = config.feeRecipient;
-        }
-        if (config.allowedInSetup) {
-            this.allowedInSetup = config.allowedInSetup;
-        } else {
-            this.allowedInSetup = await getDefaultAllowedSetupFunctions();
-        }
-        if (config.maxBlockSizeInBytes !== undefined) {
-            this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
-        }
-        if (config.governanceProposerPayload) {
-            this.publisher.setGovernancePayload(config.governanceProposerPayload);
-        }
-        if (config.maxL1TxInclusionTimeIntoSlot !== undefined) {
-            this.maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot;
-        }
-        if (config.enforceTimeTable !== undefined) {
-            this.enforceTimeTable = config.enforceTimeTable;
-        }
-        this.setTimeTable();
-        // TODO: Just read everything from the config object as needed instead of copying everything into local vars.
-        this.config = config;
+    /** Initializes the sequencer (precomputes tables and creates a publisher). Takes about 3s. */ async init() {
+        getKzg();
+        this.publisher = (await this.publisherFactory.create(undefined)).publisher;
     }
-    setTimeTable() {
-        this.timetable = new SequencerTimetable(this.l1Constants.ethereumSlotDuration, this.aztecSlotDuration, this.maxL1TxInclusionTimeIntoSlot, this.enforceTimeTable, this.metrics, this.log);
-        this.log.verbose(`Sequencer timetable updated`, {
-            enforceTimeTable: this.enforceTimeTable
+    /** Starts the sequencer and moves to IDLE state. */ start() {
+        this.runningPromise = new RunningPromise(this.safeWork.bind(this), this.log, this.config.sequencerPollingIntervalMS);
+        this.setState(SequencerState.IDLE, undefined, {
+            force: true
         });
-    }
-    /**
-   * Starts the sequencer and moves to IDLE state.
-   */ async start() {
-        await this.updateConfig(this.config);
-        this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollingIntervalMs);
-        this.setState(SequencerState.IDLE, 0n, true);
         this.runningPromise.start();
-        this.log.info(`Sequencer started with address ${this.publisher.getSenderAddress().toString()}`);
+        this.log.info('Started sequencer');
     }
-    /**
-   * Stops the sequencer from processing txs and moves to STOPPED state.
-   */ async stop() {
-        this.log.debug(`Stopping sequencer`);
-        await this.validatorClient?.stop();
+    /** 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();
         await this.runningPromise?.stop();
-        this.slasherClient.stop();
-        this.publisher.interrupt();
-        this.setState(SequencerState.STOPPED, 0n, true);
+        this.setState(SequencerState.STOPPED, undefined, {
+            force: true
+        });
         this.log.info('Stopped sequencer');
     }
-    /**
-   * Starts a previously stopped sequencer.
-   */ restart() {
-        this.log.info('Restarting sequencer');
-        this.publisher.restart();
-        this.runningPromise.start();
-        this.setState(SequencerState.IDLE, 0n, true);
+    /** 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) {
+                // 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.
-   * @returns An object with a state entry with one of SequencerState.
-   */ status() {
+    /** Returns the current state of the sequencer. */ status() {
         return {
             state: this.state
         };
     }
-    /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */ flush() {
-        this.isFlushing = true;
-    }
     /**
-   * @notice  Performs most of the sequencer duties:
-   *          - Checks if we are up to date
-   *          - If we are and we are the sequencer, collect txs and build a block
-   *          - Collect attestations for the block
-   *          - Submit block
-   *          - If our block for some reason is not included, revert the state
-   */ async doRealWork() {
-        this.setState(SequencerState.SYNCHRONIZING, 0n);
-        // Update state when the previous block has been synced
-        const chainTip = await this.getChainTip();
-        // Do not go forward with new block if the previous one has not been mined and processed
-        if (!chainTip) {
+   * Main sequencer loop:
+   * - Checks if we are up to date
+   * - If we are and we are the sequencer, collect txs and build blocks
+   * - Build multiple blocks per slot when configured
+   * - Collect attestations for the final block
+   * - Submit checkpoint
+   */ async work() {
+        this.setState(SequencerState.SYNCHRONIZING, undefined);
+        const { slot, 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;
         }
-        this.setState(SequencerState.PROPOSER_CHECK, 0n);
-        const newBlockNumber = chainTip.blockNumber + 1;
-        // If we cannot find a tip archive, assume genesis.
-        const chainTipArchive = chainTip.archive;
-        const slot = await this.slotForProposal(chainTipArchive.toBuffer(), BigInt(newBlockNumber));
-        if (!slot) {
-            this.log.debug(`Cannot propose block ${newBlockNumber}`);
-            return;
+        // 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;
         }
-        this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot}`);
-        const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(newBlockNumber), this._coinbase, this._feeRecipient, slot);
-        const enqueueGovernanceVotePromise = this.publisher.enqueueCastVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.GOVERNANCE);
-        const enqueueSlashingVotePromise = this.publisher.enqueueCastVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.SLASHING);
-        this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
-        this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-            chainTipArchive,
-            blockNumber: newBlockNumber,
+        // 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 I created a "partial" header here that should make our job much easier.
-        const proposalHeader = new BlockHeader(new AppendOnlyTreeSnapshot(chainTipArchive, 1), ContentCommitment.empty(), StateReference.empty(), newGlobalVariables, Fr.ZERO, Fr.ZERO);
-        let finishedFlushing = false;
-        const pendingTxCount = await this.p2pClient.getPendingTxCount();
-        if (pendingTxCount >= this.minTxsPerBlock || this.isFlushing) {
-            // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
-            // and also we may need to fetch more if we don't have enough valid txs.
-            const pendingTxs = this.p2pClient.iteratePendingTxs();
-            await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader).catch((err)=>{
-                this.log.error(`Error building/enqueuing block`, err, {
-                    blockNumber: newBlockNumber,
-                    slot
-                });
+        if (!syncedTo) {
+            await this.tryVoteWhenSyncFails({
+                slot,
+                ts
             });
-            finishedFlushing = true;
-        } else {
-            this.log.debug(`Not enough txs to build block ${newBlockNumber} at slot ${slot}: got ${pendingTxCount} txs, need ${this.minTxsPerBlock}`);
+            return undefined;
         }
-        await enqueueGovernanceVotePromise.catch((err)=>{
-            this.log.error(`Error enqueuing governance vote`, err, {
-                blockNumber: newBlockNumber,
-                slot
+        // 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),
+            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 an invalid checkpoint, and bail
+        if (!canPropose) {
+            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) {
+            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()
             });
-        });
-        await enqueueSlashingVotePromise.catch((err)=>{
-            this.log.error(`Error enqueuing slashing vote`, err, {
-                blockNumber: newBlockNumber,
+            this.metrics.recordBlockProposalPrecheckFailed('slot_already_taken');
+            return undefined;
+        }
+        // We now need to get ourselves a publisher.
+        // The returned attestor will be the one we provided if we provided one.
+        // Otherwise it will be a valid attestor for the returned publisher.
+        // In fisherman mode, pass undefined to use the fisherman's own keystore instead of the actual proposer's
+        const proposerForPublisher = this.config.fishermanMode ? undefined : proposer;
+        const { attestorAddress, publisher } = await this.publisherFactory.create(proposerForPublisher);
+        this.log.verbose(`Created publisher at address ${publisher.getSenderAddress()} for attestor ${attestorAddress}`);
+        this.publisher = publisher;
+        // 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 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(syncedTo.archive, proposer ?? EthAddress.ZERO, invalidateCheckpoint);
+        if (canProposeCheck === undefined) {
+            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',
                 slot
             });
-        });
-        await this.publisher.sendRequests();
-        if (finishedFlushing) {
-            this.isFlushing = false;
-        }
-        this.setState(SequencerState.IDLE, 0n);
-    }
-    async work() {
-        try {
-            await this.doRealWork();
-        } catch (err) {
-            if (err instanceof SequencerTooSlowError) {
-                this.log.warn(err.message);
-            } else {
-                // Re-throw other errors
-                throw err;
-            }
-        } finally{
-            this.setState(SequencerState.IDLE, 0n);
+            this.metrics.recordBlockProposalPrecheckFailed('rollup_contract_check_failed');
+            return undefined;
         }
-    }
-    getForwarderAddress() {
-        return this.publisher.getForwarderAddress();
-    }
-    /**
-   * Checks if we can propose at the next block and returns the slot number if we can.
-   * @param tipArchive - The archive of the previous block.
-   * @param proposalBlockNumber - The block number of the proposal.
-   * @returns The slot number if we can propose at the next block, otherwise undefined.
-   */ async slotForProposal(tipArchive, proposalBlockNumber) {
-        const result = await this.publisher.canProposeAtNextEthBlock(tipArchive);
-        if (!result) {
+        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}.`, {
+                ...logCtx,
+                rollup: canProposeCheck,
+                expectedSlot: slot
+            });
+            this.emit('proposer-rollup-check-failed', {
+                reason: 'Slot mismatch',
+                slot
+            });
+            this.metrics.recordBlockProposalPrecheckFailed('slot_mismatch');
             return undefined;
         }
-        const [slot, blockNumber] = result;
-        if (proposalBlockNumber !== blockNumber) {
-            const msg = `Sequencer block number mismatch. Expected ${proposalBlockNumber} but got ${blockNumber}.`;
-            this.log.warn(msg);
-            throw new Error(msg);
+        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,
+                expectedSlot: slot
+            });
+            this.emit('proposer-rollup-check-failed', {
+                reason: 'Block mismatch',
+                slot
+            });
+            this.metrics.recordBlockProposalPrecheckFailed('block_number_mismatch');
+            return undefined;
         }
-        return slot;
+        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, invalidateCheckpoint);
+    }
+    createCheckpointProposalJob(slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateCheckpoint) {
+        return new CheckpointProposalJob(slot, checkpointNumber, syncedToBlockNumber, proposer, publisher, attestorAddress, invalidateCheckpoint, this.validatorClient, this.globalsBuilder, this.p2pClient, this.worldState, this.l1ToL2MessageSource, this.checkpointsBuilder, this.l2BlockSource, this.l1Constants, this.config, this.timetable, this.slasherClient, this.epochCache, this.dateProvider, this.metrics, this, this.setState.bind(this), this.log, this.tracer);
     }
     /**
-   * Sets the sequencer state and checks if we have enough time left in the slot to transition to the new state.
+   * Internal helper for setting the sequencer state and checks if we have enough time left in the slot to transition to the new state.
    * @param proposedState - The new state to transition to.
-   * @param currentSlotNumber - The current slot number.
+   * @param slotNumber - The current slot number.
    * @param force - Whether to force the transition even if the sequencer is stopped.
-   *
-   * @dev If the `currentSlotNumber` doesn't matter (e.g. transitioning to IDLE), pass in `0n`;
-   * it is only used to check if we have enough time left in the slot to transition to the new state.
-   */ setState(proposedState, currentSlotNumber, force = false) {
-        if (this.state === SequencerState.STOPPED && force !== true) {
+   */ setState(proposedState, slotNumber, opts = {}) {
+        if (this.state === SequencerState.STOPPING && proposedState !== SequencerState.STOPPED && !opts.force) {
+            this.log.warn(`Cannot set sequencer to ${proposedState} as it is stopping.`);
+            throw new SequencerInterruptedError();
+        }
+        if (this.state === SequencerState.STOPPED && !opts.force) {
             this.log.warn(`Cannot set sequencer from ${this.state} to ${proposedState} as it is stopped.`);
             return;
         }
-        const secondsIntoSlot = this.getSecondsIntoSlot(currentSlotNumber);
-        this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
-        this.log.debug(`Transitioning from ${this.state} to ${proposedState}`);
+        let secondsIntoSlot = undefined;
+        if (slotNumber !== undefined) {
+            secondsIntoSlot = this.getSecondsIntoSlot(slotNumber);
+            this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
+        }
+        const boringStates = [
+            SequencerState.IDLE,
+            SequencerState.SYNCHRONIZING
+        ];
+        const logLevel = boringStates.includes(proposedState) && boringStates.includes(this.state) ? 'trace' : 'debug';
+        this.log[logLevel](`Transitioning from ${this.state} to ${proposedState}`, {
+            slotNumber,
+            secondsIntoSlot
+        });
+        this.emit('state-changed', {
+            oldState: this.state,
+            newState: proposedState,
+            secondsIntoSlot,
+            slot: slotNumber
+        });
         this.state = proposedState;
     }
     /**
-   * Build a block
-   *
-   * Shared between the sequencer and the validator for re-execution
-   *
-   * @param pendingTxs - The pending transactions to construct the block from
-   * @param newGlobalVariables - The global variables for the new block
-   * @param historicalHeader - The historical header of the parent
-   * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
-   */ async buildBlock(pendingTxs, newGlobalVariables, opts = {}) {
-        const blockNumber = newGlobalVariables.blockNumber.toNumber();
-        const slot = newGlobalVariables.slotNumber.toBigInt();
-        this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
-        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(blockNumber));
-        const msgCount = l1ToL2Messages.length;
-        this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
-            slot,
-            blockNumber,
-            msgCount,
-            validator: opts.validateOnly
-        });
-        // Sync to the previous block at least
-        await this.worldState.syncImmediate(blockNumber - 1);
-        this.log.debug(`Synced to previous block ${blockNumber - 1}`);
-        // NB: separating the dbs because both should update the state
-        const publicProcessorFork = await this.worldState.fork();
-        const orchestratorFork = await this.worldState.fork();
-        const previousBlockHeader = (await this.l2BlockSource.getBlock(blockNumber - 1))?.header ?? orchestratorFork.getInitialHeader();
-        try {
-            const processor = this.publicProcessorFactory.create(publicProcessorFork, newGlobalVariables, true);
-            const blockBuildingTimer = new Timer();
-            const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
-            await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages, previousBlockHeader);
-            // Deadline for processing depends on whether we're proposing a block
-            const secondsIntoSlot = this.getSecondsIntoSlot(slot);
-            const processingEndTimeWithinSlot = opts.validateOnly ? this.timetable.getValidatorReexecTimeEnd(secondsIntoSlot) : this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
-            // Deadline is only set if enforceTimeTable is enabled.
-            const deadline = this.enforceTimeTable ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000) : undefined;
-            this.log.verbose(`Processing pending txs`, {
+   * Returns whether all dependencies have caught up.
+   * We don't check against the previous block submitted since it may have been reorg'd out.
+   */ async checkSync(args) {
+        // Check that the archiver 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,
-                slotStart: new Date(this.getSlotStartTimestamp(slot) * 1000),
-                now: new Date(this.dateProvider.now()),
-                deadline
+                ts,
+                l1Timestamp
             });
-            const validators = createValidatorsForBlockBuilding(publicProcessorFork, this.contractDataSource, newGlobalVariables, this.allowedInSetup);
-            // TODO(#11000): Public processor should just handle processing, one tx at a time. It should be responsibility
-            // of the sequencer to update world state and iterate over txs. We should refactor this along with unifying the
-            // publicProcessorFork and orchestratorFork, to avoid doing tree insertions twice when building the block.
-            const proposerLimits = {
-                maxTransactions: this.maxTxsPerBlock,
-                maxBlockSize: this.maxBlockSizeInBytes,
-                maxBlockGas: this.maxBlockGas
-            };
-            const limits = opts.validateOnly ? {
-                deadline
-            } : {
-                deadline,
-                ...proposerLimits
-            };
-            const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(()=>processor.process(pendingTxs, limits, validators));
-            if (!opts.validateOnly && failedTxs.length > 0) {
-                const failedTxData = failedTxs.map((fail)=>fail.tx);
-                const failedTxHashes = await Tx.getHashes(failedTxData);
-                this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
-                await this.p2pClient.deleteTxs(failedTxHashes);
-            }
-            if (!opts.validateOnly && // We check for minTxCount only if we are proposing a block, not if we are validating it
-            !this.isFlushing && // And we skip the check when flushing, since we want all pending txs to go out, no matter if too few
-            this.minTxsPerBlock !== undefined && processedTxs.length < this.minTxsPerBlock) {
-                this.log.warn(`Block ${blockNumber} has too few txs to be proposed (got ${processedTxs.length} but required ${this.minTxsPerBlock})`, {
-                    slot,
-                    blockNumber,
-                    processedTxCount: processedTxs.length
-                });
-                throw new Error(`Block has too few successful txs to be proposed`);
-            }
-            const start = process.hrtime.bigint();
-            await blockBuilder.addTxs(processedTxs);
-            const end = process.hrtime.bigint();
-            const duration = Number(end - start) / 1_000;
-            this.metrics.recordBlockBuilderTreeInsertions(duration);
-            // All real transactions have been added, set the block as full and pad if needed
-            const block = await blockBuilder.setBlockCompleted();
-            // How much public gas was processed
-            const publicGas = processedTxs.reduce((acc, tx)=>acc.add(tx.gasUsed.publicGas), Gas.empty());
+            return undefined;
+        }
+        const syncedBlocks = await Promise.all([
+            this.worldState.status().then(({ syncSummary })=>({
+                    number: syncSummary.latestBlockNumber,
+                    hash: syncSummary.latestBlockHash
+                })),
+            this.l2BlockSource.getL2Tips().then((t)=>t.proposed),
+            this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
+            this.l1ToL2MessageSource.getL2Tips().then((t)=>t.proposed),
+            this.l2BlockSource.getPendingChainValidationStatus()
+        ]);
+        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.
+        // 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,
+                l2BlockSource,
+                p2p,
+                l1ToL2MessageSource
+            });
+            return undefined;
+        }
+        // Special case for genesis state
+        const blockNumber = worldState.number;
+        if (blockNumber < INITIAL_L2_BLOCK_NUM) {
+            const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
             return {
-                block,
-                publicGas,
-                publicProcessorDuration,
-                numMsgs: l1ToL2Messages.length,
-                numTxs: processedTxs.length,
-                numFailedTxs: failedTxs.length,
-                blockBuildingTimer
+                checkpointNumber: CheckpointNumber.ZERO,
+                blockNumber: BlockNumber.ZERO,
+                archive,
+                l1Timestamp,
+                pendingChainValidationStatus
             };
-        } finally{
-            // We create a fresh processor each time to reset any cached state (eg storage writes)
-            // We wait a bit to close the forks since the processor may still be working on a dangling tx
-            // which was interrupted due to the processingDeadline being hit.
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
-            setTimeout(async ()=>{
-                try {
-                    await publicProcessorFork.close();
-                    await orchestratorFork.close();
-                } catch (err) {
-                    // This can happen if the sequencer is stopped before we hit this timeout.
-                    this.log.warn(`Error closing forks for block processing`, err);
-                }
-            }, 5000);
         }
+        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,
+            checkpointNumber: block.checkpointNumber,
+            archive: block.archive.root,
+            l1Timestamp,
+            pendingChainValidationStatus
+        };
     }
     /**
-   * @notice  Build and propose a block to the chain
-   *
-   * @dev     MUST throw instead of exiting early to ensure that world-state
-   *          is being rolled back if the block is dropped.
-   *
-   * @param pendingTxs - Iterable of pending transactions to construct the block from
-   * @param proposalHeader - The partial header constructed for the proposal
-   */ async buildBlockAndEnqueuePublish(pendingTxs, proposalHeader) {
-        await this.publisher.validateBlockForSubmission(proposalHeader);
-        const newGlobalVariables = proposalHeader.globalVariables;
-        const blockNumber = newGlobalVariables.blockNumber.toNumber();
-        const slot = newGlobalVariables.slotNumber.toBigInt();
-        // this.metrics.recordNewBlock(blockNumber, validTxs.length);
-        const workTimer = new Timer();
-        this.setState(SequencerState.CREATING_BLOCK, slot);
+   * 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 {
-            const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables);
-            const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
-            this.metrics.recordBuiltBlock(workTimer.ms(), publicGas.l2Gas);
-            // TODO(@PhilWindle) We should probably periodically check for things like another
-            // block being published before ours instead of just waiting on our block
-            await this.publisher.validateBlockForSubmission(block.header);
-            const blockStats = {
-                eventName: 'l2-block-built',
-                creator: this.publisher.getSenderAddress().toString(),
-                duration: workTimer.ms(),
-                publicProcessDuration: publicProcessorDuration,
-                rollupCircuitsDuration: blockBuildingTimer.ms(),
-                ...block.getStats()
-            };
-            const blockHash = await block.hash();
-            const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
-            this.log.info(`Built block ${block.number} for slot ${slot} with ${numTxs} txs and ${numMsgs} messages. ${publicGas.l2Gas / workTimer.s()} mana/s`, {
-                blockHash,
-                globalVariables: block.header.globalVariables.toInspect(),
-                txHashes,
-                ...blockStats
-            });
-            this.log.debug('Collecting attestations');
-            const stopCollectingAttestationsTimer = this.metrics.startCollectingAttestationsTimer();
-            const attestations = await this.collectAttestations(block, txHashes);
-            if (attestations !== undefined) {
-                this.log.verbose(`Collected ${attestations.length} attestations`, {
-                    blockHash,
-                    blockNumber
-                });
+            proposer = await this.epochCache.getProposerAttesterAddressInSlot(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
+                ];
             }
-            stopCollectingAttestationsTimer();
-            return this.enqueuePublishL2Block(block, attestations, txHashes);
-        } catch (err) {
-            this.metrics.recordFailedBlock();
-            throw err;
+            this.log.error(`Error getting proposer for slot ${slot}`, e);
+            return [
+                false,
+                undefined
+            ];
         }
-    }
-    async collectAttestations(block, txHashes) {
-        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962): inefficient to have a round trip in here - this should be cached
-        const committee = await this.publisher.getCurrentEpochCommittee();
-        if (committee.length === 0) {
-            this.log.verbose(`Attesting committee is empty`);
-            return undefined;
-        } else {
-            this.log.debug(`Attesting committee length is ${committee.length}`);
-        }
-        if (!this.validatorClient) {
-            const msg = 'Missing validator client: Cannot collect attestations';
-            this.log.error(msg);
-            throw new Error(msg);
-        }
-        const numberOfRequiredAttestations = Math.floor(committee.length * 2 / 3) + 1;
-        const slotNumber = block.header.globalVariables.slotNumber.toBigInt();
-        this.setState(SequencerState.COLLECTING_ATTESTATIONS, slotNumber);
-        this.log.debug('Creating block proposal for validators');
-        const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
-        if (!proposal) {
-            const msg = `Failed to create block proposal`;
-            throw new Error(msg);
-        }
-        this.log.debug('Broadcasting block proposal to validators');
-        this.validatorClient.broadcastBlockProposal(proposal);
-        const attestationTimeAllowed = this.enforceTimeTable ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_BLOCK) : this.aztecSlotDuration;
-        const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
-        const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations, attestationDeadline);
-        // note: the smart contract requires that the signatures are provided in the order of the committee
-        return orderAttestations(attestations, committee);
+        // If proposer is undefined, then the committee is empty and anyone may propose
+        if (proposer === undefined) {
+            return [
+                true,
+                undefined
+            ];
+        }
+        // In fisherman mode, just return the current proposer
+        if (this.config.fishermanMode) {
+            return [
+                true,
+                proposer
+            ];
+        }
+        const validatorAddresses = this.validatorClient.getValidatorAddresses();
+        const weAreProposer = validatorAddresses.some((addr)=>addr.equals(proposer));
+        if (!weAreProposer) {
+            this.log.debug(`Cannot propose at slot ${slot} since we are not a proposer`, {
+                validatorAddresses,
+                proposer
+            });
+            return [
+                false,
+                proposer
+            ];
+        }
+        return [
+            true,
+            proposer
+        ];
     }
     /**
-   * Publishes the L2Block to the rollup contract.
-   * @param block - The L2Block to be published.
-   */ async enqueuePublishL2Block(block, attestations, txHashes) {
-        // Publishes new block to the network and awaits the tx to be mined
-        this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
-        // Time out tx at the end of the slot
-        const slot = block.header.globalVariables.slotNumber.toNumber();
-        const txTimeoutAt = new Date((this.getSlotStartTimestamp(slot) + this.aztecSlotDuration) * 1000);
-        const enqueued = await this.publisher.enqueueProposeL2Block(block, attestations, txHashes, {
-            txTimeoutAt
+   * Tries to vote on slashing actions and governance when the sync check fails but we're past the max time for initializing a proposal.
+   * This allows the sequencer to participate in governance/slashing votes even when it cannot build blocks.
+   */ async tryVoteWhenSyncFails(args) {
+        const { slot } = 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
         });
-        if (!enqueued) {
-            throw new Error(`Failed to enqueue publish of block ${block.number}`);
+        // 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();
     }
     /**
-   * Returns whether all dependencies have caught up.
-   * We don't check against the previous block submitted since it may have been reorg'd out.
-   * @returns Boolean indicating if our dependencies are synced to the latest block.
-   */ async getChainTip() {
-        const syncedBlocks = await Promise.all([
-            this.worldState.status().then((s)=>{
-                return {
-                    number: s.syncSummary.latestBlockNumber,
-                    hash: s.syncSummary.latestBlockHash
-                };
-            }),
-            this.l2BlockSource.getL2Tips().then((t)=>t.latest),
-            this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
-            this.l1ToL2MessageSource.getBlockNumber()
-        ]);
-        const [worldState, l2BlockSource, p2p, l1ToL2MessageSource] = syncedBlocks;
-        const result = // check that world state has caught up with archiver
-        // note that the archiver reports undefined hash for the genesis block
-        // because it doesn't have access to world state to compute it (facepalm)
-        (l2BlockSource.hash === undefined || worldState.hash === l2BlockSource.hash) && // and p2p client and message source are at least at the same block
-        // this should change to hashes once p2p client handles reorgs
-        // and once we stop pretending that the l1tol2message source is not
-        // just the archiver under a different name
-        (!l2BlockSource.hash || p2p.hash === l2BlockSource.hash) && l1ToL2MessageSource === l2BlockSource.number;
-        this.log.debug(`Sequencer sync check ${result ? 'succeeded' : 'failed'}`, {
-            worldStateNumber: worldState.number,
-            worldStateHash: worldState.hash,
-            l2BlockSourceNumber: l2BlockSource.number,
-            l2BlockSourceHash: l2BlockSource.hash,
-            p2pNumber: p2p.number,
-            p2pHash: p2p.hash,
-            l1ToL2MessageSourceNumber: l1ToL2MessageSource
-        });
-        if (!result) {
-            return undefined;
+   * Considers invalidating a checkpoint if the pending chain is invalid. Depends on how long the invalid checkpoint
+   * has been there without being invalidated and whether the sequencer is in the committee or not. We always
+   * have the proposer try to invalidate, but if they fail, the sequencers in the committee are expected to try,
+   * and if they fail, any sequencer will try as well.
+   */ async considerInvalidatingCheckpoint(syncedTo, currentSlot) {
+        const { pendingChainValidationStatus, l1Timestamp } = syncedTo;
+        if (pendingChainValidationStatus.valid) {
+            return;
         }
-        if (worldState.number >= INITIAL_L2_BLOCK_NUM) {
-            const block = await this.l2BlockSource.getBlock(worldState.number);
-            if (!block) {
-                // this shouldn't really happen because a moment ago we checked that all components were in synch
-                return undefined;
+        const invalidCheckpointNumber = pendingChainValidationStatus.checkpoint.checkpointNumber;
+        const invalidCheckpointTimestamp = pendingChainValidationStatus.checkpoint.timestamp;
+        const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidCheckpointTimestamp);
+        const ourValidatorAddresses = this.validatorClient.getValidatorAddresses();
+        const { secondsBeforeInvalidatingBlockAsCommitteeMember, secondsBeforeInvalidatingBlockAsNonCommitteeMember } = this.config;
+        const logData = {
+            invalidL1Timestamp: invalidCheckpointTimestamp,
+            l1Timestamp,
+            invalidCheckpoint: pendingChainValidationStatus.checkpoint,
+            secondsBeforeInvalidatingBlockAsCommitteeMember,
+            secondsBeforeInvalidatingBlockAsNonCommitteeMember,
+            ourValidatorAddresses,
+            currentSlot
+        };
+        const inCurrentCommittee = ()=>this.epochCache.getCommittee(currentSlot).then((c)=>c?.committee?.some((member)=>ourValidatorAddresses.some((addr)=>addr.equals(member))));
+        const invalidateAsCommitteeMember = secondsBeforeInvalidatingBlockAsCommitteeMember !== undefined && secondsBeforeInvalidatingBlockAsCommitteeMember > 0 && timeSinceChainInvalid > secondsBeforeInvalidatingBlockAsCommitteeMember && await inCurrentCommittee();
+        const invalidateAsNonCommitteeMember = secondsBeforeInvalidatingBlockAsNonCommitteeMember !== undefined && secondsBeforeInvalidatingBlockAsNonCommitteeMember > 0 && timeSinceChainInvalid > secondsBeforeInvalidatingBlockAsNonCommitteeMember;
+        if (!invalidateAsCommitteeMember && !invalidateAsNonCommitteeMember) {
+            this.log.debug(`Not invalidating pending chain`, logData);
+            return;
+        }
+        let validatorToUse;
+        if (invalidateAsCommitteeMember) {
+            // When invalidating as a committee member, use first validator that's actually in the committee
+            const { committee } = await this.epochCache.getCommittee(currentSlot);
+            if (committee) {
+                const committeeSet = new Set(committee.map((addr)=>addr.toString()));
+                validatorToUse = ourValidatorAddresses.find((addr)=>committeeSet.has(addr.toString())) ?? ourValidatorAddresses[0];
+            } else {
+                validatorToUse = ourValidatorAddresses[0];
             }
-            return {
-                blockNumber: block.number,
-                archive: block.archive.root
-            };
         } else {
-            const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
-            return {
-                blockNumber: INITIAL_L2_BLOCK_NUM - 1,
-                archive
-            };
+            // When invalidating as a non-committee member, use the first validator
+            validatorToUse = ourValidatorAddresses[0];
         }
+        const { publisher } = await this.publisherFactory.create(validatorToUse);
+        const invalidateCheckpoint = await publisher.simulateInvalidateCheckpoint(pendingChainValidationStatus);
+        if (!invalidateCheckpoint) {
+            this.log.warn(`Failed to simulate invalidate checkpoint`, logData);
+            return;
+        }
+        this.log.info(invalidateAsCommitteeMember ? `Invalidating checkpoint ${invalidCheckpointNumber} as committee member` : `Invalidating checkpoint ${invalidCheckpointNumber} as non-committee member`, logData);
+        publisher.enqueueInvalidateCheckpoint(invalidateCheckpoint);
+        if (!this.config.fishermanMode) {
+            await publisher.sendRequests();
+        } else {
+            this.log.info('Invalidating checkpoint in fisherman mode, clearing pending requests');
+            publisher.clearPendingRequests();
+        }
+    }
+    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)
+                }))
+        });
     }
-    getSlotStartTimestamp(slotNumber) {
-        return Number(this.l1Constants.l1GenesisTime) + Number(slotNumber) * this.l1Constants.slotDuration;
+    getSlotStartBuildTimestamp(slotNumber) {
+        return getSlotStartBuildTimestamp(slotNumber, this.l1Constants);
     }
     getSecondsIntoSlot(slotNumber) {
-        const slotStartTimestamp = this.getSlotStartTimestamp(slotNumber);
+        const slotStartTimestamp = this.getSlotStartBuildTimestamp(slotNumber);
         return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
     }
     get aztecSlotDuration() {
         return this.l1Constants.slotDuration;
     }
-    get coinbase() {
-        return this._coinbase;
+    get maxL2BlockGas() {
+        return this.config.maxL2BlockGas;
+    }
+    getSlasherClient() {
+        return this.slasherClient;
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    getValidatorAddresses() {
+        return this.validatorClient?.getValidatorAddresses();
+    }
+    getConfig() {
+        return this.config;
     }
-    get feeRecipient() {
-        return this._feeRecipient;
+    get l1PublishingTime() {
+        return this.config.l1PublishingTime ?? this.l1Constants.ethereumSlotDuration;
     }
 }
-_ts_decorate([
-    trackSpan('Sequencer.work')
-], Sequencer.prototype, "work", null);
-_ts_decorate([
-    trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, proposalHeader)=>({
-            [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber()
-        }))
-], Sequencer.prototype, "buildBlockAndEnqueuePublish", null);
-_ts_decorate([
-    trackSpan('Sequencer.collectAttestations', (block, txHashes)=>({
-            [Attributes.BLOCK_NUMBER]: block.number,
-            [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
-            [Attributes.BLOCK_TXS_COUNT]: txHashes.length
-        }))
-], Sequencer.prototype, "collectAttestations", null);
-_ts_decorate([
-    trackSpan('Sequencer.enqueuePublishL2Block', (block)=>({
-            [Attributes.BLOCK_NUMBER]: block.number
-        }))
-], Sequencer.prototype, "enqueuePublishL2Block", null);