@aztec/sequencer-client 0.0.0-test.1 → 0.0.1-commit.0b941701

package/dest/sequencer/metrics.js

@@ -1,78 +1,96 @@
-import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
-import { sequencerStateToNumber } from './utils.js';
+import { Attributes, Metrics } from '@aztec/telemetry-client';
+import { formatUnits } from 'viem';
+// TODO(palla/mbps): Review all metrics and add any missing ones per checkpoint
 export class SequencerMetrics {
+    rollup;
     tracer;
+    meter;
     blockCounter;
     blockBuildDuration;
     blockBuildManaPerSecond;
     stateTransitionBufferDuration;
-    currentBlockNumber;
-    currentBlockSize;
-    blockBuilderInsertions;
+    // these are gauges because for individual sequencers building a block is not something that happens often enough to warrant a histogram
     timeToCollectAttestations;
-    constructor(client, getState, name = 'Sequencer'){
-        const meter = client.getMeter(name);
+    allowanceToCollectAttestations;
+    requiredAttestions;
+    collectedAttestions;
+    rewards;
+    slots;
+    filledSlots;
+    blockProposalFailed;
+    blockProposalSuccess;
+    blockProposalPrecheckFailed;
+    checkpointSuccess;
+    slashingAttempts;
+    checkpointAttestationDelay;
+    // Fisherman fee analysis metrics
+    fishermanWouldBeIncluded;
+    fishermanTimeBeforeBlock;
+    fishermanPendingBlobTxCount;
+    fishermanIncludedBlobTxCount;
+    fishermanCalculatedPriorityFee;
+    fishermanPriorityFeeDelta;
+    fishermanEstimatedCost;
+    fishermanEstimatedOverpayment;
+    fishermanMinedBlobTxPriorityFee;
+    fishermanMinedBlobTxTotalCost;
+    lastSeenSlot;
+    constructor(client, rollup, name = 'Sequencer'){
+        this.rollup = rollup;
+        this.meter = client.getMeter(name);
         this.tracer = client.getTracer(name);
-        this.blockCounter = meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
-        this.blockBuildDuration = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
-            unit: 'ms',
-            description: 'Duration to build a block',
-            valueType: ValueType.INT
-        });
-        this.blockBuildManaPerSecond = meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
-            unit: 'mana/s',
-            description: 'Mana per second when building a block',
-            valueType: ValueType.INT
-        });
-        this.stateTransitionBufferDuration = meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION, {
-            unit: 'ms',
-            description: 'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
-            valueType: ValueType.INT
-        });
-        const currentState = meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {
-            description: 'Current state of the sequencer'
-        });
-        currentState.addCallback((observer)=>{
-            observer.observe(sequencerStateToNumber(getState()));
-        });
-        this.currentBlockNumber = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
-            description: 'Current block number',
-            valueType: ValueType.INT
-        });
-        this.currentBlockSize = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
-            description: 'Current block size',
-            valueType: ValueType.INT
-        });
-        this.timeToCollectAttestations = meter.createGauge(Metrics.SEQUENCER_TIME_TO_COLLECT_ATTESTATIONS, {
-            description: 'The time spent collecting attestations from committee members',
-            valueType: ValueType.INT
+        this.blockCounter = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
+        this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION);
+        this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND);
+        this.stateTransitionBufferDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION);
+        this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
+        // Init gauges and counters
+        this.blockCounter.add(0, {
+            [Attributes.STATUS]: 'failed'
         });
-        this.blockBuilderInsertions = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_INSERTION_TIME, {
-            description: 'Timer for tree insertions performed by the block builder',
-            unit: 'us',
-            valueType: ValueType.INT
+        this.blockCounter.add(0, {
+            [Attributes.STATUS]: 'built'
         });
-        this.setCurrentBlock(0, 0);
+        this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS);
+        this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT);
+        /**
+     * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
+     * Instead, use a computed metric, `slots - filledSlots` to get the number of slots a sequencer has missed.
+     */ this.filledSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT);
+        this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION);
+        this.allowanceToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE);
+        this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT);
+        this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT);
+        this.blockProposalFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT);
+        this.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT);
+        this.checkpointSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
+        this.blockProposalPrecheckFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT);
+        this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
+        // Fisherman fee analysis metrics
+        this.fishermanWouldBeIncluded = this.meter.createUpDownCounter(Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED);
+        this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK);
+        this.fishermanPendingBlobTxCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_TX_COUNT);
+        this.fishermanIncludedBlobTxCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_TX_COUNT);
+        this.fishermanCalculatedPriorityFee = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_CALCULATED_PRIORITY_FEE);
+        this.fishermanPriorityFeeDelta = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PRIORITY_FEE_DELTA);
+        this.fishermanEstimatedCost = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_COST);
+        this.fishermanEstimatedOverpayment = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_OVERPAYMENT);
+        this.fishermanMinedBlobTxPriorityFee = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_PRIORITY_FEE);
+        this.fishermanMinedBlobTxTotalCost = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_TOTAL_COST);
     }
-    startCollectingAttestationsTimer() {
-        const startTime = Date.now();
-        const stop = ()=>{
-            const duration = Date.now() - startTime;
-            this.recordTimeToCollectAttestations(duration);
-        };
-        return stop.bind(this);
+    recordRequiredAttestations(requiredAttestationsCount, allowanceMs) {
+        this.requiredAttestions.record(requiredAttestationsCount);
+        this.allowanceToCollectAttestations.record(Math.ceil(allowanceMs));
+        // reset
+        this.collectedAttestions.record(0);
+        this.timeToCollectAttestations.record(0);
     }
-    recordTimeToCollectAttestations(time) {
-        this.timeToCollectAttestations.record(time);
+    recordCheckpointAttestationDelay(duration) {
+        this.checkpointAttestationDelay.record(duration);
     }
-    recordBlockBuilderTreeInsertions(timeUs) {
-        this.blockBuilderInsertions.record(Math.ceil(timeUs));
-    }
-    recordCancelledBlock() {
-        this.blockCounter.add(1, {
-            [Attributes.STATUS]: 'cancelled'
-        });
-        this.setCurrentBlock(0, 0);
+    recordCollectedAttestations(count, durationMs) {
+        this.collectedAttestions.record(count);
+        this.timeToCollectAttestations.record(Math.ceil(durationMs));
     }
     recordBuiltBlock(buildDurationMs, totalMana) {
         this.blockCounter.add(1, {
@@ -85,18 +103,135 @@ export class SequencerMetrics {
         this.blockCounter.add(1, {
             [Attributes.STATUS]: 'failed'
         });
-        this.setCurrentBlock(0, 0);
-    }
-    recordNewBlock(blockNumber, txCount) {
-        this.setCurrentBlock(blockNumber, txCount);
     }
     recordStateTransitionBufferMs(durationMs, state) {
         this.stateTransitionBufferDuration.record(durationMs, {
             [Attributes.SEQUENCER_STATE]: state
         });
     }
-    setCurrentBlock(blockNumber, txCount) {
-        this.currentBlockNumber.record(blockNumber);
-        this.currentBlockSize.record(txCount);
+    incOpenSlot(slot, proposer) {
+        // sequencer went through the loop a second time. Noop
+        if (slot === this.lastSeenSlot) {
+            return;
+        }
+        this.slots.add(1, {
+            [Attributes.BLOCK_PROPOSER]: proposer
+        });
+        this.lastSeenSlot = slot;
+    }
+    async incFilledSlot(proposer, coinbase) {
+        this.filledSlots.add(1, {
+            [Attributes.BLOCK_PROPOSER]: proposer
+        });
+        this.lastSeenSlot = undefined;
+        if (coinbase) {
+            try {
+                const rewards = await this.rollup.getSequencerRewards(coinbase);
+                const fmt = parseFloat(formatUnits(rewards, 18));
+                this.rewards.record(fmt, {
+                    [Attributes.COINBASE]: coinbase.toString()
+                });
+            } catch  {
+            // no-op
+            }
+        }
+    }
+    recordCheckpointSuccess() {
+        this.checkpointSuccess.add(1);
+    }
+    recordBlockProposalFailed(reason) {
+        this.blockProposalFailed.add(1, {
+            ...reason && {
+                [Attributes.ERROR_TYPE]: reason
+            }
+        });
+    }
+    recordBlockProposalSuccess() {
+        this.blockProposalSuccess.add(1);
+    }
+    recordBlockProposalPrecheckFailed(checkType) {
+        this.blockProposalPrecheckFailed.add(1, {
+            [Attributes.ERROR_TYPE]: checkType
+        });
+    }
+    recordSlashingAttempt(actionCount) {
+        this.slashingAttempts.add(actionCount);
+    }
+    /**
+   * Records metrics for a completed fisherman fee analysis
+   * @param analysis - The completed fee analysis result
+   */ recordFishermanFeeAnalysis(analysis) {
+        // In fisherman mode, we should always have strategy results
+        if (!analysis.computedPrices.strategyResults || analysis.computedPrices.strategyResults.length === 0) {
+            // This should never happen in fisherman mode - log an error
+            // We don't record metrics without strategy IDs as that defeats the purpose
+            throw new Error(`No strategy results found in fisherman fee analysis ${analysis.id}. This indicates a bug in the fee analysis.`);
+        }
+        // Record metrics for each strategy separately
+        for (const strategyResult of analysis.computedPrices.strategyResults){
+            const strategyAttributes = {
+                [Attributes.FISHERMAN_FEE_STRATEGY_ID]: strategyResult.strategyId
+            };
+            // Record pending block snapshot data (once per strategy for comparison)
+            this.fishermanPendingBlobTxCount.record(analysis.pendingSnapshot.pendingBlobTxCount, strategyAttributes);
+            // Record mined block data if available
+            if (analysis.minedBlock) {
+                this.fishermanIncludedBlobTxCount.record(analysis.minedBlock.includedBlobTxCount, strategyAttributes);
+                // Record actual fees from blob transactions in the mined block
+                for (const blobTx of analysis.minedBlock.includedBlobTxs){
+                    // Record priority fee per gas in Gwei
+                    const priorityFeeGwei = Number(blobTx.maxPriorityFeePerGas) / 1e9;
+                    this.fishermanMinedBlobTxPriorityFee.record(priorityFeeGwei, strategyAttributes);
+                    // Calculate total cost in ETH
+                    // Cost = (gas * (baseFee + priorityFee)) + (blobCount * blobGasPerBlob * blobBaseFee)
+                    const baseFee = analysis.minedBlock.baseFeePerGas;
+                    const effectiveGasPrice = baseFee + blobTx.maxPriorityFeePerGas;
+                    // Calculate execution cost using actual gas limit from the transaction
+                    const executionCost = blobTx.gas * effectiveGasPrice;
+                    // Calculate blob cost using maxFeePerBlobGas * blobCount * GAS_PER_BLOB
+                    const blobCost = blobTx.maxFeePerBlobGas * BigInt(blobTx.blobCount) * 131072n; // 128KB per blob
+                    const totalCostWei = executionCost + blobCost;
+                    const totalCostEth = Number(totalCostWei) / 1e18;
+                    this.fishermanMinedBlobTxTotalCost.record(totalCostEth, strategyAttributes);
+                }
+            }
+            // Record the calculated priority fee for this strategy
+            const calculatedPriorityFeeGwei = Number(strategyResult.calculatedPriorityFee) / 1e9;
+            this.fishermanCalculatedPriorityFee.record(calculatedPriorityFeeGwei, strategyAttributes);
+            // Record analysis results if available
+            if (analysis.analysis) {
+                this.fishermanTimeBeforeBlock.record(Math.ceil(analysis.analysis.timeBeforeBlockMs), strategyAttributes);
+                // Record strategy-specific inclusion result
+                if (strategyResult.wouldBeIncluded !== undefined) {
+                    if (strategyResult.wouldBeIncluded) {
+                        this.fishermanWouldBeIncluded.add(1, {
+                            ...strategyAttributes,
+                            [Attributes.OK]: true
+                        });
+                    } else {
+                        this.fishermanWouldBeIncluded.add(1, {
+                            ...strategyAttributes,
+                            [Attributes.OK]: false,
+                            ...strategyResult.exclusionReason && {
+                                [Attributes.ERROR_TYPE]: strategyResult.exclusionReason
+                            }
+                        });
+                    }
+                }
+                // Record strategy-specific priority fee delta
+                if (strategyResult.priorityFeeDelta !== undefined) {
+                    const priorityFeeDeltaGwei = Number(strategyResult.priorityFeeDelta) / 1e9;
+                    this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, strategyAttributes);
+                }
+                // Record estimated cost if available
+                if (strategyResult.estimatedCostEth !== undefined) {
+                    this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, strategyAttributes);
+                }
+                // Record estimated overpayment if available
+                if (strategyResult.estimatedOverpaymentEth !== undefined) {
+                    this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, strategyAttributes);
+                }
+            }
+        }
     }
 }

package/dest/sequencer/sequencer.d.ts

@@ -1,180 +1,187 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { L2Block } from '@aztec/aztec.js';
+import type { EpochCache } from '@aztec/epoch-cache';
+import { type RollupContract } from '@aztec/ethereum/contracts';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import type { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
-import { type DateProvider, Timer } from '@aztec/foundation/timer';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { P2P } from '@aztec/p2p';
-import type { BlockBuilderFactory } from '@aztec/prover-client/block-builder';
-import type { PublicProcessorFactory } from '@aztec/simulator/server';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
-import { Gas } from '@aztec/stdlib/gas';
-import { type WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { SlasherClientInterface } from '@aztec/slasher';
+import type { L2Block, L2BlockSink, L2BlockSource, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { type ResolvedSequencerConfig, type SequencerConfig, type WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import { type GlobalVariables, Tx, type TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
-import type { ValidatorClient } from '@aztec/validator-client';
+import { FullNodeCheckpointsBuilder, type ValidatorClient } from '@aztec/validator-client';
 import type { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import { type SequencerPublisher } from '../publisher/sequencer-publisher.js';
-import type { SlasherClient } from '../slasher/slasher_client.js';
-import type { SequencerConfig } from './config.js';
+import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
+import type { InvalidateCheckpointRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import { CheckpointProposalJob } from './checkpoint_proposal_job.js';
+import type { SequencerEvents } from './events.js';
 import { SequencerTimetable } from './timetable.js';
+import type { SequencerRollupConstants } from './types.js';
 import { SequencerState } from './utils.js';
 export { SequencerState };
-type SequencerRollupConstants = Pick<L1RollupConstants, 'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration'>;
+declare const Sequencer_base: new () => TypedEventEmitter<SequencerEvents>;
 /**
  * Sequencer client
- * - Wins a period of time to become the sequencer (depending on finalized protocol).
- * - Chooses a set of txs from the tx pool to be in the rollup.
- * - Simulate the rollup of txs.
- * - Adds proof requests to the request pool (not for this milestone).
- * - Receives results to those proofs from the network (repeats as necessary) (not for this milestone).
- * - Publishes L1 tx(s) to the rollup contract via RollupPublisher.
+ * - Checks whether it is elected as proposer for the next slot
+ * - Builds multiple blocks and broadcasts them
+ * - Collects attestations for the checkpoint
+ * - Publishes the checkpoint to L1
+ * - Votes for proposals and slashes on L1
  */
-export declare class Sequencer {
-    protected publisher: SequencerPublisher;
-    protected validatorClient: ValidatorClient | undefined;
+export declare class Sequencer extends Sequencer_base {
+    protected publisherFactory: SequencerPublisherFactory;
+    protected validatorClient: ValidatorClient;
     protected globalsBuilder: GlobalVariableBuilder;
     protected p2pClient: P2P;
     protected worldState: WorldStateSynchronizer;
-    protected slasherClient: SlasherClient;
-    protected blockBuilderFactory: BlockBuilderFactory;
-    protected l2BlockSource: L2BlockSource;
+    protected slasherClient: SlasherClientInterface | undefined;
+    protected l2BlockSource: L2BlockSource & L2BlockSink;
     protected l1ToL2MessageSource: L1ToL2MessageSource;
-    protected publicProcessorFactory: PublicProcessorFactory;
-    protected contractDataSource: ContractDataSource;
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder;
     protected l1Constants: SequencerRollupConstants;
     protected dateProvider: DateProvider;
-    protected config: SequencerConfig;
-    protected log: import("@aztec/aztec.js").Logger;
+    protected epochCache: EpochCache;
+    protected rollupContract: RollupContract;
+    protected telemetry: TelemetryClient;
+    protected log: import("@aztec/foundation/log").Logger;
     private runningPromise?;
-    private pollingIntervalMs;
-    private maxTxsPerBlock;
-    private minTxsPerBlock;
-    private maxL1TxInclusionTimeIntoSlot;
-    private _coinbase;
-    private _feeRecipient;
     private state;
-    private allowedInSetup;
-    private maxBlockSizeInBytes;
-    private maxBlockGas;
     private metrics;
-    private isFlushing;
+    /** The last slot for which we attempted to perform our voting duties with degraded block production */
+    private lastSlotForFallbackVote;
+    /** The last slot for which we triggered a checkpoint proposal job, to prevent duplicate attempts. */
+    private lastSlotForCheckpointProposalJob;
+    /** Last successful checkpoint proposed */
+    private lastCheckpointProposed;
+    /** The last epoch for which we logged strategy comparison in fisherman mode. */
+    private lastEpochForStrategyComparison;
     /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */
     protected timetable: SequencerTimetable;
-    protected enforceTimeTable: boolean;
-    constructor(publisher: SequencerPublisher, validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
-    globalsBuilder: GlobalVariableBuilder, p2pClient: P2P, worldState: WorldStateSynchronizer, slasherClient: SlasherClient, blockBuilderFactory: BlockBuilderFactory, l2BlockSource: L2BlockSource, l1ToL2MessageSource: L1ToL2MessageSource, publicProcessorFactory: PublicProcessorFactory, contractDataSource: ContractDataSource, l1Constants: SequencerRollupConstants, dateProvider: DateProvider, config?: SequencerConfig, telemetry?: TelemetryClient, log?: import("@aztec/aztec.js").Logger);
-    get tracer(): Tracer;
-    /**
-     * Updates sequencer config.
-     * @param config - New parameters.
-     */
-    updateConfig(config: SequencerConfig): Promise<void>;
-    private setTimeTable;
-    /**
-     * Starts the sequencer and moves to IDLE state.
-     */
-    start(): Promise<void>;
-    /**
-     * Stops the sequencer from processing txs and moves to STOPPED state.
-     */
+    protected publisher: SequencerPublisher | undefined;
+    /** Config for the sequencer */
+    protected config: ResolvedSequencerConfig;
+    constructor(publisherFactory: SequencerPublisherFactory, validatorClient: ValidatorClient, globalsBuilder: GlobalVariableBuilder, p2pClient: P2P, worldState: WorldStateSynchronizer, slasherClient: SlasherClientInterface | undefined, l2BlockSource: L2BlockSource & L2BlockSink, l1ToL2MessageSource: L1ToL2MessageSource, checkpointsBuilder: FullNodeCheckpointsBuilder, l1Constants: SequencerRollupConstants, dateProvider: DateProvider, epochCache: EpochCache, rollupContract: RollupContract, config: SequencerConfig, telemetry?: TelemetryClient, log?: import("@aztec/foundation/log").Logger);
+    /** Updates sequencer config by the defined values and updates the timetable */
+    updateConfig(config: Partial<SequencerConfig>): void;
+    /** Initializes the sequencer (precomputes tables and creates a publisher). Takes about 3s. */
+    init(): Promise<void>;
+    /** Starts the sequencer and moves to IDLE state. */
+    start(): void;
+    /** Stops the sequencer from building blocks and moves to STOPPED state. */
     stop(): Promise<void>;
-    /**
-     * Starts a previously stopped sequencer.
-     */
-    restart(): void;
-    /**
-     * Returns the current state of the sequencer.
-     * @returns An object with a state entry with one of SequencerState.
-     */
+    /** Main sequencer loop with a try/catch */
+    protected safeWork(): Promise<void>;
+    /** Returns the current state of the sequencer. */
     status(): {
         state: SequencerState;
     };
-    /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */
-    flush(): void;
     /**
-     * @notice  Performs most of the sequencer duties:
-     *          - Checks if we are up to date
-     *          - If we are and we are the sequencer, collect txs and build a block
-     *          - Collect attestations for the block
-     *          - Submit block
-     *          - If our block for some reason is not included, revert the state
+     * Main sequencer loop:
+     * - Checks if we are up to date
+     * - If we are and we are the sequencer, collect txs and build blocks
+     * - Build multiple blocks per slot when configured
+     * - Collect attestations for the final block
+     * - Submit checkpoint
      */
-    protected doRealWork(): Promise<void>;
-    protected work(): Promise<void>;
-    getForwarderAddress(): EthAddress;
+    protected work(): Promise<Checkpoint | undefined>;
+    private prepareCheckpointProposal;
+    protected createCheckpointProposalJob(epoch: EpochNumber, slot: SlotNumber, checkpointNumber: CheckpointNumber, syncedToBlockNumber: BlockNumber, proposer: EthAddress | undefined, publisher: SequencerPublisher, attestorAddress: EthAddress, invalidateCheckpoint: InvalidateCheckpointRequest | undefined): CheckpointProposalJob;
     /**
-     * Checks if we can propose at the next block and returns the slot number if we can.
-     * @param tipArchive - The archive of the previous block.
-     * @param proposalBlockNumber - The block number of the proposal.
-     * @returns The slot number if we can propose at the next block, otherwise undefined.
-     */
-    slotForProposal(tipArchive: Buffer, proposalBlockNumber: bigint): Promise<bigint | undefined>;
-    /**
-     * Sets the sequencer state and checks if we have enough time left in the slot to transition to the new state.
+     * Internal helper for setting the sequencer state and checks if we have enough time left in the slot to transition to the new state.
      * @param proposedState - The new state to transition to.
-     * @param currentSlotNumber - The current slot number.
+     * @param slotNumber - The current slot number.
      * @param force - Whether to force the transition even if the sequencer is stopped.
-     *
-     * @dev If the `currentSlotNumber` doesn't matter (e.g. transitioning to IDLE), pass in `0n`;
-     * it is only used to check if we have enough time left in the slot to transition to the new state.
      */
-    setState(proposedState: SequencerState, currentSlotNumber: bigint, force?: boolean): void;
+    protected setState(proposedState: SequencerState, slotNumber: SlotNumber | undefined, opts?: {
+        force?: boolean;
+    }): void;
     /**
-     * Build a block
-     *
-     * Shared between the sequencer and the validator for re-execution
-     *
-     * @param pendingTxs - The pending transactions to construct the block from
-     * @param newGlobalVariables - The global variables for the new block
-     * @param historicalHeader - The historical header of the parent
-     * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
+     * Returns whether all dependencies have caught up.
+     * We don't check against the previous block submitted since it may have been reorg'd out.
      */
-    protected buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, newGlobalVariables: GlobalVariables, opts?: {
-        validateOnly?: boolean;
-    }): Promise<{
-        block: L2Block;
-        publicGas: Gas;
-        publicProcessorDuration: number;
-        numMsgs: number;
-        numTxs: number;
-        numFailedTxs: number;
-        blockBuildingTimer: Timer;
-    }>;
+    protected checkSync(args: {
+        ts: bigint;
+        slot: SlotNumber;
+    }): Promise<SequencerSyncCheckResult | undefined>;
     /**
-     * @notice  Build and propose a block to the chain
-     *
-     * @dev     MUST throw instead of exiting early to ensure that world-state
-     *          is being rolled back if the block is dropped.
-     *
-     * @param pendingTxs - Iterable of pending transactions to construct the block from
-     * @param proposalHeader - The partial header constructed for the proposal
+     * Checks if we are the proposer for the next slot.
+     * @returns True if we can propose, and the proposer address (undefined if anyone can propose)
      */
-    private buildBlockAndEnqueuePublish;
-    protected collectAttestations(block: L2Block, txHashes: TxHash[]): Promise<Signature[] | undefined>;
+    protected checkCanPropose(slot: SlotNumber): Promise<[boolean, EthAddress | undefined]>;
     /**
-     * Publishes the L2Block to the rollup contract.
-     * @param block - The L2Block to be published.
+     * Tries to vote on slashing actions and governance when the sync check fails but we're past the max time for initializing a proposal.
+     * This allows the sequencer to participate in governance/slashing votes even when it cannot build blocks.
      */
-    protected enqueuePublishL2Block(block: L2Block, attestations?: Signature[], txHashes?: TxHash[]): Promise<void>;
+    protected tryVoteWhenSyncFails(args: {
+        slot: SlotNumber;
+        ts: bigint;
+    }): Promise<void>;
     /**
-     * Returns whether all dependencies have caught up.
-     * We don't check against the previous block submitted since it may have been reorg'd out.
-     * @returns Boolean indicating if our dependencies are synced to the latest block.
+     * Tries to vote on slashing actions and governance proposals when escape hatch is open.
+     * This allows the sequencer to participate in voting without performing checkpoint proposal work.
+     */
+    protected tryVoteWhenEscapeHatchOpen(args: {
+        slot: SlotNumber;
+        proposer: EthAddress | undefined;
+    }): Promise<void>;
+    /**
+     * 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.
      */
-    protected getChainTip(): Promise<{
-        blockNumber: number;
-        archive: Fr;
-    } | undefined>;
-    private getSlotStartTimestamp;
+    protected considerInvalidatingCheckpoint(syncedTo: SequencerSyncCheckResult, currentSlot: SlotNumber): Promise<void>;
+    private logStrategyComparison;
+    private getSlotStartBuildTimestamp;
     private getSecondsIntoSlot;
     get aztecSlotDuration(): number;
-    get coinbase(): EthAddress;
-    get feeRecipient(): AztecAddress;
+    get maxL2BlockGas(): number | undefined;
+    getSlasherClient(): SlasherClientInterface | undefined;
+    get tracer(): Tracer;
+    getValidatorAddresses(): EthAddress[];
+    getConfig(): {
+        sequencerPollingIntervalMS: number;
+        maxTxsPerBlock: number;
+        minTxsPerBlock: number;
+        minValidTxsPerBlock?: number | undefined;
+        publishTxsWithProposals: boolean;
+        maxL2BlockGas: number;
+        maxDABlockGas: number;
+        coinbase?: EthAddress | undefined;
+        feeRecipient?: import("@aztec/stdlib/aztec-address").AztecAddress | undefined;
+        acvmWorkingDirectory?: string | undefined;
+        acvmBinaryPath?: string | undefined;
+        txPublicSetupAllowList?: import("@aztec/stdlib/interfaces/server").AllowedElement[] | undefined;
+        maxBlockSizeInBytes: number;
+        governanceProposerPayload?: EthAddress | undefined;
+        enforceTimeTable: boolean;
+        l1PublishingTime?: number | undefined;
+        fakeProcessingDelayPerTxMs?: number | undefined;
+        fakeThrowAfterProcessingTxCount?: number | undefined;
+        attestationPropagationTime: number;
+        secondsBeforeInvalidatingBlockAsCommitteeMember: number;
+        secondsBeforeInvalidatingBlockAsNonCommitteeMember: number;
+        skipCollectingAttestations: boolean;
+        skipInvalidateBlockAsProposer: boolean;
+        broadcastInvalidBlockProposal: boolean;
+        injectFakeAttestation: boolean;
+        fishermanMode: boolean;
+        shuffleAttestationOrdering: boolean;
+        blockDurationMs?: number | undefined;
+        buildCheckpointIfEmpty: boolean;
+        skipPushProposedBlocksToArchiver: boolean;
+    };
+    private get l1PublishingTime();
 }
-//# sourceMappingURL=sequencer.d.ts.map
+type SequencerSyncCheckResult = {
+    block?: L2Block;
+    checkpointNumber: CheckpointNumber;
+    blockNumber: BlockNumber;
+    archive: Fr;
+    l1Timestamp: bigint;
+    pendingChainValidationStatus: ValidateCheckpointResult;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VxdWVuY2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VxdWVuY2VyL3NlcXVlbmNlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNyRCxPQUFPLEVBQW9CLEtBQUssY0FBYyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDbEYsT0FBTyxFQUFFLFdBQVcsRUFBRSxnQkFBZ0IsRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFekcsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUczRCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLEdBQUcsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUN0QyxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdELE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsYUFBYSxFQUFFLHdCQUF3QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDekcsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFM0QsT0FBTyxFQUNMLEtBQUssdUJBQXVCLEVBQzVCLEtBQUssZUFBZSxFQUVwQixLQUFLLHNCQUFzQixFQUM1QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHbkUsT0FBTyxFQUFjLEtBQUssZUFBZSxFQUFFLEtBQUssTUFBTSxFQUFpQyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZILE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxLQUFLLGVBQWUsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBSzNGLE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sOENBQThDLENBQUM7QUFDMUYsT0FBTyxLQUFLLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQztBQUM3RixPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzNHLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBR3JFLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUVuRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUMzRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTVDLE9BQU8sRUFBRSxjQUFjLEVBQUUsQ0FBQzs7QUFFMUI7Ozs7Ozs7R0FPRztBQUNILHFCQUFhLFNBQVUsU0FBUSxjQUE4RDtJQWdDekYsU0FBUyxDQUFDLGdCQUFnQixFQUFFLHlCQUF5QjtJQUNyRCxTQUFTLENBQUMsZUFBZSxFQUFFLGVBQWU7SUFDMUMsU0FBUyxDQUFDLGNBQWMsRUFBRSxxQkFBcUI7SUFDL0MsU0FBUyxDQUFDLFNBQVMsRUFBRSxHQUFHO0lBQ3hCLFNBQVMsQ0FBQyxVQUFVLEVBQUUsc0JBQXNCO0lBQzVDLFNBQVMsQ0FBQyxhQUFhLEVBQUUsc0JBQXNCLEdBQUcsU0FBUztJQUMzRCxTQUFTLENBQUMsYUFBYSxFQUFFLGFBQWEsR0FBRyxXQUFXO0lBQ3BELFNBQVMsQ0FBQyxtQkFBbUIsRUFBRSxtQkFBbUI7SUFDbEQsU0FBUyxDQUFDLGtCQUFrQixFQUFFLDBCQUEwQjtJQUN4RCxTQUFTLENBQUMsV0FBVyxFQUFFLHdCQUF3QjtJQUMvQyxTQUFTLENBQUMsWUFBWSxFQUFFLFlBQVk7SUFDcEMsU0FBUyxDQUFDLFVBQVUsRUFBRSxVQUFVO0lBQ2hDLFNBQVMsQ0FBQyxjQUFjLEVBQUUsY0FBYztJQUV4QyxTQUFTLENBQUMsU0FBUyxFQUFFLGVBQWU7SUFDcEMsU0FBUyxDQUFDLEdBQUc7SUE5Q2YsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFpQjtJQUN4QyxPQUFPLENBQUMsS0FBSyxDQUEwQjtJQUN2QyxPQUFPLENBQUMsT0FBTyxDQUFtQjtJQUVsQyx1R0FBdUc7SUFDdkcsT0FBTyxDQUFDLHVCQUF1QixDQUF5QjtJQUV4RCxxR0FBcUc7SUFDckcsT0FBTyxDQUFDLGdDQUFnQyxDQUF5QjtJQUVqRSwwQ0FBMEM7SUFDMUMsT0FBTyxDQUFDLHNCQUFzQixDQUF5QjtJQUV2RCxnRkFBZ0Y7SUFDaEYsT0FBTyxDQUFDLDhCQUE4QixDQUEwQjtJQUVoRSwrR0FBK0c7SUFDL0csU0FBUyxDQUFDLFNBQVMsRUFBRyxrQkFBa0IsQ0FBQztJQVF6QyxTQUFTLENBQUMsU0FBUyxFQUFFLGtCQUFrQixHQUFHLFNBQVMsQ0FBQztJQUVwRCwrQkFBK0I7SUFDL0IsU0FBUyxDQUFDLE1BQU0sRUFBRSx1QkFBdUIsQ0FBMEI7SUFFbkUsWUFDWSxnQkFBZ0IsRUFBRSx5QkFBeUIsRUFDM0MsZUFBZSxFQUFFLGVBQWUsRUFDaEMsY0FBYyxFQUFFLHFCQUFxQixFQUNyQyxTQUFTLEVBQUUsR0FBRyxFQUNkLFVBQVUsRUFBRSxzQkFBc0IsRUFDbEMsYUFBYSxFQUFFLHNCQUFzQixHQUFHLFNBQVMsRUFDakQsYUFBYSxFQUFFLGFBQWEsR0FBRyxXQUFXLEVBQzFDLG1CQUFtQixFQUFFLG1CQUFtQixFQUN4QyxrQkFBa0IsRUFBRSwwQkFBMEIsRUFDOUMsV0FBVyxFQUFFLHdCQUF3QixFQUNyQyxZQUFZLEVBQUUsWUFBWSxFQUMxQixVQUFVLEVBQUUsVUFBVSxFQUN0QixjQUFjLEVBQUUsY0FBYyxFQUN4QyxNQUFNLEVBQUUsZUFBZSxFQUNiLFNBQVMsR0FBRSxlQUFzQyxFQUNqRCxHQUFHLHlDQUE0QixFQVcxQztJQUVELCtFQUErRTtJQUN4RSxZQUFZLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxlQUFlLENBQUMsUUFnQm5EO0lBRUQsOEZBQThGO0lBQ2pGLElBQUksa0JBR2hCO0lBRUQsb0RBQW9EO0lBQzdDLEtBQUssU0FTWDtJQUVELDJFQUEyRTtJQUM5RCxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQU9qQztJQUVELDJDQUEyQztJQUMzQyxVQUFnQixRQUFRLGtCQXFCdkI7SUFFRCxrREFBa0Q7SUFDM0MsTUFBTTs7TUFFWjtJQUVEOzs7Ozs7O09BT0c7SUFDSCxVQUNnQixJQUFJLG9DQTRCbkI7WUFRYSx5QkFBeUI7SUEySnZDLFNBQVMsQ0FBQywyQkFBMkIsQ0FDbkMsS0FBSyxFQUFFLFdBQVcsRUFDbEIsSUFBSSxFQUFFLFVBQVUsRUFDaEIsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQ2xDLG1CQUFtQixFQUFFLFdBQVcsRUFDaEMsUUFBUSxFQUFFLFVBQVUsR0FBRyxTQUFTLEVBQ2hDLFNBQVMsRUFBRSxrQkFBa0IsRUFDN0IsZUFBZSxFQUFFLFVBQVUsRUFDM0Isb0JBQW9CLEVBQUUsMkJBQTJCLEdBQUcsU0FBUyxHQUM1RCxxQkFBcUIsQ0E4QnZCO0lBRUQ7Ozs7O09BS0c7SUFDSCxTQUFTLENBQUMsUUFBUSxDQUNoQixhQUFhLEVBQUUsY0FBYyxFQUM3QixVQUFVLEVBQUUsVUFBVSxHQUFHLFNBQVMsRUFDbEMsSUFBSSxHQUFFO1FBQUUsS0FBSyxDQUFDLEVBQUUsT0FBTyxDQUFBO0tBQU8sR0FDN0IsSUFBSSxDQTZCTjtJQUVEOzs7T0FHRztJQUNILFVBQWdCLFNBQVMsQ0FBQyxJQUFJLEVBQUU7UUFBRSxFQUFFLEVBQUUsTUFBTSxDQUFDO1FBQUMsSUFBSSxFQUFFLFVBQVUsQ0FBQTtLQUFFLEdBQUcsT0FBTyxDQUFDLHdCQUF3QixHQUFHLFNBQVMsQ0FBQyxDQXNFL0c7SUFFRDs7O09BR0c7SUFDSCxVQUFnQixlQUFlLENBQUMsSUFBSSxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsVUFBVSxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBZ0M1RjtJQUVEOzs7T0FHRztJQUNILFVBQ2dCLG9CQUFvQixDQUFDLElBQUksRUFBRTtRQUFFLElBQUksRUFBRSxVQUFVLENBQUM7UUFBQyxFQUFFLEVBQUUsTUFBTSxDQUFBO0tBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBb0UxRjtJQUVEOzs7T0FHRztJQUNILFVBQ2dCLDBCQUEwQixDQUFDLElBQUksRUFBRTtRQUMvQyxJQUFJLEVBQUUsVUFBVSxDQUFDO1FBQ2pCLFFBQVEsRUFBRSxVQUFVLEdBQUcsU0FBUyxDQUFDO0tBQ2xDLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXNDaEI7SUFFRDs7Ozs7T0FLRztJQUNILFVBQWdCLDhCQUE4QixDQUM1QyxRQUFRLEVBQUUsd0JBQXdCLEVBQ2xDLFdBQVcsRUFBRSxVQUFVLEdBQ3RCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FvRmY7SUFFRCxPQUFPLENBQUMscUJBQXFCO0lBNkI3QixPQUFPLENBQUMsMEJBQTBCO0lBSWxDLE9BQU8sQ0FBQyxrQkFBa0I7SUFLMUIsSUFBVyxpQkFBaUIsV0FFM0I7SUFFRCxJQUFXLGFBQWEsSUFBSSxNQUFNLEdBQUcsU0FBUyxDQUU3QztJQUVNLGdCQUFnQixJQUFJLHNCQUFzQixHQUFHLFNBQVMsQ0FFNUQ7SUFFRCxJQUFXLE1BQU0sSUFBSSxNQUFNLENBRTFCO0lBRU0scUJBQXFCLGlCQUUzQjtJQUVNLFNBQVM7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7TUFFZjtJQUVELE9BQU8sS0FBSyxnQkFBZ0IsR0FFM0I7Q0FDRjtBQUVELEtBQUssd0JBQXdCLEdBQUc7SUFDOUIsS0FBSyxDQUFDLEVBQUUsT0FBTyxDQUFDO0lBQ2hCLGdCQUFnQixFQUFFLGdCQUFnQixDQUFDO0lBQ25DLFdBQVcsRUFBRSxXQUFXLENBQUM7SUFDekIsT0FBTyxFQUFFLEVBQUUsQ0FBQztJQUNaLFdBQVcsRUFBRSxNQUFNLENBQUM7SUFDcEIsNEJBQTRCLEVBQUUsd0JBQXdCLENBQUM7Q0FDeEQsQ0FBQyJ9