bitcoin-mempool-lifecycle: 2026-09-15

README.md

@@ -1,6 +1,6 @@
 ---
 license: odc-by
-pretty_name: "Bitcoin and Litecoin transaction lifecycle observations"
+pretty_name: "Bitcoin and Litecoin mempool: dwell times, drops, and block composition"
 tags:
   - mempool
   - bitcoin
@@ -14,98 +14,140 @@ task_categories:
   - time-series-forecasting
 size_categories:
   - 1M<n<10M
-configs:
-- config_name: bitcoin_transaction_lifecycle
-  data_files:
-  - split: train
-    path: e8_btc_mempool_lifecycle/**/*.parquet
-  default: true
-- config_name: bitcoin_mempool_comparison
-  data_files:
-  - split: train
-    path: e9_btc_mempool_divergence/**/*.parquet
-- config_name: litecoin_transaction_lifecycle
-  data_files:
-  - split: train
-    path: e11_ltc_mempool_lifecycle/**/*.parquet
-- config_name: bitcoin_block_composition
-  data_files:
-  - split: train
-    path: e8_btc_block_composition/**/*.parquet
-- config_name: collection_runs
-  data_files:
-  - split: train
-    path: e0_run_manifest/**/*.parquet
 ---
 
-# Bitcoin and Litecoin mempool lifecycle
+# Bitcoin mempool lifecycle
 
-Transaction observations covering first sight, time spent pending, confirmation and disappearance from monitored mempools. The repository also contains comparisons between Bitcoin provider views and a measure of how much of each block was visible before it arrived.
+Transactions from the moment they appear in the mempool to whatever happens to them: mined,
+still waiting, or dropped without ever reaching a block.
+
+A confirmed transaction keeps its contents forever but loses its timing. One that is never mined
+leaves no record at all. Both are recorded here as they happen.
 
 ## Contents
 
-| Table | Record |
+| name | one row is |
 |---|---|
-| `bitcoin_transaction_lifecycle` | A Bitcoin transaction's observed lifecycle, fee information and outcome |
-| `bitcoin_mempool_comparison` | A provider's pending-set size and overlap with other views |
-| `litecoin_transaction_lifecycle` | A Litecoin transaction lifecycle observation |
-| `bitcoin_block_composition` | A block's previously observed and newly seen transaction counts |
+| `e8_btc_mempool_lifecycle` | a Bitcoin transaction: first seen, fee rate, mined height, blocks waited, fate |
+| `e9_btc_mempool_divergence` | one view of the pending set at one instant, sized and compared against the others |
+| `e11_ltc_mempool_lifecycle` | the same, for Litecoin |
+| `e8_btc_block_composition` | one block: how much of it we had already seen pending |
 
-## Observation coverage
+Ethereum moved to its own repo, `ethereum-mempool`, rather than sitting inside a Bitcoin panel.
+Peer-to-peer propagation and relay floors likewise moved to `bitcoin-network-propagation`.
 
-`pre_existing` identifies transactions already pending when a collection window opened. Their first-seen times do not establish when they originally entered the network.
+## Fee rate coverage
 
-`fee_rate_sat_vb` is populated only where a fee was obtained. Coverage changed substantially during the initial collection period, especially on 2026-08-28. Measure the non-null share within each partition and outcome group before conducting fee-based analysis. A missing fee does not by itself invalidate the other lifecycle fields.
+`fee_rate_sat_vb` is present on a portion of rows and that portion changes over time. It is
+sampled, never estimated: a guessed fee rate would ruin the analyses the column exists for.
 
-Bitcoin dropped-transaction records begin on 2026-08-26. An earlier collection defect prevented this classification, so the absence of drops before that date is not evidence that none occurred.
+Coverage by day, as a share of transactions observed arriving (`pre_existing == False`):
 
-## Outcomes and package fields
+| date | coverage |
+|---|---|
+| 2026-08-25 | none |
+| 2026-08-26 | ~4% |
+| 2026-08-27 | ~14% |
+| 2026-08-28 | ~16% early, ~67% late |
+| 2026-08-29 onward | ~67% |
 
-`dropped` requires the collector's absence checks and debounce period. `unresolved` records a disappearance whose outcome could not be established. These labels describe observations within a collection window; a transaction may later reappear or confirm. Litecoin uses a single-provider view, so it has less cross-checking than Bitcoin.
+Coverage of transactions already pending when a collection window opened moved from about 1% to
+about 99% on 2026-08-28. Dropped rows inherit that figure and reached 94% on 2026-08-29.
 
-`effective_fee_rate_sat_vb` is `ancestor_fees_sat / ancestor_vsize`. Ancestor and descendant fields describe package structure when recorded, which can change as related transactions confirm. This ratio is useful context for fee analysis, but it is not a guarantee of miner selection.
+Partitions from 2026-08-29 are substantially denser than earlier ones. Compute coverage per
+partition rather than assuming a constant:
 
-## Block composition and limitations
+```python
+obs = df[~df.pre_existing.astype(bool)]
+coverage = obs.fee_rate_sat_vb.notna().mean()
+```
 
-The block-composition table excludes the coinbase and counts transactions the collector had already observed pending. Transactions first seen in a block may reflect private submission, missed polls or gaps in provider visibility. The unseen share is an upper-bound proxy for private submission, not a direct measurement.
+Rows without a fee rate are complete in every other respect, so they remain usable for lifecycle
+work. Only fee-conditioned analysis is affected.
 
-Use `polls_so_far`, `poll_failures` and `pool_size_at_block` to assess that comparison. Mempools differ between nodes, and timestamps include polling and network delays. Zero fee rates can be valid observations; distinguish them from nulls.
+## Reading the fate column
 
-## Files and access
+`dropped` means the transaction was confirmed absent from the chain, absent from every pending
+view held, and stayed absent through a debounce period. It is not inferred from a single
+observation. `unresolved` means it went missing but could not be confirmed, and is never counted
+as a drop.
 
-Data is stored as Parquet files under `dataset/YYYY/MM/`, with partitions for collection windows. Each measurement table has a fixed 7-day sample beginning at its configured collection start date. The sample windows in this repository span 2026-08-25 to 2026-09-05. Availability within each window depends on successful collection. The public sample dates remain fixed as additional history accumulates privately. Contact DataForge through the discussions tab to enquire about additional history.
+Bitcoin `fate = "dropped"` begins 2026-08-26. Earlier partitions contain no drops because a
+defect made them impossible to record, not because none occurred.
 
-### Load a table
+## How much of a block did we already know about
 
-Install `datasets` and `pandas` to run this example. The `train` split contains all observations in the selected table; it is not a predefined modelling split.
+`e8_btc_block_composition` counts, for every block, how many of its transactions were already in
+our mempool view and how many appeared for the first time in the block itself.
 
-```python
-from datasets import load_dataset
+The second number is the interesting one. A transaction that reaches a miner without crossing the
+public relay network looks exactly like this, which is what direct-to-pool submission is. So does
+a transaction broadcast in the seconds between two of our polls, and so does one our providers
+simply never held. **The column is therefore an upper bound on out-of-band submission, not a
+measurement of it**, and `polls_so_far`, `poll_failures` and `pool_size_at_block` travel on every
+row so the bound can be tightened or discarded.
 
-data = load_dataset("dataforge-labs/bitcoin-mempool-lifecycle",
-                    "bitcoin_transaction_lifecycle", split="train")
-df = data.to_pandas()
-```
+It doubles as a coverage statement for the rest of this repo. If you want to know how complete
+the mempool view behind `e8_btc_mempool_lifecycle` is, this is the answer, block by block, in the
+data rather than in a claim. One observed block held 4,823 transactions excluding the coinbase,
+of which 4,804 were already in view: 99.6% captured, and 19 seen for the first time in the block
+itself.
 
-## Coverage
+The coinbase is excluded, since it is created by the miner and never broadcast; counting it would
+add one guaranteed unseen transaction to every block. Blocks mined before a run's baseline was
+established are not recorded at all, because none of their transactions could have been seen and
+the row would read 100% unseen for a reason that has nothing to do with the network.
 
-`collection_runs` records collection windows, poll counts and failures. It is published in full and may cover dates beyond the fixed data sample. Collection gaps are not interpolated. Use this table together with measurement timestamps and error fields to assess coverage.
+## Package fee rates
 
-## License and contact
+A transaction's own fee rate is not what decides whether it is mined. A miner sorts by the
+ANCESTOR fee rate, so a transaction with an unconfirmed low-fee parent is worth less than it
+appears, and a child paying a large fee lifts its parent with it.
 
-The public sample is published under ODC-BY. Attribute it to "DataForge (dataforge-labs)". For questions about the data or access to additional history, open a discussion in this repository.
+`effective_fee_rate_sat_vb` is `ancestor_fees_sat / ancestor_vsize`. For a transaction with no
+unconfirmed parents it equals `fee_rate_sat_vb` exactly; where they diverge, the effective rate
+is the one that governs inclusion. One snapshot held a transaction paying 28.4 sat/vB whose
+effective rate was 2.1.
 
-<details>
-<summary>File paths and compatibility</summary>
+`ancestor_count` above 1 marks membership in an unconfirmed chain, which is how fee bumping by
+a child shows up. The descendant columns are the mirror: what is waiting on this transaction.
 
-The table names above are Hugging Face dataset configurations. Each configuration reads the original Parquet files, whose paths remain unchanged for existing downloads and scripts. No records are copied, moved or renamed.
+These come from a full node's own view, so they are null for transactions it never held, and
+they are recorded as first observed. Package structure changes as parents confirm, so treat
+them as the state at first sight rather than a running value.
 
-| Table name | Storage directory |
-|---|---|
-| `bitcoin_transaction_lifecycle` | `e8_btc_mempool_lifecycle/` |
-| `bitcoin_mempool_comparison` | `e9_btc_mempool_divergence/` |
-| `litecoin_transaction_lifecycle` | `e11_ltc_mempool_lifecycle/` |
-| `bitcoin_block_composition` | `e8_btc_block_composition/` |
-| `collection_runs` | `e0_run_manifest/` |
+## Before you build on this
+
+- Pending sets are node-local. What one view holds is not what the network holds, and retention
+  is a configuration choice rather than a protocol rule. `e9` exists to size that disagreement,
+  and it is large: at one instant the views ranged from about 6,000 to about 87,000 pending
+  transactions, with only 7% common to all of them.
+- Dropped rows carry a fee rate far less often than mined rows. Every drop observed so far was
+  already pending when its window opened, and fee sampling favours arrivals.
+- A fee rate of exactly 0 is real and rare. Filter on `fee_rate_sat_vb > 0` if a zero would
+  break your arithmetic rather than treating it as a decode fault.
+- Timestamps are ours, taken at observation. They are not consensus timestamps and carry our
+  network distance to whatever served the data.
+
+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-25 to 2026-09-05, 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/bitcoin-mempool-lifecycle", repo_type="dataset",
+                         allow_patterns="e8_btc_mempool_lifecycle/**")
+df = pd.concat(map(pd.read_parquet,
+                   glob.glob(f"{path}/e8_btc_mempool_lifecycle/**/*.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
 
-</details>
+ODC-BY: use it freely, credit "DataForge (dataforge-labs)". Questions and requests for the full
+history via the discussions tab.

e0_run_manifest/2026/09/2026-09-15T0614Z.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce4aa936b71bce832631c826a92fce496172d7d07141dcbbdd04965393fc7bc1
+size 13290