dataforge-labs/l2-preconfirmation-reliability

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.

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.