feat: Support v1.6 block_headers response format with backwards compatibility

Parse `blockchain.block.headers` response based on negotiated protocol version:
- v1.6+: Headers returned as array of hex strings in `headers` field
- v1.4 (legacy): Headers returned as concatenated hex in `hex` field

- Add `is_protocol_version_at_least()` helper for semantic version comparison
- Rename old response type to `GetHeadersResLegacy` (internal)
- New `GetHeadersRes` handles v1.6 format with `header_hexes` field
- Both formats produce the same public `headers: Vec<block::Header>` output

Co-Authored-By: Claude Code AI

Author: tnull

src/raw_client.rs

@@ -54,6 +54,17 @@ pub const PROTOCOL_VERSION_MIN: &str = "1.4";
 /// Maximum protocol version supported by this client.
 pub const PROTOCOL_VERSION_MAX: &str = "1.6";
 
+/// Checks if a protocol version string is at least the specified major.minor version.
+fn is_protocol_version_at_least(version: &str, major: u32, minor: u32) -> bool {
+    let mut parts = version.split('.');
+    let v_major = parts.next().and_then(|s| s.parse::<u32>().ok());
+    let v_minor = parts.next().and_then(|s| s.parse::<u32>().ok());
+    match (v_major, v_minor) {
+        (Some(v_major), Some(v_minor)) => v_major > major || (v_major == major && v_minor >= minor),
+        _ => false,
+    }
+}
+
 macro_rules! impl_batch_call {
     ( $self:expr, $data:expr, $call:ident ) => {{
         impl_batch_call!($self, $data, $call, )
@@ -926,16 +937,38 @@ impl<T: Read + Write> ElectrumApi for RawClient<T> {
         );
         let result = self.call(req)?;
 
-        let mut deserialized: GetHeadersRes = serde_json::from_value(result)?;
-        for i in 0..deserialized.count {
-            let (start, end) = (i * 80, (i + 1) * 80);
-            deserialized
-                .headers
-                .push(deserialize(&deserialized.raw_headers[start..end])?);
-        }
-        deserialized.raw_headers.clear();
+        // Check protocol version to determine response format
+        let is_v1_6_or_later = {
+            let protocol_version = self.protocol_version.lock()?;
+            protocol_version
+                .as_ref()
+                .map(|v| is_protocol_version_at_least(v, 1, 6))
+                .unwrap_or(false)
+        };
 
-        Ok(deserialized)
+        if is_v1_6_or_later {
+            // v1.6+: headers field contains array of hex strings
+            let mut deserialized: GetHeadersRes = serde_json::from_value(result)?;
+            for header_hex in &deserialized.header_hexes {
+                let header_bytes = Vec::<u8>::from_hex(header_hex)?;
+                deserialized.headers.push(deserialize(&header_bytes)?);
+            }
+            Ok(deserialized)
+        } else {
+            // v1.4: hex field contains concatenated headers
+            let deserialized: GetHeadersResLegacy = serde_json::from_value(result)?;
+            let mut headers = Vec::new();
+            for i in 0..deserialized.count {
+                let (start, end) = (i * 80, (i + 1) * 80);
+                headers.push(deserialize(&deserialized.raw_headers[start..end])?);
+            }
+            Ok(GetHeadersRes {
+                max: deserialized.max,
+                count: deserialized.count,
+                header_hexes: Vec::new(),
+                headers,
+            })
+        }
     }
 
     fn estimate_fee(&self, number: usize, mode: Option<EstimationMode>) -> Result<f64, Error> {

src/types.rs

@@ -273,17 +273,31 @@ pub struct MempoolInfoRes {
     pub incrementalrelayfee: f64,
 }
 
-/// Response to a [`block_headers`](../client/struct.Client.html#method.block_headers) request.
+/// Response to a [`block_headers`](../client/struct.Client.html#method.block_headers) request (protocol v1.4, legacy format).
+///
+/// In protocol v1.4, the headers are returned as a single concatenated hex string.
 #[derive(Clone, Debug, Deserialize)]
-pub struct GetHeadersRes {
+pub(crate) struct GetHeadersResLegacy {
     /// Maximum number of headers returned in a single response.
     pub max: usize,
     /// Number of headers in this response.
     pub count: usize,
-    /// Raw headers concatenated. Normally cleared before returning.
+    /// Raw headers concatenated.
     #[serde(rename(deserialize = "hex"), deserialize_with = "from_hex")]
     pub raw_headers: Vec<u8>,
-    /// Array of block headers.
+}
+
+/// Response to a [`block_headers`](../client/struct.Client.html#method.block_headers) request.
+#[derive(Clone, Debug, Deserialize)]
+pub struct GetHeadersRes {
+    /// Maximum number of headers returned in a single response.
+    pub max: usize,
+    /// Number of headers in this response.
+    pub count: usize,
+    /// Array of header hex strings (v1.6 format).
+    #[serde(default, rename(deserialize = "headers"))]
+    pub(crate) header_hexes: Vec<String>,
+    /// Array of block headers (populated after parsing).
     #[serde(skip)]
     pub headers: Vec<block::Header>,
 }