Revert breaking changes to jsonrpc sync client

jamillambert · jamillambert · commit 84da74661d0a · 2026-03-12T09:28:40.000Z
Restore the original sync client feature name, module name and
reexports so that downstream is not broken.
diff --git a/.github/workflows/cron-daily-fuzz.yml b/.github/workflows/cron-daily-fuzz.yml
@@ -18,7 +18,7 @@ jobs:
         # We only get 20 jobs at a time, we probably don't want to go
         # over that limit with fuzzing because of the hour run time.
         fuzz_target: [
-          bitreq_http_sync,
+          bitreq_http,
           simple_http,
         ]
     steps:
diff --git a/client/Cargo.toml b/client/Cargo.toml
@@ -18,7 +18,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 # Enable this feature to get a blocking JSON-RPC client.
-client-sync = ["jsonrpc", "jsonrpc/bitreq_http_sync"]
+client-sync = ["jsonrpc", "jsonrpc/bitreq_http"]
 # Enable this feature to get an async JSON-RPC client.
 client-async = ["jsonrpc", "jsonrpc/bitreq_http_async", "jsonrpc/client_async"]
 
diff --git a/client/src/client_sync/mod.rs b/client/src/client_sync/mod.rs
@@ -66,7 +66,7 @@ macro_rules! define_jsonrpc_bitreq_client {
 
         /// Client implements a JSON-RPC client for the Bitcoin Core daemon or compatible APIs.
         pub struct Client {
-            inner: jsonrpc::client_sync::Client,
+            inner: jsonrpc::client::Client,
         }
 
         impl fmt::Debug for Client {
@@ -81,12 +81,12 @@ macro_rules! define_jsonrpc_bitreq_client {
         impl Client {
             /// Creates a client to a bitcoind JSON-RPC server without authentication.
             pub fn new(url: &str) -> Self {
-                let transport = jsonrpc::http::bitreq_http_sync::Builder::new()
+                let transport = jsonrpc::http::bitreq_http::Builder::new()
                     .url(url)
                     .expect("jsonrpc v0.19, this function does not error")
                     .timeout(std::time::Duration::from_secs(60))
                     .build();
-                let inner = jsonrpc::client_sync::Client::with_transport(transport);
+                let inner = jsonrpc::client::Client::with_transport(transport);
 
                 Self { inner }
             }
@@ -98,13 +98,13 @@ macro_rules! define_jsonrpc_bitreq_client {
                 }
                 let (user, pass) = auth.get_user_pass()?;
 
-                let transport = jsonrpc::http::bitreq_http_sync::Builder::new()
+                let transport = jsonrpc::http::bitreq_http::Builder::new()
                     .url(url)
                     .expect("jsonrpc v0.19, this function does not error")
                     .timeout(std::time::Duration::from_secs(60))
                     .basic_auth(user.unwrap(), pass)
                     .build();
-                let inner = jsonrpc::client_sync::Client::with_transport(transport);
+                let inner = jsonrpc::client::Client::with_transport(transport);
 
                 Ok(Self { inner })
             }
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
@@ -11,7 +11,7 @@ cargo-fuzz = true
 
 [dependencies]
 honggfuzz = { version = "0.5.55", default-features = false }
-jsonrpc = { path = "../jsonrpc", features = ["bitreq_http_sync"] }
+jsonrpc = { path = "../jsonrpc", features = ["bitreq_http"] }
 
 serde = { version = "1.0.103", features = [ "derive" ] }
 serde_json = "1.0"
@@ -20,8 +20,8 @@ serde_json = "1.0"
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(fuzzing)', 'cfg(jsonrpc_fuzz)'] }
 
 [[bin]]
-name = "bitreq_http_sync"
-path = "fuzz_targets/bitreq_http_sync.rs"
+name = "bitreq_http"
+path = "fuzz_targets/bitreq_http.rs"
 
 [[bin]]
 name = "simple_http"
diff --git a/fuzz/fuzz_targets/bitreq_http.rs b/fuzz/fuzz_targets/bitreq_http.rs
@@ -8,7 +8,7 @@ fn do_test(data: &[u8]) {
     {
         use std::io;
 
-        use jsonrpc::bitreq_http_sync::{BitreqHttpTransport, FUZZ_TCP_SOCK};
+        use jsonrpc::bitreq_http::{BitreqHttpTransport, FUZZ_TCP_SOCK};
         use jsonrpc::Client;
 
         *FUZZ_TCP_SOCK.lock().unwrap() = Some(io::Cursor::new(data.to_vec()));
diff --git a/fuzz/generate-files.sh b/fuzz/generate-files.sh
@@ -23,7 +23,7 @@ cargo-fuzz = true
 
 [dependencies]
 honggfuzz = { version = "0.5.55", default-features = false }
-jsonrpc = { path = "..", features = ["bitreq_http_sync"] }
+jsonrpc = { path = "..", features = ["bitreq_http"] }
 
 serde = { version = "1.0.103", features = [ "derive" ] }
 serde_json = "1.0"
diff --git a/jsonrpc/Cargo.toml b/jsonrpc/Cargo.toml
@@ -21,7 +21,7 @@ default = [ "simple_http", "simple_tcp" ]
 # A bare-minimum HTTP transport.
 simple_http = [ "base64" ]
 # A transport that uses `bitreq` as the HTTP client.
-bitreq_http_sync = [ "base64", "bitreq" ]
+bitreq_http = [ "base64", "bitreq" ]
 # A transport that uses `bitreq` as the async HTTP client.
 bitreq_http_async = [ "base64", "bitreq", "bitreq/async", "client_async" ]
 # An async JSON-RPC client implementation.
diff --git a/jsonrpc/contrib/test_vars.sh b/jsonrpc/contrib/test_vars.sh
@@ -4,7 +4,7 @@
 FEATURES_WITH_STD=""
 
 # So this is the var to use for all tests.
-FEATURES_WITHOUT_STD="simple_http bitreq_http_sync simple_tcp simple_uds proxy"
+FEATURES_WITHOUT_STD="simple_http bitreq_http simple_tcp simple_uds proxy"
 
 # Run these examples.
 EXAMPLES=""
diff --git a/jsonrpc/src/client.rs b/jsonrpc/src/client.rs
@@ -124,7 +124,7 @@ impl Client {
     }
 }
 
-impl fmt::Debug for Client {
+impl fmt::Debug for crate::Client {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "jsonrpc::Client(")?;
         self.transport.fmt_target(f)?;
diff --git a/jsonrpc/src/http/bitreq_http.rs b/jsonrpc/src/http/bitreq_http.rs
@@ -1,4 +1,4 @@
-//! This module implements the [`crate::client_sync::Transport`] trait using [`bitreq`]
+//! This module implements the [`crate::client::Transport`] trait using [`bitreq`]
 //! as the underlying HTTP transport.
 //!
 //! [bitreq]: <https://github.com/rust-bitcoin/corepc/bitreq>
@@ -13,7 +13,7 @@ use std::{error, fmt};
 use base64::engine::general_purpose::STANDARD as BASE64;
 use base64::Engine;
 
-use crate::client_sync::Transport;
+use crate::client::Transport;
 use crate::{Request, Response};
 
 const DEFAULT_URL: &str = "http://localhost";
@@ -137,7 +137,7 @@ impl Builder {
     /// # Examples
     ///
     /// ```no_run
-    /// # use jsonrpc::bitreq_http_sync::BitreqHttpTransport;
+    /// # use jsonrpc::bitreq_http::BitreqHttpTransport;
     /// # use std::fs::{self, File};
     /// # use std::path::Path;
     /// # let cookie_file = Path::new("~/.bitcoind/.cookie");
@@ -259,7 +259,7 @@ mod impls {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::client_sync::Client;
+    use crate::Client;
 
     #[test]
     fn construct() {
diff --git a/jsonrpc/src/http/mod.rs b/jsonrpc/src/http/mod.rs
@@ -3,8 +3,8 @@
 #[cfg(feature = "simple_http")]
 pub mod simple_http;
 
-#[cfg(feature = "bitreq_http_sync")]
-pub mod bitreq_http_sync;
+#[cfg(feature = "bitreq_http")]
+pub mod bitreq_http;
 
 #[cfg(feature = "bitreq_http_async")]
 pub mod bitreq_http_async;
diff --git a/jsonrpc/src/http/simple_http.rs b/jsonrpc/src/http/simple_http.rs
@@ -19,7 +19,7 @@ use base64::Engine;
 #[cfg(feature = "proxy")]
 use socks::Socks5Stream;
 
-use crate::client_sync::{Client, Transport};
+use crate::client::Transport;
 use crate::http::DEFAULT_PORT;
 #[cfg(feature = "proxy")]
 use crate::http::DEFAULT_PROXY_PORT;
@@ -413,18 +413,18 @@ impl Default for Builder {
     fn default() -> Self { Builder::new() }
 }
 
-impl Client {
+impl crate::Client {
     /// Creates a new JSON-RPC client using a bare-minimum HTTP transport.
     pub fn simple_http(
         url: &str,
         user: Option<String>,
         pass: Option<String>,
-    ) -> Result<Client, Error> {
+    ) -> Result<crate::Client, Error> {
         let mut builder = Builder::new().url(url)?;
         if let Some(user) = user {
             builder = builder.auth(user, pass);
         }
-        Ok(Client::with_transport(builder.build()))
+        Ok(crate::Client::with_transport(builder.build()))
     }
 
     /// Creates a new JSON_RPC client using a HTTP-Socks5 proxy transport.
@@ -435,7 +435,7 @@ impl Client {
         pass: Option<String>,
         proxy_addr: &str,
         proxy_auth: Option<(&str, &str)>,
-    ) -> Result<Client, Error> {
+    ) -> Result<crate::Client, Error> {
         let mut builder = Builder::new().url(url)?;
         if let Some(user) = user {
             builder = builder.auth(user, pass);
@@ -445,7 +445,7 @@ impl Client {
             builder = builder.proxy_auth(user, pass);
         }
         let tp = builder.build();
-        Ok(Client::with_transport(tp))
+        Ok(crate::Client::with_transport(tp))
     }
 }
 
@@ -627,6 +627,7 @@ mod tests {
     use std::str::FromStr;
 
     use super::*;
+    use crate::Client;
 
     #[test]
     fn test_urls() {
diff --git a/jsonrpc/src/lib.rs b/jsonrpc/src/lib.rs
@@ -20,16 +20,16 @@ pub extern crate base64;
 #[cfg(feature = "bitreq")]
 pub extern crate bitreq;
 
+pub mod client;
 #[cfg(feature = "client_async")]
 pub mod client_async;
-pub mod client_sync;
 pub mod error;
 pub mod http;
 
+#[cfg(feature = "bitreq_http")]
+pub use http::bitreq_http;
 #[cfg(feature = "bitreq_http_async")]
 pub use http::bitreq_http_async;
-#[cfg(feature = "bitreq_http_sync")]
-pub use http::bitreq_http_sync;
 #[cfg(feature = "simple_http")]
 pub use http::simple_http;
 
@@ -42,6 +42,7 @@ pub mod simple_uds;
 use serde::{Deserialize, Serialize};
 use serde_json::value::RawValue;
 
+pub use crate::client::{Client, Transport};
 pub use crate::error::Error;
 
 /// Shorthand method to convert an argument into a boxed [`serde_json::value::RawValue`].
diff --git a/jsonrpc/src/simple_tcp.rs b/jsonrpc/src/simple_tcp.rs
@@ -5,7 +5,7 @@
 
 use std::{error, fmt, io, net, time};
 
-use crate::client_sync::Transport;
+use crate::client::Transport;
 use crate::{Request, Response};
 
 #[derive(Debug, Clone)]
@@ -110,7 +110,7 @@ mod tests {
     use std::thread;
 
     use super::*;
-    use crate::client_sync::Client;
+    use crate::Client;
 
     // Test a dummy request / response over a raw TCP transport
     #[test]
diff --git a/jsonrpc/src/simple_uds.rs b/jsonrpc/src/simple_uds.rs
@@ -5,7 +5,7 @@
 use std::os::unix::net::UnixStream;
 use std::{error, fmt, io, path, time};
 
-use crate::client_sync::Transport;
+use crate::client::Transport;
 use crate::{Request, Response};
 
 /// Simple synchronous UDS transport.
@@ -115,7 +115,7 @@ mod tests {
     use std::{fs, process, thread};
 
     use super::*;
-    use crate::client_sync::Client;
+    use crate::Client;
 
     // Test a dummy request / response over an UDS
     #[test]

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ jobs:`
`18`	`18`	`# We only get 20 jobs at a time, we probably don't want to go`
`19`	`19`	`# over that limit with fuzzing because of the hour run time.`
`20`	`20`	`fuzz_target: [`
`21`		`- bitreq_http_sync,`
	`21`	`+ bitreq_http,`
`22`	`22`	`simple_http,`
`23`	`23`	`]`
`24`	`24`	`steps:`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ fn do_test(data: &[u8]) {`
`8`	`8`	`{`
`9`	`9`	`use std::io;`
`10`	`10`
`11`		`- use jsonrpc::bitreq_http_sync::{BitreqHttpTransport, FUZZ_TCP_SOCK};`
	`11`	`+ use jsonrpc::bitreq_http::{BitreqHttpTransport, FUZZ_TCP_SOCK};`
`12`	`12`	`use jsonrpc::Client;`
`13`	`13`
`14`	`14`	`*FUZZ_TCP_SOCK.lock().unwrap() = Some(io::Cursor::new(data.to_vec()));`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ impl Client {`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`		`-impl fmt::Debug for Client {`
	`127`	`+impl fmt::Debug for crate::Client {`
`128`	`128`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`129`	`129`	`write!(f, "jsonrpc::Client(")?;`
`130`	`130`	`self.transport.fmt_target(f)?;`