refactor(client)!: use bitreq for BlockingClient

- update the `BlockingClient` to use `bitreq` instead of `minreq`

Author: oleonardolima

Cargo.toml

@@ -25,8 +25,8 @@ serde_json = { version = "1.0", default-features = false }
 bitcoin = { version = "0.32", features = ["serde", "std"], default-features = false }
 hex = { version = "0.2", package = "hex-conservative" }
 log = "^0.4"
-minreq = { version = "2.11.0", features = ["json-using-serde"], optional = true }
 reqwest = { version = "0.12",  features = ["json"], default-features = false, optional = true }
+bitreq = { version = "0.3.4", optional = true }
 
 # default async runtime
 tokio = { version = "1", features = ["time"], optional = true }
@@ -38,11 +38,11 @@ lazy_static = "1.4.0"
 
 [features]
 default = ["blocking", "async", "async-https", "tokio"]
-blocking = ["minreq", "minreq/proxy"]
-blocking-https = ["blocking", "minreq/https"]
-blocking-https-rustls = ["blocking", "minreq/https-rustls"]
-blocking-https-native = ["blocking", "minreq/https-native"]
-blocking-https-bundled = ["blocking", "minreq/https-bundled"]
+blocking = ["bitreq", "bitreq/proxy", "bitreq/json-using-serde"]
+blocking-https = ["blocking", "bitreq/https"]
+blocking-https-native = ["blocking", "bitreq/https-native-tls"]
+blocking-https-rustls = ["blocking", "bitreq/https-rustls"]
+blocking-https-rustls-probe = ["blocking", "bitreq/https-rustls-probe"]
 
 tokio = ["dep:tokio"]
 async = ["reqwest", "reqwest/socks", "tokio?/time"]

src/blocking.rs

@@ -17,11 +17,10 @@ use std::str::FromStr;
 use std::thread;
 
 use bitcoin::consensus::encode::serialize_hex;
+use bitreq::{Proxy, Request, Response};
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
-use minreq::{Proxy, Request, Response};
-
 use bitcoin::block::Header as BlockHeader;
 use bitcoin::consensus::{deserialize, serialize, Decodable};
 use bitcoin::hashes::{sha256, Hash};
@@ -68,10 +67,10 @@ impl BlockingClient {
 
     /// Perform a raw HTTP GET request with the given URI `path`.
     pub fn get_request(&self, path: &str) -> Result<Request, Error> {
-        let mut request = minreq::get(format!("{}{}", self.url, path));
+        let mut request = bitreq::get(format!("{}{}", self.url, path));
 
         if let Some(proxy) = &self.proxy {
-            let proxy = Proxy::new(proxy.as_str())?;
+            let proxy = Proxy::new_http(proxy.as_str())?;
             request = request.with_proxy(proxy);
         }
 
@@ -92,10 +91,10 @@ impl BlockingClient {
     where
         T: Into<Vec<u8>>,
     {
-        let mut request = minreq::post(format!("{}{}", self.url, path)).with_body(body);
+        let mut request = bitreq::post(format!("{}{}", self.url, path)).with_body(body);
 
         if let Some(proxy) = &self.proxy {
-            let proxy = Proxy::new(proxy.as_str())?;
+            let proxy = Proxy::new_http(proxy.as_str())?;
             request = request.with_proxy(proxy);
         }
 
@@ -128,7 +127,7 @@ impl BlockingClient {
                 Err(Error::HttpResponse { status, message })
             }
             Ok(resp) => Ok(Some(
-                Txid::from_str(resp.as_str().map_err(Error::Minreq)?).map_err(Error::HexToArray)?,
+                Txid::from_str(resp.as_str().map_err(Error::BitReq)?).map_err(Error::HexToArray)?,
             )),
             Err(e) => Err(e),
         }
@@ -143,7 +142,7 @@ impl BlockingClient {
                 Err(Error::HttpResponse { status, message })
             }
             Ok(resp) => {
-                let hex_str = resp.as_str().map_err(Error::Minreq)?;
+                let hex_str = resp.as_str().map_err(Error::BitReq)?;
                 let hex_vec = Vec::from_hex(hex_str)?;
                 deserialize::<T>(&hex_vec)
                     .map_err(Error::BitcoinEncoding)
@@ -161,7 +160,7 @@ impl BlockingClient {
                 Err(Error::HttpResponse { status, message })
             }
             Ok(resp) => {
-                let hex_str = resp.as_str().map_err(Error::Minreq)?;
+                let hex_str = resp.as_str().map_err(Error::BitReq)?;
                 let hex_vec = Vec::from_hex(hex_str)?;
                 deserialize::<T>(&hex_vec).map_err(Error::BitcoinEncoding)
             }
@@ -180,7 +179,7 @@ impl BlockingClient {
                 let message = resp.as_str().unwrap_or_default().to_string();
                 Err(Error::HttpResponse { status, message })
             }
-            Ok(resp) => Ok(resp.json::<T>().map_err(Error::Minreq)?),
+            Ok(resp) => Ok(resp.json::<T>().map_err(Error::BitReq)?),
             Err(e) => Err(e),
         }
     }
@@ -309,7 +308,7 @@ impl BlockingClient {
                 let txid = Txid::from_str(resp.as_str()?).map_err(Error::HexToArray)?;
                 Ok(txid)
             }
-            Err(e) => Err(Error::Minreq(e)),
+            Err(e) => Err(Error::BitReq(e)),
         }
     }
 
@@ -353,8 +352,8 @@ impl BlockingClient {
                 let message = resp.as_str().unwrap_or_default().to_string();
                 Err(Error::HttpResponse { status, message })
             }
-            Ok(resp) => Ok(resp.json::<SubmitPackageResult>().map_err(Error::Minreq)?),
-            Err(e) => Err(Error::Minreq(e)),
+            Ok(resp) => Ok(resp.json::<SubmitPackageResult>().map_err(Error::BitReq)?),
+            Err(e) => Err(Error::BitReq(e)),
         }
     }
 

src/lib.rs

@@ -4,7 +4,7 @@
 //! async Esplora client to query Esplora's backend.
 //!
 //! The library provides the possibility to build a blocking
-//! client using [`minreq`] and an async client using [`reqwest`].
+//! client using [`bitreq`] and an async client using [`reqwest`].
 //! The library supports communicating to Esplora via a proxy
 //! and also using TLS (SSL) for secure communication.
 //!
@@ -44,14 +44,14 @@
 //! `esplora-client = { version = "*", default-features = false, features =
 //! ["blocking"] }`
 //!
-//! * `blocking` enables [`minreq`], the blocking client with proxy.
-//! * `blocking-https` enables [`minreq`], the blocking client with proxy and TLS (SSL) capabilities
-//!   using the default [`minreq`] backend.
-//! * `blocking-https-rustls` enables [`minreq`], the blocking client with proxy and TLS (SSL)
+//! * `blocking` enables [`bitreq`], the blocking client with proxy.
+//! * `blocking-https` enables [`bitreq`], the blocking client with proxy and TLS (SSL) capabilities
+//!   using the default [`bitreq`] backend.
+//! * `blocking-https-rustls` enables [`bitreq`], the blocking client with proxy and TLS (SSL)
 //!   capabilities using the `rustls` backend.
-//! * `blocking-https-native` enables [`minreq`], the blocking client with proxy and TLS (SSL)
+//! * `blocking-https-native` enables [`bitreq`], the blocking client with proxy and TLS (SSL)
 //!   capabilities using the platform's native TLS backend (likely OpenSSL).
-//! * `blocking-https-bundled` enables [`minreq`], the blocking client with proxy and TLS (SSL)
+//! * `blocking-https-bundled` enables [`bitreq`], the blocking client with proxy and TLS (SSL)
 //!   capabilities using a bundled OpenSSL library backend.
 //! * `async` enables [`reqwest`], the async client with proxy capabilities.
 //! * `async-https` enables [`reqwest`], the async client with support for proxying and TLS (SSL)
@@ -65,7 +65,7 @@
 //!   certificates.
 //!
 //! [`dont remove this line or cargo doc will break`]: https://example.com
-#![cfg_attr(not(feature = "minreq"), doc = "[`minreq`]: https://docs.rs/minreq")]
+#![cfg_attr(not(feature = "bitreq"), doc = "[`bitreq`]: https://docs.rs/bitreq")]
 #![cfg_attr(not(feature = "reqwest"), doc = "[`reqwest`]: https://docs.rs/reqwest")]
 #![allow(clippy::result_large_err)]
 #![warn(missing_docs)]
@@ -202,9 +202,9 @@ impl Builder {
 /// Errors that can happen during a request to `Esplora` servers.
 #[derive(Debug)]
 pub enum Error {
-    /// Error during `minreq` HTTP request
+    /// Error during `bitreq` HTTP request
     #[cfg(feature = "blocking")]
-    Minreq(minreq::Error),
+    BitReq(bitreq::Error),
     /// Error during `reqwest` HTTP request
     #[cfg(feature = "async")]
     Reqwest(reqwest::Error),
@@ -262,7 +262,7 @@ macro_rules! impl_error {
 
 impl std::error::Error for Error {}
 #[cfg(feature = "blocking")]
-impl_error!(::minreq::Error, Minreq, Error);
+impl_error!(::bitreq::Error, BitReq, Error);
 #[cfg(feature = "async")]
 impl_error!(::reqwest::Error, Reqwest, Error);
 impl_error!(serde_json::Error, SerdeJson, Error);