Merge pull request #1 from ValuedMammal/tvpeter-feat/blockchain_rpc_methods_v28

feat(client): Add `v28` module

Author: tvpeter

Cargo.toml

@@ -16,4 +16,6 @@ corepc-types = { version = "0.11.0", features = ["default"]}
 jsonrpc = { version = "0.18.0", features = ["simple_http", "simple_tcp", "minreq_http", "simple_uds", "proxy"] }
 
 [features]
+default = ["30_0"]
 30_0 = []
+28_0 = []

src/client.rs

@@ -10,14 +10,17 @@ use corepc_types::{
     bitcoin::{
         block::Header, consensus::encode::deserialize_hex, Block, BlockHash, Transaction, Txid,
     },
-    model::{GetBlockCount, GetBlockFilter, GetBlockVerboseOne, GetRawMempool},
+    model::{GetBlockCount, GetBlockFilter, GetRawMempool},
 };
 use jsonrpc::{
     serde,
     serde_json::{self, json},
     Transport,
 };
 
+#[cfg(feature = "28_0")]
+pub mod v28;
+
 /// Client authentication methods for the Bitcoin Core JSON-RPC server
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
 pub enum Auth {
@@ -142,21 +145,6 @@ impl Client {
         Ok(block)
     }
 
-    /// Retrieves the verbose JSON representation of a block (verbosity 1)
-    ///
-    /// # Arguments
-    /// * `block_hash`: The hash of the block to retrieve.
-    ///
-    /// # Returns
-    /// The verbose block data as a `GetBlockVerboseOne` struct.
-    pub fn get_block_verbose(&self, block_hash: &BlockHash) -> Result<GetBlockVerboseOne, Error> {
-        let block: corepc_types::v30::GetBlockVerboseOne =
-            self.call("getblock", &[json!(block_hash), json!(1)])?;
-        let block_model = block.into_model()?;
-
-        Ok(block_model)
-    }
-
     /// Retrieves the hash of the tip of the best block chain.
     ///
     /// # Returns
@@ -238,6 +226,52 @@ impl Client {
     }
 }
 
+#[cfg(not(feature = "28_0"))]
+use corepc_types::{
+    model::{GetBlockHeaderVerbose, GetBlockVerboseOne},
+    v30,
+};
+
+#[cfg(not(feature = "28_0"))]
+impl Client {
+    /// Retrieves the verbose JSON representation of a block header (verbosity 1).
+    ///
+    /// # Arguments
+    ///
+    /// * `block_hash`: The hash of the block to retrieve.
+    ///
+    /// # Returns
+    ///
+    /// The verbose header as a `GetBlockHeaderVerbose` struct.
+    pub fn get_block_header_verbose(
+        &self,
+        hash: &BlockHash,
+    ) -> Result<GetBlockHeaderVerbose, Error> {
+        let header_info: v30::GetBlockHeaderVerbose =
+            self.call("getblockheader", &[json!(hash)])?;
+        header_info
+            .into_model()
+            .map_err(Error::GetBlockHeaderVerboseError)
+    }
+
+    /// Retrieves the verbose JSON representation of a block (verbosity 1).
+    ///
+    /// # Arguments
+    ///
+    /// * `block_hash`: The hash of the block to retrieve.
+    ///
+    /// # Returns
+    ///
+    /// The verbose block data as a `GetBlockVerboseOne` struct.
+    pub fn get_block_verbose(&self, hash: &BlockHash) -> Result<GetBlockVerboseOne, Error> {
+        let block_info: v30::GetBlockVerboseOne =
+            self.call("getblock", &[json!(hash), json!(1)])?;
+        block_info
+            .into_model()
+            .map_err(Error::GetBlockVerboseOneError)
+    }
+}
+
 #[cfg(test)]
 mod test_auth {
     use super::*;

src/client/v28.rs

@@ -0,0 +1,49 @@
+use bitcoin::BlockHash;
+use corepc_types::{
+    bitcoin,
+    model::{GetBlockHeaderVerbose, GetBlockVerboseOne},
+    v28,
+};
+
+use jsonrpc::serde_json::json;
+
+use crate::{Client, Error};
+
+impl Client {
+    /// Retrieves the verbose JSON representation of a block header (verbosity 1).
+    ///
+    /// # Arguments
+    ///
+    /// * `block_hash`: The hash of the block to retrieve.
+    ///
+    /// # Returns
+    ///
+    /// The verbose header as a `GetBlockHeaderVerbose` struct.
+    pub fn get_block_header_verbose(
+        &self,
+        hash: &BlockHash,
+    ) -> Result<GetBlockHeaderVerbose, Error> {
+        let header_info: v28::GetBlockHeaderVerbose =
+            self.call("getblockheader", &[json!(hash)])?;
+        header_info
+            .into_model()
+            .map_err(Error::GetBlockHeaderVerboseError)
+    }
+
+    /// Retrieves the verbose JSON representation of a block (verbosity 1).
+    ///
+    /// # Arguments
+    ///
+    /// * `block_hash`: The hash of the block to retrieve.
+    ///
+    /// # Returns
+    ///
+    /// The verbose block data as a `GetBlockVerboseOne` struct.
+    pub fn get_block_verbose(&self, hash: &BlockHash) -> Result<GetBlockVerboseOne, Error> {
+        let block_info: v28::GetBlockVerboseOne =
+            self.call("getblock", &[json!(hash), json!(1)])?;
+        block_info
+            .into_model()
+            .map_err(Error::GetBlockVerboseOneError)
+    }
+}

src/error.rs

@@ -2,13 +2,15 @@
 
 use std::{fmt, io, num::TryFromIntError};
 
-use corepc_types::{
-    bitcoin::{
-        consensus::{self, encode::FromHexError},
-        hex::{HexToArrayError, HexToBytesError},
-    },
-    v30::GetBlockVerboseOneError,
+use bitcoin::{
+    consensus::{self, encode::FromHexError},
+    hex::{HexToArrayError, HexToBytesError},
 };
+use corepc_types::bitcoin;
+#[cfg(feature = "28_0")]
+use corepc_types::v17::{GetBlockHeaderVerboseError, GetBlockVerboseOneError};
+#[cfg(not(feature = "28_0"))]
+use corepc_types::v30::{GetBlockHeaderVerboseError, GetBlockVerboseOneError};
 use jsonrpc::serde_json;
 
 /// Result type alias for the RPC client.
@@ -20,6 +22,9 @@ pub enum Error {
     /// Hex deserialization error
     DecodeHex(consensus::encode::FromHexError),
 
+    /// Error modeling [`GetBlockHeaderVerbose`](corepc_types::model::GetBlockHeaderVerbose).
+    GetBlockHeaderVerboseError(GetBlockHeaderVerboseError),
+
     /// Error converting `GetBlockVersboseOne` type into the model type
     GetBlockVerboseOneError(GetBlockVerboseOneError),
 
@@ -65,6 +70,7 @@ impl fmt::Display for Error {
             Error::Json(e) => write!(f, "JSON error: {e}"),
             Error::Io(e) => write!(f, "I/O error: {e}"),
             Error::DecodeHex(e) => write!(f, "Hex deserialization error: {e}"),
+            Error::GetBlockHeaderVerboseError(e) => write!(f, "{e}"),
             Error::GetBlockVerboseOneError(e) => {
                 write!(f, "Error converting getblockverboseone: {e}")
             }