Rewrite the async client

Remove the version folders with RPC macros.

Rewrite the async client to have the base methods in the main module
removing all the macroization.

Create a new module for the bdk client that has the required RPCs in it
that all return the non-version specific model types.

Rewrite the tests to use the bdk client and use a similar structure to
the sync tests.

Author: jamillambert

.gitignore

@@ -2,3 +2,4 @@
 
 Cargo.lock
 **/target
+.vscode/

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "rust-analyzer.cargo.features": [
+        "client-async"
+    ],
+    "rust-analyzer.check.features": [
+        "client-async"
+    ]
+}

client/src/client_async/bdk_client.rs

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Async JSON-RPC client with the RPC set used by BDK for Core versions 25 to 30.
+
+use bitcoin::{block, Block, BlockHash, Transaction, Txid};
+
+use crate::client_async::{into_json, Client, Result};
+use crate::types::model::{GetBlockFilter, GetBlockHeaderVerbose, GetBlockVerboseOne};
+
+impl Client {
+    /// Gets a block by blockhash.
+    pub async fn get_block(&self, hash: &BlockHash) -> Result<Block> {
+        let json: crate::types::v25::GetBlockVerboseZero =
+            self.call("getblock", &[into_json(hash)?, into_json(0)?]).await?;
+        Ok(json.into_model()?.0)
+    }
+
+    /// Gets block count.
+    pub async fn get_block_count(&self) -> Result<u64> {
+        let json: crate::types::v25::GetBlockCount = self.call("getblockcount", &[]).await?;
+        Ok(json.into_model().0)
+    }
+
+    /// Gets block hash for a height.
+    pub async fn get_block_hash(&self, height: u32) -> Result<BlockHash> {
+        let json: crate::types::v25::GetBlockHash =
+            self.call("getblockhash", &[into_json(height)?]).await?;
+        Ok(json.into_model()?.0)
+    }
+
+    /// Gets the hash of the chain tip.
+    pub async fn get_best_block_hash(&self) -> Result<BlockHash> {
+        let json: crate::types::v25::GetBestBlockHash = self.call("getbestblockhash", &[]).await?;
+        Ok(json.into_model()?.0)
+    }
+
+    /// Gets block header by blockhash.
+    pub async fn get_block_header(&self, hash: &BlockHash) -> Result<block::Header> {
+        let json: crate::types::v25::GetBlockHeader =
+            self.call("getblockheader", &[into_json(hash)?, into_json(false)?]).await?;
+        Ok(json.into_model()?.0)
+    }
+
+    /// Gets block header with verbose output.
+    pub async fn get_block_header_verbose(
+        &self,
+        hash: &BlockHash,
+    ) -> Result<GetBlockHeaderVerbose> {
+        let response: serde_json::Value =
+            self.call("getblockheader", &[into_json(hash)?, into_json(true)?]).await?;
+
+        if let Ok(json) =
+            serde_json::from_value::<crate::types::v29::GetBlockHeaderVerbose>(response.clone())
+        {
+            Ok(json.into_model()?)
+        } else {
+            let json: crate::types::v25::GetBlockHeaderVerbose = serde_json::from_value(response)?;
+            Ok(json.into_model()?)
+        }
+    }
+
+    /// Gets a block by blockhash with verbose set to 1.
+    pub async fn get_block_verbose(&self, hash: &BlockHash) -> Result<GetBlockVerboseOne> {
+        let response: serde_json::Value =
+            self.call("getblock", &[into_json(hash)?, into_json(1)?]).await?;
+
+        if let Ok(json) =
+            serde_json::from_value::<crate::types::v29::GetBlockVerboseOne>(response.clone())
+        {
+            Ok(json.into_model()?)
+        } else {
+            let json: crate::types::v25::GetBlockVerboseOne = serde_json::from_value(response)?;
+            Ok(json.into_model()?)
+        }
+    }
+
+    /// Gets block filter for a blockhash.
+    pub async fn get_block_filter(&self, hash: &BlockHash) -> Result<GetBlockFilter> {
+        let json: crate::types::v25::GetBlockFilter =
+            self.call("getblockfilter", &[into_json(hash)?]).await?;
+        Ok(json.into_model()?)
+    }
+
+    /// Gets transaction IDs currently in the mempool.
+    pub async fn get_raw_mempool(&self) -> Result<Vec<Txid>> {
+        let json: crate::types::v25::GetRawMempool = self.call("getrawmempool", &[]).await?;
+        Ok(json.into_model()?.0)
+    }
+
+    /// Gets raw transaction by txid.
+    pub async fn get_raw_transaction(&self, txid: &Txid) -> Result<Transaction> {
+        let json: crate::types::v25::GetRawTransaction =
+            self.call("getrawtransaction", &[into_json(txid)?]).await?;
+        Ok(json.into_model()?.0)
+    }
+}

client/src/client_async/error.rs

@@ -3,6 +3,15 @@
 use std::{error, fmt, io};
 
 use bitcoin::hex;
+use types::v17::{
+    GetBlockHeaderError, GetBlockHeaderVerboseError, GetBlockVerboseOneError,
+    GetRawTransactionVerboseError,
+};
+use types::v19::GetBlockFilterError;
+use types::v29::{
+    GetBlockHeaderVerboseError as GetBlockHeaderVerboseErrorV29,
+    GetBlockVerboseOneError as GetBlockVerboseOneErrorV29,
+};
 
 /// The error type for errors produced in this library.
 #[derive(Debug)]
@@ -48,6 +57,34 @@ impl From<io::Error> for Error {
     fn from(e: io::Error) -> Error { Error::Io(e) }
 }
 
+impl From<GetBlockHeaderError> for Error {
+    fn from(e: GetBlockHeaderError) -> Self { Self::Returned(e.to_string()) }
+}
+
+impl From<GetBlockHeaderVerboseError> for Error {
+    fn from(e: GetBlockHeaderVerboseError) -> Self { Self::Returned(e.to_string()) }
+}
+
+impl From<GetBlockVerboseOneError> for Error {
+    fn from(e: GetBlockVerboseOneError) -> Self { Self::Returned(e.to_string()) }
+}
+
+impl From<GetRawTransactionVerboseError> for Error {
+    fn from(e: GetRawTransactionVerboseError) -> Self { Self::Returned(e.to_string()) }
+}
+
+impl From<GetBlockHeaderVerboseErrorV29> for Error {
+    fn from(e: GetBlockHeaderVerboseErrorV29) -> Self { Self::Returned(e.to_string()) }
+}
+
+impl From<GetBlockVerboseOneErrorV29> for Error {
+    fn from(e: GetBlockVerboseOneErrorV29) -> Self { Self::Returned(e.to_string()) }
+}
+
+impl From<GetBlockFilterError> for Error {
+    fn from(e: GetBlockFilterError) -> Self { Self::Returned(e.to_string()) }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;

client/src/client_async/mod.rs

@@ -2,22 +2,10 @@
 
 //! Async JSON-RPC clients for specific versions of Bitcoin Core.
 
+pub mod bdk_client;
 mod error;
-pub mod v17;
-pub mod v18;
-pub mod v19;
-pub mod v20;
-pub mod v21;
-pub mod v22;
-pub mod v23;
-pub mod v24;
-pub mod v25;
-pub mod v26;
-pub mod v27;
-pub mod v28;
-pub mod v29;
-pub mod v30;
 
+use std::fmt;
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
@@ -55,76 +43,63 @@ impl Auth {
     }
 }
 
-/// Defines a async `jsonrpc::Client` using `bitreq`.
-#[macro_export]
-macro_rules! define_jsonrpc_bitreq_async_client {
-    ($version:literal) => {
-        use std::fmt;
-        use $crate::client_async::{log_response, Auth, Result};
-        use $crate::client_async::error::Error;
-
-        /// Client implements an async JSON-RPC client for the Bitcoin Core daemon or compatible APIs.
-        pub struct Client {
-            inner: jsonrpc::client_async::Client,
-        }
-
-        impl fmt::Debug for Client {
-            fn fmt(&self, f: &mut fmt::Formatter) -> core::fmt::Result {
-                write!(
-                    f,
-                    "corepc_client::client_async::{}::Client({:?})",
-                    $version, self.inner
-                )
-            }
-        }
+/// Client implements an async JSON-RPC client for the Bitcoin Core daemon or compatible APIs.
+pub struct Client {
+    pub(crate) inner: jsonrpc::client_async::Client,
+}
 
-        impl Client {
-            /// Creates a client to a bitcoind JSON-RPC server without authentication.
-            pub fn new(url: &str) -> Self {
-                let transport = jsonrpc::bitreq_http_async::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_async::Client::with_transport(transport);
-
-                Self { inner }
-            }
+impl fmt::Debug for Client {
+    fn fmt(&self, f: &mut fmt::Formatter) -> core::fmt::Result {
+        write!(f, "corepc_client::client_async::Client({:?})", self.inner)
+    }
+}
 
-            /// Creates a client to a bitcoind JSON-RPC server with authentication.
-            pub fn new_with_auth(url: &str, auth: Auth) -> Result<Self> {
-                if matches!(auth, Auth::None) {
-                    return Err(Error::MissingUserPassword);
-                }
-                let (user, pass) = auth.get_user_pass()?;
-                let transport = jsonrpc::bitreq_http_async::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_async::Client::with_transport(transport);
-
-                Ok(Self { inner })
-            }
+impl Client {
+    /// Creates a client to a bitcoind JSON-RPC server without authentication.
+    pub fn new(url: &str) -> Self {
+        let transport = jsonrpc::bitreq_http_async::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_async::Client::with_transport(transport);
+
+        Self { inner }
+    }
 
-            /// Call an RPC `method` with given `args` list.
-            pub async fn call<T: for<'a> serde::de::Deserialize<'a>>(
-                &self,
-                method: &str,
-                args: &[serde_json::Value],
-            ) -> Result<T> {
-                let raw = serde_json::value::to_raw_value(args)?;
-                let req = self.inner.build_request(&method, Some(&*raw));
-                if log::log_enabled!(log::Level::Debug) {
-                    log::debug!(target: "corepc", "request: {} {}", method, serde_json::Value::from(args));
-                }
+    /// Creates a client to a bitcoind JSON-RPC server with authentication.
+    pub fn new_with_auth(url: &str, auth: Auth) -> Result<Self> {
+        if matches!(auth, Auth::None) {
+            return Err(Error::MissingUserPassword);
+        }
+        let (user, pass) = auth.get_user_pass()?;
+        let user = user.ok_or(Error::MissingUserPassword)?;
+        let transport = jsonrpc::bitreq_http_async::Builder::new()
+            .url(url)
+            .expect("jsonrpc v0.19, this function does not error")
+            .timeout(std::time::Duration::from_secs(60))
+            .basic_auth(user, pass)
+            .build();
+        let inner = jsonrpc::client_async::Client::with_transport(transport);
+
+        Ok(Self { inner })
+    }
 
-                let resp = self.inner.send_request(req).await.map_err(Error::from);
-                log_response(method, &resp);
-                Ok(resp?.result()?)
-            }
+    /// Call an RPC `method` with given `args` list.
+    pub async fn call<T: for<'a> serde::de::Deserialize<'a>>(
+        &self,
+        method: &str,
+        args: &[serde_json::Value],
+    ) -> Result<T> {
+        let raw = serde_json::value::to_raw_value(args)?;
+        let req = self.inner.build_request(method, Some(&*raw));
+        if log::log_enabled!(log::Level::Debug) {
+            log::debug!(target: "corepc", "request: {} {}", method, serde_json::Value::from(args));
         }
+
+        let resp = self.inner.send_request(req).await.map_err(Error::from);
+        log_response(method, &resp);
+        Ok(resp?.result()?)
     }
 }
 
@@ -156,7 +131,7 @@ macro_rules! impl_async_client_check_expected_server_version {
 }
 
 /// Shorthand for converting a variable into a `serde_json::Value`.
-fn into_json<T>(val: T) -> Result<serde_json::Value>
+pub(crate) fn into_json<T>(val: T) -> Result<serde_json::Value>
 where
     T: serde::ser::Serialize,
 {
@@ -179,10 +154,12 @@ fn log_response(method: &str, resp: &Result<jsonrpc::Response>) {
                         log::debug!(target: "corepc", "response error for {}: {:?}", method, e);
                     }
                 } else if log::log_enabled!(Trace) {
-                    let def =
-                        serde_json::value::to_raw_value(&serde_json::value::Value::Null).unwrap();
-                    let result = resp.result.as_ref().unwrap_or(&def);
-                    log::trace!(target: "corepc", "response for {}: {}", method, result);
+                    if let Ok(def) =
+                        serde_json::value::to_raw_value(&serde_json::value::Value::Null)
+                    {
+                        let result = resp.result.as_ref().unwrap_or(&def);
+                        log::trace!(target: "corepc", "response for {}: {}", method, result);
+                    }
                 },
         }
     }