feat(client): Remove Auth::None and update Error

Author: tvpeter

src/client.rs

@@ -25,8 +25,6 @@ pub mod v28;
 /// Client authentication methods for the Bitcoin Core JSON-RPC server
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
 pub enum Auth {
-    /// No authentication (not recommended)
-    None,
     /// Username and password authentication (RPC user/pass)
     UserPass(String, String),
     /// Authentication via a cookie file
@@ -42,7 +40,6 @@ impl Auth {
     /// Returns an error if the `CookieFile` cannot be read or invalid
     pub fn get_user_pass(self) -> Result<(Option<String>, Option<String>), Error> {
         match self {
-            Auth::None => Ok((None, None)),
             Auth::UserPass(u, p) => Ok((Some(u), Some(p))),
             Auth::CookieFile(path) => {
                 let line = BufReader::new(File::open(path)?)
@@ -78,21 +75,15 @@ impl Client {
     ///
     /// # Errors
     ///
-    /// * Returns `Error::MissingAuthentication` if `Auth::None` is provided.
-    /// * Returns `Error::InvalidResponse` if the URL is invalid.
+    /// * Returns `Error::InvalidUrl` if the URL is invalid.
     /// * Returns errors related to reading the cookie file.
     pub fn with_auth(url: &str, auth: Auth) -> Result<Self, Error> {
-        if matches!(auth, Auth::None) {
-            return Err(Error::MissingAuthentication);
-        }
-
         let mut builder = Builder::new()
             .url(url)
-            .map_err(|e| Error::InvalidResponse(format!("Invalid URL: {e}")))?
+            .map_err(|e| Error::InvalidUrl(format!("{e}")))?
             .timeout(std::time::Duration::from_secs(60));
 
         builder = match auth {
-            Auth::None => unreachable!(),
             Auth::UserPass(user, pass) => builder.basic_auth(user, Some(pass)),
             Auth::CookieFile(path) => {
                 let cookie = std::fs::read_to_string(path)
@@ -148,7 +139,7 @@ impl Client {
     /// The deserialized `Block` struct.
     pub fn get_block(&self, block_hash: &BlockHash) -> Result<Block, Error> {
         self.call::<String>("getblock", &[json!(block_hash), json!(0)])
-            .and_then(|blockhash_hex| deserialize_hex(&blockhash_hex).map_err(Error::DecodeHex))
+            .and_then(|block_hex| deserialize_hex(&block_hex).map_err(Error::DecodeHex))
     }
 
     /// Retrieves the hash of the tip of the best block chain.
@@ -294,14 +285,6 @@ mod test_auth {
         assert_eq!(result, (Some("user".to_string()), Some("pass".to_string())));
     }
 
-    #[test]
-    fn test_auth_none_get_user_pass() {
-        let auth = Auth::None;
-        let result = auth.get_user_pass().expect("failed to get user pass");
-
-        assert_eq!(result, (None, None));
-    }
-
     #[test]
     fn test_auth_cookie_file_get_user_pass() {
         let temp_dir = std::env::temp_dir();

src/error.rs

@@ -27,14 +27,11 @@ pub enum Error {
     /// Error modeling [`GetBlockFilter`](corepc_types::model::GetBlockFilter)
     GetBlockFilter(GetBlockFilterError),
 
-    /// Missing authentication credentials.
-    MissingAuthentication,
-
     /// Invalid or corrupted cookie file.
     InvalidCookieFile,
 
-    /// Invalid response from the RPC server.
-    InvalidResponse(String),
+    /// The provided URL is syntactically incorrect
+    InvalidUrl(String),
 
     /// JSON-RPC error from the server.
     JsonRpc(jsonrpc::Error),
@@ -55,20 +52,34 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Error::MissingAuthentication => {
-                write!(f, "authentication is required but none was provided")
-            }
-            Error::InvalidCookieFile => write!(f, "invalid cookie file"),
-            Error::InvalidResponse(e) => write!(f, "invalid response: {e}"),
-            Error::HexToArray(e) => write!(f, "Hash parsing eror: {e}"),
+            Error::DecodeHex(e) => write!(f, "hex deserialization error: {e}"),
+            Error::GetBlockVerboseOne(e) => write!(f, "block verbose error: {e}"),
+            Error::GetBlockHeaderVerbose(e) => write!(f, "block header verbose error: {e}"),
+            Error::GetBlockFilter(e) => write!(f, "block filter error: {e}"),
+            Error::InvalidCookieFile => write!(f, "invalid or missing cookie file"),
+            Error::InvalidUrl(e) => write!(f, "invalid RPC URL: {e}"),
+            Error::HexToArray(e) => write!(f, "hash parsing error: {e}"),
             Error::JsonRpc(e) => write!(f, "JSON-RPC error: {e}"),
             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::GetBlockHeaderVerbose(e) => write!(f, "{e}"),
-            Error::GetBlockVerboseOne(e) => write!(f, "{e}"),
-            Error::TryFromInt(e) => write!(f, "Integer conversion overflow error: {e}"),
-            Error::GetBlockFilter(e) => write!(f, "{e}"),
+            Error::TryFromInt(e) => write!(f, "integer conversion overflow: {e}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::DecodeHex(e) => Some(e),
+            Error::JsonRpc(e) => Some(e),
+            Error::HexToArray(e) => Some(e),
+            Error::Json(e) => Some(e),
+            Error::Io(e) => Some(e),
+            Error::TryFromInt(e) => Some(e),
+            Error::GetBlockVerboseOne(e) => Some(e),
+            Error::GetBlockHeaderVerbose(e) => Some(e),
+            Error::GetBlockFilter(e) => Some(e),
+            _ => None,
         }
     }
 }

tests/test_rpc_client.rs

@@ -73,17 +73,6 @@ fn test_client_with_user_pass() {
     node.stop().expect("failed to stop node");
 }
 
-#[test]
-fn test_auth_none_returns_error() {
-    let result = Client::with_auth("http://invalid-url", Auth::None);
-
-    assert!(result.is_err());
-    match result {
-        Err(Error::MissingAuthentication) => (),
-        _ => panic!("expected MissingAuthentication error"),
-    }
-}
-
 #[test]
 fn test_invalid_credentials() {
     let (_, mut node) = setup();