bitcoin-mempool-lifecycle: 2026-08-29

README.md

@@ -19,117 +19,118 @@ size_categories:
 
 # Bitcoin mempool lifecycle
 
-What happens to a transaction between being broadcast and being mined: when we first saw it, how
-long it waited, what fee it paid, and whether it was ever mined at all.
+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 body forever but loses its timing, and one that is never mined
-leaves no trace at all. We checked this on Bitcoin before collecting anything: the public
-first-seen lookup answers while a transaction is unconfirmed and returns 0 once it is mined,
-whether that was a day ago or a year ago. So it gets recorded as it happens or not at all.
+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.
 
-Bitcoin is the point of this repo. Litecoin runs the same collector. Ethereum is included as a
-second observation, but if you want Ethereum specifically, the
-[Flashbots Mempool Dumpster](https://github.com/flashbots/mempool-dumpster) publishes the same
-measurement daily under CC-0, from a wider node network and going back to September 2023. Theirs
-is better than ours; use it.
-
-## What is in here
+## Contents
 
 | name | one row is |
 |---|---|
 | `e8_btc_mempool_lifecycle` | a Bitcoin transaction: first seen, fee rate, mined height, blocks waited, fate |
-| `e9_btc_mempool_divergence` | one provider's pending-set size and overlap with another, at an instant |
-| `e11_ltc_mempool_lifecycle` | the same as e8, for Litecoin (single provider, no cross-check) |
-| `e15_fee_estimators` | one fee estimate from one of five providers, at one confirmation target |
-| `e1_mempool_minutely` | one minute of Ethereum mempool activity: arrivals, fates, dwell quantiles |
-| `e1_mempool_dropped` | an Ethereum transaction that was never mined, in full |
-| `e3_mempool_divergence` | one Ethereum node's pending view against three others |
-| `e0_run_manifest` | one collection window: polls, failures, coverage counters |
+| `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 |
+| `e15_fee_estimators` | one fee estimate from one provider at one moment, with its target |
+| `e1_mempool_lifecycle` | an Ethereum transaction seen pending (ends 2026-08-26, see below) |
+| `e1_mempool_minutely` | one minute of Ethereum mempool activity |
+| `e1_mempool_dropped` | an Ethereum transaction that was never mined |
+| `e3_mempool_divergence` | Ethereum pending-set comparison across views |
+| `e21_btc_relay_floor` | one peer's own minimum relay fee, at the moment it announced it |
+
+`e1_mempool_lifecycle` stops at 2026-08-26. Per-transaction Ethereum rows were discontinued
+there: the Flashbots Mempool Dumpster publishes the same measurement under CC-0 from a wider
+node set, so a duplicate was not worth the storage it took. `e1_mempool_minutely` and
+`e1_mempool_dropped` continue. The earlier partitions are kept and keep their own name, so
+nothing joins them to the newer tables and reads a change of population as a trend.
+
+## Fee rate coverage
+
+`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.
+
+Coverage by day, as a share of transactions observed arriving (`pre_existing == False`):
+
+| 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% |
+
+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.
+
+Partitions from 2026-08-29 are substantially denser than earlier ones. Compute coverage per
+partition rather than assuming a constant:
+
+```python
+obs = df[~df.pre_existing.astype(bool)]
+coverage = obs.fee_rate_sat_vb.notna().mean()
+```
+
+Rows without a fee rate are complete in every other respect, so they remain usable for lifecycle
+work. Only fee-conditioned analysis is affected.
+
+## Reading the fate column
+
+`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.
+
+Bitcoin `fate = "dropped"` begins 2026-08-26. Earlier partitions contain no drops because a
+defect made them impossible to record, not because none occurred.
+
+## Package fee rates
+
+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.
+
+`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.
+
+`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.
+
+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.
+
+## Relay floors
+
+A transaction below a node's minimum relay fee is not merely deprioritised: that node will not
+forward it, so it never reaches the miners at all. Every peer announces its own floor on
+connect and again whenever it moves, and those announcements are kept by nobody.
+
+`e21_btc_relay_floor` is one row per announcement, so a peer appears repeatedly as its floor
+changes. `min_relay_fee_sat_kvb` is the wire value; `min_relay_fee_sat_vb` is the same number
+in the units fee tools quote.
+
+Expect little variation while the mempool is quiet, because nodes then sit at whatever they
+were configured with. The floor moves when a mempool fills and starts evicting, which is
+exactly when it matters and exactly when it cannot be reconstructed afterwards.
 
 ## Before you build on this
 
-Most of these came out of getting something wrong first.
-
-- `first_seen_ts` is when WE saw it, on our clock, from our own polling. The network saw it a
-  little earlier. We never copy a provider's own first-seen field.
-- Rows with `pre_existing = true` were already pending when a window opened. Their real arrival
-  time is unknowable, so `first_seen_ts` is null there rather than a made-up value.
-- Bitcoin `fate = "dropped"` starts 2026-08-26. Before that, a bug made drops impossible to
-  record: the status endpoint reports `confirmed: false` for a replaced transaction exactly as it
-  does for a waiting one, and we read that as proof it was still pending. Earlier partitions are
-  kept as collected rather than rewritten.
-- We only call something dropped once it is missing from the chain, missing from two providers'
-  pools, and missing for ten polls running. Weaker tests do not work: a plain poll-to-poll diff
-  invented 642 "drops" in 200 seconds and every one we checked was still in the mempool.
-- `fee_rate_sat_vb` is PARTIAL, and its coverage IMPROVES over the life of the dataset. It is
-  sampled from the recent-arrivals feed, which returns only the ten newest transactions per call,
-  so coverage is bounded by how often we call it. It is never estimated for the rest, because a
-  guessed fee rate would ruin the analyses the column exists for.
-  Measured coverage, as a share of arrivals we actually observed (`pre_existing == False`):
-  **2026-08-25 none, 2026-08-26 ~4%, 2026-08-27 ~14%, 2026-08-28 ~16% early, ~75% late.**
-  Coverage of PRE-EXISTING transactions -- which is what dropped rows inherit -- moved from
-  **~1% to ~93%** on 2026-08-28. Partitions from 2026-08-29 onward are far denser than anything
-  earlier, and the gap is now large enough that pooling them unexamined would be a mistake.
-  Four things held it down, all fixed on 2026-08-28: fee capture did not exist on the first day;
-  the quote collectors shared a thread with the sampler and blocked it for ~40 minutes of every
-  4.5-hour run; the sampler's intended 2-second cadence never actually ran, because it was
-  checked inside a loop that sleeps 5 seconds; and fees were fetched one transaction at a time
-  when a full node returns its ENTIRE mempool, with an exact fee and vsize per entry, in a single
-  request. That last one is what mattered, and the lesson is which node you ask: public Bitcoin
-  RPC nodes hold wildly different mempools, and one with a 4 GB `maxmempool` covers 93% of our
-  tracked set in a single call where a 256 MB node covers 34%.
-  **Even repaired, 100% is not attainable, and the reason is worth understanding before you rely
-  on this column.** The feed returns only the TEN NEWEST transactions per call, so capture is
-  capped at 10 per poll however fast we ask. Measured Bitcoin arrival rates ran between 4.3/s and
-  11.0/s within a single hour. At a 2-second cadence the ceiling is 5/s, which is above the quiet
-  rate and well below the busy one -- so coverage is itself a function of network congestion, and
-  is LOWEST exactly when the mempool is most interesting. Treat the sampled set as a sample, and
-  do not assume it is representative across congestion regimes without checking.
-  DO NOT take these figures on trust -- they are computable from the data itself, and any
-  analysis sensitive to coverage should compute them per partition rather than assume a constant:
-  ```python
-  obs = df[~df.pre_existing.astype(bool)]
-  coverage = obs.fee_rate_sat_vb.notna().mean()
-  ```
-  Rows without a fee rate are complete in every other respect (first seen, dwell, fate, blocks
-  waited), so they remain usable for lifecycle work; only fee-conditioned analysis is affected.
-- **`fee_rate_sat_vb` is effectively ABSENT on dropped rows (~1%), and this is structural.**
-  Every dropped transaction observed so far was already in the mempool when its run began
-  (`pre_existing == True`), which follows from the mechanism: a transaction we watch from arrival
-  is mined or still pending within a 4.5-hour window, whereas eviction takes far longer, so only
-  transactions that predate the run live long enough to be dropped. Fees come from the
-  recent-ARRIVALS feed, which by definition never saw them.
-  Recovering the fee afterwards does not work, and this was tested rather than assumed: a
-  transaction that leaves the mempool unmined returns **HTTP 404 immediately** from `/tx/{id}`.
-  A run's confirmed drops were probed and **0 of 147** were retrievable. The provider forgets
-  them at once, so there is no window in which to ask.
-  Related trap, worth knowing if you query the API yourself: `/tx/{id}/status` answers
-  `{"confirmed": false}` for txids that CANNOT EXIST (all-zeros, all-f's were both tested), so
-  that field distinguishes "not in a block" and nothing more. Our drop classification does not
-  rest on it -- pool membership is the discriminator -- but a naive reading of it would be wrong.
-- Four columns come from a full Bitcoin node's mempool rather than an explorer API, and are
-  **null for transactions that node did not hold** (~32% coverage, the node's share of the
-  tracked set). None of them survives confirmation or eviction, which is why they are collected:
-  `node_first_seen_ts` (that node's own first-seen clock, an independent check on ours),
-  `rbf_signalled` (BIP-125 replaceability as live mempool state), and `ancestor_count` /
-  `descendant_count` (unconfirmed chains, which is how CPFP fee-bumping appears).
-  A caveat on `node_first_seen_ts` that we have not explained: on transactions where both clocks
-  exist, ours is a median ~7,000s LATER than the node's. Some of that is our polling interval and
-  some is rebroadcast, but not all of it, so treat the two clocks as different measurements
-  rather than one corrected version of the other.
-- A fee rate of exactly 0 is real and rare, about 1 in 6,000 of the sampled arrivals, and most of
-  those we have seen went on to confirm. Filter on `fee_rate_sat_vb > 0` if a zero would break
-  your arithmetic, rather than treating it as a decode fault.
-- Mempools are node-local, and how long a node keeps things is its own choice rather than a
-  protocol rule. Ours served 115-day-old entries where Bitcoin Core would have evicted after 336
-  hours. `e9` tracks how far apart two providers are, usually several thousand transactions.
-- Bitcoin dwell times are long. Around 10 minutes for transactions that confirm quickly, but the
-  pool also holds a standing backlog whose median age is over 100 days. That is Bitcoin's fee
-  market, not a collection error.
-- Fee estimators disagree much more than their marketing suggests: one sample showed a 6.7x
-  spread across five providers on the same six-block target. Targets are normalised to a block
-  count and the raw payload field is kept per row, so you can check that rather than trust it.
-- Ethereum is stored as per-minute aggregates plus full rows for never-mined transactions.
+- 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.
+- Ethereum rows are included for comparison. If Ethereum is your subject, the Flashbots Mempool
+  Dumpster publishes the same measurement daily under CC-0 from a wider node set and a longer
+  history. Theirs is better; use it.
 
 Partitions are parquet, one file per collection window, under `dataset/YYYY/MM/`. This repo carries a FIXED 7-day sample (2026-08-25 to 2026-08-31) 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.