client: Fix call_async for MSRV

Changed `send_fn` argument in `call_async` to take an owned `Value`
in order to workaround the lifetime constraint in the absence
of `AsyncFn`.

Author: ValuedMammal

examples/async.rs

@@ -17,23 +17,23 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Create RPC client
     let client = bdk_bitcoind_client::Client::new();
 
-    // Implement send request function
-    use jsonrpc::{Request, Response};
-    let send_fn = async |request: Request| -> Result<Response, bitreq::Error> {
-        bitreq::post(URL)
-            .with_header(
-                "Authorization",
-                format!("Basic {}", BASE64.encode(cookie.as_bytes())),
-            )
-            .with_json(&request)?
-            .send_async()
-            .await?
-            .json::<jsonrpc::Response>()
+    // Implement async send request function
+    let auth_header = format!("Basic {}", BASE64.encode(cookie.as_bytes()));
+    let send_fn = move |request_value: serde_json::Value| {
+        let auth_header = auth_header.clone();
+        async move {
+            bitreq::post(URL)
+                .with_header("Authorization", auth_header)
+                .with_json(&request_value)?
+                .send_async()
+                .await?
+                .json::<jsonrpc::Response>()
+        }
     };
 
     // Execute the RPC
     let blockchain_info = client
-        .call_async::<v29::GetBlockchainInfo, _>(Rpc::GetBlockchainInfo, &[], send_fn)
+        .call_async::<v29::GetBlockchainInfo, _, _, _>(Rpc::GetBlockchainInfo, &[], send_fn)
         .await?
         .into_model()?;
 

src/client.rs

@@ -1,3 +1,4 @@
+use core::future::Future;
 use core::sync::atomic::{AtomicUsize, Ordering};
 
 use jsonrpc::serde_json;
@@ -61,15 +62,17 @@ impl Client {
     }
 
     /// Execute the RPC asynchronously.
-    pub async fn call_async<T, E>(
+    pub async fn call_async<T, E, F, Fut>(
         &self,
         rpc: impl RpcMethod,
         params: &[Value],
-        send_fn: impl AsyncFn(Request) -> Result<Response, E>,
+        send_fn: F,
     ) -> Result<T, Error>
     where
         T: for<'de> Deserialize<'de>,
         E: std::error::Error + Send + Sync + 'static,
+        F: Fn(Value) -> Fut,
+        Fut: Future<Output = Result<Response, E>>,
     {
         let method = rpc.method();
         let raw_value = if params.is_empty() {
@@ -79,7 +82,8 @@ impl Client {
         };
         let request = self.request(&method, raw_value.as_deref());
         let request_id = request.id.clone();
-        let response = send_fn(request).await.map_err(Error::transport)?;
+        let value = serde_json::to_value(request)?;
+        let response = send_fn(value).await.map_err(Error::transport)?;
         if response.id != request_id {
             return Err(Error::NonceMismatch);
         }