Remove async, upgrade electrum-client

src/blockchain/electrum.rs

@@ -5,23 +5,22 @@ use log::{debug, error, info, trace};
 
 use bitcoin::{Script, Transaction, Txid};
 
-use electrum_client::tokio::io::{AsyncRead, AsyncWrite};
-use electrum_client::Client;
+use electrum_client::{Client, ElectrumApi};
 
 use self::utils::{ELSGetHistoryRes, ELSListUnspentRes, ElectrumLikeSync};
 use super::*;
 use crate::database::{BatchDatabase, DatabaseUtils};
 use crate::error::Error;
 
-pub struct ElectrumBlockchain<T: AsyncRead + AsyncWrite + Send>(Option<Client<T>>);
+pub struct ElectrumBlockchain(Option<Client>);
 
-impl<T: AsyncRead + AsyncWrite + Send> std::convert::From<Client<T>> for ElectrumBlockchain<T> {
-    fn from(client: Client<T>) -> Self {
+impl std::convert::From<Client> for ElectrumBlockchain {
+    fn from(client: Client) -> Self {
         ElectrumBlockchain(Some(client))
     }
 }
 
-impl<T: AsyncRead + AsyncWrite + Send> Blockchain for ElectrumBlockchain<T> {
+impl Blockchain for ElectrumBlockchain {
     fn offline() -> Self {
         ElectrumBlockchain(None)
     }
@@ -31,15 +30,14 @@ impl<T: AsyncRead + AsyncWrite + Send> Blockchain for ElectrumBlockchain<T> {
     }
 }
 
-#[async_trait(?Send)]
-impl<T: AsyncRead + AsyncWrite + Send> OnlineBlockchain for ElectrumBlockchain<T> {
-    async fn get_capabilities(&self) -> HashSet<Capability> {
+impl OnlineBlockchain for ElectrumBlockchain {
+    fn get_capabilities(&self) -> HashSet<Capability> {
         vec![Capability::FullHistory, Capability::GetAnyTx]
             .into_iter()
             .collect()
     }
 
-    async fn setup<D: BatchDatabase + DatabaseUtils, P: Progress>(
+    fn setup<D: BatchDatabase + DatabaseUtils, P: Progress>(
         &mut self,
         stop_gap: Option<usize>,
         database: &mut D,
@@ -49,30 +47,27 @@ impl<T: AsyncRead + AsyncWrite + Send> OnlineBlockchain for ElectrumBlockchain<T
             .as_mut()
             .ok_or(Error::OfflineClient)?
             .electrum_like_setup(stop_gap, database, progress_update)
-            .await
     }
 
-    async fn get_tx(&mut self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+    fn get_tx(&mut self, txid: &Txid) -> Result<Option<Transaction>, Error> {
         Ok(self
             .0
             .as_mut()
             .ok_or(Error::OfflineClient)?
             .transaction_get(txid)
-            .await
             .map(Option::Some)?)
     }
 
-    async fn broadcast(&mut self, tx: &Transaction) -> Result<(), Error> {
+    fn broadcast(&mut self, tx: &Transaction) -> Result<(), Error> {
         Ok(self
             .0
             .as_mut()
             .ok_or(Error::OfflineClient)?
             .transaction_broadcast(tx)
-            .await
             .map(|_| ())?)
     }
 
-    async fn get_height(&mut self) -> Result<usize, Error> {
+    fn get_height(&mut self) -> Result<usize, Error> {
         // TODO: unsubscribe when added to the client, or is there a better call to use here?
 
         Ok(self
@@ -80,19 +75,16 @@ impl<T: AsyncRead + AsyncWrite + Send> OnlineBlockchain for ElectrumBlockchain<T
             .as_mut()
             .ok_or(Error::OfflineClient)?
             .block_headers_subscribe()
-            .await
             .map(|data| data.height)?)
     }
 }
 
-#[async_trait(?Send)]
-impl<T: AsyncRead + AsyncWrite + Send> ElectrumLikeSync for Client<T> {
-    async fn els_batch_script_get_history<'s, I: IntoIterator<Item = &'s Script>>(
+impl ElectrumLikeSync for Client {
+    fn els_batch_script_get_history<'s, I: IntoIterator<Item = &'s Script>>(
         &mut self,
         scripts: I,
     ) -> Result<Vec<Vec<ELSGetHistoryRes>>, Error> {
         self.batch_script_get_history(scripts)
-            .await
             .map(|v| {
                 v.into_iter()
                     .map(|v| {
@@ -112,12 +104,11 @@ impl<T: AsyncRead + AsyncWrite + Send> ElectrumLikeSync for Client<T> {
             .map_err(Error::Electrum)
     }
 
-    async fn els_batch_script_list_unspent<'s, I: IntoIterator<Item = &'s Script>>(
+    fn els_batch_script_list_unspent<'s, I: IntoIterator<Item = &'s Script>>(
         &mut self,
         scripts: I,
     ) -> Result<Vec<Vec<ELSListUnspentRes>>, Error> {
         self.batch_script_list_unspent(scripts)
-            .await
             .map(|v| {
                 v.into_iter()
                     .map(|v| {
@@ -141,7 +132,7 @@ impl<T: AsyncRead + AsyncWrite + Send> ElectrumLikeSync for Client<T> {
             .map_err(Error::Electrum)
     }
 
-    async fn els_transaction_get(&mut self, txid: &Txid) -> Result<Transaction, Error> {
-        self.transaction_get(txid).await.map_err(Error::Electrum)
+    fn els_transaction_get(&mut self, txid: &Txid) -> Result<Transaction, Error> {
+        self.transaction_get(txid).map_err(Error::Electrum)
     }
 }