test(rpc): cover the block-tree derived record, which had no test at all

A mutation audit of the header change found that dropping the header from
`Context::header_record` entirely failed no test. That path builds a BlockRecord
from the block tree rather than from applied-block bytes, and this change gave
it a `serialize(&node.header).try_into().ok()` whose failure mode is a silently
absent header -- where the old String field would at least have carried
something. It was the one part of the change nothing exercised.

`tree_derived_record_carries_the_header` seeds a tree node, resolves the record
through `record_for_hash` without pushing anything into `blocks`, and asserts
both the raw bytes and the rendered hex match the header the tree holds.

The rest of the change is well covered, and the audit says so rather than
assuming it: neutering `header_from_block_bytes` fails five tests, three of them
pre-existing `getblock` tests, and emptying `header_hex()` fails the round-trip
test. The new test now fails under the mutation that found the gap.

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

Author: rabbitson87

crates/rpc/src/context.rs

@@ -1046,6 +1046,51 @@ mod tests {
         assert!(record.header_bytes().is_none());
         assert!(record.header_hex().is_empty());
     }
+
+    /// Covers the record the block tree derives, which had no test at all.
+    ///
+    /// `header_record` builds its header with `try_into().ok()`, so a length that
+    /// does not fit yields `None` and the header vanishes silently — where the
+    /// old `String` field would at least have carried something. A mutation that
+    /// dropped the header from this path failed no test before this one existed.
+    #[test]
+    fn tree_derived_record_carries_the_header() {
+        use bitcoin::block::Version;
+        use bitcoin::hashes::Hash as _;
+        use bitcoin::{BlockHash, CompactTarget, TxMerkleNode};
+        use bitcoin_rs_chain::NodeStatus;
+
+        let ctx = Context::new();
+        let header = bitcoin::block::Header {
+            version: Version::ONE,
+            prev_blockhash: BlockHash::all_zeros(),
+            merkle_root: TxMerkleNode::all_zeros(),
+            time: 1_000_000,
+            bits: CompactTarget::from_consensus(0x207f_ffff),
+            nonce: 7,
+        };
+        let hash = {
+            let mut tree = ctx.block_tree.write();
+            let id = tree
+                .insert_node(None, header, NodeStatus::Active)
+                .expect("genesis inserts");
+            tree.node(id).expect("inserted node").hash
+        };
+
+        // Nothing was pushed into `blocks`, so the record can only come from the
+        // tree.
+        let record = ctx.record_for_hash(hash).expect("tree resolves the hash");
+
+        assert_eq!(
+            record.header_bytes().map(|bytes| bytes.as_slice()),
+            Some(serialize(&header).as_slice()),
+            "the tree-derived record must carry the header the tree holds"
+        );
+        assert_eq!(
+            record.header_hex(),
+            serialize(&header).to_lower_hex_string()
+        );
+    }
     #[test]
     fn block_by_height_returns_record_after_add_block() {
         use bitcoin_rs_primitives::Hash256;