@aztec/sequencer-client 0.0.1-commit.c7c42ec → 0.0.1-commit.f295ac2

package/dest/sequencer/checkpoint_proposal_job.js

@@ -63,6 +63,380 @@ function _ts_dispose_resources(env) {
         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 { NUM_CHECKPOINT_END_MARKER_FIELDS, getNumBlockEndBlobFields } from '@aztec/blob-lib/encoding';
 import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { randomInt } from '@aztec/foundation/crypto/random';
@@ -74,31 +448,44 @@ import { unfreeze } from '@aztec/foundation/types';
 import { CommitteeAttestationsAndSigners, MaliciousCommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
 import { getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
+import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { orderAttestations } 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 { 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.slot
+    };
+}), _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 {
+    epoch;
     slot;
     checkpointNumber;
     syncedToBlockNumber;
     proposer;
     publisher;
     attestorAddress;
-    invalidateBlock;
+    invalidateCheckpoint;
     validatorClient;
     globalsBuilder;
     p2pClient;
     worldState;
     l1ToL2MessageSource;
+    l2BlockSource;
     checkpointsBuilder;
+    blockSink;
     l1Constants;
     config;
     timetable;
@@ -109,21 +496,69 @@ import { SequencerState } from './utils.js';
     eventEmitter;
     setStateFn;
     log;
-    constructor(slot, checkpointNumber, syncedToBlockNumber, // TODO(palla/mbps): Can we remove the proposer in favor of attestorAddress? Need to check fisherman-node flows.
-    proposer, publisher, attestorAddress, invalidateBlock, validatorClient, globalsBuilder, p2pClient, worldState, l1ToL2MessageSource, checkpointsBuilder, l1Constants, config, timetable, slasherClient, epochCache, dateProvider, metrics, eventEmitter, setStateFn, log){
+    tracer;
+    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"
+            ]
+        ], []));
+    }
+    constructor(epoch, slot, 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, eventEmitter, setStateFn, log, tracer){
+        this.epoch = epoch;
         this.slot = slot;
         this.checkpointNumber = checkpointNumber;
         this.syncedToBlockNumber = syncedToBlockNumber;
         this.proposer = proposer;
         this.publisher = publisher;
         this.attestorAddress = attestorAddress;
-        this.invalidateBlock = invalidateBlock;
+        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;
@@ -134,6 +569,8 @@ import { SequencerState } from './utils.js';
         this.eventEmitter = eventEmitter;
         this.setStateFn = setStateFn;
         this.log = log;
+        this.tracer = tracer;
+        _initProto(this);
     }
     /**
    * Executes the checkpoint proposal job.
@@ -188,26 +625,60 @@ import { SequencerState } from './utils.js';
                 // Start the checkpoint
                 this.setStateFn(SequencerState.INITIALIZING_CHECKPOINT, this.slot);
                 this.metrics.incOpenSlot(this.slot, this.proposer?.toString() ?? 'unknown');
-                // Enqueues block invalidation (constant for the whole slot)
-                if (this.invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
-                    this.publisher.enqueueInvalidateBlock(this.invalidateBlock);
+                // 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
                 const checkpointGlobalVariables = await this.globalsBuilder.buildCheckpointGlobalVariables(coinbase, feeRecipient, this.slot);
-                // Collect L1 to L2 messages for the checkpoint
+                // 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 previousCheckpoints = (await this.l2BlockSource.getCheckpointsForEpoch(this.epoch)).filter((c)=>c.number < this.checkpointNumber);
+                const previousCheckpointOutHashes = previousCheckpoints.map((c)=>c.getCheckpointOutHash());
                 const fork = _ts_add_disposable_resource(env, await this.worldState.fork(this.syncedToBlockNumber, {
                     closeDelayMs: 12_000
                 }), false);
                 // Create checkpoint builder for the entire slot
-                const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(this.checkpointNumber, checkpointGlobalVariables, l1ToL2Messages, fork);
+                const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(this.checkpointNumber, checkpointGlobalVariables, l1ToL2Messages, previousCheckpointOutHashes, fork);
                 // Options for the validator client when creating block and checkpoint proposals
                 const blockProposalOptions = {
                     publishFullTxs: !!this.config.publishTxsWithProposals,
                     broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
                 };
-                // Main loop: build blocks for the checkpoint
-                const { blocksInCheckpoint, pendingBroadcast } = await this.buildBlocksForCheckpoint(checkpointBuilder, checkpointGlobalVariables.timestamp, blockProposalOptions);
+                const checkpointProposalOptions = {
+                    publishFullTxs: !!this.config.publishTxsWithProposals,
+                    broadcastInvalidCheckpointProposal: this.config.broadcastInvalidBlockProposal
+                };
+                let blocksInCheckpoint = [];
+                let blockPendingBroadcast = undefined;
+                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 (err instanceof DutyAlreadySignedError) {
+                        this.log.info(`Checkpoint proposal for slot ${this.slot} already signed by another HA node, yielding`, {
+                            slot: this.slot,
+                            signedByNode: err.signedByNode
+                        });
+                        return undefined;
+                    }
+                    if (err instanceof SlashingProtectionError) {
+                        this.log.info(`Checkpoint proposal for slot ${this.slot} blocked by slashing protection, yielding`, {
+                            slot: this.slot,
+                            existingMessageHash: err.existingMessageHash,
+                            attemptedMessageHash: err.attemptedMessageHash
+                        });
+                        return undefined;
+                    }
+                    throw err;
+                }
                 if (blocksInCheckpoint.length === 0) {
                     this.log.warn(`No blocks were built for slot ${this.slot}`, {
                         slot: this.slot
@@ -231,17 +702,45 @@ import { SequencerState } from './utils.js';
                     this.metrics.recordCheckpointSuccess();
                     return checkpoint;
                 }
-                // TODO(palla/mbps): Wire this to the new p2p API once available, including the pendingBroadcast.block
-                const proposal = await this.validatorClient.createCheckpointProposal(checkpoint.header, checkpoint.archive.root, pendingBroadcast?.txs ?? [], this.proposer, blockProposalOptions);
+                // Include the block pending broadcast in the checkpoint proposal if any
+                const lastBlock = blockPendingBroadcast && {
+                    blockHeader: blockPendingBroadcast.block.header,
+                    indexWithinCheckpoint: blockPendingBroadcast.block.indexWithinCheckpoint,
+                    txs: blockPendingBroadcast.txs
+                };
+                // Create the checkpoint proposal and broadcast it
+                const proposal = await this.validatorClient.createCheckpointProposal(checkpoint.header, checkpoint.archive.root, lastBlock, this.proposer, checkpointProposalOptions);
                 const blockProposedAt = this.dateProvider.now();
-                await this.p2pClient.broadcastProposal(proposal);
+                await this.p2pClient.broadcastCheckpointProposal(proposal);
                 this.setStateFn(SequencerState.COLLECTING_ATTESTATIONS, this.slot);
                 const attestations = await this.waitForAttestations(proposal);
                 const blockAttestedAt = this.dateProvider.now();
-                this.metrics.recordBlockAttestationDelay(blockAttestedAt - blockProposedAt);
+                this.metrics.recordCheckpointAttestationDelay(blockAttestedAt - blockProposedAt);
                 // Proposer must sign over the attestations before pushing them to L1
                 const signer = this.proposer ?? this.publisher.getSenderAddress();
-                const attestationsSignature = await this.validatorClient.signAttestationsAndSigners(attestations, signer);
+                let attestationsSignature;
+                try {
+                    attestationsSignature = await this.validatorClient.signAttestationsAndSigners(attestations, signer, this.slot, this.checkpointNumber);
+                } catch (err) {
+                    // We shouldn't really get here since we yield to another HA node
+                    // as soon as we see these errors when creating block proposals.
+                    if (err instanceof DutyAlreadySignedError) {
+                        this.log.info(`Attestations signature for slot ${this.slot} already signed by another HA node, yielding`, {
+                            slot: this.slot,
+                            signedByNode: err.signedByNode
+                        });
+                        return undefined;
+                    }
+                    if (err instanceof SlashingProtectionError) {
+                        this.log.info(`Attestations signature for slot ${this.slot} blocked by slashing protection, yielding`, {
+                            slot: this.slot,
+                            existingMessageHash: err.existingMessageHash,
+                            attemptedMessageHash: err.attemptedMessageHash
+                        });
+                        return undefined;
+                    }
+                    throw err;
+                }
                 // Enqueue publishing the checkpoint to L1
                 this.setStateFn(SequencerState.PUBLISHING_CHECKPOINT, this.slot);
                 const aztecSlotDuration = this.l1Constants.slotDuration;
@@ -249,7 +748,7 @@ import { SequencerState } from './utils.js';
                 const txTimeoutAt = new Date((slotStartBuildTimestamp + aztecSlotDuration) * 1000);
                 await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, {
                     txTimeoutAt,
-                    forcePendingBlockNumber: this.invalidateBlock?.forcePendingBlockNumber
+                    forcePendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber
                 });
                 return checkpoint;
             } catch (e) {
@@ -265,12 +764,14 @@ import { SequencerState } from './utils.js';
     }
     /**
    * Builds blocks for a checkpoint within the current slot.
-   */ async buildBlocksForCheckpoint(checkpointBuilder, timestamp, blockProposalOptions) {
+   */ async buildBlocksForCheckpoint(checkpointBuilder, timestamp, inHash, blockProposalOptions) {
         const blocksInCheckpoint = [];
         const txHashesAlreadyIncluded = new Set();
         const initialBlockNumber = BlockNumber(this.syncedToBlockNumber + 1);
+        // Remaining blob fields available for blocks (checkpoint end marker already subtracted)
+        let remainingBlobFields = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
         // Last block in the checkpoint will usually be flagged as pending broadcast, so we send it along with the checkpoint proposal
-        let pendingBroadcast = undefined;
+        let blockPendingBroadcast = undefined;
         while(true){
             const blocksBuilt = blocksInCheckpoint.length;
             const indexWithinCheckpoint = blocksBuilt;
@@ -294,7 +795,8 @@ import { SequencerState } from './utils.js';
                 buildDeadline: timingInfo.deadline ? new Date((this.getSlotStartBuildTimestamp() + timingInfo.deadline) * 1000) : undefined,
                 blockNumber,
                 indexWithinCheckpoint,
-                txHashesAlreadyIncluded
+                txHashesAlreadyIncluded,
+                remainingBlobFields
             });
             if (!buildResult && timingInfo.isLastBlock) {
                 break;
@@ -315,8 +817,10 @@ import { SequencerState } from './utils.js';
                 }
                 break;
             }
-            const { block, usedTxs } = buildResult;
+            const { block, usedTxs, remainingBlobFields: newRemainingBlobFields } = buildResult;
             blocksInCheckpoint.push(block);
+            // Update remaining blob fields for the next block
+            remainingBlobFields = newRemainingBlobFields;
             // Sync the proposed block to the archiver to make it available
             // Note that the checkpoint builder uses its own fork so it should not need to wait for this syncing
             // Eventually we should refactor the checkpoint builder to not need a separate long-lived fork
@@ -328,7 +832,7 @@ import { SequencerState } from './utils.js';
                     blockNumber,
                     blocksBuilt
                 });
-                pendingBroadcast = {
+                blockPendingBroadcast = {
                     block,
                     txs: usedTxs
                 };
@@ -337,8 +841,7 @@ import { SequencerState } from './utils.js';
             // For non-last blocks, broadcast the block proposal (unless we're in fisherman mode)
             // If the block is the last one, we'll broadcast it along with the checkpoint at the end of the loop
             if (!this.config.fishermanMode) {
-                // TODO(palla/mbps): Wire this to the new p2p API once available
-                const proposal = await this.validatorClient.createBlockProposal(block.header.globalVariables.blockNumber, (await checkpointBuilder.getCheckpoint()).header, block.archive.root, usedTxs, this.proposer, blockProposalOptions);
+                const proposal = await this.validatorClient.createBlockProposal(block.header, block.indexWithinCheckpoint, inHash, block.archive.root, usedTxs, this.proposer, blockProposalOptions);
                 await this.p2pClient.broadcastProposal(proposal);
             }
             // Wait until the next block's start time
@@ -350,7 +853,7 @@ import { SequencerState } from './utils.js';
         });
         return {
             blocksInCheckpoint,
-            pendingBroadcast
+            blockPendingBroadcast
         };
     }
     /** Sleeps until it is time to produce the next block in the slot */ async waitUntilNextSubslot(nextSubslotStart) {
@@ -361,7 +864,7 @@ import { SequencerState } from './utils.js';
         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;
+        const { blockTimestamp, forceCreate, blockNumber, indexWithinCheckpoint, buildDeadline, txHashesAlreadyIncluded, remainingBlobFields } = opts;
         this.log.verbose(`Preparing block ${blockNumber} index ${indexWithinCheckpoint} at checkpoint ${this.checkpointNumber} for slot ${this.slot}`, {
             ...checkpointBuilder.getConstantData(),
             ...opts
@@ -393,16 +896,19 @@ import { SequencerState } from './utils.js';
                 indexWithinCheckpoint
             });
             this.setStateFn(SequencerState.CREATING_BLOCK, this.slot);
+            // Calculate blob fields limit for txs (remaining capacity - this block's end overhead)
+            const blockEndOverhead = getNumBlockEndBlobFields(indexWithinCheckpoint === 0);
+            const maxBlobFieldsForTxs = remainingBlobFields - blockEndOverhead;
             const blockBuilderOptions = {
                 maxTransactions: this.config.maxTxsPerBlock,
                 maxBlockSize: this.config.maxBlockSizeInBytes,
                 maxBlockGas: new Gas(this.config.maxDABlockGas, this.config.maxL2BlockGas),
-                maxBlobFields: BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB,
+                maxBlobFields: maxBlobFieldsForTxs,
                 deadline: buildDeadline
             };
             // Actually build the block by executing txs
             const workTimer = new Timer();
-            const { publicGas, block, publicProcessorDuration, numTxs, blockBuildingTimer, usedTxs, failedTxs } = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
+            const { publicGas, block, publicProcessorDuration, numTxs, blockBuildingTimer, usedTxs, failedTxs, usedTxBlobFields } = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
             const blockBuildDuration = workTimer.ms();
             // If any txs failed during execution, drop them from the mempool so we don't pick them up again
             await this.dropFailedTxsFromP2P(failedTxs);
@@ -448,7 +954,8 @@ import { SequencerState } from './utils.js';
             this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
             return {
                 block,
-                usedTxs
+                usedTxs,
+                remainingBlobFields: maxBlobFieldsForTxs - usedTxBlobFields
             };
         } catch (err) {
             this.eventEmitter.emit('block-build-failed', {
@@ -534,8 +1041,7 @@ import { SequencerState } from './utils.js';
             const sorted = orderAttestations(attestations, committee);
             // Manipulate the attestations if we've been configured to do so
             if (this.config.injectFakeAttestation || this.config.shuffleAttestationOrdering) {
-                const checkpoint = proposal.payload.header;
-                return this.manipulateAttestations(checkpoint, epoch, seed, committee, sorted);
+                return this.manipulateAttestations(proposal.slotNumber, epoch, seed, committee, sorted);
             }
             return new CommitteeAttestationsAndSigners(sorted);
         } catch (err) {
@@ -547,10 +1053,9 @@ import { SequencerState } from './utils.js';
             this.metrics.recordCollectedAttestations(collectedAttestationsCount, collectAttestationsTimer.ms());
         }
     }
-    /** Breaks the attestations before publishing based on attack configs */ manipulateAttestations(checkpoint, epoch, seed, committee, attestations) {
+    /** 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 { slotNumber } = checkpoint;
         const proposerIndex = Number(this.epochCache.computeProposerIndex(slotNumber, epoch, seed, BigInt(committee.length)));
         if (this.config.injectFakeAttestation) {
             // Find non-empty attestations that are not from the proposer
@@ -595,15 +1100,23 @@ import { SequencerState } from './utils.js';
         await this.p2pClient.deleteTxs(failedTxHashes);
     }
     /**
-   * Placeholder for pushing block to archiver and waiting for sync.
-   * To be implemented when archiver and world-state support proposed blocks.
+   * 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.
    */ async syncProposedBlockToArchiver(block) {
-        this.log.debug(`Syncing proposed block ${block.number}`, {
+        // TODO(palla/mbps): Change default to false once block sync is stable.
+        if (this.config.skipPushProposedBlocksToArchiver !== false) {
+            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
         });
-        // TODO(palla/mbps): Implement actual sync to archiver and world-state
-        await Promise.resolve();
+        await this.blockSink.addBlock(block);
     }
     /** Runs fee analysis and logs checkpoint outcome as fisherman */ async handleCheckpointEndAsFisherman(checkpoint) {
         // Perform L1 fee analysis before clearing requests