@aztec/sequencer-client 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/dest/sequencer/metrics.js

@@ -1,6 +1,5 @@
 import { Attributes, Metrics, createUpDownCounterWithDefault } 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;
@@ -9,6 +8,7 @@ export class SequencerMetrics {
     blockBuildDuration;
     blockBuildManaPerSecond;
     stateTransitionBufferDuration;
+    stateDuration;
     // these are gauges because for individual sequencers building a block is not something that happens often enough to warrant a histogram
     timeToCollectAttestations;
     allowanceToCollectAttestations;
@@ -18,22 +18,32 @@ export class SequencerMetrics {
     slots;
     filledSlots;
     blockProposalFailed;
-    blockProposalSuccess;
-    blockProposalPrecheckFailed;
+    checkpointProposalSuccess;
+    checkpointPrecheckFailed;
+    checkpointProposalFailed;
     checkpointSuccess;
     slashingAttempts;
-    checkpointAttestationDelay;
+    pipelineDepth;
+    pipelineDiscards;
+    pipelineParentCheckpointMismatches;
     // Fisherman fee analysis metrics
     fishermanWouldBeIncluded;
     fishermanTimeBeforeBlock;
     fishermanPendingBlobTxCount;
     fishermanIncludedBlobTxCount;
+    fishermanPendingBlobCount;
+    fishermanIncludedBlobCount;
+    fishermanBlockBlobsFull;
+    fishermanMaxBlobCapacity;
     fishermanCalculatedPriorityFee;
     fishermanPriorityFeeDelta;
     fishermanEstimatedCost;
     fishermanEstimatedOverpayment;
     fishermanMinedBlobTxPriorityFee;
     fishermanMinedBlobTxTotalCost;
+    blockInterBlockTime;
+    lastBlockBuiltTimestamp;
+    lastBlockBuiltSlot;
     lastSeenSlot;
     constructor(client, rollup, name = 'Sequencer'){
         this.rollup = rollup;
@@ -47,9 +57,10 @@ export class SequencerMetrics {
         });
         this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION);
         this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND);
+        this.blockInterBlockTime = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_INTER_BLOCK_TIME);
         this.stateTransitionBufferDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION);
-        this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
-        this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS);
+        this.stateDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_DURATION);
+        this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_SLOT_REWARDS);
         this.slots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLOT_COUNT);
         /**
      * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
@@ -60,9 +71,9 @@ export class SequencerMetrics {
         this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT);
         this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT);
         this.blockProposalFailed = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT);
-        this.blockProposalSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT);
+        this.checkpointProposalSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_SUCCESS_COUNT);
         this.checkpointSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
-        this.blockProposalPrecheckFailed = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT, {
+        this.checkpointPrecheckFailed = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_PRECHECK_FAILED_COUNT, {
             [Attributes.ERROR_TYPE]: [
                 'slot_already_taken',
                 'rollup_contract_check_failed',
@@ -70,12 +81,29 @@ export class SequencerMetrics {
                 'block_number_mismatch'
             ]
         });
+        this.checkpointProposalFailed = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_FAILED_COUNT);
         this.slashingAttempts = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
+        this.pipelineDepth = this.meter.createGauge(Metrics.SEQUENCER_PIPELINE_DEPTH);
+        this.pipelineDiscards = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_PIPELINE_DISCARDS_COUNT);
+        this.pipelineParentCheckpointMismatches = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_PIPELINE_PARENT_CHECKPOINT_MISMATCH_COUNT, {
+            [Attributes.ERROR_TYPE]: [
+                'archiver-sync-timeout',
+                'parent-not-on-l1',
+                'parent-hash-mismatch',
+                'parent-invalid-attestations',
+                'unexpected-parent-appeared'
+            ]
+        });
+        this.pipelineDepth.record(0);
         // Fisherman fee analysis metrics
         this.fishermanWouldBeIncluded = createUpDownCounterWithDefault(this.meter, Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED, {
             [Attributes.OK]: [
                 true,
                 false
+            ],
+            [Attributes.BLOCK_FULL]: [
+                'true',
+                'false'
             ]
         });
         this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK);
@@ -87,6 +115,15 @@ export class SequencerMetrics {
         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);
+        this.fishermanPendingBlobCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_COUNT);
+        this.fishermanIncludedBlobCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_COUNT);
+        this.fishermanBlockBlobsFull = createUpDownCounterWithDefault(this.meter, Metrics.FISHERMAN_FEE_ANALYSIS_BLOCK_BLOBS_FULL, {
+            [Attributes.OK]: [
+                true,
+                false
+            ]
+        });
+        this.fishermanMaxBlobCapacity = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_MAX_BLOB_CAPACITY);
     }
     recordRequiredAttestations(requiredAttestationsCount, allowanceMs) {
         this.requiredAttestions.record(requiredAttestationsCount);
@@ -95,19 +132,23 @@ export class SequencerMetrics {
         this.collectedAttestions.record(0);
         this.timeToCollectAttestations.record(0);
     }
-    recordCheckpointAttestationDelay(duration) {
-        this.checkpointAttestationDelay.record(duration);
-    }
     recordCollectedAttestations(count, durationMs) {
         this.collectedAttestions.record(count);
         this.timeToCollectAttestations.record(Math.ceil(durationMs));
     }
-    recordBuiltBlock(buildDurationMs, totalMana) {
+    recordBuiltBlock(buildDurationMs, totalMana, slot) {
         this.blockCounter.add(1, {
             [Attributes.STATUS]: 'built'
         });
         this.blockBuildDuration.record(Math.ceil(buildDurationMs));
         this.blockBuildManaPerSecond.record(Math.ceil(totalMana * 1000 / buildDurationMs));
+        // Only record inter-block time between blocks built within the same slot.
+        const now = Date.now();
+        if (this.lastBlockBuiltTimestamp !== undefined && this.lastBlockBuiltSlot === slot) {
+            this.blockInterBlockTime.record(now - this.lastBlockBuiltTimestamp);
+        }
+        this.lastBlockBuiltTimestamp = now;
+        this.lastBlockBuiltSlot = slot;
     }
     recordFailedBlock() {
         this.blockCounter.add(1, {
@@ -119,6 +160,22 @@ export class SequencerMetrics {
             [Attributes.SEQUENCER_STATE]: state
         });
     }
+    recordStateDuration(durationMs, state) {
+        this.stateDuration.record(Math.ceil(durationMs), {
+            [Attributes.SEQUENCER_STATE]: state
+        });
+    }
+    recordPipelineDepth(depth) {
+        this.pipelineDepth.record(depth);
+    }
+    recordPipelineDiscard(count = 1) {
+        this.pipelineDiscards.add(count);
+    }
+    recordPipelineParentCheckpointMismatch(reason) {
+        this.pipelineParentCheckpointMismatches.add(1, {
+            [Attributes.ERROR_TYPE]: reason
+        });
+    }
     incOpenSlot(slot, proposer) {
         // sequencer went through the loop a second time. Noop
         if (slot === this.lastSeenSlot) {
@@ -156,14 +213,21 @@ export class SequencerMetrics {
             }
         });
     }
-    recordBlockProposalSuccess() {
-        this.blockProposalSuccess.add(1);
+    recordCheckpointProposalSuccess() {
+        this.checkpointProposalSuccess.add(1);
     }
-    recordBlockProposalPrecheckFailed(checkType) {
-        this.blockProposalPrecheckFailed.add(1, {
+    recordCheckpointPrecheckFailed(checkType) {
+        this.checkpointPrecheckFailed.add(1, {
             [Attributes.ERROR_TYPE]: checkType
         });
     }
+    recordCheckpointProposalFailed(reason) {
+        this.checkpointProposalFailed.add(1, {
+            ...reason && {
+                [Attributes.ERROR_TYPE]: reason
+            }
+        });
+    }
     recordSlashingAttempt(actionCount) {
         this.slashingAttempts.add(actionCount);
     }
@@ -184,9 +248,11 @@ export class SequencerMetrics {
             };
             // Record pending block snapshot data (once per strategy for comparison)
             this.fishermanPendingBlobTxCount.record(analysis.pendingSnapshot.pendingBlobTxCount, strategyAttributes);
+            this.fishermanPendingBlobCount.record(analysis.pendingSnapshot.pendingBlobCount, strategyAttributes);
             // Record mined block data if available
             if (analysis.minedBlock) {
                 this.fishermanIncludedBlobTxCount.record(analysis.minedBlock.includedBlobTxCount, strategyAttributes);
+                this.fishermanIncludedBlobCount.record(analysis.minedBlock.includedBlobCount, 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
@@ -211,16 +277,34 @@ export class SequencerMetrics {
             // Record analysis results if available
             if (analysis.analysis) {
                 this.fishermanTimeBeforeBlock.record(Math.ceil(analysis.analysis.timeBeforeBlockMs), strategyAttributes);
+                // Record whether the block reached 100% blob capacity
+                if (analysis.analysis.blockBlobsFull) {
+                    this.fishermanBlockBlobsFull.add(1, {
+                        ...strategyAttributes,
+                        [Attributes.OK]: true
+                    });
+                } else {
+                    this.fishermanBlockBlobsFull.add(1, {
+                        ...strategyAttributes,
+                        [Attributes.OK]: false
+                    });
+                }
+                // Record the max blob capacity for this block
+                this.fishermanMaxBlobCapacity.record(analysis.analysis.maxBlobCapacity, strategyAttributes);
                 // Record strategy-specific inclusion result
                 if (strategyResult.wouldBeIncluded !== undefined) {
+                    const inclusionAttributes = {
+                        ...strategyAttributes,
+                        [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false'
+                    };
                     if (strategyResult.wouldBeIncluded) {
                         this.fishermanWouldBeIncluded.add(1, {
-                            ...strategyAttributes,
+                            ...inclusionAttributes,
                             [Attributes.OK]: true
                         });
                     } else {
                         this.fishermanWouldBeIncluded.add(1, {
-                            ...strategyAttributes,
+                            ...inclusionAttributes,
                             [Attributes.OK]: false,
                             ...strategyResult.exclusionReason && {
                                 [Attributes.ERROR_TYPE]: strategyResult.exclusionReason
@@ -231,15 +315,27 @@ export class SequencerMetrics {
                 // Record strategy-specific priority fee delta
                 if (strategyResult.priorityFeeDelta !== undefined) {
                     const priorityFeeDeltaGwei = Number(strategyResult.priorityFeeDelta) / 1e9;
-                    this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, strategyAttributes);
+                    const deltaAttributes = {
+                        ...strategyAttributes,
+                        [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false'
+                    };
+                    this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, deltaAttributes);
                 }
                 // Record estimated cost if available
                 if (strategyResult.estimatedCostEth !== undefined) {
-                    this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, strategyAttributes);
+                    const costAttributes = {
+                        ...strategyAttributes,
+                        [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false'
+                    };
+                    this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, costAttributes);
                 }
                 // Record estimated overpayment if available
                 if (strategyResult.estimatedOverpaymentEth !== undefined) {
-                    this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, strategyAttributes);
+                    const overpaymentAttributes = {
+                        ...strategyAttributes,
+                        [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false'
+                    };
+                    this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, overpaymentAttributes);
                 }
             }
         }

package/dest/sequencer/missing_committee.d.ts

@@ -0,0 +1,72 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import { EpochNumber, type SlotNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+/** Collaborators {@link logMissingCommittee} needs to diagnose and report why no committee exists. */
+export interface MissingCommitteeContext {
+    epochCache: Pick<EpochCache, 'getL1Constants' | 'getLagInEpochsForValidatorSet'>;
+    rollupContract: Pick<RollupContract, 'getActiveAttesterCount' | 'getAttesterCountAtTime'>;
+    l2BlockSource: Pick<L2BlockSource, 'getBlockNumber'>;
+    l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration'>;
+    dateProvider: Pick<DateProvider, 'nowInSeconds'>;
+    logger: Pick<Logger, 'info' | 'warn' | 'debug'>;
+}
+/**
+ * Why the sequencer cannot find a validator committee for an upcoming slot. A committee for an epoch is
+ * sampled from the validator set as of `lagInEpochsForValidatorSet` epochs earlier, and L1 refuses to
+ * produce one until at least `targetCommitteeSize` validators were staked at that sampling time.
+ */
+export type MissingCommitteeCause = 
+/** Enough validators are staked now; the committee is just waiting for the sampling window to advance. */
+'awaiting-sampling-lag'
+/** The chain has not produced any block yet and too few validators are staked: normal bootstrap state. */
+ | 'awaiting-first-validators'
+/** The chain has produced blocks before but the validator set has since dropped below the required size. */
+ | 'validator-set-shrank';
+export interface MissingCommitteeDiagnosis {
+    cause: MissingCommitteeCause;
+    /** Log severity: bootstrap and lag are expected (`info`); a shrunken set on a live chain is not (`warn`). */
+    severity: 'info' | 'warn';
+}
+/**
+ * Logs why no validator committee exists for the given slot. Rather than the cryptic "committee does not
+ * exist on L1", it diagnoses the cause from the live attester count and whether the chain has ever produced
+ * a block: a bootstrapping chain waiting for validators to stake, a full set still waiting for the sampling
+ * lag to elapse, or a validator set that has shrunk below the required size on a live chain. Only the last is
+ * a genuine problem, so only it is logged at `warn`.
+ *
+ * Best-effort: if the diagnostic L1 reads fail we fall back to a neutral message so this never throws on the
+ * propose path.
+ */
+export declare function logMissingCommittee(targetSlot: SlotNumber, targetEpoch: EpochNumber, ctx: MissingCommitteeContext): Promise<void>;
+/**
+ * Classifies why no committee exists for a slot, using only cheap live signals: the current attester count
+ * and whether the chain has ever produced a block. See {@link MissingCommitteeCause} for the reasoning.
+ */
+export declare function classifyMissingCommittee(args: {
+    attesterCount: number;
+    targetCommitteeSize: number;
+    hasProducedBlocks: boolean;
+}): MissingCommitteeDiagnosis;
+/**
+ * Given each candidate epoch after the one we failed to propose at, paired with the attester count staked at
+ * that epoch's validator-set sample time (`undefined` when the sample time is still in the future), returns
+ * the earliest epoch that will have a committee, or `undefined` if none qualifies.
+ *
+ * Candidates must be ordered ascending by epoch. A committee for epoch `E` exists iff at least
+ * `targetCommitteeSize` validators were staked at `E`'s sample time, so the first candidate whose sampled
+ * count meets the target is the answer; a candidate whose sample time is still in the future is assumed to
+ * have a committee if the set holds and wins as soon as it is reached. The predicate is not monotone in `E`
+ * (the set can dip below target between sample times), so this must scan ascending rather than binary-search.
+ */
+export declare function findFirstEpochWithCommittee(args: {
+    candidates: {
+        epoch: EpochNumber;
+        sampledAttesterCount: number | undefined;
+    }[];
+    targetCommitteeSize: number;
+}): EpochNumber | undefined;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"missing_committee.d.ts","sourceRoot":"","sources":["../../src/sequencer/missing_committee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE/E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,KAAK,iBAAiB,EAA6B,MAAM,6BAA6B,CAAC;AAEhG,sGAAsG;AACtG,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,gBAAgB,GAAG,+BAA+B,CAAC,CAAC;IACjF,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,wBAAwB,GAAG,wBAAwB,CAAC,CAAC;IAC1F,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAC;IACrD,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,GAAG,eAAe,CAAC,CAAC;IACzF,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;IACjD,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CACjD;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB;AAC/B,0GAA0G;AACxG,uBAAuB;AACzB,0GAA0G;GACxG,2BAA2B;AAC7B,4GAA4G;GAC1G,sBAAsB,CAAC;AAE3B,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,qBAAqB,CAAC;IAC7B,6GAA6G;IAC7G,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,EACxB,GAAG,EAAE,uBAAuB,GAC3B,OAAO,CAAC,IAAI,CAAC,CA0Df;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,OAAO,CAAC;CAC5B,GAAG,yBAAyB,CAY5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE;IAChD,UAAU,EAAE;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,EAAE,CAAC;IAC/E,mBAAmB,EAAE,MAAM,CAAC;CAC7B,GAAG,WAAW,GAAG,SAAS,CAI1B"}

package/dest/sequencer/missing_committee.js

@@ -0,0 +1,139 @@
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { timesParallel } from '@aztec/foundation/collection';
+import { formatSeconds } from '@aztec/foundation/string';
+import { getStartTimestampForEpoch } from '@aztec/stdlib/epoch-helpers';
+/**
+ * Logs why no validator committee exists for the given slot. Rather than the cryptic "committee does not
+ * exist on L1", it diagnoses the cause from the live attester count and whether the chain has ever produced
+ * a block: a bootstrapping chain waiting for validators to stake, a full set still waiting for the sampling
+ * lag to elapse, or a validator set that has shrunk below the required size on a live chain. Only the last is
+ * a genuine problem, so only it is logged at `warn`.
+ *
+ * Best-effort: if the diagnostic L1 reads fail we fall back to a neutral message so this never throws on the
+ * propose path.
+ */ export async function logMissingCommittee(targetSlot, targetEpoch, ctx) {
+    const targetCommitteeSize = ctx.epochCache.getL1Constants().targetCommitteeSize;
+    const lag = ctx.epochCache.getLagInEpochsForValidatorSet();
+    let attesterCount;
+    let hasProducedBlocks;
+    try {
+        [attesterCount, hasProducedBlocks] = await Promise.all([
+            ctx.rollupContract.getActiveAttesterCount(),
+            ctx.l2BlockSource.getBlockNumber().then((n)=>n > 0)
+        ]);
+    } catch (err) {
+        ctx.logger.warn(`No committee found for slot ${targetSlot}; could not determine validator set size`, {
+            targetSlot,
+            targetEpoch,
+            targetCommitteeSize,
+            err
+        });
+        return;
+    }
+    const diagnosis = classifyMissingCommittee({
+        attesterCount,
+        targetCommitteeSize,
+        hasProducedBlocks
+    });
+    const logCtx = {
+        targetSlot,
+        targetEpoch,
+        attesterCount,
+        targetCommitteeSize,
+        cause: diagnosis.cause
+    };
+    switch(diagnosis.cause){
+        case 'awaiting-sampling-lag':
+            {
+                const firstCommitteeEpoch = await estimateFirstCommitteeEpoch(targetEpoch, lag, targetCommitteeSize, ctx);
+                const staked = `${attesterCount} validators are staked (>= ${targetCommitteeSize} required)`;
+                const forming = `the committee is still forming as the ${lag}-epoch sampling window advances`;
+                // When we could not pin the exact epoch, report the safe upper bound rather than a misleading ETA.
+                const epoch = firstCommitteeEpoch ?? EpochNumber(targetEpoch + lag + 1);
+                const expectation = firstCommitteeEpoch === undefined ? `A committee should exist no later than epoch ${epoch}.` : `The first committee is expected at epoch ${epoch}${formatEpochEta(epoch, ctx)}.`;
+                ctx.logger.info(`No committee for slot ${targetSlot} yet: ${staked}, ${forming}. ${expectation}`, {
+                    ...logCtx,
+                    firstCommitteeEpoch: epoch
+                });
+                break;
+            }
+        case 'awaiting-first-validators':
+            ctx.logger.info(`No committee for slot ${targetSlot}: the chain has not started producing blocks and only ${attesterCount} ` + `of the ${targetCommitteeSize} required validators are staked. Block production begins once at least ` + `${targetCommitteeSize} validators stake and the ${lag}-epoch sampling lag elapses.`, logCtx);
+            break;
+        case 'validator-set-shrank':
+            ctx.logger.warn(`No committee for slot ${targetSlot}: the validator set has dropped to ${attesterCount}, below the ` + `${targetCommitteeSize} required to form a committee. The chain cannot progress until enough validators ` + `are staked again — check for validators exiting or being slashed.`, logCtx);
+            break;
+    }
+}
+/**
+ * Classifies why no committee exists for a slot, using only cheap live signals: the current attester count
+ * and whether the chain has ever produced a block. See {@link MissingCommitteeCause} for the reasoning.
+ */ export function classifyMissingCommittee(args) {
+    const { attesterCount, targetCommitteeSize, hasProducedBlocks } = args;
+    if (attesterCount >= targetCommitteeSize) {
+        return {
+            cause: 'awaiting-sampling-lag',
+            severity: 'info'
+        };
+    }
+    if (hasProducedBlocks) {
+        return {
+            cause: 'validator-set-shrank',
+            severity: 'warn'
+        };
+    }
+    return {
+        cause: 'awaiting-first-validators',
+        severity: 'info'
+    };
+}
+/**
+ * Given each candidate epoch after the one we failed to propose at, paired with the attester count staked at
+ * that epoch's validator-set sample time (`undefined` when the sample time is still in the future), returns
+ * the earliest epoch that will have a committee, or `undefined` if none qualifies.
+ *
+ * Candidates must be ordered ascending by epoch. A committee for epoch `E` exists iff at least
+ * `targetCommitteeSize` validators were staked at `E`'s sample time, so the first candidate whose sampled
+ * count meets the target is the answer; a candidate whose sample time is still in the future is assumed to
+ * have a committee if the set holds and wins as soon as it is reached. The predicate is not monotone in `E`
+ * (the set can dip below target between sample times), so this must scan ascending rather than binary-search.
+ */ export function findFirstEpochWithCommittee(args) {
+    return args.candidates.find((c)=>c.sampledAttesterCount === undefined || c.sampledAttesterCount >= args.targetCommitteeSize)?.epoch;
+}
+/**
+ * Earliest epoch expected to have a committee, replaying L1's validator-set sampling rule: a committee for
+ * epoch `E` exists iff at least `targetCommitteeSize` attesters were staked at `E`'s sample time
+ * (`epochStart(E) - lag * epochDuration`). Only epochs after the one we failed at can qualify, and the set
+ * must have crossed the target within the last `lag` epochs' sample window, so the answer lies in
+ * `(targetEpoch, targetEpoch + lag + 1]`. Reads the historical attester count at each candidate's sample time
+ * (at most `lag` on-chain reads; future sample times are assumed to hold). Returns `undefined` if no candidate
+ * qualifies or the reads fail, leaving the caller to report a bound instead of an ETA.
+ */ async function estimateFirstCommitteeEpoch(targetEpoch, lag, targetCommitteeSize, ctx) {
+    try {
+        const epochDurationSeconds = BigInt(ctx.l1Constants.epochDuration * ctx.l1Constants.slotDuration);
+        const nowSeconds = BigInt(ctx.dateProvider.nowInSeconds());
+        const candidates = await timesParallel(lag + 1, async (i)=>{
+            const epoch = EpochNumber(targetEpoch + 1 + i);
+            const sampleTime = getStartTimestampForEpoch(epoch, ctx.l1Constants) - epochDurationSeconds * BigInt(lag);
+            const sampledAttesterCount = sampleTime > nowSeconds ? undefined : await ctx.rollupContract.getAttesterCountAtTime(sampleTime);
+            return {
+                epoch,
+                sampledAttesterCount
+            };
+        });
+        return findFirstEpochWithCommittee({
+            candidates,
+            targetCommitteeSize
+        });
+    } catch (err) {
+        ctx.logger.debug(`Could not estimate first committee epoch after epoch ${targetEpoch}`, {
+            targetEpoch,
+            err
+        });
+        return undefined;
+    }
+}
+/** Formats the ETA to the start of the given epoch as ` (~12m from now)`, or empty if it is in the past. */ function formatEpochEta(epoch, ctx) {
+    const secondsUntil = Number(getStartTimestampForEpoch(epoch, ctx.l1Constants)) - ctx.dateProvider.nowInSeconds();
+    return secondsUntil > 0 ? ` (~${formatSeconds(secondsUntil)} from now)` : '';
+}

package/dest/sequencer/requests_tracker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tracks fire-and-forget requests so a shutdown path can interrupt any in-flight work and await it to
+ * settle. Each tracked request is a promise plus an optional interrupt callback; the entry removes itself
+ * from the bag once its promise settles, so the tracker only ever holds requests that are still in flight.
+ */
+export declare class RequestsTracker {
+    private readonly requests;
+    private nextId;
+    /** Number of in-flight requests currently tracked. */
+    get size(): number;
+    /**
+     * Tracks a fire-and-forget request. `interrupt`, when provided, is invoked by {@link interruptRequests}
+     * to cancel the in-flight work so its promise settles promptly. The entry auto-removes once `promise`
+     * settles, whether it resolves or rejects.
+     */
+    trackRequest(promise: Promise<unknown>, interrupt?: () => void): void;
+    /** Interrupts every in-flight request that was tracked with an interrupt callback. */
+    interruptRequests(): void;
+    /** Awaits every currently in-flight request to settle. */
+    awaitRequests(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdHNfdHJhY2tlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlcXVlbmNlci9yZXF1ZXN0c190cmFja2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7O0dBSUc7QUFDSCxxQkFBYSxlQUFlO0lBQzFCLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFxQztJQUM5RCxPQUFPLENBQUMsTUFBTSxDQUFLO0lBRW5CLHNEQUFzRDtJQUN0RCxJQUFXLElBQUksSUFBSSxNQUFNLENBRXhCO0lBRUQ7Ozs7T0FJRztJQUNJLFlBQVksQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLFNBQVMsQ0FBQyxFQUFFLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FPM0U7SUFFRCxzRkFBc0Y7SUFDL0UsaUJBQWlCLElBQUksSUFBSSxDQUkvQjtJQUVELDBEQUEwRDtJQUM3QyxhQUFhLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUUxQztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"requests_tracker.d.ts","sourceRoot":"","sources":["../../src/sequencer/requests_tracker.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;IAC9D,OAAO,CAAC,MAAM,CAAK;IAEnB,sDAAsD;IACtD,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;OAIG;IACI,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAO3E;IAED,sFAAsF;IAC/E,iBAAiB,IAAI,IAAI,CAI/B;IAED,0DAA0D;IAC7C,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAE1C;CACF"}

package/dest/sequencer/requests_tracker.js

@@ -0,0 +1,33 @@
+/** A tracked request: the awaitable to wait on, plus an optional interrupt to cancel it early. */ /**
+ * Tracks fire-and-forget requests so a shutdown path can interrupt any in-flight work and await it to
+ * settle. Each tracked request is a promise plus an optional interrupt callback; the entry removes itself
+ * from the bag once its promise settles, so the tracker only ever holds requests that are still in flight.
+ */ export class RequestsTracker {
+    requests = new Map();
+    nextId = 0;
+    /** Number of in-flight requests currently tracked. */ get size() {
+        return this.requests.size;
+    }
+    /**
+   * Tracks a fire-and-forget request. `interrupt`, when provided, is invoked by {@link interruptRequests}
+   * to cancel the in-flight work so its promise settles promptly. The entry auto-removes once `promise`
+   * settles, whether it resolves or rejects.
+   */ trackRequest(promise, interrupt) {
+        const id = this.nextId++;
+        const settled = promise.then(()=>this.requests.delete(id), ()=>this.requests.delete(id));
+        this.requests.set(id, {
+            promise: settled,
+            interrupt
+        });
+    }
+    /** Interrupts every in-flight request that was tracked with an interrupt callback. */ interruptRequests() {
+        for (const { interrupt } of this.requests.values()){
+            interrupt?.();
+        }
+    }
+    /** Awaits every currently in-flight request to settle. */ async awaitRequests() {
+        await Promise.all([
+            ...this.requests.values()
+        ].map((request)=>request.promise));
+    }
+}