---
license: odc-by
pretty_name: "Whether L2 sequencers keep the inclusion promises they make"
tags:
  - layer-2
  - rollup
  - sequencer
  - ethereum
  - reliability
  - blockchain
  - time-series
task_categories:
  - time-series-forecasting
size_categories:
  - 100K<n<1M
---

# L2 sequencer preconfirmation reliability

A rollup sequencer tells you your transaction is included before anything is settled on L1. This
records whether that promise held.

The promise is the ephemeral part. If a sequencer replaces an unsafe block, the version it
originally gossiped is discarded and no archive serves it, so a broken promise is only
observable to somebody who wrote down the original.

## Contents

| name | one row is |
|---|---|
| `e14_l2_preconf` | either a heartbeat, recording how far the unsafe head ran ahead of the safe head, or a violation |

## Mostly an attested absence

Violations are rare, and the value here is in the zeros being credible rather than in the
events. That requires the coverage rows: `n_checked` counts promises actually verified against
the canonical chain and `n_failed` counts the checks that could not complete. A run with no
violations and no checks is not the same as a run with no violations and thousands.

`row_type` separates heartbeats from violations.

## Before you build on this

- `lag_blocks` is only meaningful where `safe_tag_plausible` is true. One chain's endpoint has
  served a stale safe tag intermittently, giving a lag of tens of millions of blocks against
  another chain's few dozen, then recovering to a normal figure hours later. It is kept rather
  than dropped, because an endpoint's own inconsistency is a fact about running on public
  infrastructure, and because it comes and goes you cannot exclude a chain once and be done.
  The flag is false on exactly the affected rows; filter on it, not on the chain name.
- The unsafe head is sampled every few seconds, so a block that was proposed and replaced between
  two samples is invisible. This undercounts violations and cannot overcount them.
- Nine chains, ALL OP-stack. That is nine independent sequencer operators, which is enough to
  compare them against each other, but it is still one rollup architecture: nothing here
  generalises to a rollup built differently.
- Safe-head lag varies enormously between them even at rest, from tens of blocks to several
  thousand, and one endpoint reports a lag of tens of millions. Compare a chain against its own
  history rather than against another chain's absolute level.

Partitions are parquet, one file per collection window, under `dataset/YYYY/MM/`. Every dataset here carries a FIXED 7-day sample WINDOW starting at its own first day of collection, together spanning 2026-08-26 to 2026-09-01, so you can check schema, coverage and quality before asking for more. It does not advance, so there is nothing to gain by re-downloading it. The full history is held privately, available on request.

```python
from huggingface_hub import snapshot_download
import pandas as pd, glob

path = snapshot_download("dataforge-labs/l2-preconfirmation-reliability", repo_type="dataset",
                         allow_patterns="e14_l2_preconf/**")
df = pd.concat(map(pd.read_parquet,
                   glob.glob(f"{path}/e14_l2_preconf/**/*.parquet", recursive=True)))
```

## Coverage

`e0_run_manifest` lists every collection window with its poll counts and failure counts, and is
published in full rather than windowed. Gaps between windows are real, cannot be filled in
afterwards, and nothing here is interpolated.

## License and contact

ODC-BY: use it freely, credit "DataForge (dataforge-labs)". Questions and requests for the full
history via the discussions tab.