as_ref in aleph-client for Connection types

aleph-client/src/connections.rs

@@ -1,4 +1,4 @@
-use std::{thread::sleep, time::Duration};
+use std::{convert::AsRef, thread::sleep, time::Duration};
 
 use anyhow::anyhow;
 use codec::Decode;
@@ -58,6 +58,12 @@ impl SudoCall for RootConnection {
     }
 }
 
+impl AsRef<Connection> for Connection {
+    fn as_ref(&self) -> &Connection {
+        self
+    }
+}
+
 impl Connection {
     const DEFAULT_RETRIES: u32 = 10;
     const RETRY_WAIT_SECS: u64 = 1;
@@ -161,6 +167,12 @@ impl SignedConnection {
     }
 }
 
+impl AsRef<Connection> for SignedConnection {
+    fn as_ref(&self) -> &Connection {
+        &self.connection
+    }
+}
+
 impl RootConnection {
     pub async fn new(address: String, root: KeyPair) -> anyhow::Result<Self> {
         RootConnection::try_from_connection(Connection::new(address).await, root).await

aleph-client/src/pallets/session.rs

@@ -22,29 +22,30 @@ pub trait SessionUserApi {
 }
 
 #[async_trait::async_trait]
-impl SessionApi for Connection {
+impl<C: AsRef<Connection> + Sync + ?Sized> SessionApi for C {
     async fn get_next_session_keys(
         &self,
         account: AccountId,
         at: Option<BlockHash>,
     ) -> Option<SessionKeys> {
         let addrs = api::storage().session().next_keys(account);
 
-        self.get_storage_entry_maybe(&addrs, at).await
+        self.as_ref().get_storage_entry_maybe(&addrs, at).await
     }
 
     async fn get_session(&self, at: Option<BlockHash>) -> SessionIndex {
         let addrs = api::storage().session().current_index();
 
-        self.get_storage_entry_maybe(&addrs, at)
+        self.as_ref()
+            .get_storage_entry_maybe(&addrs, at)
             .await
             .unwrap_or_default()
     }
 
     async fn get_validators(&self, at: Option<BlockHash>) -> Vec<AccountId> {
         let addrs = api::storage().session().validators();
 
-        self.get_storage_entry(&addrs, at).await
+        self.as_ref().get_storage_entry(&addrs, at).await
     }
 }
 

aleph-client/src/waiting.rs

@@ -34,11 +34,23 @@ pub trait WaitingExt {
 }
 
 #[async_trait::async_trait]
-impl AlephWaiting for Connection {
+impl<C: AsRef<Connection> + Sync> AlephWaiting for C {
     async fn wait_for_block<P: Fn(u32) -> bool + Send>(&self, predicate: P, status: BlockStatus) {
         let mut block_sub = match status {
-            BlockStatus::Best => self.client.blocks().subscribe_best().await.unwrap(),
-            BlockStatus::Finalized => self.client.blocks().subscribe_finalized().await.unwrap(),
+            BlockStatus::Best => self
+                .as_ref()
+                .client
+                .blocks()
+                .subscribe_best()
+                .await
+                .unwrap(),
+            BlockStatus::Finalized => self
+                .as_ref()
+                .client
+                .blocks()
+                .subscribe_finalized()
+                .await
+                .unwrap(),
         };
 
         while let Some(Ok(block)) = block_sub.next().await {
@@ -54,8 +66,20 @@ impl AlephWaiting for Connection {
         status: BlockStatus,
     ) -> T {
         let mut block_sub = match status {
-            BlockStatus::Best => self.client.blocks().subscribe_best().await.unwrap(),
-            BlockStatus::Finalized => self.client.blocks().subscribe_finalized().await.unwrap(),
+            BlockStatus::Best => self
+                .as_ref()
+                .client
+                .blocks()
+                .subscribe_best()
+                .await
+                .unwrap(),
+            BlockStatus::Finalized => self
+                .as_ref()
+                .client
+                .blocks()
+                .subscribe_finalized()
+                .await
+                .unwrap(),
         };
 
         info!(target: "aleph-client", "waiting for event {}.{}", T::PALLET, T::EVENT);
@@ -81,7 +105,7 @@ impl AlephWaiting for Connection {
 
     async fn wait_for_era(&self, era: EraIndex, status: BlockStatus) {
         let addrs = aleph_zero::api::constants().staking().sessions_per_era();
-        let sessions_per_era = self.client.constants().at(&addrs).unwrap();
+        let sessions_per_era = self.as_ref().client.constants().at(&addrs).unwrap();
         let first_session_in_era = era * sessions_per_era;
 
         self.wait_for_session(first_session_in_era, status).await;