POC generalized requests

Author: stevenroose

client/src/client.rs

@@ -18,6 +18,7 @@ use bitcoin;
 use jsonrpc;
 use serde;
 use serde_json;
+use serde_json::value::RawValue;
 
 use bitcoin::hashes::hex::{FromHex, ToHex};
 use bitcoin::secp256k1::Signature;
@@ -215,14 +216,46 @@ impl Auth {
     }
 }
 
-pub trait RpcApi: Sized {
+pub struct Request<'c, T: 'static> {
+    method: &'static str,
+    args: Vec<serde_json::Value>, //TODO(stevenroose) something more efficient?
+    converter: &'static dyn Fn(&RawValue) -> Result<T>,
+    client: &'c dyn RpcClient,
+}
+
+impl<'c, T> Request<'c, T> {
+    pub fn sync(self) -> Result<T> {
+        let raw = self.client.call(self.method, &self.args)?;
+        let conv = self.converter;
+        conv(&raw)
+    }
+
+    fn async(self) -> Result<T> {
+        // use the async function of the client
+        unimplemented!()
+    }
+
+    fn batch(self, batch: &mut Batch<Self>) {
+        batch.insert(self);
+    }
+}
+
+fn converter_hex<T: bitcoin::consensus::encode::Decodable>(raw: &RawValue) -> Result<T> {
+    let hex: &str = serde_json::from_str(raw.get())?;
+    let bytes = Vec::<u8>::from_hex(&hex)?;
+    Ok(bitcoin::consensus::encode::deserialize(&bytes)?)
+}
+
+fn converter_json<T: serde::de::DeserializeOwned>(raw: &RawValue) -> Result<T> {
+    Ok(serde_json::from_str(raw.get())?)
+}
+
+pub trait RpcClient {
     /// Call a `cmd` rpc with given `args` list
-    fn call<T: for<'a> serde::de::Deserialize<'a>>(
-        &self,
-        cmd: &str,
-        args: &[serde_json::Value],
-    ) -> Result<T>;
+    fn call(&self, cmd: &str, args: &[serde_json::Value]) -> Result<Box<RawValue>>;
+}
 
+pub trait RpcApi: RpcClient + Sized {
     /// Query an object implementing `Querable` type
     fn get_by_id<T: queryable::Queryable<Self>>(
         &self,
@@ -231,17 +264,58 @@ pub trait RpcApi: Sized {
         T::query(&self, &id)
     }
 
+    // this method could be moved outside of the trait
+    fn get_network_info_request(&self) -> Request<json::GetNetworkInfoResult> {
+        Request {
+            method: "getnetworkinfo",
+            args: vec![],
+            converter: &|raw| converter_json::<json::GetNetworkInfoResult>(raw),
+            client: self,
+        }
+    }
+    #[cfg(not(feature = "async"))]
     fn get_network_info(&self) -> Result<json::GetNetworkInfoResult> {
-        self.call("getnetworkinfo", &[])
+        self.get_network_info_request().sync()
+    }
+    #[cfg(feature = "async")]
+    async fn get_network_info(&self) -> Result<json::GetNetworkInfoResult> {
+        self.get_network_info_request().async()
+    }
+    // this is some way through which it would be possible to have an API with both sync and async
+    // methods when async is supported
+    #[cfg(feature = "both-sync-async")]
+    fn get_network_info_sync(&self) -> Result<json::GetNetworkInfoResult> {
+        self.get_network_info_request().sync()
+    }
+    fn batch_get_network_info<R>(&self, batch: &mut Batch<R>) where Self: Sized {
+        self.get_network_info_request().batch(batch);
     }
 
-    fn version(&self) -> Result<usize> {
-        #[derive(Deserialize)]
-        struct Response {
-            pub version: usize,
+    fn version_request(&self) -> Request<usize> {
+        Request {
+            method: "getnetworkinfo",
+            args: vec![],
+            converter: &|raw| {
+                #[derive(Deserialize)]
+                struct Response {
+                    pub version: usize,
+                }
+                let ret: Response = serde_json::from_str(raw.get())?;
+                Ok(ret.version)
+            },
+            client: self,
         }
-        let res: Response = self.call("getnetworkinfo", &[])?;
-        Ok(res.version)
+    }
+    #[cfg(not(feature = "async"))]
+    fn version(&self) -> Result<usize> {
+        self.version_request().sync()
+    }
+    #[cfg(feature = "async")]
+    fn version(&self) -> Result<usize> {
+        self.version_request().async()
+    }
+    fn batch_version<R>(&self, batch: &mut Batch<R>) where Self: Sized {
+        self.version_request().batch(batch);
     }
 
     fn add_multisig_address(
@@ -747,7 +821,7 @@ pub trait RpcApi: Sized {
         tx: R,
         options: Option<&json::FundRawTransactionOptions>,
         is_witness: Option<bool>,
-    ) -> Result<json::FundRawTransactionResult> {
+    ) -> Result<json::FundRawTransactionResult> where Self: Sized {
         let mut args = [tx.raw_hex().into(), opt_into_json(options)?, opt_into_json(is_witness)?];
         let defaults = [empty_obj(), null()];
         self.call("fundrawtransaction", handle_defaults(&mut args, &defaults))
@@ -760,7 +834,7 @@ pub trait RpcApi: Sized {
         utxos: Option<&[json::SignRawTransactionInput]>,
         private_keys: Option<&[PrivateKey]>,
         sighash_type: Option<json::SigHashType>,
-    ) -> Result<json::SignRawTransactionResult> {
+    ) -> Result<json::SignRawTransactionResult> where Self: Sized {
         let mut args = [
             tx.raw_hex().into(),
             opt_into_json(utxos)?,
@@ -776,7 +850,7 @@ pub trait RpcApi: Sized {
         tx: R,
         utxos: Option<&[json::SignRawTransactionInput]>,
         sighash_type: Option<json::SigHashType>,
-    ) -> Result<json::SignRawTransactionResult> {
+    ) -> Result<json::SignRawTransactionResult> where Self: Sized {
         let mut args = [tx.raw_hex().into(), opt_into_json(utxos)?, opt_into_json(sighash_type)?];
         let defaults = [empty_arr(), null()];
         self.call("signrawtransactionwithwallet", handle_defaults(&mut args, &defaults))
@@ -788,7 +862,7 @@ pub trait RpcApi: Sized {
         privkeys: &[PrivateKey],
         prevtxs: Option<&[json::SignRawTransactionInput]>,
         sighash_type: Option<json::SigHashType>,
-    ) -> Result<json::SignRawTransactionResult> {
+    ) -> Result<json::SignRawTransactionResult> where Self: Sized {
         let mut args = [
             tx.raw_hex().into(),
             into_json(privkeys)?,
@@ -802,7 +876,7 @@ pub trait RpcApi: Sized {
     fn test_mempool_accept<R: RawTx>(
         &self,
         rawtxs: &[R],
-    ) -> Result<Vec<json::TestMempoolAcceptResult>> {
+    ) -> Result<Vec<json::TestMempoolAcceptResult>> where Self: Sized {
         let hexes: Vec<serde_json::Value> =
             rawtxs.to_vec().into_iter().map(|r| r.raw_hex().into()).collect();
         self.call("testmempoolaccept", &[hexes.into()])
@@ -999,7 +1073,7 @@ pub trait RpcApi: Sized {
         self.call("ping", &[])
     }
 
-    fn send_raw_transaction<R: RawTx>(&self, tx: R) -> Result<bitcoin::Txid> {
+    fn send_raw_transaction<R: RawTx>(&self, tx: R) -> Result<bitcoin::Txid> where Self: Sized {
         self.call("sendrawtransaction", &[tx.raw_hex().into()])
     }
 
@@ -1188,13 +1262,9 @@ impl Client {
     }
 }
 
-impl RpcApi for Client {
+impl RpcClient for Client {
     /// Call an `cmd` rpc with given `args` list
-    fn call<T: for<'a> serde::de::Deserialize<'a>>(
-        &self,
-        cmd: &str,
-        args: &[serde_json::Value],
-    ) -> Result<T> {
+    fn call(&self, cmd: &str, args: &[serde_json::Value]) -> Result<Box<RawValue>> {
         let raw_args: Vec<_> = args
             .iter()
             .map(|a| {
@@ -1213,6 +1283,8 @@ impl RpcApi for Client {
         Ok(resp?.result()?)
     }
 }
+impl RpcApi for Client {
+}
 
 fn log_response(cmd: &str, resp: &Result<jsonrpc::Response>) {
     if log_enabled!(Warn) || log_enabled!(Debug) || log_enabled!(Trace) {