@aztec/sequencer-client 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/dest/sequencer/checkpoint_proposal_job.js

@@ -0,0 +1,1355 @@
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+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, _dec3, _dec4, _dec5, _dec6, _dec7, _initProto;
+import { BlockNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { flipSignature, generateRecoverableSignature, generateUnrecoverableSignature } from '@aztec/foundation/crypto/secp256k1-signer';
+import { filter } from '@aztec/foundation/iterator';
+import { createLogger } from '@aztec/foundation/log';
+import { sleep, sleepUntil } from '@aztec/foundation/sleep';
+import { Timer } from '@aztec/foundation/timer';
+import { isErrorClass, unfreeze } from '@aztec/foundation/types';
+import { CommitteeAttestationsAndSigners, MaliciousCommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { validateCheckpoint } from '@aztec/stdlib/checkpoint';
+import { computeQuorum, getSlotStartBuildTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { Gas } from '@aztec/stdlib/gas';
+import { InsufficientValidTxsError } from '@aztec/stdlib/interfaces/server';
+import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import { orderAttestations, trimAttestations } from '@aztec/stdlib/p2p';
+import { AttestationTimeoutError } from '@aztec/stdlib/validators';
+import { Attributes, trackSpan } from '@aztec/telemetry-client';
+import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec/validator-ha-signer/errors';
+import { buildPipelinedParentSimulationOverridesPlan, buildSubmissionSimulationOverridesPlan } from './chain_state_overrides.js';
+import { CheckpointVoter } from './checkpoint_voter.js';
+import { SequencerInterruptedError } from './errors.js';
+import { SequencerState } from './utils.js';
+/** How much time to sleep while waiting for min transactions to accumulate for a block */ const TXS_POLLING_MS = 500;
+_dec = trackSpan('CheckpointProposalJob.execute'), _dec1 = trackSpan('CheckpointProposalJob.proposeCheckpoint', function() {
+    return {
+        // nullish operator needed for tests
+        [Attributes.COINBASE]: this.validatorClient.getCoinbaseForAttestor(this.attestorAddress)?.toString(),
+        [Attributes.SLOT_NUMBER]: this.targetSlot
+    };
+}), _dec2 = trackSpan('CheckpointProposalJob.buildBlocksForCheckpoint'), _dec3 = trackSpan('CheckpointProposalJob.waitUntilNextSubslot'), _dec4 = trackSpan('CheckpointProposalJob.buildSingleBlock'), _dec5 = trackSpan('CheckpointProposalJob.waitForMinTxs'), _dec6 = trackSpan('CheckpointProposalJob.waitForAttestations'), _dec7 = trackSpan('CheckpointProposalJob.waitUntilTimeInSlot');
+/**
+ * Handles the execution of a checkpoint proposal after the initial preparation phase.
+ * This includes building blocks, collecting attestations, and publishing the checkpoint to L1,
+ * as well as enqueueing votes for slashing and governance proposals. This class is created from
+ * the Sequencer once the check for being the proposer for the slot has succeeded.
+ */ export class CheckpointProposalJob {
+    slotNow;
+    targetSlot;
+    targetEpoch;
+    checkpointNumber;
+    syncedToBlockNumber;
+    proposer;
+    publisher;
+    attestorAddress;
+    invalidateCheckpoint;
+    validatorClient;
+    globalsBuilder;
+    p2pClient;
+    worldState;
+    l1ToL2MessageSource;
+    l2BlockSource;
+    checkpointsBuilder;
+    blockSink;
+    l1Constants;
+    config;
+    timetable;
+    slasherClient;
+    epochCache;
+    dateProvider;
+    metrics;
+    checkpointMetrics;
+    eventEmitter;
+    setStateFn;
+    tracer;
+    proposedCheckpointData;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "execute"
+            ],
+            [
+                _dec1,
+                2,
+                "proposeCheckpoint"
+            ],
+            [
+                _dec2,
+                2,
+                "buildBlocksForCheckpoint"
+            ],
+            [
+                _dec3,
+                2,
+                "waitUntilNextSubslot"
+            ],
+            [
+                _dec4,
+                2,
+                "buildSingleBlock"
+            ],
+            [
+                _dec5,
+                2,
+                "waitForMinTxs"
+            ],
+            [
+                _dec6,
+                2,
+                "waitForAttestations"
+            ],
+            [
+                _dec7,
+                2,
+                "waitUntilTimeInSlot"
+            ]
+        ], []));
+    }
+    log;
+    /** Tracks the fire-and-forget L1 submission promise so it can be awaited during shutdown. */ pendingL1Submission;
+    /** Pipelined parent chain state used while building and later submitting this checkpoint. */ pipelinedParentSimulationOverridesPlan;
+    constructor(slotNow, targetSlot, targetEpoch, checkpointNumber, syncedToBlockNumber, // TODO(palla/mbps): Can we remove the proposer in favor of attestorAddress? Need to check fisherman-node flows.
+    proposer, publisher, attestorAddress, invalidateCheckpoint, validatorClient, globalsBuilder, p2pClient, worldState, l1ToL2MessageSource, l2BlockSource, checkpointsBuilder, blockSink, l1Constants, config, timetable, slasherClient, epochCache, dateProvider, metrics, checkpointMetrics, eventEmitter, setStateFn, tracer, bindings, proposedCheckpointData){
+        this.slotNow = slotNow;
+        this.targetSlot = targetSlot;
+        this.targetEpoch = targetEpoch;
+        this.checkpointNumber = checkpointNumber;
+        this.syncedToBlockNumber = syncedToBlockNumber;
+        this.proposer = proposer;
+        this.publisher = publisher;
+        this.attestorAddress = attestorAddress;
+        this.invalidateCheckpoint = invalidateCheckpoint;
+        this.validatorClient = validatorClient;
+        this.globalsBuilder = globalsBuilder;
+        this.p2pClient = p2pClient;
+        this.worldState = worldState;
+        this.l1ToL2MessageSource = l1ToL2MessageSource;
+        this.l2BlockSource = l2BlockSource;
+        this.checkpointsBuilder = checkpointsBuilder;
+        this.blockSink = blockSink;
+        this.l1Constants = l1Constants;
+        this.config = config;
+        this.timetable = timetable;
+        this.slasherClient = slasherClient;
+        this.epochCache = epochCache;
+        this.dateProvider = dateProvider;
+        this.metrics = metrics;
+        this.checkpointMetrics = checkpointMetrics;
+        this.eventEmitter = eventEmitter;
+        this.setStateFn = setStateFn;
+        this.tracer = tracer;
+        this.proposedCheckpointData = proposedCheckpointData;
+        _initProto(this);
+        this.log = createLogger('sequencer:checkpoint-proposal', {
+            ...bindings,
+            instanceId: `slot-${this.slotNow}`
+        });
+    }
+    /** Awaits the pending L1 submission if one is in progress. Call during shutdown. */ async awaitPendingSubmission() {
+        this.log.info('Awaiting pending L1 payload submission');
+        await this.pendingL1Submission;
+    }
+    /**
+   * Executes the checkpoint proposal job.
+   * Builds blocks, assembles checkpoint, and broadcasts the proposal (blocking).
+   * Attestation collection, signing, and L1 submission are backgrounded so the
+   * work loop can return to IDLE immediately for consecutive slot proposals.
+   * Returns the built checkpoint if successful, undefined otherwise.
+   */ async execute() {
+        // Enqueue governance and slashing votes (returns promises that will be awaited later)
+        // In fisherman mode, we simulate slashing but don't actually publish to L1
+        // These are constant for the whole slot, so we only enqueue them once
+        const votesPromises = new CheckpointVoter(this.targetSlot, this.publisher, this.attestorAddress, this.validatorClient, this.slasherClient, this.l1Constants, this.config, this.metrics, this.log).enqueueVotes();
+        // Build blocks, assemble checkpoint, and broadcast proposal (BLOCKING).
+        // Returns after broadcast — attestation collection is deferred.
+        const broadcast = await this.proposeCheckpoint();
+        if (!broadcast) {
+            await Promise.all(votesPromises);
+            // Still submit votes even without a checkpoint
+            if (!this.config.fishermanMode) {
+                this.pendingL1Submission = this.publisher.sendRequestsAt(this.dateProvider.nowAsDate()).then(()=>{});
+            }
+            return undefined;
+        }
+        const { checkpoint } = broadcast;
+        this.metrics.recordCheckpointProposalSuccess();
+        // Do not post anything to L1 if we are fishermen, but do perform L1 fee analysis
+        if (this.config.fishermanMode) {
+            await this.handleCheckpointEndAsFisherman(checkpoint);
+            return checkpoint;
+        }
+        // Background the attestation → signing → L1 pipeline so the work loop is unblocked
+        this.pendingL1Submission = this.waitForAttestationsAndEnqueueSubmissionAsync(broadcast, votesPromises);
+        // Return the built checkpoint immediately — the work loop is now unblocked
+        return checkpoint;
+    }
+    /**
+   * Background pipeline: collects attestations, signs them, enqueues the checkpoint, and submits to L1.
+   * Runs as a fire-and-forget task stored in `pendingL1Submission` so the work loop is unblocked.
+   */ async waitForAttestationsAndEnqueueSubmissionAsync(broadcast, votesPromises) {
+        const { checkpoint, proposal, blockProposedAt } = broadcast;
+        try {
+            await Promise.all(votesPromises);
+            this.setStateFn(SequencerState.COLLECTING_ATTESTATIONS, this.targetSlot);
+            const attestations = await this.waitForAttestations(proposal);
+            this.checkpointMetrics.recordCheckpointAttestationDelay(this.dateProvider.now() - blockProposedAt);
+            // Proposer must sign over the attestations before pushing them to L1
+            const signer = this.proposer ?? this.publisher.getSenderAddress();
+            let attestationsSignature;
+            try {
+                attestationsSignature = await this.validatorClient.signAttestationsAndSigners(attestations, signer, this.targetSlot, this.checkpointNumber);
+            } catch (err) {
+                if (this.handleHASigningError(err, 'Attestations signature')) {
+                    return;
+                }
+                throw err;
+            }
+            // Enqueue the checkpoint for L1 submission
+            await this.enqueueCheckpointForSubmission({
+                checkpoint,
+                attestations,
+                attestationsSignature
+            });
+            // Compute the earliest time to submit: pipeline slot start when pipelining, now otherwise.
+            const submitAfter = this.epochCache.isProposerPipeliningEnabled() ? new Date(Number(getTimestampForSlot(this.targetSlot, this.l1Constants)) * 1000) : new Date(this.dateProvider.now());
+            const l1Response = await this.publisher.sendRequestsAt(submitAfter);
+            const proposedAction = l1Response?.successfulActions.find((a)=>a === 'propose');
+            if (proposedAction) {
+                this.eventEmitter.emit('checkpoint-published', {
+                    checkpoint: this.checkpointNumber,
+                    slot: this.targetSlot
+                });
+                const coinbase = checkpoint.header.coinbase;
+                await this.metrics.incFilledSlot(this.publisher.getSenderAddress().toString(), coinbase);
+            } else {
+                this.eventEmitter.emit('checkpoint-publish-failed', {
+                    ...l1Response,
+                    slot: this.targetSlot
+                });
+                if (this.epochCache.isProposerPipeliningEnabled()) {
+                    this.metrics.recordPipelineDiscard();
+                }
+            }
+        } catch (err) {
+            if (err instanceof SequencerInterruptedError) {
+                return;
+            }
+            this.log.error(`Background attestation/L1 pipeline failed for slot ${this.targetSlot}`, err);
+            this.eventEmitter.emit('checkpoint-publish-failed', {
+                slot: this.targetSlot
+            });
+            if (this.epochCache.isProposerPipeliningEnabled()) {
+                this.metrics.recordPipelineDiscard();
+            }
+        }
+    }
+    /** Enqueues the checkpoint for L1 submission. Called after pipeline sleep in execute(). */ async enqueueCheckpointForSubmission(result) {
+        const { checkpoint, attestations, attestationsSignature } = result;
+        this.setStateFn(SequencerState.PUBLISHING_CHECKPOINT, this.targetSlot);
+        const aztecSlotDuration = this.l1Constants.slotDuration;
+        const submissionSlotStart = Number(getTimestampForSlot(this.targetSlot, this.l1Constants));
+        const txTimeoutAt = new Date((submissionSlotStart + aztecSlotDuration) * 1000);
+        // If we have been configured to potentially skip publishing checkpoint then roll the dice here
+        if (this.config.skipPublishingCheckpointsPercent !== undefined && this.config.skipPublishingCheckpointsPercent > 0) {
+            const roll = Math.max(0, randomInt(100));
+            if (roll < this.config.skipPublishingCheckpointsPercent) {
+                this.log.warn(`Skipping publishing proposal for checkpoint ${checkpoint.number}. Configured percentage: ${this.config.skipPublishingCheckpointsPercent}, generated value: ${roll}`);
+                return;
+            }
+        }
+        const isPipelining = this.epochCache.isProposerPipeliningEnabled();
+        const submissionSimulationOverridesPlan = buildSubmissionSimulationOverridesPlan({
+            pipelinedParentPlan: this.pipelinedParentSimulationOverridesPlan,
+            invalidateToPendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber,
+            lastArchiveRoot: checkpoint.header.lastArchiveRoot,
+            pipeliningEnabled: isPipelining
+        });
+        await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, {
+            txTimeoutAt,
+            ...submissionSimulationOverridesPlan ? {
+                simulationOverridesPlan: submissionSimulationOverridesPlan
+            } : {}
+        });
+    }
+    async proposeCheckpoint() {
+        try {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                const now = this.dateProvider.now();
+                if (this.epochCache.isProposerPipeliningEnabled() && this.proposedCheckpointData) {
+                    // Measure against the wall-clock slot whose build window we are currently using.
+                    // In pipelining mode `targetSlot` is intentionally one slot ahead, which makes the
+                    // target-slot boundary a full slot away from the actual build start time.
+                    const slotBoundaryMs = Number(getTimestampForSlot(this.slotNow, this.l1Constants)) * 1000;
+                    this.checkpointMetrics.recordPipelinedCheckpointBuildStartOffsetFromSlotBoundary(now - slotBoundaryMs);
+                }
+                this.checkpointMetrics.startCheckpointTiming(now);
+                // Get operator configured coinbase and fee recipient for this attestor
+                const coinbase = this.validatorClient.getCoinbaseForAttestor(this.attestorAddress);
+                const feeRecipient = this.validatorClient.getFeeRecipientForAttestor(this.attestorAddress);
+                // Start the checkpoint
+                this.setStateFn(SequencerState.INITIALIZING_CHECKPOINT, this.targetSlot);
+                this.log.info(`Starting checkpoint proposal`, {
+                    buildSlot: this.slotNow,
+                    submissionSlot: this.targetSlot,
+                    pipelining: this.epochCache.isProposerPipeliningEnabled(),
+                    proposer: this.proposer?.toString(),
+                    coinbase: coinbase.toString()
+                });
+                this.metrics.incOpenSlot(this.targetSlot, this.proposer?.toString() ?? 'unknown');
+                // Enqueues checkpoint invalidation (constant for the whole slot)
+                if (this.invalidateCheckpoint && !this.config.skipInvalidateBlockAsProposer) {
+                    this.publisher.enqueueInvalidateCheckpoint(this.invalidateCheckpoint);
+                }
+                // Create checkpoint builder for the slot.
+                // When pipelining, force the proposed checkpoint number and fee header to our parent so the
+                // fee computation sees the same chain tip that L1 will see once the previous pipelined checkpoint lands.
+                const isPipelining = this.epochCache.isProposerPipeliningEnabled();
+                this.pipelinedParentSimulationOverridesPlan = isPipelining ? await buildPipelinedParentSimulationOverridesPlan({
+                    checkpointNumber: this.checkpointNumber,
+                    proposedCheckpointData: this.proposedCheckpointData,
+                    rollup: this.publisher.rollupContract,
+                    log: this.log
+                }) : undefined;
+                const checkpointGlobalVariables = await this.globalsBuilder.buildCheckpointGlobalVariables(coinbase, feeRecipient, this.targetSlot, this.pipelinedParentSimulationOverridesPlan);
+                // Collect L1 to L2 messages for the checkpoint and compute their hash
+                const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(this.checkpointNumber);
+                const inHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
+                // Collect the out hashes of all the checkpoints before this one in the same epoch
+                const previousCheckpointOutHashes = (await this.l2BlockSource.getCheckpointsDataForEpoch(this.targetEpoch)).filter((c)=>c.checkpointNumber < this.checkpointNumber).map((c)=>c.checkpointOutHash);
+                // Get the fee asset price modifier from the oracle
+                const feeAssetPriceModifier = await this.publisher.getFeeAssetPriceModifier();
+                const fork = _ts_add_disposable_resource(env, await this.worldState.fork(this.syncedToBlockNumber, {
+                    closeDelayMs: 12_000
+                }), true);
+                // Create checkpoint builder for the entire slot
+                const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(this.checkpointNumber, checkpointGlobalVariables, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, this.log.getBindings());
+                // Options for the validator client when creating block and checkpoint proposals
+                const blockProposalOptions = {
+                    publishFullTxs: !!this.config.publishTxsWithProposals,
+                    broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
+                };
+                const checkpointProposalOptions = {
+                    publishFullTxs: !!this.config.publishTxsWithProposals,
+                    broadcastInvalidCheckpointProposal: this.config.broadcastInvalidBlockProposal
+                };
+                let blocksInCheckpoint = [];
+                let blockPendingBroadcast = undefined;
+                const checkpointBuildTimer = new Timer();
+                try {
+                    // Main loop: build blocks for the checkpoint
+                    const result = await this.buildBlocksForCheckpoint(checkpointBuilder, checkpointGlobalVariables.timestamp, inHash, blockProposalOptions);
+                    blocksInCheckpoint = result.blocksInCheckpoint;
+                    blockPendingBroadcast = result.blockPendingBroadcast;
+                } catch (err) {
+                    // These errors are expected in HA mode, so we yield and let another HA node handle the slot
+                    // The only distinction between the 2 errors is SlashingProtectionError throws when the payload is different,
+                    // which is normal for block building (may have picked different txs)
+                    if (this.handleHASigningError(err, 'Block proposal')) {
+                        return undefined;
+                    }
+                    throw err;
+                }
+                if (blocksInCheckpoint.length === 0) {
+                    this.log.warn(`No blocks were built for slot ${this.targetSlot}`, {
+                        slot: this.targetSlot
+                    });
+                    this.eventEmitter.emit('checkpoint-empty', {
+                        slot: this.targetSlot
+                    });
+                    return undefined;
+                }
+                const minBlocksForCheckpoint = this.config.minBlocksForCheckpoint;
+                if (minBlocksForCheckpoint !== undefined && blocksInCheckpoint.length < minBlocksForCheckpoint) {
+                    this.log.warn(`Checkpoint has fewer blocks than minimum (${blocksInCheckpoint.length} < ${minBlocksForCheckpoint}), skipping proposal`, {
+                        slot: this.targetSlot,
+                        blocksBuilt: blocksInCheckpoint.length,
+                        minBlocksForCheckpoint
+                    });
+                    return undefined;
+                }
+                // Assemble and broadcast the checkpoint proposal, including the last block that was not
+                // broadcasted yet, and wait to collect the committee attestations.
+                this.setStateFn(SequencerState.ASSEMBLING_CHECKPOINT, this.targetSlot);
+                const checkpoint = await checkpointBuilder.completeCheckpoint();
+                // Final validation: per-block limits are only checked if the operator set them explicitly.
+                // Otherwise, checkpoint-level budgets were already enforced by the redistribution logic.
+                try {
+                    validateCheckpoint(checkpoint, {
+                        rollupManaLimit: this.l1Constants.rollupManaLimit,
+                        maxL2BlockGas: this.config.maxL2BlockGas,
+                        maxDABlockGas: this.config.maxDABlockGas,
+                        maxTxsPerBlock: this.config.maxTxsPerBlock,
+                        maxTxsPerCheckpoint: this.config.maxTxsPerCheckpoint
+                    });
+                } catch (err) {
+                    this.log.error(`Built an invalid checkpoint at slot ${this.slotNow} (skipping proposal)`, err, {
+                        checkpoint: checkpoint.header.toInspect()
+                    });
+                    return undefined;
+                }
+                // Record checkpoint-level build metrics
+                this.checkpointMetrics.recordCheckpointBuild(checkpointBuildTimer.ms(), blocksInCheckpoint.length, checkpoint.getStats().txCount, Number(checkpoint.header.totalManaUsed.toBigInt()));
+                // In fisherman mode, return the checkpoint without broadcasting or collecting attestations
+                if (this.config.fishermanMode) {
+                    this.log.info(`Built checkpoint for slot ${this.targetSlot} with ${blocksInCheckpoint.length} blocks. ` + `Skipping proposal in fisherman mode.`, {
+                        slot: this.targetSlot,
+                        checkpoint: checkpoint.header.toInspect(),
+                        blocksBuilt: blocksInCheckpoint.length
+                    });
+                    this.metrics.recordCheckpointSuccess();
+                    // Return a broadcast result with a dummy proposal — fisherman mode skips attestation collection
+                    return {
+                        checkpoint,
+                        proposal: undefined,
+                        blockProposedAt: this.dateProvider.now()
+                    };
+                }
+                // Create the checkpoint proposal and broadcast it
+                const proposal = await this.validatorClient.createCheckpointProposal(checkpoint.header, checkpoint.archive.root, this.checkpointNumber, feeAssetPriceModifier, blockPendingBroadcast, this.proposer, checkpointProposalOptions);
+                const blockProposedAt = this.dateProvider.now();
+                await this.p2pClient.broadcastCheckpointProposal(proposal);
+                this.checkpointMetrics.noteCheckpointBroadcast(this.dateProvider.now());
+                // Return immediately after broadcast — attestation collection happens in the background
+                return {
+                    checkpoint,
+                    proposal,
+                    blockProposedAt
+                };
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        } catch (err) {
+            if (err && (err instanceof DutyAlreadySignedError || err instanceof SlashingProtectionError)) {
+                // swallow this error. It's already been logged by a function deeper in the stack
+                return undefined;
+            }
+            this.log.error(`Error building checkpoint at slot ${this.targetSlot}`, err);
+            return undefined;
+        }
+    }
+    /**
+   * Builds blocks for a checkpoint within the current slot.
+   */ async buildBlocksForCheckpoint(checkpointBuilder, timestamp, inHash, blockProposalOptions) {
+        const blocksInCheckpoint = [];
+        const txHashesAlreadyIncluded = new Set();
+        const initialBlockNumber = BlockNumber(this.syncedToBlockNumber + 1);
+        // Last block in the checkpoint will usually be flagged as pending broadcast, so we send it along with the checkpoint proposal
+        let blockPendingBroadcast = undefined;
+        while(true){
+            const blocksBuilt = blocksInCheckpoint.length;
+            const indexWithinCheckpoint = IndexWithinCheckpoint(blocksBuilt);
+            const blockNumber = BlockNumber(initialBlockNumber + blocksBuilt);
+            const secondsIntoSlot = this.getSecondsIntoSlot();
+            const timingInfo = this.timetable.canStartNextBlock(secondsIntoSlot);
+            if (!timingInfo.canStart) {
+                this.log.debug(`Not enough time left in slot to start another block`, {
+                    slot: this.targetSlot,
+                    blocksBuilt,
+                    secondsIntoSlot
+                });
+                break;
+            }
+            const buildResult = await this.buildSingleBlock(checkpointBuilder, {
+                // Create all blocks with the same timestamp
+                blockTimestamp: timestamp,
+                // Create an empty block if we haven't already and this is the last one
+                forceCreate: timingInfo.isLastBlock && blocksBuilt === 0 && this.config.buildCheckpointIfEmpty,
+                // Build deadline is only set if we are enforcing the timetable
+                buildDeadline: timingInfo.deadline ? new Date((this.getSlotStartBuildTimestamp() + timingInfo.deadline) * 1000) : undefined,
+                blockNumber,
+                indexWithinCheckpoint,
+                txHashesAlreadyIncluded
+            });
+            // If we failed to build the block due to insufficient txs, we try again if there is still time left in the slot
+            if ('failure' in buildResult) {
+                // If this was the last subslot, or we're running with a single block per slot, we're done
+                if (timingInfo.isLastBlock || timingInfo.deadline === undefined) {
+                    break;
+                }
+                // Otherwise, if there is still time for more blocks, we wait until the next subslot and try again
+                await this.waitUntilNextSubslot(timingInfo.deadline);
+                continue;
+            }
+            // If there was an error building the block, we just exit the loop and give up the rest of the slot.
+            // We don't want to risk building more blocks if something went wrong.
+            if ('error' in buildResult) {
+                if (!(buildResult.error instanceof SequencerInterruptedError)) {
+                    this.log.warn(`Halting block building for slot ${this.targetSlot}`, {
+                        slot: this.targetSlot,
+                        blocksBuilt,
+                        error: buildResult.error
+                    });
+                }
+                break;
+            }
+            const { block, usedTxs } = buildResult;
+            this.checkpointMetrics.noteCheckpointBlockBuilt(this.dateProvider.now(), {
+                isFirstBlock: blocksBuilt === 0,
+                isLastBlock: timingInfo.isLastBlock
+            });
+            blocksInCheckpoint.push(block);
+            usedTxs.forEach((tx)=>txHashesAlreadyIncluded.add(tx.txHash.toString()));
+            // Sign the block proposal. This will throw if HA signing fails.
+            const proposal = await this.createBlockProposal(block, inHash, usedTxs, blockProposalOptions);
+            // Sync the proposed block to the archiver to make it available, only after we've managed to sign the proposal,
+            // so we avoid polluting our archive with a block that would fail.
+            // We wait for the sync to succeed, as this helps catch consistency errors, even if it means we lose some time for block-building.
+            // If this throws, we abort the entire checkpoint.
+            await this.syncProposedBlockToArchiver(block);
+            // If this is the last block, do not broadcast it, since it will be included in the checkpoint proposal.
+            if (timingInfo.isLastBlock) {
+                this.log.verbose(`Completed final block ${blockNumber} for slot ${this.targetSlot}`, {
+                    slot: this.targetSlot,
+                    blockNumber,
+                    blocksBuilt
+                });
+                blockPendingBroadcast = proposal;
+                break;
+            }
+            // Once we have a signed proposal and the archiver agreed with our proposed block, then we broadcast it.
+            proposal && await this.p2pClient.broadcastProposal(proposal);
+            // Wait until the next block's start time
+            await this.waitUntilNextSubslot(timingInfo.deadline);
+        }
+        this.log.verbose(`Block building loop completed for slot ${this.targetSlot}`, {
+            slot: this.targetSlot,
+            blocksBuilt: blocksInCheckpoint.length
+        });
+        return {
+            blocksInCheckpoint,
+            blockPendingBroadcast
+        };
+    }
+    /** Creates a block proposal for a given block via the validator client (unless in fisherman mode) */ createBlockProposal(block, inHash, usedTxs, blockProposalOptions) {
+        if (this.config.fishermanMode) {
+            this.log.info(`Skipping block proposal for block ${block.number} in fisherman mode`);
+            return Promise.resolve(undefined);
+        }
+        return this.validatorClient.createBlockProposal(block.header, this.checkpointNumber, block.indexWithinCheckpoint, inHash, block.archive.root, usedTxs, this.proposer, blockProposalOptions);
+    }
+    /** Sleeps until it is time to produce the next block in the slot */ async waitUntilNextSubslot(nextSubslotStart) {
+        this.setStateFn(SequencerState.WAITING_UNTIL_NEXT_BLOCK, this.targetSlot);
+        this.log.verbose(`Waiting until time for the next block at ${nextSubslotStart}s into slot`, {
+            slot: this.targetSlot
+        });
+        await this.waitUntilTimeInSlot(nextSubslotStart);
+    }
+    /** Builds a single block. Called from the main block building loop. */ async buildSingleBlock(checkpointBuilder, opts) {
+        const { blockTimestamp, forceCreate, blockNumber, indexWithinCheckpoint, buildDeadline, txHashesAlreadyIncluded } = opts;
+        this.log.verbose(`Preparing block ${blockNumber} index ${indexWithinCheckpoint} at checkpoint ${this.checkpointNumber} for slot ${this.targetSlot}`, {
+            ...checkpointBuilder.getConstantData(),
+            ...opts
+        });
+        try {
+            // Wait until we have enough txs to build the block
+            const { availableTxs, canStartBuilding, minTxs } = await this.waitForMinTxs(opts);
+            if (!canStartBuilding) {
+                this.log.warn(`Not enough txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.targetSlot} (got ${availableTxs} txs but needs ${minTxs})`, {
+                    blockNumber,
+                    slot: this.targetSlot,
+                    indexWithinCheckpoint
+                });
+                this.eventEmitter.emit('block-tx-count-check-failed', {
+                    minTxs,
+                    availableTxs,
+                    slot: this.targetSlot
+                });
+                this.metrics.recordBlockProposalFailed('insufficient_txs');
+                return {
+                    failure: 'insufficient-txs'
+                };
+            }
+            // Create iterator to pending txs. We filter out txs already included in previous blocks in the checkpoint
+            // just in case p2p failed to sync the provisional block and didn't get to remove those txs from the mempool yet.
+            const pendingTxs = filter(this.p2pClient.iterateEligiblePendingTxs(), (tx)=>!txHashesAlreadyIncluded.has(tx.txHash.toString()));
+            this.log.debug(`Building block ${blockNumber} at index ${indexWithinCheckpoint} for slot ${this.targetSlot} with ${availableTxs} available txs`, {
+                slot: this.targetSlot,
+                blockNumber,
+                indexWithinCheckpoint
+            });
+            this.setStateFn(SequencerState.CREATING_BLOCK, this.targetSlot);
+            // Per-block limits are operator overrides (from SEQ_MAX_L2_BLOCK_GAS etc.) further capped
+            // by remaining checkpoint-level budgets inside CheckpointBuilder before each block is built.
+            // minValidTxs is passed into the builder so it can reject the block *before* updating state.
+            const minValidTxs = forceCreate ? 0 : this.config.minValidTxsPerBlock ?? minTxs;
+            const blockBuilderOptions = {
+                maxTransactions: this.config.maxTxsPerBlock,
+                maxBlockGas: this.config.maxL2BlockGas !== undefined || this.config.maxDABlockGas !== undefined ? new Gas(this.config.maxDABlockGas ?? Infinity, this.config.maxL2BlockGas ?? Infinity) : undefined,
+                deadline: buildDeadline,
+                isBuildingProposal: true,
+                minValidTxs,
+                maxBlocksPerCheckpoint: this.timetable.maxNumberOfBlocks,
+                perBlockAllocationMultiplier: this.config.perBlockAllocationMultiplier
+            };
+            // Actually build the block by executing txs. The builder throws InsufficientValidTxsError
+            // if the number of successfully processed txs is below minValidTxs, ensuring state is not
+            // updated for blocks that will be discarded.
+            const buildResult = await this.buildSingleBlockWithCheckpointBuilder(checkpointBuilder, pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
+            // If any txs failed during execution, drop them from the mempool so we don't pick them up again
+            await this.dropFailedTxsFromP2P(buildResult.failedTxs);
+            if (buildResult.status === 'insufficient-valid-txs') {
+                this.log.warn(`Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.targetSlot} has too few valid txs to be proposed`, {
+                    slot: this.targetSlot,
+                    blockNumber,
+                    numTxs: buildResult.processedCount,
+                    indexWithinCheckpoint,
+                    minValidTxs
+                });
+                this.eventEmitter.emit('block-build-failed', {
+                    reason: `Insufficient valid txs`,
+                    slot: this.targetSlot
+                });
+                this.metrics.recordBlockProposalFailed('insufficient_valid_txs');
+                return {
+                    failure: 'insufficient-valid-txs'
+                };
+            }
+            // Block creation succeeded, emit stats and metrics
+            const { block, publicProcessorDuration, usedTxs, blockBuildDuration, numTxs } = buildResult;
+            const blockStats = {
+                eventName: 'l2-block-built',
+                duration: blockBuildDuration,
+                publicProcessDuration: publicProcessorDuration,
+                ...block.getStats()
+            };
+            const blockHash = await block.hash();
+            const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
+            const manaPerSec = block.header.totalManaUsed.toNumberUnsafe() / (blockBuildDuration / 1000);
+            this.log.info(`Built block ${block.number} at checkpoint ${this.checkpointNumber} for slot ${this.targetSlot} with ${numTxs} txs`, {
+                blockHash,
+                txHashes,
+                manaPerSec,
+                ...blockStats
+            });
+            // `slot` is the target/submission slot (may be one ahead when pipelining),
+            // `buildSlot` is the wall-clock slot during which the block was actually built.
+            this.eventEmitter.emit('block-proposed', {
+                blockNumber: block.number,
+                slot: this.targetSlot,
+                buildSlot: this.slotNow
+            });
+            this.metrics.recordBuiltBlock(blockBuildDuration, block.header.totalManaUsed.toNumberUnsafe(), this.targetSlot);
+            return {
+                block,
+                usedTxs
+            };
+        } catch (err) {
+            this.eventEmitter.emit('block-build-failed', {
+                reason: err.message,
+                slot: this.targetSlot
+            });
+            this.log.error(`Error building block`, err, {
+                blockNumber,
+                slot: this.targetSlot
+            });
+            this.metrics.recordBlockProposalFailed(err.name || 'unknown_error');
+            this.metrics.recordFailedBlock();
+            return {
+                error: err
+            };
+        }
+    }
+    /** Uses the checkpoint builder to build a block, catching InsufficientValidTxsError. */ async buildSingleBlockWithCheckpointBuilder(checkpointBuilder, pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions) {
+        try {
+            const workTimer = new Timer();
+            const result = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
+            const blockBuildDuration = workTimer.ms();
+            return {
+                ...result,
+                blockBuildDuration,
+                status: 'success'
+            };
+        } catch (err) {
+            if (isErrorClass(err, InsufficientValidTxsError)) {
+                return {
+                    failedTxs: err.failedTxs,
+                    processedCount: err.processedCount,
+                    status: 'insufficient-valid-txs'
+                };
+            }
+            throw err;
+        }
+    }
+    /** Waits until minTxs are available on the pool for building a block. */ async waitForMinTxs(opts) {
+        const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
+        // We only allow a block with 0 txs in the first block of the checkpoint
+        const minTxs = indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0 ? 1 : this.config.minTxsPerBlock;
+        // Deadline is undefined if we are not enforcing the timetable, meaning we'll exit immediately when out of time
+        const startBuildingDeadline = buildDeadline ? new Date(buildDeadline.getTime() - this.timetable.minExecutionTime * 1000) : undefined;
+        let availableTxs = await this.p2pClient.getPendingTxCount();
+        while(!forceCreate && availableTxs < minTxs){
+            // If we're past deadline, or we have no deadline, give up
+            const now = this.dateProvider.nowAsDate();
+            if (startBuildingDeadline === undefined || now >= startBuildingDeadline) {
+                return {
+                    canStartBuilding: false,
+                    availableTxs,
+                    minTxs
+                };
+            }
+            // Wait a bit before checking again
+            this.setStateFn(SequencerState.WAITING_FOR_TXS, this.targetSlot);
+            this.log.verbose(`Waiting for enough txs to build block ${blockNumber} at index ${indexWithinCheckpoint} in slot ${this.targetSlot} (have ${availableTxs} but need ${minTxs})`, {
+                blockNumber,
+                slot: this.targetSlot,
+                indexWithinCheckpoint
+            });
+            await this.waitForTxsPollingInterval();
+            availableTxs = await this.p2pClient.getPendingTxCount();
+        }
+        return {
+            canStartBuilding: true,
+            availableTxs,
+            minTxs
+        };
+    }
+    /**
+   * Waits for enough attestations to be collected via p2p.
+   * This is run after all blocks for the checkpoint have been built.
+   */ async waitForAttestations(proposal) {
+        if (this.config.fishermanMode) {
+            this.log.debug('Skipping attestation collection in fisherman mode');
+            return CommitteeAttestationsAndSigners.empty();
+        }
+        const slotNumber = proposal.slotNumber;
+        const { committee, seed, epoch } = await this.epochCache.getCommittee(slotNumber);
+        if (!committee) {
+            throw new Error('No committee when collecting attestations');
+        } else if (committee.length === 0) {
+            this.log.verbose(`Attesting committee is empty`);
+            return CommitteeAttestationsAndSigners.empty();
+        } else {
+            this.log.debug(`Attesting committee length is ${committee.length}`, {
+                committee
+            });
+        }
+        const numberOfRequiredAttestations = computeQuorum(committee.length);
+        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, this.checkpointNumber);
+            return new CommitteeAttestationsAndSigners(orderAttestations(attestations ?? [], committee));
+        }
+        const attestationTimeAllowed = this.config.enforceTimeTable ? this.timetable.getCheckpointAttestationDeadline() : this.l1Constants.slotDuration;
+        const attestationDeadline = new Date((this.getSlotStartBuildTimestamp() + attestationTimeAllowed) * 1000);
+        this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
+        const collectAttestationsTimer = new Timer();
+        let collectedAttestationsCount = 0;
+        try {
+            const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations, attestationDeadline, this.checkpointNumber);
+            collectedAttestationsCount = attestations.length;
+            // Trim attestations to minimum required to save L1 calldata gas
+            const localAddresses = this.validatorClient.getValidatorAddresses();
+            const trimmed = trimAttestations(attestations, numberOfRequiredAttestations, this.attestorAddress, localAddresses);
+            if (trimmed.length < attestations.length) {
+                this.log.debug(`Trimmed attestations from ${attestations.length} to ${trimmed.length} for L1 submission`);
+            }
+            // Rollup contract requires that the signatures are provided in the order of the committee
+            const sorted = orderAttestations(trimmed, committee);
+            // Manipulate the attestations if we've been configured to do so
+            if (this.config.injectFakeAttestation || this.config.injectHighSValueAttestation || this.config.injectUnrecoverableSignatureAttestation || this.config.shuffleAttestationOrdering) {
+                return this.manipulateAttestations(proposal.slotNumber, epoch, seed, committee, sorted);
+            }
+            return new CommitteeAttestationsAndSigners(sorted);
+        } catch (err) {
+            if (err && err instanceof AttestationTimeoutError) {
+                collectedAttestationsCount = err.collectedCount;
+            }
+            throw err;
+        } finally{
+            this.metrics.recordCollectedAttestations(collectedAttestationsCount, collectAttestationsTimer.ms());
+        }
+    }
+    /** Breaks the attestations before publishing based on attack configs */ manipulateAttestations(slotNumber, epoch, seed, committee, attestations) {
+        // Compute the proposer index in the committee, since we dont want to tweak it.
+        // Otherwise, the L1 rollup contract will reject the block outright.
+        const proposerIndex = Number(this.epochCache.computeProposerIndex(slotNumber, epoch, seed, BigInt(committee.length)));
+        if (this.config.injectFakeAttestation || this.config.injectHighSValueAttestation || this.config.injectUnrecoverableSignatureAttestation) {
+            // Find non-empty attestations that are not from the proposer
+            const nonProposerIndices = [];
+            for(let i = 0; i < attestations.length; i++){
+                if (!attestations[i].signature.isEmpty() && i !== proposerIndex) {
+                    nonProposerIndices.push(i);
+                }
+            }
+            if (nonProposerIndices.length > 0) {
+                const targetIndex = nonProposerIndices[randomInt(nonProposerIndices.length)];
+                if (this.config.injectHighSValueAttestation) {
+                    this.log.warn(`Injecting high-s value attestation in checkpoint for slot ${slotNumber} at index ${targetIndex}`);
+                    unfreeze(attestations[targetIndex]).signature = flipSignature(attestations[targetIndex].signature);
+                } else if (this.config.injectUnrecoverableSignatureAttestation) {
+                    this.log.warn(`Injecting unrecoverable signature attestation in checkpoint for slot ${slotNumber} at index ${targetIndex}`);
+                    unfreeze(attestations[targetIndex]).signature = generateUnrecoverableSignature();
+                } else {
+                    this.log.warn(`Injecting fake attestation in checkpoint for slot ${slotNumber} at index ${targetIndex}`);
+                    unfreeze(attestations[targetIndex]).signature = generateRecoverableSignature();
+                }
+            }
+            return new CommitteeAttestationsAndSigners(attestations);
+        }
+        if (this.config.shuffleAttestationOrdering) {
+            this.log.warn(`Shuffling attestation ordering in checkpoint for slot ${slotNumber} (proposer #${proposerIndex})`);
+            const shuffled = [
+                ...attestations
+            ];
+            // Find two non-proposer positions that both have non-empty signatures to swap.
+            // This ensures the bitmap doesn't change, so the MaliciousCommitteeAttestationsAndSigners
+            // signers array stays correctly aligned with L1's committee reconstruction.
+            const swappable = [];
+            for(let k = 0; k < shuffled.length; k++){
+                if (!shuffled[k].signature.isEmpty() && k !== proposerIndex) {
+                    swappable.push(k);
+                }
+            }
+            if (swappable.length >= 2) {
+                const [i, j] = [
+                    swappable[0],
+                    swappable[1]
+                ];
+                [shuffled[i], shuffled[j]] = [
+                    shuffled[j],
+                    shuffled[i]
+                ];
+            }
+            const signers = new CommitteeAttestationsAndSigners(attestations).getSigners();
+            return new MaliciousCommitteeAttestationsAndSigners(shuffled, signers);
+        }
+        return new CommitteeAttestationsAndSigners(attestations);
+    }
+    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.handleFailedExecution(failedTxHashes);
+    }
+    /**
+   * Adds the proposed block to the archiver so it's available via P2P.
+   * Gossip doesn't echo messages back to the sender, so the proposer's archiver/world-state
+   * would never receive its own block without this explicit sync.
+   *
+   * In fisherman mode we skip this push: the fisherman builds blocks locally for validation
+   * and fee analysis only, and pushing them to the archiver causes spurious reorg cascades
+   * whenever the real proposer's block arrives from L1.
+   */ async syncProposedBlockToArchiver(block) {
+        if (this.config.skipPushProposedBlocksToArchiver || this.config.fishermanMode) {
+            this.log.warn(`Skipping push of proposed block ${block.number} to archiver`, {
+                blockNumber: block.number,
+                slot: block.header.globalVariables.slotNumber
+            });
+            return;
+        }
+        this.log.debug(`Syncing proposed block ${block.number} to archiver`, {
+            blockNumber: block.number,
+            slot: block.header.globalVariables.slotNumber
+        });
+        await this.blockSink.addBlock(block);
+    }
+    /** Runs fee analysis and logs checkpoint outcome as fisherman */ async handleCheckpointEndAsFisherman(checkpoint) {
+        // Perform L1 fee analysis before clearing requests
+        // The callback is invoked asynchronously after the next block is mined
+        const feeAnalysis = await this.publisher.analyzeL1Fees(this.targetSlot, (analysis)=>this.metrics.recordFishermanFeeAnalysis(analysis));
+        if (checkpoint) {
+            this.log.info(`Validation checkpoint building SUCCEEDED for slot ${this.targetSlot}`, {
+                ...checkpoint.toCheckpointInfo(),
+                ...checkpoint.getStats(),
+                feeAnalysisId: feeAnalysis?.id
+            });
+        } else {
+            this.log.warn(`Validation block building FAILED for slot ${this.targetSlot}`, {
+                slot: this.targetSlot,
+                feeAnalysisId: feeAnalysis?.id
+            });
+            this.metrics.recordCheckpointProposalFailed('block_build_failed');
+        }
+        this.publisher.clearPendingRequests();
+    }
+    /**
+   * Helper to handle HA double-signing errors. Returns true if the error was handled (caller should yield).
+   */ handleHASigningError(err, errorContext) {
+        if (err instanceof DutyAlreadySignedError) {
+            this.log.info(`${errorContext} for slot ${this.targetSlot} already signed by another HA node, yielding`, {
+                slot: this.targetSlot,
+                signedByNode: err.signedByNode
+            });
+            return true;
+        }
+        if (err instanceof SlashingProtectionError) {
+            this.log.info(`${errorContext} for slot ${this.targetSlot} blocked by slashing protection, yielding`, {
+                slot: this.targetSlot,
+                existingMessageHash: err.existingMessageHash,
+                attemptedMessageHash: err.attemptedMessageHash
+            });
+            return true;
+        }
+        return false;
+    }
+    /** Waits until a specific time within the current slot */ async waitUntilTimeInSlot(targetSecondsIntoSlot) {
+        const slotStartTimestamp = this.getSlotStartBuildTimestamp();
+        const targetTimestamp = slotStartTimestamp + targetSecondsIntoSlot;
+        await sleepUntil(new Date(targetTimestamp * 1000), this.dateProvider.nowAsDate());
+    }
+    /** Waits the polling interval for transactions. Extracted for test overriding. */ async waitForTxsPollingInterval() {
+        await sleep(TXS_POLLING_MS);
+    }
+    getSlotStartBuildTimestamp() {
+        return getSlotStartBuildTimestamp(this.slotNow, this.l1Constants);
+    }
+    getSecondsIntoSlot() {
+        const slotStartTimestamp = this.getSlotStartBuildTimestamp();
+        return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
+    }
+    getPublisher() {
+        return this.publisher;
+    }
+}