@aztec-labs/sequencer-client 6.0.0-nightly.20260829

package/src/sequencer/checkpoint_proposal_job_metrics.ts

@@ -0,0 +1,128 @@
+import {
+  Attributes,
+  type Gauge,
+  type Histogram,
+  type Meter,
+  Metrics,
+  type TelemetryClient,
+} from '@aztec-labs/telemetry-client';
+
+type CheckpointProposalJobInstruments = {
+  checkpointAttestationDelay: Histogram;
+  checkpointBuildDuration: Histogram;
+  checkpointStartToFirstBlockDuration: Histogram;
+  checkpointLastBlockToBroadcastDuration: Histogram;
+  pipelinedCheckpointBuildStartOffsetFromSlotBoundary: Histogram;
+  checkpointBlockCount: Gauge;
+  checkpointTxCount: Gauge;
+  checkpointTotalMana: Gauge;
+};
+
+/**
+ * Per-job recording surface used by {@link CheckpointProposalJob}.
+ *
+ * Ownership split:
+ * - {@link CheckpointProposalJobMetrics} owns the OpenTelemetry meter and instruments and should live for the
+ *   lifetime of the sequencer process.
+ * - A recorder owns only mutable timing state for one checkpoint proposal job so overlapping jobs cannot
+ *   overwrite each other's timing markers.
+ */
+export interface CheckpointProposalJobMetricsRecorder {
+  recordCheckpointAttestationDelay(durationMs: number): void;
+  recordCheckpointBuild(durationMs: number, blockCount: number, txCount: number, totalMana: number): void;
+  recordPipelinedCheckpointBuildStartOffsetFromSlotBoundary(offsetMs: number): void;
+  startCheckpointTiming(nowMs: number): void;
+  noteCheckpointBlockBuilt(nowMs: number, opts: { isFirstBlock: boolean; isLastBlock: boolean }): void;
+  noteCheckpointBroadcast(nowMs: number): void;
+}
+
+/**
+ * Concrete per-job recorder.
+ *
+ * This class should be short-lived: create one recorder per checkpoint proposal job and discard it when the job
+ * completes. It intentionally does not create instruments; it only holds the job-local timestamps needed to derive
+ * timing metrics safely.
+ */
+class CheckpointProposalJobMetricsRecorderImpl implements CheckpointProposalJobMetricsRecorder {
+  private checkpointStartedAt?: number;
+  private checkpointLastBlockBuiltAt?: number;
+
+  constructor(private readonly instruments: CheckpointProposalJobInstruments) {}
+
+  public recordCheckpointAttestationDelay(durationMs: number) {
+    this.instruments.checkpointAttestationDelay.record(Math.ceil(durationMs));
+  }
+
+  public recordCheckpointBuild(durationMs: number, blockCount: number, txCount: number, totalMana: number) {
+    this.instruments.checkpointBuildDuration.record(Math.ceil(durationMs));
+    this.instruments.checkpointBlockCount.record(blockCount);
+    this.instruments.checkpointTxCount.record(txCount);
+    this.instruments.checkpointTotalMana.record(totalMana);
+  }
+
+  public recordPipelinedCheckpointBuildStartOffsetFromSlotBoundary(offsetMs: number) {
+    this.instruments.pipelinedCheckpointBuildStartOffsetFromSlotBoundary.record(Math.ceil(Math.abs(offsetMs)), {
+      [Attributes.SLOT_BOUNDARY_SIDE]: offsetMs < 0 ? 'before' : 'after',
+    });
+  }
+
+  public startCheckpointTiming(nowMs: number) {
+    this.checkpointStartedAt = nowMs;
+    this.checkpointLastBlockBuiltAt = undefined;
+  }
+
+  public noteCheckpointBlockBuilt(nowMs: number, opts: { isFirstBlock: boolean; isLastBlock: boolean }) {
+    if (opts.isFirstBlock && this.checkpointStartedAt !== undefined) {
+      this.instruments.checkpointStartToFirstBlockDuration.record(Math.ceil(nowMs - this.checkpointStartedAt));
+    }
+
+    if (opts.isLastBlock) {
+      this.checkpointLastBlockBuiltAt = nowMs;
+    }
+  }
+
+  public noteCheckpointBroadcast(nowMs: number) {
+    if (this.checkpointLastBlockBuiltAt !== undefined) {
+      this.instruments.checkpointLastBlockToBroadcastDuration.record(
+        Math.ceil(nowMs - this.checkpointLastBlockBuiltAt),
+      );
+    }
+
+    this.checkpointLastBlockBuiltAt = undefined;
+  }
+}
+
+/**
+ * Long-lived owner of checkpoint proposal job telemetry instruments.
+ *
+ * The sequencer should construct this once and reuse it across jobs. Each call to {@link createRecorder} returns a
+ * lightweight recorder with isolated mutable state for a single checkpoint proposal job.
+ */
+export class CheckpointProposalJobMetrics {
+  private readonly meter: Meter;
+  private readonly instruments: CheckpointProposalJobInstruments;
+
+  constructor(client: TelemetryClient, name = 'CheckpointProposalJob') {
+    this.meter = client.getMeter(name);
+    this.instruments = {
+      checkpointAttestationDelay: this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY),
+      checkpointBuildDuration: this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_BUILD_DURATION),
+      checkpointStartToFirstBlockDuration: this.meter.createHistogram(
+        Metrics.SEQUENCER_CHECKPOINT_START_TO_FIRST_BLOCK_DURATION,
+      ),
+      checkpointLastBlockToBroadcastDuration: this.meter.createHistogram(
+        Metrics.SEQUENCER_CHECKPOINT_LAST_BLOCK_TO_BROADCAST_DURATION,
+      ),
+      pipelinedCheckpointBuildStartOffsetFromSlotBoundary: this.meter.createHistogram(
+        Metrics.SEQUENCER_PIPELINED_CHECKPOINT_BUILD_START_OFFSET_FROM_SLOT_BOUNDARY,
+      ),
+      checkpointBlockCount: this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_BLOCK_COUNT),
+      checkpointTxCount: this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TX_COUNT),
+      checkpointTotalMana: this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TOTAL_MANA),
+    };
+  }
+
+  public createRecorder(): CheckpointProposalJobMetricsRecorder {
+    return new CheckpointProposalJobMetricsRecorderImpl(this.instruments);
+  }
+}

package/src/sequencer/checkpoint_voter.ts

@@ -0,0 +1,118 @@
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { SlasherClientInterface } from '@aztec-labs/slasher';
+import type { ResolvedSequencerConfig } from '@aztec-labs/stdlib/interfaces/server';
+import type { ValidatorClient } from '@aztec-labs/validator-client';
+import { DutyAlreadySignedError } from '@aztec-labs/validator-ha-signer/errors';
+import { DutyType, type SigningContext } from '@aztec-labs/validator-ha-signer/types';
+import type { TypedDataDefinition } from 'viem';
+
+import type { SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import type { SequencerMetrics } from './metrics.js';
+import type { SequencerRollupConstants } from './types.js';
+
+/**
+ * Handles governance and slashing voting for a given slot.
+ */
+export class CheckpointVoter {
+  private governanceSigner: (msg: TypedDataDefinition) => Promise<`0x${string}`>;
+  private slashingSigner: (msg: TypedDataDefinition) => Promise<`0x${string}`>;
+
+  constructor(
+    private readonly slot: SlotNumber,
+    private readonly publisher: SequencerPublisher,
+    private readonly attestorAddress: EthAddress,
+    private readonly validatorClient: ValidatorClient,
+    private readonly slasherClient: SlasherClientInterface | undefined,
+    private readonly l1Constants: SequencerRollupConstants,
+    private readonly config: ResolvedSequencerConfig,
+    private readonly metrics: SequencerMetrics,
+    private readonly log: Logger,
+  ) {
+    // Create separate signers with appropriate duty contexts for governance and slashing votes
+    // These use HA protection to ensure only one node signs per slot/duty
+    const governanceContext: SigningContext = { slot: this.slot, dutyType: DutyType.GOVERNANCE_VOTE };
+    this.governanceSigner = (msg: TypedDataDefinition) =>
+      this.validatorClient.signWithAddress(this.attestorAddress, msg, governanceContext).then(s => s.toString());
+
+    const slashingContext: SigningContext = { slot: this.slot, dutyType: DutyType.SLASHING_VOTE };
+    this.slashingSigner = (msg: TypedDataDefinition) =>
+      this.validatorClient.signWithAddress(this.attestorAddress, msg, slashingContext).then(s => s.toString());
+  }
+
+  /**
+   * Enqueues governance and slashing votes with the publisher.
+   * Returns a tuple of promises that resolve to whether each vote was successfully enqueued.
+   */
+  enqueueVotes(): [Promise<boolean | undefined>, Promise<boolean | undefined>] {
+    try {
+      const enqueueGovernancePromise = this.enqueueGovernanceVote();
+      const enqueueSlashingPromise = this.enqueueSlashingVote();
+
+      return [enqueueGovernancePromise, enqueueSlashingPromise];
+    } catch (err) {
+      this.log.error(`Error enqueueing governance and slashing votes`, err);
+      return [Promise.resolve(false), Promise.resolve(false)];
+    }
+  }
+
+  private async enqueueGovernanceVote(): Promise<boolean | undefined> {
+    const governanceProposerPayload = this.config.governanceProposerPayload;
+    if (!governanceProposerPayload || governanceProposerPayload.isZero()) {
+      return undefined;
+    }
+
+    this.log.info(`Enqueuing vote for ${governanceProposerPayload} governance for slot ${this.slot}`, {
+      slot: this.slot,
+      governanceProposerPayload: governanceProposerPayload.toString(),
+    });
+
+    try {
+      return await this.publisher.enqueueGovernanceCastSignal(
+        governanceProposerPayload,
+        this.slot,
+        this.attestorAddress,
+        this.governanceSigner,
+      );
+    } catch (err) {
+      if (err instanceof DutyAlreadySignedError) {
+        this.log.info(`Governance vote already signed by another node`, {
+          slot: this.slot,
+          signedByNode: err.signedByNode,
+        });
+      } else {
+        this.log.error(`Error enqueueing governance vote`, err);
+      }
+      return false;
+    }
+  }
+
+  private async enqueueSlashingVote(): Promise<boolean | undefined> {
+    try {
+      const actions = await this.slasherClient?.getProposerActions(this.slot);
+      if (!actions || actions.length === 0) {
+        return undefined;
+      }
+
+      this.log.info(`Enqueuing vote for ${actions.length} slashing actions for slot ${this.slot}`, {
+        slot: this.slot,
+        actionCount: actions.length,
+      });
+
+      this.metrics.recordSlashingAttempt(actions.length);
+
+      return await this.publisher.enqueueSlashingActions(actions, this.slot, this.attestorAddress, this.slashingSigner);
+    } catch (err) {
+      if (err instanceof DutyAlreadySignedError) {
+        this.log.info(`Slashing vote already signed by another node`, {
+          slot: this.slot,
+          signedByNode: err.signedByNode,
+        });
+      } else {
+        this.log.error(`Error enqueueing slashing vote`, err);
+      }
+      return false;
+    }
+  }
+}

package/src/sequencer/config.ts

@@ -0,0 +1,9 @@
+import type { GovernanceProposerContract } from '@aztec-labs/ethereum/contracts';
+import type { RollupContract } from '@aztec-labs/ethereum/contracts/rollup';
+
+export { type SequencerConfig } from '@aztec-labs/stdlib/config';
+
+export type SequencerContracts = {
+  rollupContract: RollupContract;
+  governanceProposerContract: GovernanceProposerContract;
+};

package/src/sequencer/errors.ts

@@ -0,0 +1,21 @@
+import type { SequencerState } from './utils.js';
+
+export class SequencerTooSlowError extends Error {
+  constructor(
+    public readonly proposedState: SequencerState,
+    public readonly maxAllowedTime: number,
+    public readonly currentTime: number,
+  ) {
+    super(
+      `Too far into slot for ${proposedState} (time into slot ${currentTime}s greater than ${maxAllowedTime}s allowance)`,
+    );
+    this.name = 'SequencerTooSlowError';
+  }
+}
+
+export class SequencerInterruptedError extends Error {
+  constructor() {
+    super(`Sequencer was interrupted`);
+    this.name = 'SequencerInterruptedError';
+  }
+}

package/src/sequencer/events.ts

@@ -0,0 +1,93 @@
+import type {
+  BlockNumber,
+  CheckpointNumber,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec-labs/foundation/branded-types';
+import type { BlockHash } from '@aztec-labs/stdlib/block';
+
+import type { Action } from '../publisher/sequencer-publisher.js';
+import type { SequencerState } from './utils.js';
+
+export type SequencerEvents = {
+  /**
+   * Emitted on every sequencer state transition (including no-op transitions to the same state). The
+   * timing fields are anchored to the build frame of the slot being proposed for, not to wall-clock
+   * slot boundaries, because the proposer builds for `targetSlot` during the previous (build) slot.
+   *
+   * - `oldState` / `newState` are the previous and new {@link SequencerState}.
+   * - `secondsIntoBuildFrame` is the wall-clock seconds elapsed since the build-frame start of
+   *   `targetSlot` (`now − getBuildFrameStart(targetSlot)`). Undefined for lifecycle states with no
+   *   associated slot (e.g. IDLE/STOPPING). It can be negative if the transition happens before the
+   *   build frame opens.
+   * - `targetSlot` is the slot the checkpoint is being proposed for (the submission slot, one ahead of
+   *   the wall-clock build slot under pipelining). Undefined for lifecycle states with no slot.
+   */
+  ['state-changed']: (args: {
+    oldState: SequencerState;
+    newState: SequencerState;
+    secondsIntoBuildFrame?: number;
+    targetSlot?: SlotNumber;
+  }) => void;
+  /**
+   * Emitted by the sequencer once it has decided it is going to attempt to build a
+   * checkpoint for `targetSlot`, after computing the L1 simulation overrides used by
+   * `canProposeAt`. Fired BEFORE the L1 simulation is run, so consumers can observe the
+   * decision regardless of whether the propose ultimately lands.
+   *
+   * - `hadProposedParent` indicates whether the build saw a proposed (pipelined) parent
+   *   checkpoint that hasn't landed on L1 yet.
+   * - `provenOverride` is the assumed proven checkpoint number pinned for the L1
+   *   simulation. The plan always pins both chain tips to short-circuit `canPruneAtTime`,
+   *   so this is populated whenever a simulation plan was built — the value either
+   *   matches the on-chain proven snapshot (defensive pin) or the assumed-proven
+   *   checkpoint when building optimistically across a pruning boundary.
+   * - `simulatedPending` is the pending checkpoint passed to L1 simulation. The plan
+   *   always pins both chain tips to short-circuit `canPruneAtTime`, so this reflects
+   *   either the pipelined/invalidated tip or the on-chain pending snapshot.
+   */
+  ['preparing-checkpoint']: (args: {
+    targetSlot: SlotNumber;
+    checkpointNumber: CheckpointNumber;
+    hadProposedParent: boolean;
+    provenOverride: CheckpointNumber | undefined;
+    simulatedPending: CheckpointNumber | undefined;
+  }) => void;
+  ['proposer-rollup-check-failed']: (args: { reason: string; slot: SlotNumber }) => void;
+  ['block-tx-count-check-failed']: (args: { minTxs: number; slot: SlotNumber }) => void;
+  ['block-build-failed']: (args: { reason: string; slot: SlotNumber }) => void;
+  ['block-proposed']: (args: {
+    blockNumber: BlockNumber;
+    blockHash: BlockHash;
+    checkpointNumber: CheckpointNumber;
+    indexWithinCheckpoint: IndexWithinCheckpoint;
+    slot: SlotNumber;
+    buildSlot: SlotNumber;
+  }) => void;
+  ['checkpoint-empty']: (args: { slot: SlotNumber }) => void;
+  /**
+   * Emitted when the proposer's pre-broadcast `validateCheckpointHeader` simulation fails. This is a
+   * last-chance check before we gossip a checkpoint proposal: a failure here means the header
+   * would not be accepted by L1 (e.g. archive mismatch, stale chain tip, or some other state
+   * drift between when we built the checkpoint and when we are about to broadcast it).
+   */
+  ['header-validation-failed']: (args: {
+    slot: SlotNumber;
+    checkpointNumber: CheckpointNumber;
+    reason: string;
+  }) => void;
+  ['checkpoint-publish-failed']: (args: {
+    slot: SlotNumber;
+    successfulActions?: Action[];
+    failedActions?: Action[];
+    sentActions?: Action[];
+    expiredActions?: Action[];
+  }) => void;
+  ['checkpoint-published']: (args: { checkpoint: CheckpointNumber; slot: SlotNumber }) => void;
+  ['checkpoint-error']: (args: { error: Error }) => void;
+  ['pipelined-checkpoint-discarded']: (args: {
+    slot: SlotNumber;
+    checkpointNumber: CheckpointNumber;
+    reason: string;
+  }) => void;
+};

package/src/sequencer/inbox_bucket_selector.ts

@@ -0,0 +1,160 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type InboxBucket, type L1ToL2MessageSource, isInboxConsumptionSufficient } from '@aztec-labs/stdlib/messaging';
+
+/** The subset of the archiver's Inbox-bucket queries the selector needs. */
+export type InboxBucketSource = Pick<
+  L1ToL2MessageSource,
+  'getInboxBucket' | 'getLatestInboxBucketAtOrBefore' | 'getL1ToL2MessagesBetweenBuckets'
+>;
+
+/**
+ * The last-consumed Inbox bucket a block streams from. Only the sequence number and cumulative message count are
+ * needed: the sequence number bounds the derived bundle, and the count is the per-block/per-checkpoint cap origin.
+ * At a checkpoint's first block this is the parent checkpoint's last-consumed bucket; the genesis base case is
+ * `{ seq: 0, totalMsgCount: 0 }` (bundles derive from the start of the Inbox).
+ */
+export type ConsumedBucketCursor = Pick<InboxBucket, 'seq' | 'totalMsgCount'>;
+
+/** Inputs to a single block's streaming Inbox-bucket selection. */
+export type SelectInboxBucketInput = {
+  /** Archiver Inbox-bucket queries. */
+  messageSource: InboxBucketSource;
+  /** Wall-clock time of this sub-slot, in seconds; the lag-eligibility anchor. */
+  now: bigint;
+  /**
+   * Minimum bucket age in seconds for a bucket to be lag-eligible this sub-slot: one configured Ethereum slot, the
+   * same value the validator's acceptance check applies (which documents why age in seconds is only a proxy for the
+   * L1 reorg depth this really guards against).
+   */
+  minBucketAgeSeconds: bigint;
+  /** The last bucket consumed by this checkpoint so far (parent checkpoint's at the first block). */
+  parent: ConsumedBucketCursor;
+  /** Cumulative Inbox message count consumed as of the parent checkpoint; the per-checkpoint cap origin. */
+  checkpointStartTotalMsgCount: bigint;
+  /** Maximum number of messages this block may consume. */
+  perBlockCap: number;
+  /** Maximum number of messages the checkpoint may consume in total. */
+  perCheckpointCap: number;
+  /** True on the checkpoint's final block, where the censorship cutoff becomes a consumption floor. */
+  isLastBlock: boolean;
+  /**
+   * Censorship cutoff timestamp from `getInboxCutoffTimestamp` (mirrors `ProposeLib.validateInboxConsumption`).
+   * Buckets opened at or before it are mandatory to consume by the checkpoint's last block.
+   */
+  cutoffTimestamp: bigint;
+};
+
+/** Whether and through which bucket a block consumes. */
+type InboxBucketConsumption =
+  | {
+      /** The block consumes messages, advancing to `bucket`. */
+      consume: true;
+      /** The newest bucket this block consumes through. */
+      bucket: InboxBucket;
+      /** The message leaves consumed this block, in insertion order (may be empty for an empty bucket). */
+      bundle: Fr[];
+    }
+  | {
+      /** The block consumes nothing; it reuses the parent bucket reference. */
+      consume: false;
+    };
+
+/** Result of a block's streaming Inbox-bucket selection. */
+export type InboxBucketSelection = InboxBucketConsumption & {
+  /**
+   * Set on the checkpoint's final block when the selected position still leaves a mandatory bucket unconsumed, so no
+   * checkpoint ending on this block can satisfy the censorship floor. The consumption fields still describe the best
+   * reachable prefix, but proposing it would produce a checkpoint every honest validator refuses to attest and that
+   * L1 `propose` would revert, so the caller is expected to abandon the checkpoint rather than build on it.
+   */
+  insufficientFinalBlockCapacity?: true;
+};
+
+/**
+ * Selects the newest Inbox bucket a block streams from, mirroring the L1 consumption predicate in
+ * `ProposeLib.validateInboxConsumption`. The policy, per block:
+ *
+ * 1. Pick the newest lag-eligible bucket: the newest bucket opened at or before `now - minBucketAgeSeconds`. On the
+ *    checkpoint's last block, also consider the cutoff bucket (newest opened at or before `cutoffTimestamp`) and take
+ *    whichever is newer, so the checkpoint reaches the censorship floor even if the sub-slot lag preferred less.
+ * 2. If nothing is newer than the parent bucket, consume nothing.
+ * 3. Otherwise walk back from the candidate to the newest bucket whose consumption fits both the per-block cap
+ *    (`bucket.totalMsgCount - parent.totalMsgCount`) and the per-checkpoint cap
+ *    (`bucket.totalMsgCount - checkpointStartTotalMsgCount`). If even the first bucket past the parent overshoots the
+ *    per-checkpoint cap, consume nothing — the L1 cap-escape (`ProposeLib` allows leaving a bucket unconsumed when
+ *    consuming through it would exceed the per-checkpoint cap).
+ * 4. On the last block only, check the resulting position against the censorship floor with the shared
+ *    `isInboxConsumptionSufficient` predicate. Because buckets are indivisible, the walk-back in step 3 can be forced
+ *    onto a prefix that still leaves a mandatory bucket behind; that is reported as
+ *    `insufficientFinalBlockCapacity` rather than passed off as a usable selection.
+ *
+ * The `<=` comparisons make a bucket exactly `minBucketAgeSeconds` old lag-eligible and a bucket exactly at the cutoff
+ * mandatory, matching the strict `>` "past cutoff" test on L1 (`next.timestamp > cutoff` leaves it optional).
+ *
+ * A single bucket never exceeds the per-block cap by construction (the Inbox bucket size is at most the per-block cap),
+ * so per-block walk-back always lands on at least one bucket; only the per-checkpoint cap can force consuming nothing.
+ */
+export async function selectInboxBucketForBlock(input: SelectInboxBucketInput): Promise<InboxBucketSelection> {
+  const consumption = await selectConsumption(input);
+  if (!input.isLastBlock) {
+    return consumption;
+  }
+
+  const { messageSource, parent, checkpointStartTotalMsgCount, perCheckpointCap, cutoffTimestamp } = input;
+  const finalSeq = consumption.consume ? consumption.bucket.seq : parent.seq;
+  const nextBucket = await messageSource.getInboxBucket(finalSeq + 1n);
+  const sufficient = isInboxConsumptionSufficient({
+    nextBucket,
+    cutoffTimestamp,
+    checkpointStartTotalMsgCount,
+    perCheckpointCap,
+  });
+  return sufficient ? consumption : { ...consumption, insufficientFinalBlockCapacity: true };
+}
+
+/** Steps 1 to 3 of {@link selectInboxBucketForBlock}: the cap-bounded walk back from the newest eligible bucket. */
+async function selectConsumption(input: SelectInboxBucketInput): Promise<InboxBucketConsumption> {
+  const {
+    messageSource,
+    now,
+    minBucketAgeSeconds,
+    parent,
+    checkpointStartTotalMsgCount,
+    perBlockCap,
+    perCheckpointCap,
+    isLastBlock,
+    cutoffTimestamp,
+  } = input;
+
+  let candidate = await messageSource.getLatestInboxBucketAtOrBefore(now - minBucketAgeSeconds);
+
+  if (isLastBlock) {
+    const cutoffBucket = await messageSource.getLatestInboxBucketAtOrBefore(cutoffTimestamp);
+    if (cutoffBucket !== undefined && (candidate === undefined || cutoffBucket.seq > candidate.seq)) {
+      candidate = cutoffBucket;
+    }
+  }
+
+  if (candidate === undefined || candidate.seq <= parent.seq) {
+    return { consume: false };
+  }
+
+  const perBlockCapBig = BigInt(perBlockCap);
+  const perCheckpointCapBig = BigInt(perCheckpointCap);
+
+  let selected: InboxBucket | undefined = candidate;
+  while (selected !== undefined && selected.seq > parent.seq) {
+    const blockCount = selected.totalMsgCount - parent.totalMsgCount;
+    const checkpointCount = selected.totalMsgCount - checkpointStartTotalMsgCount;
+    if (blockCount <= perBlockCapBig && checkpointCount <= perCheckpointCapBig) {
+      const bundle = await messageSource.getL1ToL2MessagesBetweenBuckets(parent.seq, selected.seq);
+      return { consume: true, bucket: selected, bundle };
+    }
+    if (selected.seq - 1n <= parent.seq) {
+      break;
+    }
+    selected = await messageSource.getInboxBucket(selected.seq - 1n);
+  }
+
+  return { consume: false };
+}

package/src/sequencer/index.ts

@@ -0,0 +1,5 @@
+export * from './checkpoint_proposal_job.js';
+export * from './checkpoint_voter.js';
+export * from './config.js';
+export * from './events.js';
+export * from './sequencer.js';