wip(feat(minireq)): add minireq/bitreq HTTP client blocking support

Author: oleonardolima

.github/workflows/cont_integration.yml

@@ -23,8 +23,8 @@ jobs:
           - blocking
           - blocking-https
           - blocking-https-rustls
-          - blocking-https-native
-          - blocking-https-bundled
+          # - blocking-https-native
+          # - blocking-https-bundled
           - async
           - async-https
           - async-https-native
@@ -55,7 +55,7 @@ jobs:
       if: matrix.rust.version == '1.63.0'
       run: |
         cargo update -p reqwest --precise "0.12.4"
-        cargo update -p minreq --precise "2.13.2"
+        # cargo update -p minreq --precise "2.13.2"
         cargo update -p home --precise "0.5.5"
         cargo update -p url --precise "2.5.0"
         cargo update -p tokio --precise "1.38.1"

Cargo.toml

@@ -18,32 +18,56 @@ path = "src/lib.rs"
 
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
-bitcoin = { version = "0.32", features = ["serde", "std"], 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 }
+# minreq = { version = "2.11.0", features = [
+#     "json-using-serde",
+# ], optional = true }
+reqwest = { version = "0.12", features = [
+    "json",
+], default-features = false, optional = true }
+minireq = { git = "https://github.com/tcharding/minireq.git", branch = "master", optional = true }
 
 # default async runtime
 tokio = { version = "1", features = ["time"], optional = true }
 
+serde_json = { version = "1.0", optional = true }
+
 [dev-dependencies]
 serde_json = "1.0"
 tokio = { version = "1.20.1", features = ["full"] }
-electrsd = { version = "0.33.0", features = ["legacy", "esplora_a33e97e1", "corepc-node_28_0"] }
+electrsd = { version = "0.33.0", features = [
+    "legacy",
+    "esplora_a33e97e1",
+    "corepc-node_28_0",
+] }
 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"]
+default = ["blocking", "async", "async-https", "tokio", "serde_json"]
+blocking = ["minireq", "minireq/proxy", "serde_json"]
+blocking-https = ["blocking", "minireq/https", "serde_json"]
+blocking-https-rustls = ["blocking", "minireq/https-rustls"]
+# blocking-https-native = ["blocking", "minreq/https-native"]
+# blocking-https-bundled = ["blocking", "minreq/https-bundled"]
 
 tokio = ["dep:tokio"]
 async = ["reqwest", "reqwest/socks", "tokio?/time"]
 async-https = ["async", "reqwest/default-tls"]
 async-https-native = ["async", "reqwest/native-tls"]
 async-https-rustls = ["async", "reqwest/rustls-tls"]
 async-https-rustls-manual-roots = ["async", "reqwest/rustls-tls-manual-roots"]
+
+# # TODO: (@oleonardolima) add new minireq feature flag
+# minireq = [
+#     "dep:minireq",
+#     "minireq/urlencoding",
+#     "minireq/punycode",
+#     "minireq/base64",
+#     "minireq/proxy",
+#     "serde_json",
+# ]

src/blocking.rs

@@ -9,7 +9,7 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
-//! Esplora by way of `minreq` HTTP client.
+//! Esplora by way of `minireq` HTTP client.
 
 use std::collections::HashMap;
 use std::convert::TryFrom;
@@ -19,7 +19,7 @@ use std::thread;
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
-use minreq::{Proxy, Request, Response};
+use minireq::{Proxy, Request, Response};
 
 use bitcoin::consensus::{deserialize, serialize, Decodable};
 use bitcoin::hashes::{sha256, Hash};
@@ -68,7 +68,7 @@ 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 = minireq::get(format!("{}{}", self.url, path));
 
         if let Some(proxy) = &self.proxy {
             let proxy = Proxy::new(proxy.as_str())?;
@@ -110,7 +110,8 @@ 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::MiniReq)?)
+                    .map_err(Error::HexToArray)?,
             )),
             Err(e) => Err(e),
         }
@@ -125,7 +126,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::MiniReq)?;
                 let hex_vec = Vec::from_hex(hex_str).unwrap();
                 deserialize::<T>(&hex_vec)
                     .map_err(Error::BitcoinEncoding)
@@ -143,7 +144,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::MiniReq)?;
                 let hex_vec = Vec::from_hex(hex_str).unwrap();
                 deserialize::<T>(&hex_vec).map_err(Error::BitcoinEncoding)
             }
@@ -162,7 +163,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(self.into_json(&resp)?),
             Err(e) => Err(e),
         }
     }
@@ -178,7 +179,7 @@ impl BlockingClient {
                 let message = resp.as_str().unwrap_or_default().to_string();
                 Err(Error::HttpResponse { status, message })
             }
-            Ok(resp) => Ok(Some(resp.json::<T>()?)),
+            Ok(resp) => Ok(Some(self.into_json(&resp)?)),
             Err(e) => Err(e),
         }
     }
@@ -195,6 +196,20 @@ impl BlockingClient {
         }
     }
 
+    pub fn into_json<'a, T>(&self, res: &'a Response) -> Result<T, Error>
+    where
+        T: serde::de::Deserialize<'a>,
+    {
+        let str = match res.as_str() {
+            Ok(str) => str,
+            Err(_) => return Err(Error::InvalidUtf8InResponse),
+        };
+        match serde_json::from_str(str) {
+            Ok(json) => Ok(json),
+            Err(err) => Err(Error::SerdeJsonError(err)),
+        }
+    }
+
     /// Get a [`Transaction`] option given its [`Txid`]
     pub fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
         self.get_opt_response(&format!("/tx/{txid}/raw"))
@@ -268,7 +283,7 @@ impl BlockingClient {
 
     /// Broadcast a [`Transaction`] to Esplora
     pub fn broadcast(&self, transaction: &Transaction) -> Result<(), Error> {
-        let mut request = minreq::post(format!("{}/tx", self.url)).with_body(
+        let mut request = minireq::post(format!("{}/tx", self.url)).with_body(
             serialize(transaction)
                 .to_lower_hex_string()
                 .as_bytes()
@@ -291,7 +306,7 @@ impl BlockingClient {
                 Err(Error::HttpResponse { status, message })
             }
             Ok(_resp) => Ok(()),
-            Err(e) => Err(Error::Minreq(e)),
+            Err(e) => Err(Error::MiniReq(e)),
         }
     }
 

src/lib.rs

@@ -65,14 +65,15 @@
 //!   certificates.
 //!
 //! [`dont remove this line or cargo doc will break`]: https://example.com
-#![cfg_attr(not(feature = "minreq"), doc = "[`minreq`]: https://docs.rs/minreq")]
+// TODO: (@oleonardolima) update it to bitreq once released
+#![cfg_attr(not(feature = "minireq"), doc = "[`minireq`]: https://docs.rs/minireq")]
 #![cfg_attr(not(feature = "reqwest"), doc = "[`reqwest`]: https://docs.rs/reqwest")]
 #![allow(clippy::result_large_err)]
 
 use std::collections::HashMap;
-use std::fmt;
 use std::num::TryFromIntError;
 use std::time::Duration;
+use std::{fmt, str};
 
 #[cfg(feature = "async")]
 pub use r#async::Sleeper;
@@ -83,12 +84,18 @@ pub mod r#async;
 #[cfg(feature = "blocking")]
 pub mod blocking;
 
+#[cfg(feature = "minireq")]
+pub mod minireq;
+
 pub use api::*;
 #[cfg(feature = "blocking")]
 pub use blocking::BlockingClient;
 #[cfg(feature = "async")]
 pub use r#async::AsyncClient;
 
+// #[cfg(feature = "minireq")]
+// use crate::minireq::;
+
 /// Response status codes for which the request may be retried.
 pub const RETRYABLE_ERROR_CODES: [u16; 3] = [
     429, // TOO_MANY_REQUESTS
@@ -195,14 +202,22 @@ impl Builder {
     pub fn build_async_with_sleeper<S: Sleeper>(self) -> Result<AsyncClient<S>, Error> {
         AsyncClient::from_builder(self)
     }
+
+    // #[cfg(feature = "minireq")]
+    // pub fn build_blocking_minireq(self) ->  {
+    //     ::from_builder(self)
+    // }
 }
 
 /// Errors that can happen during a request to `Esplora` servers.
 #[derive(Debug)]
 pub enum Error {
-    /// Error during `minreq` HTTP request
+    // /// Error during `minreq` HTTP request
+    // #[cfg(feature = "blocking")]
+    // Minreq(::minreq::Error),
+    /// Error during `minireq` HTTP request
     #[cfg(feature = "blocking")]
-    Minreq(::minreq::Error),
+    MiniReq(::minireq::Error),
     /// Error during reqwest HTTP request
     #[cfg(feature = "async")]
     Reqwest(::reqwest::Error),
@@ -230,6 +245,14 @@ pub enum Error {
     InvalidHttpHeaderValue(String),
     /// The server sent an invalid response
     InvalidResponse,
+
+    // TODO: (@oleonardolima) improve these error variants
+    /// Ran into a Serde error.
+    #[cfg(feature = "serde_json")]
+    SerdeJsonError(serde_json::Error),
+    /// The response contained invalid UTF-8 where it should be valid
+    /// (eg. headers), so the response cannot interpreted correctly.
+    InvalidUtf8InResponse,
 }
 
 impl fmt::Display for Error {
@@ -253,7 +276,7 @@ macro_rules! impl_error {
 
 impl std::error::Error for Error {}
 #[cfg(feature = "blocking")]
-impl_error!(::minreq::Error, Minreq, Error);
+impl_error!(::minireq::Error, MiniReq, Error);
 #[cfg(feature = "async")]
 impl_error!(::reqwest::Error, Reqwest, Error);
 impl_error!(std::num::ParseIntError, Parsing, Error);
@@ -325,7 +348,7 @@ mod test {
 
         let mut builder = Builder::new(&format!("http://{esplora_url}"));
         if !headers.is_empty() {
-            builder.headers = headers;
+            builder.headers = headers.clone();
         }
 
         let blocking_client = builder.build_blocking();
@@ -951,7 +974,7 @@ mod test {
         assert_eq!(blocks_genesis, blocks_genesis_async);
     }
 
-    #[cfg(all(feature = "blocking", feature = "async"))]
+    #[cfg(all(feature = "blocking", feature = "async", feature = "minireq"))]
     #[tokio::test]
     async fn test_get_tx_with_http_header() {
         let headers = [(