@aztec/sequencer-client 5.0.0-private.20260319 → 6.0.0-nightly.20260602

package/README.md

@@ -1,45 +1,306 @@
 # Sequencer Client
 
-The sequencer is a module responsible for creating and publishing new rollup blocks. This involves fetching txs from the P2P pool, ordering them, executing any public functions, running them through the rollup circuits, assembling the L2 block, and posting it to the L1 rollup contract along with any contract deployment public data.
+The sequencer client is the proposer-side counterpart to the [validator client](../validator-client/README.md): it builds checkpoints, broadcasts the block and checkpoint proposals that validators attest to, and publishes the resulting checkpoint to L1. It runs on any node whose configured validator address has been selected as proposer for the current (or next) slot.
 
-The client itself is implemented as a continuous loop. After being started, it polls the P2P pool for new txs, assembles a new block if any is found, and goes back to sleep. On every new block assembled, it modifies the world state database to reflect the txs processed, but these changes are only committed once the world state synchronizer sees the new block on L1.
+A single instance owns the entire proposer flow for one slot: deciding whether to propose, building several L2 blocks one after another, signing them, gossiping them, collecting attestations from the committee, and submitting the final checkpoint to L1 in one Multicall3 transaction together with governance and slashing votes.
 
-## Components
+The sequencer does **not** decide what is in the next block on its own. It composes the work of several other subsystems: the [tx pool](../p2p/README.md) supplies transactions, the [validator client](../validator-client/README.md) owns operator keys and contains the `CheckpointBuilder` that actually executes them, the [archiver](../archiver/README.md) provides the L2 chain state needed to anchor each block, the [epoch cache](../epoch-cache/README.md) answers proposer/committee lookups, and the [slasher](../slasher/README.md) supplies offenses to vote on.
 
-_What components are used to build a sequencer client._
+## Key Concepts
 
-- The **block builder** is responsible for assembling an L2 block out of a set of processed transactions (we say a tx has been _processed_ if all its function calls have been executed). This involves running the txs through the base, merge, and rollup circuits, updating the world state trees, and building the L2 block object.
+### Slots, Blocks, and Checkpoints
 
-- The **prover** generates proofs for every circuit used. For the time being, no proofs are being actually generated, so the only implementation is an empty one.
+The Aztec consensus design splits each Aztec slot into multiple L2 blocks. This is the design originally called [building in chunks](https://github.com/AztecProtocol/engineering-designs/blob/main/docs/building-in-chunks/index.md).
 
-- The **publisher** deals with sending L1 transactions to the rollup and contract deployment emitter contracts. It is responsible for assembling the Ethereum tx, choosing reasonable gas settings, and monitoring the tx until it gets mined. Note that the current implementation does not handle unstable network conditions (gas price spikes, reorgs, etc).
+- **Slot** — a fixed time window (e.g. 72 s) during which one proposer is allowed to build.
+- **Block** — a single batch of transactions, executed and validated as a unit, with its own header.
+- **Checkpoint** — the collection of all blocks built within one slot. The proposer commits to a checkpoint on L1 by submitting a `propose` transaction containing the aggregated header, the blocks' tx effects (as blobs), and the committee attestations.
+- **Sub-slot** — a fixed-duration window within the slot during which one block is built. Sub-slots are equal in length and have deadlines fixed relative to the start of the slot.
 
-- The **public processor** executes any public function calls in the transactions. Unlike private function calls, which are resolved in the client, public functions require access to the latest data trees, so they are executed by the sequencer, much like in any non-private L2.
+Several blocks per slot is intentional: it amortizes the fixed L1 cost of a checkpoint over more transactions, and it lets the rest of the network reach a usable state-root much sooner than the full L1 confirmation latency.
 
-- The **simulator** is an interface to the wasm implementations of the circuits used by the sequencer.
+### Proposed vs Checkpointed Chain
 
-- The **sequencer** pulls txs from the P2P pool, orchestrates all the components above to assemble and publish a block, and updates the world state database.
+There are two tips the sequencer cares about:
 
-## Circuits
+- The **proposed chain** is the set of blocks that have been broadcast over p2p but not yet committed to L1. Both the sequencer and validators push these blocks into the archiver so the rest of the node can serve them.
+- The **checkpointed chain** is the set of checkpoints that have landed on L1, recovered from `CheckpointProposed` events.
 
-_What circuits does the sequencer depend on._
+Within a slot, the proposer adds blocks to the proposed chain as it goes. Only the last block within the slot is bundled with a `CheckpointProposal` that committee members attest to; intermediate blocks are accepted onto the proposed chain by virtue of the proposer's signature alone, and every node that wants to follow the proposed chain re-executes them. See the [validator client README](../validator-client/README.md) for the consumer side.
 
-- The **public circuit** is responsible for proving the execution of Brillig (public function bytecode). At the moment, we are using a fake version that actually runs ACIR (intermediate representation for private functions) and does not emit any proofs.
+### Proposer Pipelining
 
-- The **public kernel circuit** then validates the output of the public circuit, and outputs a set of changes to the world state in the same format as the private kernel circuit, meaning we get a standard representation for all txs, regardless of whether public or private functions (or both) were run. The kernel circuits are run iteratively for every recursive call in the transaction.
+The legacy ("non-pipelined") flow has the proposer for slot `N` build, attest, and publish inside slot `N`. The proposer spends most of `N` collecting attestations and waiting for the L1 transaction to be mined, leaving a long idle window. Pipelining, [proposed in this discussion](https://github.com/AztecProtocol/governance/discussions/8), removes that idle window: the proposer for slot `N` builds blocks during slot `N - 1`, finishes attestation collection before the slot boundary, and submits the L1 transaction at the start of slot `N`.
 
-- The **base rollup circuit** aggregates the changes from two txs (more precisely, the outputs from their kernel circuits once all call stacks are emptied) into a single output.
+Pipelining shifts the work like this:
 
-- The **merge rollup circuit** aggregates two outputs from base rollup circuits into a single one. This circuit is executed recursively until only two outputs are left. This setup means that an L2 block needs to contain always a power-of-two number of txs; if there are not enough, then empty txs are added.
+| Phase                              | Non-pipelined | Pipelined        |
+| ---------------------------------- | ------------- | ---------------- |
+| Block building                     | slot `N`      | slot `N - 1`     |
+| Last-block re-execution            | slot `N`      | slot `N - 1`     |
+| Attestation collection             | slot `N`      | slot `N - 1` *   |
+| L1 submission                      | slot `N`      | slot `N`         |
 
-- The **root rollup circuit** consumes two outputs from base or merge rollups and outputs the data to assemble an L2 block. The L1 rollup contract then verifies the proof from this circuit, which implies that all txs included in it were correct.
+\* The pipelined timing model reserves enough end-of-slot budget for attestations to be in hand by the slot boundary, but the enforced deadline (`checkpointAttestationDeadline`) actually extends to `2 * aztecSlotDuration - l1PublishingTime`, so a late attestation can still spill into the target slot.
+
+In practice, "non-pipelined mode" is being removed; this README treats pipelining as the default. The toggle still exists (`enableProposerPipelining`) because `EpochCache` consults it when looking up the proposer for the next L1 slot — when pipelining is enabled, the sequencer asks the cache for the proposer of `slot + 1` rather than `slot`.
+
+The pipelining flow introduces two failure modes that block building has to handle:
+
+- **Pipeline depth** is bounded to 2 (`checkpointNumber ≤ confirmedCheckpoint + 2`). Building further ahead would require trusting more in-flight parent proposals than the design allows.
+- **Pipelined parent invalidation**: if the parent checkpoint we built on top of fails to land cleanly on L1, the next proposer's work is discarded (`pipelined-checkpoint-discarded` event) and an `invalidate` request is enqueued for the parent.
+
+## Architecture
+
+```
+       ┌──────────────────────────────────────────────────────────────┐
+       │                          Sequencer                           │
+       │              (state machine, one slot at a time)             │
+       │                                                              │
+       │   work() ──► prepareCheckpointProposal() ──► proposal job    │
+       └─────┬────────────────┬──────────────────┬──────────────────┬─┘
+             │                │                  │                  │
+             ▼                ▼                  ▼                  ▼
+   ┌──────────────────┐  ┌──────────┐  ┌──────────────────┐ ┌────────────────┐
+   │ ValidatorClient  │  │ Epoch    │  │ CheckpointBuilder│ │ Sequencer      │
+   │  (owns keys,     │  │ Cache    │  │ (forked world    │ │ Publisher      │
+   │   HA signer,     │  │ (proposer│  │  state, per-block│ │ (Multicall3    │
+   │   signs the      │  │  +       │  │  execution via   │ │  L1 tx, with   │
+   │   proposals)     │  │  comm.)  │  │  PublicProcessor)│ │  pre-checks)   │
+   └──────────────────┘  └──────────┘  └──────────────────┘ └────────────────┘
+            │                              │                        │
+            │  block + checkpoint          │ pull txs               │
+            │  proposals over p2p          ▼                        ▼
+            │                          ┌──────────┐           ┌────────────┐
+            ├────────────────────────► │   Tx     │           │ L1 Rollup  │
+            │                          │ Provider │           │ Contract   │
+            │  push blocks to          └──────────┘           └────────────┘
+            ▼  proposed chain
+   ┌──────────────────┐
+   │     Archiver     │
+   │   (l2 tips,      │
+   │    addBlock)     │
+   └──────────────────┘
+```
+
+`SequencerClient.new(config, deps)` is the entrypoint and is constructed by the full node. It reads L1 constants (`l1GenesisTime`, `slotDuration`, `rollupManaLimit`) from the rollup contract, builds the publisher factory, validator client wiring, and timetable, then instantiates the `Sequencer`. See `src/client/sequencer-client.ts`.
+
+### Sequencer (work loop)
+
+`Sequencer` (`src/sequencer/sequencer.ts`) drives one slot at a time using a `RunningPromise` that ticks every `sequencerPollingIntervalMS` (default 500 ms). On each tick it:
+
+1. Asks the [epoch cache](../epoch-cache/README.md) for the slot at the next L1 block, and, when pipelining, for the *target* slot (`slot + 1`). Building runs during the wall-clock slot; the checkpoint commits to the target slot.
+2. Calls `prepareCheckpointProposal`, which:
+   - Dedupes against the last slot we tried to propose for.
+   - Runs `checkSync()` — verifies world-state, l2 block source, p2p, and l1-to-l2 message source agree on the parent tip.
+   - Checks the escape hatch (governance-controlled freeze) for the target epoch.
+   - Calls `checkCanPropose(targetSlot)` to verify one of our configured validator addresses is the elected proposer.
+   - Falls back to `considerInvalidatingCheckpoint()` if we are *not* the proposer but a previous checkpoint is stuck with bad attestations and the slot is far enough along to invalidate (`secondsBeforeInvalidatingBlockAsCommitteeMember` / `…AsNonCommitteeMember`).
+   - Refuses to build further than two checkpoints ahead of the confirmed tip when pipelining.
+   - Builds L1 `eth_call` simulation overrides (so `Rollup.canProposeAt` sees the expected pending tip when we are building on a pipelined parent or invalidating).
+   - Calls `publisher.canProposeAt(...)` — if L1 rejects the simulated propose, abort early.
+3. Constructs a `CheckpointProposalJob` and calls `.execute()`, parking the returned `pendingL1Submission` on the sequencer so `stop()` can await it without re-entering the loop.
+
+Each state transition flows through `setState()`, which calls `timetable.assertTimeLeft()`. If the slot has advanced past the deadline for the new state, this throws `SequencerTooSlowError` and the slot is abandoned.
+
+The sequencer is a `TypedEventEmitter<SequencerEvents>`. The most useful events are:
+
+| Event                              | When emitted                                                          |
+| ---------------------------------- | --------------------------------------------------------------------- |
+| `state-changed`                    | Every `setState()` call.                                              |
+| `preparing-checkpoint`             | After the canPropose check decides to build, before L1 simulation.    |
+| `block-proposed`                   | After `buildSingleBlock` succeeds, before sign + archiver push.       |
+| `checkpoint-published`             | After the L1 submission lands.                                        |
+| `checkpoint-publish-failed`        | Multicall3 tx failed or expired.                                      |
+| `pipelined-checkpoint-discarded`   | Pipelined parent failed to land; this slot's work is thrown away.     |
+| `checkpoint-error`                 | Catch-all: an exception escaped `work()`.                             |
+
+State enum (`src/sequencer/utils.ts`):
+
+```
+STOPPED → STOPPING → IDLE → SYNCHRONIZING → PROPOSER_CHECK
+       → INITIALIZING_CHECKPOINT
+       → (WAITING_FOR_TXS ↔ CREATING_BLOCK ↔ WAITING_UNTIL_NEXT_BLOCK)*
+       → ASSEMBLING_CHECKPOINT
+       → COLLECTING_ATTESTATIONS
+       → PUBLISHING_CHECKPOINT
+       → IDLE
+```
+
+### CheckpointProposalJob
+
+`CheckpointProposalJob` (`src/sequencer/checkpoint_proposal_job.ts`) is the per-slot unit of work. It owns the lifecycle from "we have decided to propose" through "the L1 transaction has been submitted". The contract is:
+
+- `execute()` returns once the checkpoint has been broadcast over p2p (or has failed before that). The L1 submission runs in the background as `pendingL1Submission`.
+- All work scheduled on the publisher (governance vote, slashing actions, propose, invalidate) is enqueued early and then flushed together in a single Multicall3 transaction.
+
+Inside `execute()`:
+
+1. **Vote enqueueing.** `CheckpointVoter.enqueueVotes()` signs and enqueues the governance and slashing vote requests up front. Even if block-building fails, these still go out in the final Multicall3 — they are the proposer's duty for the slot.
+2. **`proposeCheckpoint()`** (blocking, returns a `CheckpointProposal`):
+   - Transitions to `INITIALIZING_CHECKPOINT`. If there is a pending invalidation, enqueue it.
+   - Builds **pipelined-parent simulation overrides**: when building on top of a parent that hasn't landed on L1 yet, the fee-asset price modifier must be computed against the parent fee header we predicted (not the L1 one), so all in-flight checkpoints in the pipeline agree on the same modifier.
+   - Asks the global variables builder for the slot's `CheckpointGlobalVariables` (`coinbase`, `feeRecipient`, `timestamp`, `gasFees`, `chainId`, `version`, `slotNumber`). These are shared across every block within the checkpoint — only `blockNumber` increments.
+   - Computes `inHash` from the L1→L2 messages for the checkpoint, and collects `previousCheckpointOutHashes` for prior checkpoints in the same epoch.
+   - Forks world state at the parent (`closeDelayMs: 12 s`) and asks `FullNodeCheckpointsBuilder` for a `CheckpointBuilder` bound to that fork.
+   - Runs `buildBlocksForCheckpoint()` — the per-block loop, described below.
+   - Transitions to `ASSEMBLING_CHECKPOINT`, asks the builder to `completeCheckpoint()`, validates it against the configured caps, and asks the validator client to sign the `CheckpointProposal` (which bundles the final block proposal so the two travel together).
+   - Broadcasts the `CheckpointProposal` via p2p.
+3. **Attestation collection** (`waitForAttestationsAndEnqueueSubmissionAsync`) runs in the background:
+   - Transitions to `COLLECTING_ATTESTATIONS`. Reads the committee from `EpochCache`, computes the quorum (`2/3 + 1`), and waits for that many attestations on p2p. The validator client adds the proposer's own signature.
+   - If pipelining: `waitForValidParentCheckpointOnL1()` waits for the archiver to confirm the parent we built on top of has landed on L1 with matching hash and valid attestations. If not, the work is dropped (`pipelined-checkpoint-discarded`) and we enqueue an invalidation for the parent so the next proposer doesn't repeat the same mistake.
+   - Computes `submitAfter`: `getTimestampForSlot(targetSlot)` when pipelining (so the Multicall3 mines inside the target slot — EIP-712 signatures are bound to a slot and would silently fail if mined outside it), otherwise "now".
+   - Calls `publisher.sendRequestsAt(submitAfter)`, which sleeps until the deadline, re-runs each request's `preCheck` against fresh L1 state, and submits the bundled Multicall3.
+
+### Per-block loop (`buildBlocksForCheckpoint`)
+
+The per-block loop is the heart of the building flow:
+
+```
+loop:
+  timing = timetable.canStartNextBlock(secondsIntoSlot)
+  if !timing.canStart:                       break
+  if blocksBuilt >= maxBlocksPerCheckpoint:  break
+
+  state = WAITING_FOR_TXS
+  result = checkpointBuilder.buildBlock(
+              pendingTxs, blockNumber, timestamp,
+              { maxTransactions, maxBlockGas, deadline,
+                minValidTxs, maxBlocksPerCheckpoint, perBlockAllocationMultiplier })
+
+  if result is 'insufficient-txs' or 'insufficient-valid-txs':
+    if isLastBlock or no deadline:           break
+    else:                                    continue (try next sub-slot)
+  if result is error:                        halt
+
+  blockProposal = validatorClient.createBlockProposal(block)
+  archiver.addBlock(block)                   // push to proposed chain
+  if not timing.isLastBlock:
+    p2pClient.broadcastProposal(blockProposal)
+  else:
+    blockPendingBroadcast = blockProposal    // shipped with the CheckpointProposal
+
+  state = WAITING_UNTIL_NEXT_BLOCK
+  waitUntilNextSubSlot(timing.deadline)
+```
+
+The deadlines passed to `CheckpointBuilder.buildBlock` are absolute timestamps (`slotStart + timing.deadline`). The builder uses these as hard caps on tx execution, so a slow block cannot eat into the next sub-slot.
+
+`maxBlocksPerCheckpoint` (the timetable's `maxNumberOfBlocks`) and `perBlockAllocationMultiplier` (default 1.2) are passed in opts so that the builder can redistribute the remaining checkpoint budget (L2 gas, DA gas, blob fields, tx count) across the remaining blocks. See [validator-client/README.md § Block Building Limits](../validator-client/README.md#block-building-limits) for the redistribution math; the sequencer only sets the inputs.
+
+### Timetable
+
+`SequencerTimetable` (`src/sequencer/timetable.ts`) is a thin wrapper around `CheckpointTiming` (from `@aztec/stdlib/timetable`). It owns two responsibilities:
+
+- **Sub-slot scheduling**: `canStartNextBlock(secondsIntoSlot)` finds the next sub-slot with at least `minExecutionTime` remaining and returns its deadline and whether it is the last sub-slot. If we are running late, sub-slots are skipped; we never start a block we cannot finish.
+- **Per-state deadlines**: `getMaxAllowedTime(state)` returns the latest seconds-into-slot value a state is allowed to be entered; `assertTimeLeft()` enforces it.
+
+See [`src/sequencer/README.md`](src/sequencer/README.md) for the full timing model, including the pipelining math and the failure-mode walkthroughs.
+
+### SequencerPublisher
+
+`SequencerPublisher` (`src/publisher/sequencer-publisher.ts`) translates "I want to propose a checkpoint" into "submit this Multicall3 transaction to L1". It maintains an ordered queue of `RequestWithExpiry` entries — each one has a label (`propose`, `invalidate-by-*`, `governance-signal`, `vote-offenses`, `execute-slash`), a `preCheck` callback, and an ABI-encoded call. The queue is sorted so invalidations go first and proposes precede votes.
+
+Key entry points:
+
+- `canProposeAt(archive, msgSender, simulationOverridesPlan?)` — eth_call simulation of `Rollup.canProposeAt`. The sequencer runs this before deciding to build.
+- `enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, opts)` — adds the propose call, with a `preCheck` that re-validates the proposal against real L1 state when it is finally sent (catches drift between build time and submit time).
+- `enqueueInvalidateCheckpoint`, `enqueueGovernanceCastSignal`, `enqueueSlashingActions` — the rest of the actions a proposer may bundle.
+- `sendRequests()` — immediately flushes the queue as one Multicall3 transaction.
+- `sendRequestsAt(submitAfter)` — sleeps (cancellable) until `submitAfter`, runs each request's `preCheck` (dropping those that fail), and then calls `sendRequests()`, which filters expired requests, sorts the remainder, and submits one Multicall3. Pipelining is implemented entirely by passing `getTimestampForSlot(targetSlot)` here.
+
+`SequencerPublisherFactory` produces one publisher per attempt, wrapping an L1 publisher (EOA + `L1TxUtils`) leased from `PublisherManager`. Leases free the publisher when the job completes so multiple validator addresses on the same node can take turns without conflicts.
+
+### Other components
+
+| Component | File | Responsibility |
+| --- | --- | --- |
+| `CheckpointVoter` | `src/sequencer/checkpoint_voter.ts` | Signs and enqueues governance/slashing votes. Used by both the job and the "vote even though we can't propose" fallbacks. |
+| `GlobalVariableBuilder` | `src/global_variable_builder/` | Computes `CheckpointGlobalVariables` and predicts the per-slot fee asset price modifier. See its [README](src/global_variable_builder/README.md). |
+| `L1TxFailedStore` | `src/publisher/l1_tx_failed_store/` | Persists actions that returned a revert reason so they aren't retried in the same form on the next slot. |
+| `ChainStateOverrides` | `src/sequencer/chain_state_overrides.ts` | Builds the L1 `eth_call` overrides used during the pipelined parent + invalidation simulations. |
+| `AutomineSequencer` | `src/sequencer/automine/` | Minimal queue-driven sequencer for single-sequencer e2e tests. Bypasses consensus, pipelining, and timetable enforcement. See [`src/sequencer/automine/README.md`](src/sequencer/automine/README.md). |
+
+## Configuration
+
+The configuration object is `SequencerConfig` (`src/sequencer/config.ts` + `src/publisher/config.ts`). The options that most directly affect block building are:
+
+### Block budgets
+
+| Option / env var | Default | Purpose |
+| --- | --- | --- |
+| `minTxsPerBlock` / `SEQ_MIN_TX_PER_BLOCK` | 1 | Wait for at least this many txs before starting a block. |
+| `minValidTxsPerBlock` | falls back to `minTxsPerBlock` | After execution, discard the block if fewer txs validated. |
+| `maxTxsPerBlock` / `SEQ_MAX_TX_PER_BLOCK` | unset | Hard per-block tx cap (capped at `maxTxsPerCheckpoint` at startup). |
+| `maxTxsPerCheckpoint` / `SEQ_MAX_TX_PER_CHECKPOINT` | unset | Total tx cap across the checkpoint. Enables redistribution when set. |
+| `maxBlocksPerCheckpoint` / `MAX_BLOCKS_PER_CHECKPOINT` | 24 | Hard ceiling beyond what the timetable allows. Also caps the `indexWithinCheckpoint` accepted on inbound block proposals. |
+| `maxL2BlockGas` / `SEQ_MAX_L2_BLOCK_GAS` | unset | Per-block mana cap, capped at `rollupManaLimit`. |
+| `maxDABlockGas` / `SEQ_MAX_DA_BLOCK_GAS` | unset | Per-block DA gas cap, capped at `MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT`. |
+| `perBlockAllocationMultiplier` / `SEQ_PER_BLOCK_ALLOCATION_MULTIPLIER` | 1.2 | Multiplier passed to the checkpoint builder so early blocks can use slightly more than their even share. |
+| `redistributeCheckpointBudget` / `SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET` | true | Legacy flag. Redistribution is always on during proposal building. |
+
+### Timing
+
+| Option / env var | Default | Purpose |
+| --- | --- | --- |
+| `blockDurationMs` / `SEQ_BLOCK_DURATION_MS` | unset | Length of one sub-slot in ms. `undefined` falls back to single-block-per-slot mode (used by tests / sandbox). |
+| `enforceTimeTable` / `SEQ_ENFORCE_TIME_TABLE` | true | If false, deadlines are not enforced and a single block is built with unbounded time. |
+| `attestationPropagationTime` / `SEQ_ATTESTATION_PROPAGATION_TIME` | 2 s | One-way p2p estimate fed to the timetable. |
+| `l1PublishingTime` / `SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT` | full L1 slot | Time reserved for the L1 tx to land. |
+| `sequencerPollingIntervalMS` / `SEQ_POLLING_INTERVAL_MS` | 500 | Work-loop tick rate. |
+| `enableProposerPipelining` / `SEQ_ENABLE_PROPOSER_PIPELINING` | false | When true, the sequencer builds for `slot + 1`. The flag lives in shared `PipelineConfig` and is read by `EpochCache`, not by the sequencer directly. |
+
+### Behavior
+
+| Option / env var | Default | Purpose |
+| --- | --- | --- |
+| `buildCheckpointIfEmpty` / `SEQ_BUILD_CHECKPOINT_IF_EMPTY` | false | Build and submit even when no txs are available. |
+| `publishTxsWithProposals` / `SEQ_PUBLISH_TXS_WITH_PROPOSALS` | false | Embed full transactions in p2p block proposals (DA fallback for validators). |
+| `fishermanMode` / `FISHERMAN_MODE` | false | Build internally for monitoring; never publish. |
+| `coinbase` / `COINBASE` | proposer addr | Recipient of block rewards. |
+| `feeRecipient` / `FEE_RECIPIENT` | proposer addr | Recipient of tx fees. |
+| `governanceProposerPayload` / `GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS` | unset | Payload signaled in the governance vote each slot. |
+| `secondsBeforeInvalidatingBlockAsCommitteeMember` | 144 | When *not* the proposer, committee members may invalidate a stuck checkpoint after this many seconds into the slot. |
+| `secondsBeforeInvalidatingBlockAsNonCommitteeMember` | 432 | Same for any node — last resort. |
+
+The full list (including test/fault-injection hooks like `pauseProposingForSlots` and `skipPublishingCheckpointsPercent`) lives in `src/config.ts`.
+
+## Failure modes
+
+- **Not the proposer**: `checkCanPropose` returns false → no work done. If a previous checkpoint is stuck with invalid attestations and we are past the configured invalidation threshold, we fall through to `considerInvalidatingCheckpoint` and may still submit an invalidation tx.
+- **Out of sync**: `checkSync` fails → governance/slashing votes still go out via `tryVoteWhenSyncFails`, but no block is built.
+- **Insufficient txs in a sub-slot**: `CheckpointBuilder.buildBlock` returns `insufficient-txs`. The sub-slot is skipped without committing state; the next sub-slot retries. On the last sub-slot, if `buildCheckpointIfEmpty` is true, the block is still built with whatever is available (possibly zero txs).
+- **Sub-slot deadline exceeded**: `CheckpointBuilder` enforces the deadline and stops executing further txs. The block is finalized with whatever fit.
+- **Timetable deadline exceeded**: `assertTimeLeft` throws `SequencerTooSlowError`. The current slot is abandoned and the loop resets to `IDLE`.
+- **Pipelined parent fails on L1**: `waitForValidParentCheckpointOnL1` returns false. The whole proposal is discarded (`pipelined-checkpoint-discarded`), the parent is enqueued for invalidation, and the L1 submission for *this* checkpoint is not sent.
+- **L1 submission reverts or expires**: `checkpoint-publish-failed` is emitted with the individual action results so observability can break down which actions in the Multicall3 went through and which didn't.
+
+## Where to look first
+
+| Question | File |
+| --- | --- |
+| How does the work loop decide whether to propose? | `src/sequencer/sequencer.ts` → `prepareCheckpointProposal`, `checkCanPropose` |
+| How does a checkpoint get built block-by-block? | `src/sequencer/checkpoint_proposal_job.ts` → `proposeCheckpoint`, `buildBlocksForCheckpoint` |
+| How do sub-slot deadlines work? | `src/sequencer/timetable.ts` + `src/sequencer/README.md` |
+| How does an L1 transaction get scheduled and submitted? | `src/publisher/sequencer-publisher.ts` → `sendRequestsAt` |
+| How does pipelining wait for the parent to land? | `src/sequencer/checkpoint_proposal_job.ts` → `waitForValidParentCheckpointOnL1` |
+| How do governance and slashing votes get into the L1 tx? | `src/sequencer/checkpoint_voter.ts` |
+| How are fees predicted for the slot? | `src/global_variable_builder/README.md` |
+| How are full-node services wired together? | `src/client/sequencer-client.ts` |
 
 ## Development
 
-Start by running `bootstrap.sh` in the project root.
+Build, format, lint, and test from `yarn-project/`:
 
-To build the package, run `yarn build` in the root.
+```bash
+yarn workspace @aztec/sequencer-client build
+yarn workspace @aztec/sequencer-client test
+```
 
-To watch for changes, `yarn build:dev`.
+The integration tests of interest are:
 
-To run the tests, execute `yarn test`.
+- `src/sequencer/sequencer.test.ts` — work-loop behavior, escape-hatch and invalidation fallbacks.
+- `src/sequencer/checkpoint_proposal_job.test.ts` — full per-slot job, both pipelined and non-pipelined.
+- `src/sequencer/checkpoint_proposal_job.timing.test.ts` — sub-slot timing and skip behavior under simulated clock drift.
+- `src/sequencer/timetable.test.ts` — pure math against `CheckpointTiming`.
+- `src/publisher/sequencer-publisher.test.ts` — request ordering, `sendRequestsAt`, preCheck re-runs.

package/dest/client/sequencer-client.d.ts

@@ -7,12 +7,13 @@ import type { DateProvider } from '@aztec/foundation/timer';
 import type { KeystoreManager } from '@aztec/node-keystore';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
-import type { L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import type { L2BlockSink, L2BlockSource, ProposedCheckpointSink } from '@aztec/stdlib/block';
 import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { L1Metrics, type TelemetryClient } from '@aztec/telemetry-client';
 import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
 import { type SequencerClientConfig } from '../config.js';
+import type { GlobalVariableBuilder } from '../global_variable_builder/index.js';
 import { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
 import { Sequencer, type SequencerConfig } from '../sequencer/index.js';
 /**
@@ -44,7 +45,7 @@ export declare class SequencerClient {
         worldStateSynchronizer: WorldStateSynchronizer;
         slasherClient: SlasherClientInterface | undefined;
         checkpointsBuilder: FullNodeCheckpointsBuilder;
-        l2BlockSource: L2BlockSource & L2BlockSink;
+        l2BlockSource: L2BlockSource & L2BlockSink & ProposedCheckpointSink;
         l1ToL2MessageSource: L1ToL2MessageSource;
         telemetry: TelemetryClient;
         publisherFactory?: SequencerPublisherFactory;
@@ -52,7 +53,9 @@ export declare class SequencerClient {
         dateProvider: DateProvider;
         epochCache?: EpochCache;
         l1TxUtils: L1TxUtils[];
+        funderL1TxUtils?: L1TxUtils;
         nodeKeyStore: KeystoreManager;
+        globalVariableBuilder: GlobalVariableBuilder;
     }): Promise<SequencerClient>;
     /**
      * Updates sequencer and validator client config.
@@ -65,6 +68,8 @@ export declare class SequencerClient {
      * Stops the sequencer from processing new txs.
      */
     stop(): Promise<void>;
+    /** Triggers an immediate run of the sequencer, bypassing the polling interval. */
+    trigger(): Promise<void> | undefined;
     getSequencer(): Sequencer;
     /** Updates the publisher factory's node keystore adapter after a keystore reload. */
     updatePublisherNodeKeyStore(adapter: NodeKeystoreAdapter): void;
@@ -73,4 +78,4 @@ export declare class SequencerClient {
     get validatorAddresses(): EthAddress[] | undefined;
     get maxL2BlockGas(): number | undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/client/sequencer-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequencer-client.d.ts","sourceRoot":"","sources":["../../src/client/sequencer-client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sequencer-client.d.ts","sourceRoot":"","sources":["../../src/client/sequencer-client.ts"],"names":[],"mappings":"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"}

package/dest/client/sequencer-client.js

@@ -4,13 +4,10 @@ import { isAnvilTestChain } from '@aztec/ethereum/chain';
 import { getPublicClient } from '@aztec/ethereum/client';
 import { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
 import { PublisherManager } from '@aztec/ethereum/publisher-manager';
-import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import { L1Metrics } from '@aztec/telemetry-client';
 import { NodeKeystoreAdapter } from '@aztec/validator-client';
 import { getPublisherConfigFromSequencerConfig } from '../config.js';
-import { GlobalVariableBuilder } from '../global_variable_builder/index.js';
 import { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
 import { Sequencer } from '../sequencer/index.js';
 /**
@@ -48,16 +45,18 @@ import { Sequencer } from '../sequencer/index.js';
         const publicClient = getPublicClient(config);
         const l1TxUtils = deps.l1TxUtils;
         const l1Metrics = new L1Metrics(telemetryClient.getMeter('L1PublisherMetrics'), publicClient, l1TxUtils.map((x)=>x.getSenderAddress()));
-        const publisherManager = new PublisherManager(l1TxUtils, getPublisherConfigFromSequencerConfig(config), log.getBindings());
-        const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
-        const [l1GenesisTime, slotDuration, rollupVersion, rollupManaLimit] = await Promise.all([
+        const publisherManager = new PublisherManager(l1TxUtils, getPublisherConfigFromSequencerConfig(config), {
+            bindings: log.getBindings(),
+            funder: deps.funderL1TxUtils
+        });
+        const rollupContract = new RollupContract(publicClient, config.rollupAddress.toString());
+        const [l1GenesisTime, slotDuration, rollupManaLimit] = await Promise.all([
             rollupContract.getL1GenesisTime(),
             rollupContract.getSlotDuration(),
-            rollupContract.getVersion(),
             rollupContract.getManaLimit().then(Number)
         ]);
-        const governanceProposerContract = new GovernanceProposerContract(publicClient, config.l1Contracts.governanceProposerAddress.toString());
-        const epochCache = deps.epochCache ?? await EpochCache.create(config.l1Contracts.rollupAddress, {
+        const governanceProposerContract = new GovernanceProposerContract(publicClient, config.governanceProposerAddress.toString());
+        const epochCache = deps.epochCache ?? await EpochCache.create(config.rollupAddress, {
             l1RpcUrls: rpcUrls,
             l1ChainId: chainId,
             viemPollingIntervalMS: config.viemPollingIntervalMS,
@@ -66,13 +65,11 @@ import { Sequencer } from '../sequencer/index.js';
         }, {
             dateProvider: deps.dateProvider
         });
-        const slashFactoryContract = new SlashFactoryContract(publicClient, config.l1Contracts.slashFactoryAddress?.toString() ?? EthAddress.ZERO.toString());
         const publisherFactory = deps.publisherFactory ?? new SequencerPublisherFactory(config, {
             telemetry: telemetryClient,
             blobClient: deps.blobClient,
             epochCache,
             governanceProposerContract,
-            slashFactoryContract,
             rollupContract,
             dateProvider: deps.dateProvider,
             publisherManager,
@@ -80,13 +77,7 @@ import { Sequencer } from '../sequencer/index.js';
             logger: log
         });
         const ethereumSlotDuration = config.ethereumSlotDuration;
-        const globalsBuilder = new GlobalVariableBuilder({
-            ...config,
-            l1GenesisTime,
-            slotDuration: Number(slotDuration),
-            ethereumSlotDuration,
-            rollupVersion
-        });
+        const globalsBuilder = deps.globalVariableBuilder;
         // When running in anvil, assume we can post a tx up until one second before the end of an L1 slot.
         // Otherwise, we need the full L1 slot duration for publishing to ensure inclusion.
         // In theory, the L1 slot has an initial 4s phase where the block is propagated, so we could
@@ -99,7 +90,8 @@ import { Sequencer } from '../sequencer/index.js';
             l1GenesisTime,
             slotDuration: Number(slotDuration),
             ethereumSlotDuration,
-            rollupManaLimit
+            rollupManaLimit,
+            epochDuration: config.aztecEpochDuration
         };
         const sequencer = new Sequencer(publisherFactory, validatorClient, globalsBuilder, p2pClient, worldStateSynchronizer, slasherClient, l2BlockSource, l1ToL2MessageSource, checkpointsBuilder, l1Constants, deps.dateProvider, epochCache, rollupContract, {
             ...config,
@@ -125,16 +117,19 @@ import { Sequencer } from '../sequencer/index.js';
         await this.validatorClient?.start();
         this.sequencer.start();
         this.l1Metrics?.start();
-        await this.publisherManager.loadState();
+        await this.publisherManager.start();
     }
     /**
    * Stops the sequencer from processing new txs.
    */ async stop() {
         await this.sequencer.stop();
         await this.validatorClient?.stop();
-        this.publisherManager.interrupt();
+        await this.publisherManager.stop();
         this.l1Metrics?.stop();
     }
+    /** Triggers an immediate run of the sequencer, bypassing the polling interval. */ trigger() {
+        return this.sequencer.trigger();
+    }
     getSequencer() {
         return this.sequencer;
     }

package/dest/config.d.ts

@@ -25,7 +25,9 @@ export declare const DefaultSequencerConfig: {
     secondsBeforeInvalidatingBlockAsNonCommitteeMember: number;
     skipCollectingAttestations: false;
     skipInvalidateBlockAsProposer: false;
+    skipWaitForValidParentCheckpointOnL1: false;
     broadcastInvalidBlockProposal: false;
+    broadcastInvalidCheckpointProposalOnly: false;
     injectFakeAttestation: false;
     injectHighSValueAttestation: false;
     injectUnrecoverableSignatureAttestation: false;
@@ -33,6 +35,7 @@ export declare const DefaultSequencerConfig: {
     shuffleAttestationOrdering: false;
     skipPushProposedBlocksToArchiver: false;
     skipPublishingCheckpointsPercent: number;
+    maxBlocksPerCheckpoint: number;
 };
 /**
  * Configuration settings for the SequencerClient.
@@ -44,4 +47,4 @@ export declare const sequencerClientConfigMappings: ConfigMappingsType<Sequencer
  * Creates an instance of SequencerClientConfig out of environment variables using sensible defaults for integration testing if not set.
  */
 export declare function getConfigEnvVars(): SequencerClientConfig;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUE2QixNQUFNLHdCQUF3QixDQUFDO0FBQzNGLE9BQU8sRUFBRSxLQUFLLGNBQWMsRUFBMEIsTUFBTSwyQkFBMkIsQ0FBQztBQUN4RixPQUFPLEVBQ0wsS0FBSyxrQkFBa0IsRUFLeEIsTUFBTSwwQkFBMEIsQ0FBQztBQUVsQyxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQTBCLE1BQU0sNkJBQTZCLENBQUM7QUFDMUYsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFxQixNQUFNLG1CQUFtQixDQUFDO0FBRXRFLE9BQU8sRUFDTCxLQUFLLFdBQVcsRUFDaEIsS0FBSyxjQUFjLEVBQ25CLEtBQUssZUFBZSxFQUlyQixNQUFNLHNCQUFzQixDQUFDO0FBRzlCLE9BQU8sRUFBRSxLQUFLLHFCQUFxQixFQUFpQyxNQUFNLGdDQUFnQyxDQUFDO0FBRTNHLE9BQU8sRUFDTCxLQUFLLHdCQUF3QixFQUM3QixLQUFLLHVCQUF1QixFQUc3QixNQUFNLHVCQUF1QixDQUFDO0FBRS9CLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsWUFBWSxFQUFFLGVBQWUsRUFBRSxDQUFDO0FBRWhDOzs7R0FHRztBQUNILGVBQU8sTUFBTSxzQkFBc0I7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQXFCQSxDQUFDO0FBRXBDOztHQUVHO0FBQ0gsTUFBTSxNQUFNLHFCQUFxQixHQUFHLHdCQUF3QixHQUMxRCxjQUFjLEdBQ2QscUJBQXFCLEdBQ3JCLHVCQUF1QixHQUN2QixlQUFlLEdBQ2YsY0FBYyxHQUNkLFdBQVcsR0FDWCxjQUFjLEdBQ2QsSUFBSSxDQUFDLFNBQVMsRUFBRSw4QkFBOEIsQ0FBQyxHQUMvQyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsc0JBQXNCLEdBQUcsbUJBQW1CLEdBQUcsb0JBQW9CLENBQUMsQ0FBQztBQUUvRixlQUFPLE1BQU0sdUJBQXVCLEVBQUUsa0JBQWtCLENBQUMsZUFBZSxDQWdLdkUsQ0FBQztBQUVGLGVBQU8sTUFBTSw2QkFBNkIsRUFBRSxrQkFBa0IsQ0FBQyxxQkFBcUIsQ0FVbkYsQ0FBQztBQUVGOztHQUVHO0FBQ0gsd0JBQWdCLGdCQUFnQixJQUFJLHFCQUFxQixDQUV4RCJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUE2QixNQUFNLHdCQUF3QixDQUFDO0FBQzNGLE9BQU8sRUFBRSxLQUFLLGNBQWMsRUFBMEIsTUFBTSwyQkFBMkIsQ0FBQztBQUN4RixPQUFPLEVBQ0wsS0FBSyxrQkFBa0IsRUFNeEIsTUFBTSwwQkFBMEIsQ0FBQztBQUVsQyxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQTBCLE1BQU0sNkJBQTZCLENBQUM7QUFDMUYsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFxQixNQUFNLG1CQUFtQixDQUFDO0FBRXRFLE9BQU8sRUFDTCxLQUFLLFdBQVcsRUFFaEIsS0FBSyxjQUFjLEVBQ25CLEtBQUssZUFBZSxFQUlyQixNQUFNLHNCQUFzQixDQUFDO0FBRzlCLE9BQU8sRUFBRSxLQUFLLHFCQUFxQixFQUFpQyxNQUFNLGdDQUFnQyxDQUFDO0FBRTNHLE9BQU8sRUFDTCxLQUFLLHdCQUF3QixFQUM3QixLQUFLLHVCQUF1QixFQUc3QixNQUFNLHVCQUF1QixDQUFDO0FBRS9CLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsWUFBWSxFQUFFLGVBQWUsRUFBRSxDQUFDO0FBRWhDOzs7R0FHRztBQUNILGVBQU8sTUFBTSxzQkFBc0I7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQXdCQSxDQUFDO0FBRXBDOztHQUVHO0FBQ0gsTUFBTSxNQUFNLHFCQUFxQixHQUFHLHdCQUF3QixHQUMxRCxjQUFjLEdBQ2QscUJBQXFCLEdBQ3JCLHVCQUF1QixHQUN2QixlQUFlLEdBQ2YsY0FBYyxHQUNkLFdBQVcsR0FDWCxjQUFjLEdBQ2QsSUFBSSxDQUFDLFNBQVMsRUFBRSw4QkFBOEIsQ0FBQyxHQUMvQyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsc0JBQXNCLEdBQUcsbUJBQW1CLEdBQUcsb0JBQW9CLENBQUMsQ0FBQztBQUUvRixlQUFPLE1BQU0sdUJBQXVCLEVBQUUsa0JBQWtCLENBQUMsZUFBZSxDQXdMdkUsQ0FBQztBQUVGLGVBQU8sTUFBTSw2QkFBNkIsRUFBRSxrQkFBa0IsQ0FBQyxxQkFBcUIsQ0FVbkYsQ0FBQztBQUVGOztHQUVHO0FBQ0gsd0JBQWdCLGdCQUFnQixJQUFJLHFCQUFxQixDQUV4RCJ9

package/dest/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAA6B,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,2BAA2B,CAAC;AACxF,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,6BAA6B,CAAC;AAC1F,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,mBAAmB,CAAC;AAEtE,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,eAAe,EAIrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,KAAK,qBAAqB,EAAiC,MAAM,gCAAgC,CAAC;AAE3G,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAG7B,MAAM,uBAAuB,CAAC;AAE/B,cAAc,uBAAuB,CAAC;AACtC,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;CAqBA,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,GAC1D,cAAc,GACd,qBAAqB,GACrB,uBAAuB,GACvB,eAAe,GACf,cAAc,GACd,WAAW,GACX,cAAc,GACd,IAAI,CAAC,SAAS,EAAE,8BAA8B,CAAC,GAC/C,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,GAAG,mBAAmB,GAAG,oBAAoB,CAAC,CAAC;AAE/F,eAAO,MAAM,uBAAuB,EAAE,kBAAkB,CAAC,eAAe,CAgKvE,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,qBAAqB,CAUnF,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAA6B,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,2BAA2B,CAAC;AACxF,OAAO,EACL,KAAK,kBAAkB,EAMxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,6BAA6B,CAAC;AAC1F,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,mBAAmB,CAAC;AAEtE,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,cAAc,EACnB,KAAK,eAAe,EAIrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,KAAK,qBAAqB,EAAiC,MAAM,gCAAgC,CAAC;AAE3G,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAG7B,MAAM,uBAAuB,CAAC;AAE/B,cAAc,uBAAuB,CAAC;AACtC,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CAwBA,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,GAC1D,cAAc,GACd,qBAAqB,GACrB,uBAAuB,GACvB,eAAe,GACf,cAAc,GACd,WAAW,GACX,cAAc,GACd,IAAI,CAAC,SAAS,EAAE,8BAA8B,CAAC,GAC/C,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,GAAG,mBAAmB,GAAG,oBAAoB,CAAC,CAAC;AAE/F,eAAO,MAAM,uBAAuB,EAAE,kBAAkB,CAAC,eAAe,CAwLvE,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,qBAAqB,CAUnF,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD"}