perf(rpc): answer gettxoutproof from the txindex instead of scanning the chain

Called without a block hash, the handler deep-copied every BlockRecord, then
loaded, deserialized and hashed every block on the chain to answer one call.
At tip that is roughly a million block loads, almost all of them discarded --
unbounded work for one authenticated RPC call, which stalls the node and evicts
everything else from cache while it runs.

Context.indexer already knows which block confirms a txid. Resolve the
confirming height, build the proof from that block alone, and take the same
route Bitcoin Core does: it requires the block hash unless txindex is enabled.

The scan is kept whole as proof_from_records. It is the fallback whenever the
index cannot answer -- no indexer, an unresolved or stale row, a pruned body, or
a candidate block that does not hold every wanted txid -- and it is the oracle
the equivalence tests compare against. That last fallback is not belt and
braces: BIP30 duplicate coinbase txids mean a txid can confirm in more than one
block, so a block chosen from a single txid is a candidate, never a verdict.

IndexerLike gains resolve_transaction_height, defaulting to Ok(None), so every
existing implementation keeps compiling and no caller may drop its fallback.

Measured on an idle machine, both arms in one Criterion run over one fixture:
21.118 ms -> 32.983 us for the scan worst case, and within noise of each other
for its best case, because the index arm is flat at 28-33 us regardless of
position. Extrapolating the scan's 10.56 us per record to a mainnet-sized chain
gives about 10 seconds per call, and that is a floor -- fixture blocks hold 8
small transactions where real ones hold thousands. See
docs/benchmarks/gettxoutproof.md.

The twelve tests were audited by mutation rather than trusted for being green.
That audit found the three crates/index tests were not running at all, because
their module is gated on a feature the crate does not enable by default, and
that one of them passed vacuously when both resolvers returned None. Both are
fixed here.

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

Author: rabbitson87

Cargo.lock

@@ -436,6 +436,40 @@ impl<S: KvStore> Indexer<S> {
         Ok(None)
     }
 
+    /// Resolves the height of the block confirming `txid`, without
+    /// materializing the transaction.
+    ///
+    /// Same candidate walk as [`Self::resolve_transaction`] — positions first,
+    /// then a full-block scan that answers the rare stale row or 8-byte
+    /// txid-prefix collision — but it reports *which block* rather than which
+    /// transaction, which is what a merkle-proof caller needs. Returns `None`
+    /// when no candidate row resolves to `txid`, and "not found" is never
+    /// reported on the strength of positions alone.
+    pub fn resolve_transaction_height<B: BlockSource + ?Sized>(
+        &self,
+        txid: bitcoin::Txid,
+        source: &B,
+    ) -> Result<Option<u32>, IndexError> {
+        let rows = self.iter_txid_rows_with_values(&txid)?;
+        for (row, value) in &rows {
+            let height = row.height();
+            if let Some(positions) = crate::types::TxPositionValue::decode(value)
+                && positions
+                    .iter()
+                    .filter_map(|position| transaction_at(height, *position, source))
+                    .any(|tx| tx.compute_txid() == txid)
+            {
+                return Ok(Some(height));
+            }
+            if let Some(block) = source.block_at_height(height)
+                && block.txdata.iter().any(|tx| tx.compute_txid() == txid)
+            {
+                return Ok(Some(height));
+            }
+        }
+        Ok(None)
+    }
+
     /// Naive reference implementation of [`Self::resolve_transaction`].
     ///
     /// Loads and fully decodes the block for each candidate row, then computes
@@ -1442,6 +1476,20 @@ pub trait IndexerLike: Send + Sync {
         Ok(None)
     }
 
+    /// Resolves the height of the block confirming `txid` via `source`.
+    ///
+    /// Default implementations may return `Ok(None)` when the concrete indexer
+    /// does not support transaction lookup, so a caller that must answer
+    /// correctly without an index keeps its own fallback path.
+    fn resolve_transaction_height(
+        &self,
+        txid: bitcoin::Txid,
+        source: &dyn BlockSource,
+    ) -> Result<Option<u32>, IndexError> {
+        let _ = (txid, source);
+        Ok(None)
+    }
+
     /// Resolves the satoshi value of the transaction output at `outpoint` via
     /// `source`. Returns `Ok(None)` when the transaction is not indexed or the
     /// `vout` is out of range.
@@ -1594,6 +1642,14 @@ impl<S: KvStore + Send + Sync + 'static> IndexerLike for Indexer<S> {
         Self::resolve_transaction(self, txid, source)
     }
 
+    fn resolve_transaction_height(
+        &self,
+        txid: bitcoin::Txid,
+        source: &dyn BlockSource,
+    ) -> Result<Option<u32>, IndexError> {
+        Self::resolve_transaction_height(self, txid, source)
+    }
+
     fn resolve_outpoint_value(
         &self,
         outpoint: bitcoin::OutPoint,
@@ -1961,6 +2017,71 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn resolve_transaction_height_returns_the_confirming_height()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let block = bitcoin::blockdata::constants::genesis_block(bitcoin::Network::Regtest);
+        let Some(tx) = block.txdata.first() else {
+            return Err(std::io::Error::other("genesis block has no transactions").into());
+        };
+        let txid = tx.compute_txid();
+        let (_dir, mut indexer) = indexer()?;
+
+        indexer.ingest_block(&serialize(&block), 0)?;
+
+        let source = FakeSource {
+            block,
+            target_height: 0,
+        };
+
+        assert_eq!(indexer.resolve_transaction_height(txid, &source)?, Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_transaction_height_returns_none_for_unknown_txid()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let (_dir, indexer) = indexer()?;
+        let txid = bitcoin::Txid::from_byte_array([0xff; 32]);
+        let source = FakeSource {
+            block: bitcoin::blockdata::constants::genesis_block(bitcoin::Network::Regtest),
+            target_height: 0,
+        };
+
+        assert_eq!(indexer.resolve_transaction_height(txid, &source)?, None);
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_transaction_height_agrees_with_the_transaction_resolver()
+    -> Result<(), Box<dyn std::error::Error>> {
+        // The two resolvers walk the same candidate rows; a caller that picks a
+        // block by height must land on the block the transaction resolver would
+        // have read the transaction out of.
+        let block = bitcoin::blockdata::constants::genesis_block(bitcoin::Network::Regtest);
+        let Some(tx) = block.txdata.first() else {
+            return Err(std::io::Error::other("genesis block has no transactions").into());
+        };
+        let txid = tx.compute_txid();
+        let (_dir, mut indexer) = indexer()?;
+
+        indexer.ingest_block(&serialize(&block), 0)?;
+
+        let source = FakeSource {
+            block,
+            target_height: 0,
+        };
+
+        let by_height = indexer.resolve_transaction_height(txid, &source)?;
+        let by_transaction = indexer.resolve_tx_with_height(txid, &source)?;
+
+        // Both resolvers returning `None` would satisfy the equality below while
+        // proving nothing, so pin the resolved value before comparing.
+        assert_eq!(by_height, Some(0));
+        assert_eq!(by_height, by_transaction.map(|(_, height)| height));
+        Ok(())
+    }
+
     #[test]
     fn resolve_outpoint_value_returns_genesis_coinbase_subsidy()
     -> Result<(), Box<dyn std::error::Error>> {

crates/index/src/index.rs

@@ -47,3 +47,9 @@ tracing.workspace = true
 [dev-dependencies]
 proptest.workspace = true
 tempfile = "3"
+criterion.workspace = true
+
+[[bench]]
+name = "txoutproof"
+harness = false
+required-features = ["rocksdb"]