@aztec/sequencer-client 1.2.1 → 2.0.0-nightly.20250814

package/dest/sequencer/sequencer.js

@@ -6,8 +6,7 @@ function _ts_decorate(decorators, target, key, desc) {
 }
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { FormattedViemError, NoCommitteeError } from '@aztec/ethereum';
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { omit } from '@aztec/foundation/collection';
+import { omit, pick } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
@@ -17,16 +16,17 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
+import { orderAttestations } from '@aztec/stdlib/p2p';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { ContentCommitment, ProposedBlockHeader, Tx } from '@aztec/stdlib/tx';
+import { ContentCommitment, ProposedBlockHeader } from '@aztec/stdlib/tx';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { Attributes, L1Metrics, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import EventEmitter from 'node:events';
-import { VoteType } from '../publisher/sequencer-publisher.js';
+import { SignalType } from '../publisher/sequencer-publisher.js';
 import { SequencerMetrics } from './metrics.js';
 import { SequencerTimetable, SequencerTooSlowError } from './timetable.js';
-import { SequencerState, orderAttestations } from './utils.js';
+import { SequencerState } from './utils.js';
 export { SequencerState };
 /**
  * Sequencer client
@@ -65,17 +65,18 @@ export { SequencerState };
     metrics;
     l1Metrics;
     lastBlockPublished;
-    isFlushing;
     /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */ timetable;
     enforceTimeTable;
     constructor(publisher, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, l2BlockSource, l1ToL2MessageSource, blockBuilder, l1Constants, dateProvider, config = {}, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
-        super(), this.publisher = publisher, this.validatorClient = validatorClient, this.globalsBuilder = globalsBuilder, this.p2pClient = p2pClient, this.worldState = worldState, this.slasherClient = slasherClient, this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.blockBuilder = blockBuilder, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.config = config, this.telemetry = telemetry, this.log = log, this.pollingIntervalMs = 1000, this.maxTxsPerBlock = 32, this.minTxsPerBlock = 1, this.maxL1TxInclusionTimeIntoSlot = 0, this._coinbase = EthAddress.ZERO, this._feeRecipient = AztecAddress.ZERO, this.state = SequencerState.STOPPED, this.maxBlockSizeInBytes = 1024 * 1024, this.maxBlockGas = new Gas(100e9, 100e9), this.isFlushing = false, this.enforceTimeTable = false;
+        super(), this.publisher = publisher, this.validatorClient = validatorClient, this.globalsBuilder = globalsBuilder, this.p2pClient = p2pClient, this.worldState = worldState, this.slasherClient = slasherClient, this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.blockBuilder = blockBuilder, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.config = config, this.telemetry = telemetry, this.log = log, this.pollingIntervalMs = 1000, this.maxTxsPerBlock = 32, this.minTxsPerBlock = 1, this.maxL1TxInclusionTimeIntoSlot = 0, this._coinbase = EthAddress.ZERO, this._feeRecipient = AztecAddress.ZERO, this.state = SequencerState.STOPPED, this.maxBlockSizeInBytes = 1024 * 1024, this.maxBlockGas = new Gas(100e9, 100e9), this.enforceTimeTable = false;
         this.metrics = new SequencerMetrics(telemetry, ()=>this.state, this.config.coinbase ?? this.publisher.getSenderAddress(), this.publisher.getRollupContract(), 'Sequencer');
         this.l1Metrics = new L1Metrics(telemetry.getMeter('SequencerL1Metrics'), publisher.l1TxUtils.client, [
             publisher.getSenderAddress()
         ]);
         // Register the slasher on the publisher to fetch slashing payloads
         this.publisher.registerSlashPayloadGetter(this.slasherClient.getSlashPayload.bind(this.slasherClient));
+        // Initialize config
+        this.updateConfig(this.config);
     }
     get tracer() {
         return this.metrics.tracer;
@@ -83,6 +84,9 @@ export { SequencerState };
     getValidatorAddresses() {
         return this.validatorClient?.getValidatorAddresses();
     }
+    getConfig() {
+        return this.config;
+    }
     /**
    * Updates sequencer config by the defined values in the config on input.
    * @param config - New parameters.
@@ -128,18 +132,22 @@ export { SequencerState };
         Object.assign(this.config, config);
     }
     setTimeTable() {
-        this.timetable = new SequencerTimetable(this.l1Constants.ethereumSlotDuration, this.aztecSlotDuration, this.maxL1TxInclusionTimeIntoSlot, this.enforceTimeTable, this.metrics, this.log);
-        this.log.verbose(`Sequencer timetable updated`, {
-            enforceTimeTable: this.enforceTimeTable
-        });
+        this.timetable = new SequencerTimetable({
+            ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
+            aztecSlotDuration: this.aztecSlotDuration,
+            maxL1TxInclusionTimeIntoSlot: this.maxL1TxInclusionTimeIntoSlot,
+            attestationPropagationTime: this.config.attestationPropagationTime,
+            enforce: this.enforceTimeTable
+        }, this.metrics, this.log);
     }
     /**
    * Starts the sequencer and moves to IDLE state.
    */ start() {
-        this.updateConfig(this.config);
         this.metrics.start();
         this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollingIntervalMs);
-        this.setState(SequencerState.IDLE, 0n, true);
+        this.setState(SequencerState.IDLE, undefined, {
+            force: true
+        });
         this.runningPromise.start();
         this.l1Metrics.start();
         this.log.info(`Sequencer started with address ${this.publisher.getSenderAddress().toString()}`);
@@ -147,12 +155,14 @@ export { SequencerState };
     /**
    * Stops the sequencer from processing txs and moves to STOPPED state.
    */ async stop() {
-        this.log.debug(`Stopping sequencer`);
+        this.log.info(`Stopping sequencer`);
         this.metrics.stop();
         await this.validatorClient?.stop();
         await this.runningPromise?.stop();
         this.publisher.interrupt();
-        this.setState(SequencerState.STOPPED, 0n, true);
+        this.setState(SequencerState.STOPPED, undefined, {
+            force: true
+        });
         this.l1Metrics.stop();
         this.log.info('Stopped sequencer');
     }
@@ -162,7 +172,9 @@ export { SequencerState };
         this.log.info('Restarting sequencer');
         this.publisher.restart();
         this.runningPromise.start();
-        this.setState(SequencerState.IDLE, 0n, true);
+        this.setState(SequencerState.IDLE, undefined, {
+            force: true
+        });
     }
     /**
    * Returns the current state of the sequencer.
@@ -172,9 +184,6 @@ export { SequencerState };
             state: this.state
         };
     }
-    /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */ flush() {
-        this.isFlushing = true;
-    }
     /**
    * @notice  Performs most of the sequencer duties:
    *          - Checks if we are up to date
@@ -183,14 +192,14 @@ export { SequencerState };
    *          - Submit block
    *          - If our block for some reason is not included, revert the state
    */ async doRealWork() {
-        this.setState(SequencerState.SYNCHRONIZING, 0n);
+        this.setState(SequencerState.SYNCHRONIZING, undefined);
         // Check all components are synced to latest as seen by the archiver
         const syncedTo = await this.getChainTip();
         // Do not go forward with new block if the previous one has not been mined and processed
         if (!syncedTo) {
             return;
         }
-        this.setState(SequencerState.PROPOSER_CHECK, 0n);
+        this.setState(SequencerState.PROPOSER_CHECK, undefined);
         const chainTipArchive = syncedTo.archive;
         const newBlockNumber = syncedTo.blockNumber + 1;
         const { slot, ts, now } = this.publisher.epochCache.getEpochAndSlotInNextL1Slot();
@@ -204,7 +213,9 @@ export { SequencerState };
             syncedToL2Slot: getSlotAtTimestamp(syncedTo.l1Timestamp, this.l1Constants),
             nextL2Slot: slot,
             nextL2SlotTs: ts,
-            l1SlotDuration: this.l1Constants.ethereumSlotDuration
+            l1SlotDuration: this.l1Constants.ethereumSlotDuration,
+            newBlockNumber,
+            isPendingChainValid: pick(syncedTo.pendingChainValidationStatus, 'valid', 'reason', 'invalidIndex')
         };
         if (syncedTo.l1Timestamp + BigInt(this.l1Constants.ethereumSlotDuration) < ts) {
             this.log.debug(`Cannot propose block ${newBlockNumber} at next L2 slot ${slot} due to pending sync from L1`, syncLogData);
@@ -226,32 +237,37 @@ export { SequencerState };
             });
             return;
         }
+        // Check that we are a proposer for the next slot
         let proposerInNextSlot;
         try {
-            // Check that we are a proposer for the next slot
             proposerInNextSlot = await this.publisher.epochCache.getProposerAttesterAddressInNextSlot();
         } catch (e) {
             if (e instanceof NoCommitteeError) {
-                this.log.warn(`Cannot propose block ${newBlockNumber} since the committee does not exist on L1`);
+                this.log.warn(`Cannot propose block ${newBlockNumber} at next L2 slot ${slot} since the committee does not exist on L1`);
                 return;
             }
         }
-        const validatorAddresses = this.validatorClient.getValidatorAddresses();
         // If get proposer in next slot is undefined, then the committee is empty and anyone may propose.
-        // If the committee is defined and not empty, but none of our validators are the proposer,
-        // then stop.
+        // If the committee is defined and not empty, but none of our validators are the proposer, then stop.
+        const validatorAddresses = this.validatorClient.getValidatorAddresses();
         if (proposerInNextSlot !== undefined && !validatorAddresses.some((addr)=>addr.equals(proposerInNextSlot))) {
             this.log.debug(`Cannot propose block ${newBlockNumber} since we are not a proposer`, {
                 us: validatorAddresses,
                 proposer: proposerInNextSlot,
                 ...syncLogData
             });
+            // If the pending chain is invalid, we may need to invalidate the block if no one else is doing it.
+            if (!syncedTo.pendingChainValidationStatus.valid) {
+                await this.considerInvalidatingBlock(syncedTo, slot, validatorAddresses);
+            }
             return;
         }
-        // Double check we are good for proposing at the next block before we start operations.
-        // We should never fail this check assuming the logic above is good.
+        // Prepare invalidation request if the pending chain is invalid (returns undefined if no need)
+        const invalidateBlock = await this.publisher.simulateInvalidateBlock(syncedTo.pendingChainValidationStatus);
+        // Check with the rollup if we can indeed propose at the next L2 slot. This check should not fail
+        // if all the previous checks are good, but we do it just in case.
         const proposerAddress = proposerInNextSlot ?? EthAddress.ZERO;
-        const canProposeCheck = await this.publisher.canProposeAtNextEthBlock(chainTipArchive.toBuffer(), proposerAddress);
+        const canProposeCheck = await this.publisher.canProposeAtNextEthBlock(chainTipArchive, proposerAddress, invalidateBlock);
         if (canProposeCheck === undefined) {
             this.log.warn(`Cannot propose block ${newBlockNumber} at slot ${slot} due to failed rollup contract check`, syncLogData);
             this.emit('proposer-rollup-check-failed', {
@@ -281,13 +297,16 @@ export { SequencerState };
             });
             return;
         }
-        this.log.debug(`${proposerInNextSlot ? `Validator ${proposerInNextSlot.toString()} can` : 'Can'} propose block ${newBlockNumber} at slot ${slot}`, {
+        this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot}` + (proposerInNextSlot ? ` as ${proposerInNextSlot}` : ''), {
             ...syncLogData,
             validatorAddresses
         });
         const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(newBlockNumber, this.coinbase, this._feeRecipient, slot);
-        const enqueueGovernanceVotePromise = this.publisher.enqueueCastVote(slot, newGlobalVariables.timestamp, VoteType.GOVERNANCE, proposerAddress, (msg)=>this.validatorClient.signWithAddress(proposerAddress, Buffer32.fromString(msg)).then((s)=>s.toString()));
-        const enqueueSlashingVotePromise = this.publisher.enqueueCastVote(slot, newGlobalVariables.timestamp, VoteType.SLASHING, proposerAddress, (msg)=>this.validatorClient.signWithAddress(proposerAddress, Buffer32.fromString(msg)).then((s)=>s.toString()));
+        const enqueueGovernanceVotePromise = this.publisher.enqueueCastSignal(slot, newGlobalVariables.timestamp, SignalType.GOVERNANCE, proposerAddress, (msg)=>this.validatorClient.signWithAddress(proposerAddress, msg).then((s)=>s.toString()));
+        const enqueueSlashingVotePromise = this.publisher.enqueueCastSignal(slot, newGlobalVariables.timestamp, SignalType.SLASHING, proposerAddress, (msg)=>this.validatorClient.signWithAddress(proposerAddress, msg).then((s)=>s.toString()));
+        if (invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
+            this.publisher.enqueueInvalidateBlock(invalidateBlock);
+        }
         this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
         this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
             proposer: proposerInNextSlot?.toString(),
@@ -304,15 +323,14 @@ export { SequencerState };
             contentCommitment: ContentCommitment.empty(),
             totalManaUsed: Fr.ZERO
         });
-        let finishedFlushing = false;
         let block;
         const pendingTxCount = await this.p2pClient.getPendingTxCount();
-        if (pendingTxCount >= this.minTxsPerBlock || this.isFlushing) {
+        if (pendingTxCount >= this.minTxsPerBlock) {
             // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
             // and also we may need to fetch more if we don't have enough valid txs.
             const pendingTxs = this.p2pClient.iteratePendingTxs();
             try {
-                block = await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerInNextSlot);
+                block = await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerInNextSlot, invalidateBlock);
             } catch (err) {
                 this.emit('block-build-failed', {
                     reason: err.message
@@ -325,8 +343,6 @@ export { SequencerState };
                         slot
                     });
                 }
-            } finally{
-                finishedFlushing = true;
             }
         } else {
             this.log.verbose(`Not enough txs to build block ${newBlockNumber} at slot ${slot} (got ${pendingTxCount} txs, need ${this.minTxsPerBlock})`, {
@@ -352,7 +368,7 @@ export { SequencerState };
             });
         });
         const l1Response = await this.publisher.sendRequests();
-        const proposedBlock = l1Response?.validActions.find((a)=>a === 'propose');
+        const proposedBlock = l1Response?.successfulActions.find((a)=>a === 'propose');
         if (proposedBlock) {
             this.lastBlockPublished = block;
             this.emit('block-published', {
@@ -360,16 +376,10 @@ export { SequencerState };
                 slot: Number(slot)
             });
             this.metrics.incFilledSlot(this.publisher.getSenderAddress().toString());
-            if (finishedFlushing) {
-                this.isFlushing = false;
-            }
         } else if (block) {
-            this.emit('block-publish-failed', {
-                validActions: l1Response?.validActions,
-                expiredActions: l1Response?.expiredActions
-            });
+            this.emit('block-publish-failed', l1Response ?? {});
         }
-        this.setState(SequencerState.IDLE, 0n);
+        this.setState(SequencerState.IDLE, undefined);
     }
     async work() {
         try {
@@ -382,28 +392,28 @@ export { SequencerState };
                 throw err;
             }
         } finally{
-            this.setState(SequencerState.IDLE, 0n);
+            this.setState(SequencerState.IDLE, undefined);
         }
     }
-    /**
-   * Sets the sequencer state and checks if we have enough time left in the slot to transition to the new state.
-   * @param proposedState - The new state to transition to.
-   * @param currentSlotNumber - The current slot number.
-   * @param force - Whether to force the transition even if the sequencer is stopped.
-   *
-   * @dev If the `currentSlotNumber` doesn't matter (e.g. transitioning to IDLE), pass in `0n`;
-   * it is only used to check if we have enough time left in the slot to transition to the new state.
-   */ setState(proposedState, currentSlotNumber, force = false) {
-        if (this.state === SequencerState.STOPPED && force !== true) {
+    setState(proposedState, slotNumber, opts = {}) {
+        if (this.state === SequencerState.STOPPED && !opts.force) {
             this.log.warn(`Cannot set sequencer from ${this.state} to ${proposedState} as it is stopped.`);
             return;
         }
-        const secondsIntoSlot = this.getSecondsIntoSlot(currentSlotNumber);
-        this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
-        this.log.debug(`Transitioning from ${this.state} to ${proposedState}`);
+        let secondsIntoSlot = undefined;
+        if (slotNumber !== undefined) {
+            secondsIntoSlot = this.getSecondsIntoSlot(slotNumber);
+            this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
+        }
+        this.log.debug(`Transitioning from ${this.state} to ${proposedState}`, {
+            slotNumber,
+            secondsIntoSlot
+        });
         this.emit('state-changed', {
             oldState: this.state,
-            newState: proposedState
+            newState: proposedState,
+            secondsIntoSlot,
+            slotNumber
         });
         this.state = proposedState;
     }
@@ -412,16 +422,16 @@ export { SequencerState };
             return;
         }
         const failedTxData = failedTxs.map((fail)=>fail.tx);
-        const failedTxHashes = await Tx.getHashes(failedTxData);
+        const failedTxHashes = failedTxData.map((tx)=>tx.getTxHash());
         this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
         await this.p2pClient.deleteTxs(failedTxHashes);
     }
-    getDefaultBlockBuilderOptions(slot) {
+    getBlockBuilderOptions(slot) {
         // Deadline for processing depends on whether we're proposing a block
         const secondsIntoSlot = this.getSecondsIntoSlot(slot);
         const processingEndTimeWithinSlot = this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
         // Deadline is only set if enforceTimeTable is enabled.
-        const deadline = this.enforceTimeTable ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000) : undefined;
+        const deadline = this.enforceTimeTable ? new Date((this.getSlotStartBuildTimestamp(slot) + processingEndTimeWithinSlot) * 1000) : undefined;
         return {
             maxTransactions: this.maxTxsPerBlock,
             maxBlockSize: this.maxBlockSizeInBytes,
@@ -439,8 +449,8 @@ export { SequencerState };
    * @param proposalHeader - The partial header constructed for the proposal
    * @param newGlobalVariables - The global variables for the new block
    * @param proposerAddress - The address of the proposer
-   */ async buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerAddress) {
-        await this.publisher.validateBlockHeader(proposalHeader);
+   */ async buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerAddress, invalidateBlock) {
+        await this.publisher.validateBlockHeader(proposalHeader, invalidateBlock);
         const blockNumber = newGlobalVariables.blockNumber;
         const slot = proposalHeader.slotNumber.toBigInt();
         const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
@@ -448,12 +458,12 @@ export { SequencerState };
         const workTimer = new Timer();
         this.setState(SequencerState.CREATING_BLOCK, slot);
         try {
-            const blockBuilderOptions = this.getDefaultBlockBuilderOptions(Number(slot));
+            const blockBuilderOptions = this.getBlockBuilderOptions(Number(slot));
             const buildBlockRes = await this.blockBuilder.buildBlock(pendingTxs, l1ToL2Messages, newGlobalVariables, blockBuilderOptions);
             const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer, usedTxs, failedTxs } = buildBlockRes;
             const blockBuildDuration = workTimer.ms();
             await this.dropFailedTxsFromP2P(failedTxs);
-            const minTxsPerBlock = this.isFlushing ? 0 : this.minTxsPerBlock;
+            const minTxsPerBlock = this.minTxsPerBlock;
             if (numTxs < minTxsPerBlock) {
                 this.log.warn(`Block ${blockNumber} has too few txs to be proposed (got ${numTxs} but required ${minTxsPerBlock})`, {
                     slot,
@@ -464,7 +474,7 @@ export { SequencerState };
             }
             // TODO(@PhilWindle) We should probably periodically check for things like another
             // block being published before ours instead of just waiting on our block
-            await this.publisher.validateBlockHeader(block.header.toPropose());
+            await this.publisher.validateBlockHeader(block.header.toPropose(), invalidateBlock);
             const blockStats = {
                 eventName: 'l2-block-built',
                 creator: this.publisher.getSenderAddress().toString(),
@@ -489,7 +499,7 @@ export { SequencerState };
                     blockNumber
                 });
             }
-            await this.enqueuePublishL2Block(block, attestations, txHashes);
+            await this.enqueuePublishL2Block(block, attestations, txHashes, invalidateBlock);
             this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
             return block;
         } catch (err) {
@@ -498,8 +508,7 @@ export { SequencerState };
         }
     }
     async collectAttestations(block, txs, proposerAddress) {
-        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962): inefficient to have a round trip in here - this should be cached
-        const committee = await this.publisher.getCurrentEpochCommittee();
+        const { committee } = await this.publisher.epochCache.getCommittee(block.header.getSlot());
         // We checked above that the committee is defined, so this should never happen.
         if (!committee) {
             throw new Error('No committee when collecting attestations');
@@ -524,8 +533,12 @@ export { SequencerState };
         };
         const proposal = await this.validatorClient.createBlockProposal(block.header.globalVariables.blockNumber, block.header.toPropose(), block.archive.root, block.header.state, txs, proposerAddress, blockProposalOptions);
         if (!proposal) {
-            const msg = `Failed to create block proposal`;
-            throw new Error(msg);
+            throw new Error(`Failed to create block proposal`);
+        }
+        if (this.config.skipCollectingAttestations) {
+            this.log.warn('Skipping attestation collection as per config (attesting with own keys only)');
+            const attestations = await this.validatorClient?.collectOwnAttestations(proposal);
+            return orderAttestations(attestations ?? [], committee);
         }
         this.log.debug('Broadcasting block proposal to validators');
         await this.validatorClient.broadcastBlockProposal(proposal);
@@ -551,14 +564,15 @@ export { SequencerState };
     /**
    * Publishes the L2Block to the rollup contract.
    * @param block - The L2Block to be published.
-   */ async enqueuePublishL2Block(block, attestations, txHashes) {
+   */ async enqueuePublishL2Block(block, attestations, txHashes, invalidateBlock) {
         // Publishes new block to the network and awaits the tx to be mined
         this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
         // Time out tx at the end of the slot
         const slot = block.header.globalVariables.slotNumber.toNumber();
-        const txTimeoutAt = new Date((this.getSlotStartTimestamp(slot) + this.aztecSlotDuration) * 1000);
+        const txTimeoutAt = new Date((this.getSlotStartBuildTimestamp(slot) + this.aztecSlotDuration) * 1000);
         const enqueued = await this.publisher.enqueueProposeL2Block(block, attestations, txHashes, {
-            txTimeoutAt
+            txTimeoutAt,
+            forcePendingBlockNumber: invalidateBlock?.forcePendingBlockNumber
         });
         if (!enqueued) {
             throw new Error(`Failed to enqueue publish of block ${block.number}`);
@@ -577,9 +591,10 @@ export { SequencerState };
             this.l2BlockSource.getL2Tips().then((t)=>t.latest),
             this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
             this.l1ToL2MessageSource.getL2Tips().then((t)=>t.latest),
-            this.l2BlockSource.getL1Timestamp()
+            this.l2BlockSource.getL1Timestamp(),
+            this.l2BlockSource.getPendingChainValidationStatus()
         ]);
-        const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, l1Timestamp] = syncedBlocks;
+        const [worldState, l2BlockSource, p2p, l1ToL2MessageSource, l1Timestamp, pendingChainValidationStatus] = syncedBlocks;
         // The archiver reports 'undefined' hash for the genesis block
         // because it doesn't have access to world state to compute it (facepalm)
         const result = l2BlockSource.hash === undefined ? worldState.number === 0 && p2p.number === 0 && l1ToL2MessageSource.number === 0 : worldState.hash === l2BlockSource.hash && p2p.hash === l2BlockSource.hash && l1ToL2MessageSource.hash === l2BlockSource.hash;
@@ -605,22 +620,63 @@ export { SequencerState };
                 block,
                 blockNumber: block.number,
                 archive: block.archive.root,
-                l1Timestamp
+                l1Timestamp,
+                pendingChainValidationStatus
             };
         } else {
             const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
             return {
                 blockNumber: INITIAL_L2_BLOCK_NUM - 1,
                 archive,
-                l1Timestamp
+                l1Timestamp,
+                pendingChainValidationStatus
             };
         }
     }
-    getSlotStartTimestamp(slotNumber) {
-        return Number(this.l1Constants.l1GenesisTime) + Number(slotNumber) * this.l1Constants.slotDuration;
+    /**
+   * Considers invalidating a block if the pending chain is invalid. Depends on how long the invalid block
+   * has been there without being invalidated and whether the sequencer is in the committee or not. We always
+   * have the proposer try to invalidate, but if they fail, the sequencers in the committee are expected to try,
+   * and if they fail, any sequencer will try as well.
+   */ async considerInvalidatingBlock(syncedTo, currentSlot, ourValidatorAddresses) {
+        const { pendingChainValidationStatus, l1Timestamp } = syncedTo;
+        if (pendingChainValidationStatus.valid) {
+            return;
+        }
+        const invalidL1Timestamp = pendingChainValidationStatus.block.l1.timestamp;
+        const timeSinceChainInvalid = this.dateProvider.nowInSeconds() - Number(invalidL1Timestamp);
+        const invalidBlockNumber = pendingChainValidationStatus.block.block.number;
+        const { secondsBeforeInvalidatingBlockAsCommitteeMember, secondsBeforeInvalidatingBlockAsNonCommitteeMember } = this.config;
+        const logData = {
+            invalidL1Timestamp,
+            l1Timestamp,
+            invalidBlock: pendingChainValidationStatus.block.block.toBlockInfo(),
+            secondsBeforeInvalidatingBlockAsCommitteeMember,
+            secondsBeforeInvalidatingBlockAsNonCommitteeMember,
+            ourValidatorAddresses,
+            currentSlot
+        };
+        const inCurrentCommittee = ()=>this.publisher.epochCache.getCommittee(currentSlot).then((c)=>c?.committee?.some((member)=>ourValidatorAddresses.some((addr)=>addr.equals(member))));
+        const invalidateAsCommitteeMember = secondsBeforeInvalidatingBlockAsCommitteeMember !== undefined && secondsBeforeInvalidatingBlockAsCommitteeMember > 0 && timeSinceChainInvalid > secondsBeforeInvalidatingBlockAsCommitteeMember && await inCurrentCommittee();
+        const invalidateAsNonCommitteeMember = secondsBeforeInvalidatingBlockAsNonCommitteeMember !== undefined && secondsBeforeInvalidatingBlockAsNonCommitteeMember > 0 && timeSinceChainInvalid > secondsBeforeInvalidatingBlockAsNonCommitteeMember;
+        if (!invalidateAsCommitteeMember && !invalidateAsNonCommitteeMember) {
+            this.log.debug(`Not invalidating pending chain`, logData);
+            return;
+        }
+        const invalidateBlock = await this.publisher.simulateInvalidateBlock(pendingChainValidationStatus);
+        if (!invalidateBlock) {
+            this.log.warn(`Failed to simulate invalidate block`, logData);
+            return;
+        }
+        this.log.info(invalidateAsCommitteeMember ? `Invalidating block ${invalidBlockNumber} as committee member` : `Invalidating block ${invalidBlockNumber} as non-committee member`, logData);
+        this.publisher.enqueueInvalidateBlock(invalidateBlock);
+        await this.publisher.sendRequests();
+    }
+    getSlotStartBuildTimestamp(slotNumber) {
+        return Number(this.l1Constants.l1GenesisTime) + Number(slotNumber) * this.l1Constants.slotDuration - this.l1Constants.ethereumSlotDuration;
     }
     getSecondsIntoSlot(slotNumber) {
-        const slotStartTimestamp = this.getSlotStartTimestamp(slotNumber);
+        const slotStartTimestamp = this.getSlotStartBuildTimestamp(slotNumber);
         return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
     }
     get aztecSlotDuration() {

package/dest/sequencer/timetable.d.ts

@@ -1,10 +1,6 @@
 import type { SequencerMetrics } from './metrics.js';
 import { SequencerState } from './utils.js';
 export declare class SequencerTimetable {
-    private readonly ethereumSlotDuration;
-    private readonly aztecSlotDuration;
-    private readonly maxL1TxInclusionTimeIntoSlot;
-    private readonly enforce;
     private readonly metrics?;
     private readonly log;
     /**
@@ -27,7 +23,21 @@ export declare class SequencerTimetable {
     readonly attestationPropagationTime: number;
     /** How much time we spend validating and processing a block after building it, and assembling the proposal to send to attestors */
     readonly blockValidationTime: number;
-    constructor(ethereumSlotDuration: number, aztecSlotDuration: number, maxL1TxInclusionTimeIntoSlot: number, enforce?: boolean, metrics?: SequencerMetrics | undefined, log?: import("@aztec/aztec.js").Logger);
+    /** Ethereum slot duration in seconds */
+    readonly ethereumSlotDuration: number;
+    /** Aztec slot duration in seconds (must be multiple of ethereum slot duration) */
+    readonly aztecSlotDuration: number;
+    /** How late into an L1 slot we can send a tx to make sure it gets included in the immediate next block. Complement of l1PublishingTime. */
+    readonly maxL1TxInclusionTimeIntoSlot: number;
+    /** Whether assertTimeLeft will throw if not enough time. */
+    readonly enforce: boolean;
+    constructor(opts: {
+        ethereumSlotDuration: number;
+        aztecSlotDuration: number;
+        maxL1TxInclusionTimeIntoSlot: number;
+        attestationPropagationTime?: number;
+        enforce: boolean;
+    }, metrics?: SequencerMetrics | undefined, log?: import("@aztec/aztec.js").Logger);
     private get afterBlockBuildingTimeNeededWithoutReexec();
     getBlockProposalExecTimeEnd(secondsIntoSlot: number): number;
     private get afterBlockReexecTimeNeeded();

package/dest/sequencer/timetable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timetable.d.ts","sourceRoot":"","sources":["../../src/sequencer/timetable.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAO5C,qBAAa,kBAAkB;IA4B3B,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,4BAA4B;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAhCtB;;;;OAIG;IACH,SAAgB,kBAAkB,EAAE,MAAM,CAAC;IAE3C;;;;OAIG;IACH,SAAgB,gBAAgB,SAAC;IAEjC,sHAAsH;IACtH,SAAgB,gBAAgB,EAAE,MAAM,CAAsB;IAE9D,uDAAuD;IACvD,SAAgB,gBAAgB,EAAE,MAAM,CAAsB;IAE9D,mGAAmG;IACnG,SAAgB,0BAA0B,EAAE,MAAM,CAAgC;IAElF,mIAAmI;IACnI,SAAgB,mBAAmB,EAAE,MAAM,CAAyB;gBAGjD,oBAAoB,EAAE,MAAM,EAC5B,iBAAiB,EAAE,MAAM,EACzB,4BAA4B,EAAE,MAAM,EACpC,OAAO,GAAE,OAAc,EACvB,OAAO,CAAC,EAAE,gBAAgB,YAAA,EAC1B,GAAG,mCAAsC;IA0B5D,OAAO,KAAK,yCAAyC,GAEpD;IAEM,2BAA2B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;IAenE,OAAO,KAAK,0BAA0B,GAErC;IAEM,yBAAyB,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM;IAU3D,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS;IAsB5D,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM;CAkBxE;AAED,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,aAAa,EAAE,cAAc;aAC7B,cAAc,EAAE,MAAM;aACtB,WAAW,EAAE,MAAM;gBAFnB,aAAa,EAAE,cAAc,EAC7B,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM;CAOtC"}
+{"version":3,"file":"timetable.d.ts","sourceRoot":"","sources":["../../src/sequencer/timetable.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAM5C,qBAAa,kBAAkB;IA+C3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG;IA/CtB;;;;OAIG;IACH,SAAgB,kBAAkB,EAAE,MAAM,CAAC;IAE3C;;;;OAIG;IACH,SAAgB,gBAAgB,SAAC;IAEjC,sHAAsH;IACtH,SAAgB,gBAAgB,EAAE,MAAM,CAAsB;IAE9D,uDAAuD;IACvD,SAAgB,gBAAgB,EAAE,MAAM,CAAsB;IAE9D,mGAAmG;IACnG,SAAgB,0BAA0B,EAAE,MAAM,CAAC;IAEnD,mIAAmI;IACnI,SAAgB,mBAAmB,EAAE,MAAM,CAAyB;IAEpE,wCAAwC;IACxC,SAAgB,oBAAoB,EAAE,MAAM,CAAC;IAE7C,kFAAkF;IAClF,SAAgB,iBAAiB,EAAE,MAAM,CAAC;IAE1C,2IAA2I;IAC3I,SAAgB,4BAA4B,EAAE,MAAM,CAAC;IAErD,4DAA4D;IAC5D,SAAgB,OAAO,EAAE,OAAO,CAAC;gBAG/B,IAAI,EAAE;QACJ,oBAAoB,EAAE,MAAM,CAAC;QAC7B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,4BAA4B,EAAE,MAAM,CAAC;QACrC,0BAA0B,CAAC,EAAE,MAAM,CAAC;QACpC,OAAO,EAAE,OAAO,CAAC;KAClB,EACgB,OAAO,CAAC,EAAE,gBAAgB,YAAA,EAC1B,GAAG,mCAAsC;IA+C5D,OAAO,KAAK,yCAAyC,GAEpD;IAEM,2BAA2B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;IAenE,OAAO,KAAK,0BAA0B,GAErC;IAEM,yBAAyB,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM;IAU3D,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS;IAsB5D,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM;CAkBxE;AAED,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,aAAa,EAAE,cAAc;aAC7B,cAAc,EAAE,MAAM;aACtB,WAAW,EAAE,MAAM;gBAFnB,aAAa,EAAE,cAAc,EAC7B,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM;CAOtC"}

package/dest/sequencer/timetable.js

@@ -1,14 +1,10 @@
 import { createLogger } from '@aztec/aztec.js';
+import { DEFAULT_ATTESTATION_PROPAGATION_TIME } from '../config.js';
 import { SequencerState } from './utils.js';
 const MIN_EXECUTION_TIME = 1;
 const BLOCK_PREPARE_TIME = 1;
 const BLOCK_VALIDATION_TIME = 1;
-const ATTESTATION_PROPAGATION_TIME = 2;
 export class SequencerTimetable {
-    ethereumSlotDuration;
-    aztecSlotDuration;
-    maxL1TxInclusionTimeIntoSlot;
-    enforce;
     metrics;
     log;
     /**
@@ -25,18 +21,22 @@ export class SequencerTimetable {
     /** How long it takes to get ready to start building */ blockPrepareTime;
     /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */ attestationPropagationTime;
     /** How much time we spend validating and processing a block after building it, and assembling the proposal to send to attestors */ blockValidationTime;
-    constructor(ethereumSlotDuration, aztecSlotDuration, maxL1TxInclusionTimeIntoSlot, enforce = true, metrics, log = createLogger('sequencer:timetable')){
-        this.ethereumSlotDuration = ethereumSlotDuration;
-        this.aztecSlotDuration = aztecSlotDuration;
-        this.maxL1TxInclusionTimeIntoSlot = maxL1TxInclusionTimeIntoSlot;
-        this.enforce = enforce;
+    /** Ethereum slot duration in seconds */ ethereumSlotDuration;
+    /** Aztec slot duration in seconds (must be multiple of ethereum slot duration) */ aztecSlotDuration;
+    /** How late into an L1 slot we can send a tx to make sure it gets included in the immediate next block. Complement of l1PublishingTime. */ maxL1TxInclusionTimeIntoSlot;
+    /** Whether assertTimeLeft will throw if not enough time. */ enforce;
+    constructor(opts, metrics, log = createLogger('sequencer:timetable')){
         this.metrics = metrics;
         this.log = log;
         this.minExecutionTime = MIN_EXECUTION_TIME;
         this.blockPrepareTime = BLOCK_PREPARE_TIME;
-        this.attestationPropagationTime = ATTESTATION_PROPAGATION_TIME;
         this.blockValidationTime = BLOCK_VALIDATION_TIME;
+        this.ethereumSlotDuration = opts.ethereumSlotDuration;
+        this.aztecSlotDuration = opts.aztecSlotDuration;
+        this.maxL1TxInclusionTimeIntoSlot = opts.maxL1TxInclusionTimeIntoSlot;
+        this.attestationPropagationTime = opts.attestationPropagationTime ?? DEFAULT_ATTESTATION_PROPAGATION_TIME;
         this.l1PublishingTime = this.ethereumSlotDuration - this.maxL1TxInclusionTimeIntoSlot;
+        this.enforce = opts.enforce;
         // Assume zero-cost propagation time and faster runs in test environments where L1 slot duration is shortened
         if (this.ethereumSlotDuration < 8) {
             this.attestationPropagationTime = 0;
@@ -45,10 +45,23 @@ export class SequencerTimetable {
         }
         const allWorkToDo = this.blockPrepareTime + this.minExecutionTime * 2 + this.attestationPropagationTime * 2 + this.blockValidationTime + this.l1PublishingTime;
         const initializeDeadline = this.aztecSlotDuration - allWorkToDo;
+        this.initializeDeadline = initializeDeadline;
+        this.log.verbose(`Sequencer timetable initialized (${this.enforce ? 'enforced' : 'not enforced'})`, {
+            ethereumSlotDuration: this.ethereumSlotDuration,
+            aztecSlotDuration: this.aztecSlotDuration,
+            maxL1TxInclusionTimeIntoSlot: this.maxL1TxInclusionTimeIntoSlot,
+            l1PublishingTime: this.l1PublishingTime,
+            minExecutionTime: this.minExecutionTime,
+            blockPrepareTime: this.blockPrepareTime,
+            attestationPropagationTime: this.attestationPropagationTime,
+            blockValidationTime: this.blockValidationTime,
+            initializeDeadline: this.initializeDeadline,
+            enforce: this.enforce,
+            allWorkToDo
+        });
         if (initializeDeadline <= 0) {
             throw new Error(`Block proposal initialize deadline cannot be negative (got ${initializeDeadline} from total time needed ${allWorkToDo} and a slot duration of ${this.aztecSlotDuration}).`);
         }
-        this.initializeDeadline = initializeDeadline;
     }
     get afterBlockBuildingTimeNeededWithoutReexec() {
         return this.blockValidationTime + this.attestationPropagationTime * 2 + this.l1PublishingTime;

package/dest/sequencer/utils.d.ts

@@ -1,6 +1,3 @@
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { CommitteeAttestation } from '@aztec/stdlib/block';
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
 export declare enum SequencerState {
     /**
      * Sequencer is stopped and not processing any txs from the pool.
@@ -35,14 +32,7 @@ export declare enum SequencerState {
      */
     PUBLISHING_BLOCK = "PUBLISHING_BLOCK"
 }
+export type SequencerStateWithSlot = SequencerState.INITIALIZING_PROPOSAL | SequencerState.CREATING_BLOCK | SequencerState.COLLECTING_ATTESTATIONS | SequencerState.PUBLISHING_BLOCK;
 export type SequencerStateCallback = () => SequencerState;
 export declare function sequencerStateToNumber(state: SequencerState): number;
-/** Order Attestations
- *
- * Returns attestation signatures in the order of a series of provided ethereum addresses
- * The rollup smart contract expects attestations to appear in the order of the committee
- *
- * @todo: perform this logic within the memory attestation store instead?
- */
-export declare function orderAttestations(attestations: BlockAttestation[], orderAddresses: EthAddress[]): CommitteeAttestation[];
 //# sourceMappingURL=utils.d.ts.map