perf(rpc): read the chain-info figures off the block log instead of folding it

`Context::blocks` holds one record per applied block and grows for the life of
the process — ~963k entries on a mainnet node. `getblockchaininfo` and
`getchaintxstats` both walked all of it to produce five scalars, and
`getblockchaininfo` used exactly one of them: it folded 963k records to report
`size_on_disk` and discarded the rest.

The walk ran under the log read lock, which is the lock `apply_block` takes to
append the record for the block it just connected, so the call stalled block
application for its duration and got slower with every block.

`BlockLog` now maintains what the fold used to compute. `total_body_size` is a
running sum and answers `size_on_disk` outright. `cumulative_tx_count[i]` is the
sum over `records[..=i]` and answers both transaction counts as differences
across two boundaries. It is a type rather than a `Vec<BlockRecord>` with totals
kept beside it because the log is appended from `apply`, from
`Context::add_block` and from tests; a total any of those could forget to update
is a total that will drift. Reads are unchanged - it derefs to `[BlockRecord]`.

`chain_stats` replaces the fold for `getchaintxstats`. The log is appended in
height order and only ever popped from the tail, so it binary-searches the three
boundaries it needs - the same property `Context::block_at_height` already
relies on. Only the caller's window is then walked, and only for
`earliest_window_time`: block timestamps are not monotonic, so no prefix sum can
answer a minimum over them.

Measured over one fixture in one process, `before_fold` against `after_indexed`:

  10,000 records:   19.32 us ->  3.83 us      5.0x
  100,000 records: 552.70 us ->  3.94 us    140x
  500,000 records:   4.214 ms -> 4.24 us    993x
  963,124 records:   7.450 ms -> 3.77 us  1,977x

End to end the dispatch is flat: `getblockchaininfo` 2.79 us and
`getchaintxstats` 4.43 us at 963k records, against 2.66 us and 4.88 us at 10k.

Prefix sums rather than one more running total because the benchmark caught the
cheaper version being a cliff. A single total answers `txcount` only when the
applied tip is the log last record; anywhere else it subtracts the records above
the tip, and with no applied tip that tail is the whole log. `getchaintxstats`
measured 6.23 ms while its own reader measured 4.79 us. Prefix sums cost 8 bytes
per record, ~7.7 MB at a mainnet tip against the ~254 MB the records occupy.

`fold_block_records` is retained whole as the oracle and as the benchmark before
arm. `chain_stats_matches_the_fold_it_replaced` sweeps every applied height
against every window length over a log with a duplicate height and a backwards
timestamp. Ten mutations, all killed; see docs/benchmarks/chain-info-fold.md,
which also records that the first audit run misreported every kill as an invalid
mutation because the harness could not tell a red test from a broken build.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: rabbitson87

crates/mempool/benches/pareto.rs

@@ -16,7 +16,9 @@
 use std::hint::black_box;
 use std::sync::Arc;
 
-use bitcoin::{Amount, ScriptBuf, Sequence, Transaction, TxIn, TxOut, Witness, absolute, transaction};
+use bitcoin::{
+    Amount, ScriptBuf, Sequence, Transaction, TxIn, TxOut, Witness, absolute, transaction,
+};
 use bitcoin_rs_mempool::{MempoolEntry, ParetoFront};
 use criterion::{Criterion, criterion_group, criterion_main};
 

crates/node/src/apply.rs

@@ -12,7 +12,7 @@ use bitcoin_rs_chain::{BlockTree, NodeId, TipSnapshot};
 use bitcoin_rs_consensus::{MAX_SCRIPT_SIZE, rust_path::UtxoView};
 use bitcoin_rs_mempool::Mempool;
 use bitcoin_rs_primitives::{Hash256, Network, OutPoint};
-use bitcoin_rs_rpc::BlockRecord;
+use bitcoin_rs_rpc::{BlockLog, BlockRecord};
 use bitcoin_rs_utxo::{
     LiveOutput, LiveOutputMeta, UtxoSet,
     set::{BorrowedBlockChanges, BorrowedUtxoAdd},
@@ -944,7 +944,7 @@ pub struct ApplyHandles {
     /// Shared mempool.
     pub mempool: Arc<RwLock<Mempool>>,
     /// Shared block records exposed to RPC handlers.
-    pub blocks: Arc<RwLock<Vec<BlockRecord>>>,
+    pub blocks: Arc<RwLock<BlockLog>>,
     /// Shared transaction map exposed to RPC handlers.
     pub transactions: Arc<RwLock<HashMap<Txid, Transaction>>>,
     /// Shared ZMQ-event publisher (default: `NoOpZmqPublisher`).
@@ -1010,7 +1010,7 @@ impl ApplyHandles {
         tx_index_runtime: Option<Arc<crate::txindex_worker::TxIndexRuntime>>,
         filter_index: Arc<Box<dyn bitcoin_rs_filters::FilterIndexLike>>,
         mempool: Arc<RwLock<Mempool>>,
-        blocks: Arc<RwLock<Vec<BlockRecord>>>,
+        blocks: Arc<RwLock<BlockLog>>,
         transactions: Arc<RwLock<HashMap<Txid, Transaction>>>,
         zmq_publisher: Arc<dyn crate::ZmqPublisher>,
     ) -> Self {
@@ -8645,7 +8645,7 @@ mod consensus_rule_tests {
             None,
             filter_index,
             Arc::new(RwLock::new(Mempool::new(MempoolLimits::default()))),
-            Arc::new(RwLock::new(Vec::new())),
+            Arc::new(RwLock::new(BlockLog::new())),
             Arc::new(RwLock::new(HashMap::<bitcoin::Txid, Transaction>::new())),
             Arc::new(crate::NoOpZmqPublisher),
         )
@@ -9659,7 +9659,7 @@ mod consensus_rule_tests {
             None,
             noop_filter_index(),
             Arc::new(RwLock::new(Mempool::new(MempoolLimits::default()))),
-            Arc::new(RwLock::new(Vec::new())),
+            Arc::new(RwLock::new(BlockLog::new())),
             Arc::new(RwLock::new(HashMap::<bitcoin::Txid, Transaction>::new())),
             Arc::new(crate::NoOpZmqPublisher),
         )

crates/node/src/block_source.rs

@@ -14,15 +14,15 @@ use bitcoin::hex::FromHex as _;
 use bitcoin_rs_chain::{BlockTree, NodeId, TipSnapshot};
 use bitcoin_rs_index::BlockSource;
 use bitcoin_rs_primitives::Hash256;
-use bitcoin_rs_rpc::{BlockBodySource, BlockRecord};
+use bitcoin_rs_rpc::{BlockBodySource, BlockLog, BlockRecord};
 use parking_lot::RwLock;
 
 /// Reads decoded Bitcoin blocks from the shared in-memory log.
 ///
 /// Cheap-clonable; the inner Arc is shared with `NodeState`'s record store.
 #[derive(Clone)]
 pub struct NodeBlockSource {
-    blocks: Arc<RwLock<Vec<BlockRecord>>>,
+    blocks: Arc<RwLock<BlockLog>>,
     block_body_source: Option<Arc<dyn BlockBodySource>>,
     block_tree: Option<Arc<RwLock<BlockTree>>>,
     applied_tip: Option<Arc<arc_swap::ArcSwapOption<TipSnapshot>>>,
@@ -31,7 +31,7 @@ pub struct NodeBlockSource {
 impl NodeBlockSource {
     /// Builds a source over the shared block-record vector.
     #[must_use]
-    pub const fn new(blocks: Arc<RwLock<Vec<BlockRecord>>>) -> Self {
+    pub const fn new(blocks: Arc<RwLock<BlockLog>>) -> Self {
         Self {
             blocks,
             block_body_source: None,
@@ -378,7 +378,7 @@ mod tests {
     fn block_at_height_returns_some_after_record_added() {
         let genesis = genesis_block(Network::Regtest);
         let record = BlockRecord::from_block(0, &genesis);
-        let blocks = Arc::new(RwLock::new(vec![record]));
+        let blocks = Arc::new(RwLock::new(BlockLog::from_iter([record])));
         let source = NodeBlockSource::new(blocks);
         let Some(decoded) = source.block_at_height(0) else {
             panic!("expected block at height 0");
@@ -424,7 +424,7 @@ mod tests {
             hash: record.hash,
             bytes: bytes.clone(),
         });
-        let blocks = Arc::new(RwLock::new(vec![record]));
+        let blocks = Arc::new(RwLock::new(BlockLog::from_iter([record])));
         let source = NodeBlockSource::new(blocks).with_block_body_source(body_source);
 
         for offset in 0..u32::try_from(bytes.len())? {
@@ -455,7 +455,7 @@ mod tests {
         // `block_at_height`, which is what it would have done anyway.
         let genesis = genesis_block(Network::Regtest);
         let record = BlockRecord::from_block(0, &genesis);
-        let blocks = Arc::new(RwLock::new(vec![record]));
+        let blocks = Arc::new(RwLock::new(BlockLog::from_iter([record])));
         let source = NodeBlockSource::new(blocks);
 
         assert!(source.block_bytes_at_height(0, 0, 4).is_none());
@@ -467,7 +467,7 @@ mod tests {
 
     #[test]
     fn block_at_height_returns_none_when_missing() {
-        let blocks: Arc<RwLock<Vec<BlockRecord>>> = Arc::new(RwLock::new(Vec::new()));
+        let blocks: Arc<RwLock<BlockLog>> = Arc::new(RwLock::new(BlockLog::new()));
         let source = NodeBlockSource::new(blocks);
         assert!(source.block_at_height(0).is_none());
     }
@@ -493,7 +493,7 @@ mod tests {
             hash: record.hash,
             bytes: serialize(&genesis),
         });
-        let blocks = Arc::new(RwLock::new(vec![record]));
+        let blocks = Arc::new(RwLock::new(BlockLog::from_iter([record])));
         let source = NodeBlockSource::new(blocks).with_block_body_source(body_source);
 
         let Some(decoded) = source.block_at_height(0) else {
@@ -514,7 +514,9 @@ mod tests {
             BlockRecord::from_block(2, &first),
             BlockRecord::from_block(2, &second),
         ];
-        let source = NodeBlockSource::new(Arc::new(RwLock::new(records)));
+        let source = NodeBlockSource::new(Arc::new(RwLock::new(
+            records.into_iter().collect::<BlockLog>(),
+        )));
 
         let Some(decoded) = source.block_at_height(2) else {
             panic!("expected duplicate height record");
@@ -534,7 +536,7 @@ mod tests {
         let tree = Arc::new(RwLock::new(tree));
 
         // Empty record vector — simulates post-checkpoint-restore state.
-        let blocks: Arc<RwLock<Vec<BlockRecord>>> = Arc::new(RwLock::new(Vec::new()));
+        let blocks: Arc<RwLock<BlockLog>> = Arc::new(RwLock::new(BlockLog::new()));
         let source = NodeBlockSource::new(blocks)
             .with_block_body_source(Arc::new(FixedBody {
                 height: 0,
@@ -566,7 +568,7 @@ mod tests {
 
         // Record vector has a STALE entry at height 0 (different hash).
         let stale_record = BlockRecord::from_block(0, &stale_block);
-        let blocks = Arc::new(RwLock::new(vec![stale_record]));
+        let blocks = Arc::new(RwLock::new(BlockLog::from_iter([stale_record])));
 
         let body_source = Arc::new(CorrectBody {
             hash: correct_hash,
@@ -618,7 +620,7 @@ mod tests {
         applied_tip.store(Some(Arc::new(applied)));
 
         let record = BlockRecord::from_block(0, &genesis);
-        let blocks = Arc::new(RwLock::new(vec![record]));
+        let blocks = Arc::new(RwLock::new(BlockLog::from_iter([record])));
         let source = NodeBlockSource::new(blocks)
             .with_block_tree(tree)
             .with_applied_tip(applied_tip);

crates/node/src/p2p_chain.rs

@@ -13,24 +13,21 @@ use bitcoin::p2p::message_blockdata::Inventory;
 use bitcoin_rs_chain::BlockTree;
 use bitcoin_rs_p2p::{ChainQuery, InventoryResponse};
 use bitcoin_rs_primitives::Hash256;
-use bitcoin_rs_rpc::{BlockBodySource, BlockRecord};
+use bitcoin_rs_rpc::{BlockBodySource, BlockLog};
 use parking_lot::RwLock;
 
 /// Read-only in-memory active-chain view for P2P `getheaders` / `getdata`.
 #[derive(Clone)]
 pub struct NodeP2pChainQuery {
     block_tree: Arc<RwLock<BlockTree>>,
-    blocks: Arc<RwLock<Vec<BlockRecord>>>,
+    blocks: Arc<RwLock<BlockLog>>,
     block_body_source: Option<Arc<dyn BlockBodySource>>,
 }
 
 impl NodeP2pChainQuery {
     /// Builds a P2P chain query view over the node's shared active-chain state.
     #[must_use]
-    pub const fn new(
-        block_tree: Arc<RwLock<BlockTree>>,
-        blocks: Arc<RwLock<Vec<BlockRecord>>>,
-    ) -> Self {
+    pub const fn new(block_tree: Arc<RwLock<BlockTree>>, blocks: Arc<RwLock<BlockLog>>) -> Self {
         Self {
             block_tree,
             blocks,
@@ -201,6 +198,7 @@ mod tests {
     use bitcoin::pow::CompactTarget;
     use bitcoin::{Block, TxMerkleNode, Txid};
     use bitcoin_rs_chain::NodeStatus;
+    use bitcoin_rs_rpc::BlockRecord;
 
     #[test]
     fn getheaders_empty_locator_returns_only_active_stop() -> Result<(), Box<dyn std::error::Error>>
@@ -277,7 +275,7 @@ mod tests {
         tree.insert_node(Some(genesis_id), fork1, NodeStatus::Stale)?;
         let query = NodeP2pChainQuery::new(
             Arc::new(RwLock::new(tree)),
-            Arc::new(RwLock::new(Vec::new())),
+            Arc::new(RwLock::new(BlockLog::new())),
         );
 
         let response = query.headers_after(&[fork1.block_hash()], BlockHash::all_zeros(), 10);
@@ -378,7 +376,7 @@ mod tests {
         }
         Ok(NodeP2pChainQuery::new(
             Arc::new(RwLock::new(tree)),
-            Arc::new(RwLock::new(records)),
+            Arc::new(RwLock::new(records.into_iter().collect::<BlockLog>())),
         ))
     }
 

crates/node/src/state.rs

@@ -11,7 +11,7 @@ use bitcoin::hex::FromHex as _;
 use bitcoin::{Transaction, Txid};
 use bitcoin_rs_chain::TipSnapshot;
 use bitcoin_rs_rpc::{
-    BlockBodyMetadata, BlockBodySource, BlockRecord, NetworkState, PruneResult, PruneService,
+    BlockBodyMetadata, BlockBodySource, BlockLog, NetworkState, PruneResult, PruneService,
     PruneServiceError, PruneStatus, ZmqNotification,
 };
 use compact_str::CompactString;
@@ -330,7 +330,7 @@ impl NodeStorage {
         &self,
         block_files: &Arc<FlatFileBlockStore>,
         block_body_store: &Arc<dyn crate::apply::PruneBodyStore>,
-        blocks: Arc<RwLock<Vec<BlockRecord>>>,
+        blocks: Arc<RwLock<BlockLog>>,
         transactions: Arc<RwLock<HashMap<Txid, Transaction>>>,
         durable_tip_height: &Arc<AtomicU32>,
     ) -> Result<Arc<dyn PruneService>> {
@@ -549,7 +549,7 @@ pub struct NodePruneService<S: KvStore> {
     store: Arc<S>,
     block_files: Arc<FlatFileBlockStore>,
     block_body_store: Arc<dyn crate::apply::PruneBodyStore>,
-    blocks: Arc<RwLock<Vec<BlockRecord>>>,
+    blocks: Arc<RwLock<BlockLog>>,
     transactions: Arc<RwLock<HashMap<Txid, Transaction>>>,
     pruneheight: Mutex<Option<u32>>,
     /// Height the last clean checkpoint would restore to, 0 when none exists.
@@ -565,7 +565,7 @@ impl<S: KvStore> NodePruneService<S> {
         store: Arc<S>,
         block_files: Arc<FlatFileBlockStore>,
         block_body_store: Arc<dyn crate::apply::PruneBodyStore>,
-        blocks: Arc<RwLock<Vec<BlockRecord>>>,
+        blocks: Arc<RwLock<BlockLog>>,
         transactions: Arc<RwLock<HashMap<Txid, Transaction>>>,
         durable_tip_height: Arc<AtomicU32>,
     ) -> Result<Self> {
@@ -659,7 +659,7 @@ impl<S: KvStore> PruneService for NodePruneService<S> {
             }
         }
 
-        for record in blocks.iter_mut() {
+        for record in blocks.records_mut() {
             if record.height < updated_pruneheight {
                 record.block_hex = String::new();
             }
@@ -870,7 +870,7 @@ pub struct NodeState {
     chain_tip: Arc<ArcSwapOption<TipSnapshot>>,
     applied_tip: Arc<ArcSwapOption<TipSnapshot>>,
     block_tree: Arc<RwLock<bitcoin_rs_chain::BlockTree>>,
-    blocks: Arc<RwLock<Vec<BlockRecord>>>,
+    blocks: Arc<RwLock<BlockLog>>,
     transactions: Arc<RwLock<HashMap<Txid, Transaction>>>,
     network: Arc<RwLock<NetworkState>>,
     peers: Arc<RwLock<Vec<bitcoin_rs_p2p::PeerInfo>>>,
@@ -1058,7 +1058,7 @@ impl NodeState {
         if let Some(restored_applied_tip) = restored_applied_tip {
             applied_tip.store(Some(Arc::new(restored_applied_tip)));
         }
-        let blocks = Arc::new(RwLock::new(Vec::new()));
+        let blocks = Arc::new(RwLock::new(BlockLog::new()));
         let transactions = Arc::new(RwLock::new(HashMap::new()));
         let tx_index_open = open_tx_index(&config)?;
         let (tx_index_runtime, tx_index_worker, tx_index_query) = match tx_index_open {
@@ -1374,7 +1374,7 @@ impl NodeState {
 
     /// Returns the shared block-records handle exposed to RPC handlers.
     #[must_use]
-    pub fn blocks(&self) -> Arc<RwLock<Vec<BlockRecord>>> {
+    pub fn blocks(&self) -> Arc<RwLock<BlockLog>> {
         Arc::clone(&self.blocks)
     }
 
@@ -1555,6 +1555,7 @@ impl Drop for NodeState {
 mod tests {
     use super::*;
     use bitcoin::hashes::Hash as _;
+    use bitcoin_rs_rpc::BlockRecord;
 
     #[test]
     fn open_constructs_empty_handles() -> anyhow::Result<()> {

crates/node/src/sync.rs

@@ -7398,7 +7398,7 @@ mod tests {
             None,
             noop_filter_index(),
             Arc::new(RwLock::new(Mempool::new(MempoolLimits::default()))),
-            Arc::new(RwLock::new(Vec::new())),
+            Arc::new(RwLock::new(bitcoin_rs_rpc::BlockLog::new())),
             Arc::new(RwLock::new(HashMap::<Txid, Transaction>::new())),
             Arc::new(crate::NoOpZmqPublisher),
         )

crates/node/src/txindex_worker_query_tests.rs

@@ -232,7 +232,9 @@ impl QueryFixture {
         } else {
             Vec::new()
         };
-        let block_source = NodeBlockSource::new(Arc::new(RwLock::new(records)));
+        let block_source = NodeBlockSource::new(Arc::new(RwLock::new(
+            records.into_iter().collect::<bitcoin_rs_rpc::BlockLog>(),
+        )));
         let engine =
             TxIndexQueryEngine::new(runtime, reader, block_source, tree, applied_tip, None);
         Ok(Self { engine })

crates/node/tests/sync_smoke.rs

@@ -572,7 +572,7 @@ fn apply_handles_with_coin_stats_and_utxo(
         None,
         noop_filter_index(),
         Arc::new(RwLock::new(Mempool::new(MempoolLimits::default()))),
-        Arc::new(RwLock::new(Vec::new())),
+        Arc::new(RwLock::new(bitcoin_rs_rpc::BlockLog::new())),
         Arc::new(RwLock::new(HashMap::<Txid, Transaction>::new())),
         Arc::new(bitcoin_rs_node::NoOpZmqPublisher),
     );