wrap client

aleph-client/src/connections.rs

@@ -150,7 +150,8 @@ impl<C: AsConnection> ConnectionExt for C {
         at: Option<BlockHash>,
     ) -> Option<T::Target> {
         info!(target: "aleph-client", "accessing storage at {}::{} at block {:?}", addrs.pallet_name(), addrs.entry_name(), at);
-        self.as_client()
+        self.as_connection()
+            .as_client()
             .storage()
             .fetch(addrs, at)
             .await
@@ -159,7 +160,12 @@ impl<C: AsConnection> ConnectionExt for C {
 
     async fn rpc_call<R: Decode>(&self, func_name: String, params: RpcParams) -> anyhow::Result<R> {
         info!(target: "aleph-client", "submitting rpc call `{}`, with params {:?}", func_name, params);
-        let bytes: Bytes = self.as_client().rpc().request(&func_name, params).await?;
+        let bytes: Bytes = self
+            .as_connection()
+            .as_client()
+            .rpc()
+            .request(&func_name, params)
+            .await?;
 
         Ok(R::decode(&mut bytes.as_ref())?)
     }
@@ -198,6 +204,7 @@ impl SignedConnection {
         }
         let progress = self
             .connection
+            .as_connection()
             .as_client()
             .tx()
             .sign_and_submit_then_watch(&tx, &self.signer, params)
@@ -227,6 +234,7 @@ impl RootConnection {
         let root_address = api::storage().sudo().key();
 
         let root = match connection
+            .as_connection()
             .as_client()
             .storage()
             .fetch(&root_address, None)

aleph-client/src/pallets/author.rs

@@ -10,7 +10,7 @@ pub trait AuthorRpc {
 #[async_trait::async_trait]
 impl<C: ConnectionExt> AuthorRpc for C {
     async fn author_rotate_keys(&self) -> anyhow::Result<SessionKeys> {
-        let bytes = self.as_client().rpc().rotate_keys().await?;
+        let bytes = self.as_connection().as_client().rpc().rotate_keys().await?;
         SessionKeys::decode(&mut bytes.0.as_slice()).map_err(|e| e.into())
     }
 }

aleph-client/src/pallets/elections.rs

@@ -166,7 +166,8 @@ impl<C: ConnectionExt> ElectionsApi for C {
 
     async fn get_session_period(&self) -> anyhow::Result<u32> {
         let addrs = api::constants().elections().session_period();
-        self.as_client()
+        self.as_connection()
+            .as_client()
             .constants()
             .at(&addrs)
             .map_err(|e| e.into())

aleph-client/src/pallets/staking.rs

@@ -183,7 +183,8 @@ impl<C: ConnectionExt> StakingApi for C {
 
     async fn get_session_per_era(&self) -> anyhow::Result<u32> {
         let addrs = api::constants().staking().sessions_per_era();
-        self.as_client()
+        self.as_connection()
+            .as_client()
             .constants()
             .at(&addrs)
             .map_err(|e| e.into())
@@ -306,7 +307,8 @@ impl<C: ConnectionExt> StakingRawApi for C {
         let key_addrs = api::storage().staking().eras_stakers_root();
         let mut key = key_addrs.to_root_bytes();
         StorageMapKey::new(era, StorageHasher::Twox64Concat).to_bytes(&mut key);
-        self.as_client()
+        self.as_connection()
+            .as_client()
             .storage()
             .fetch_keys(&key, 10, None, at)
             .await

aleph-client/src/utility.rs

@@ -41,7 +41,8 @@ impl<C: ConnectionExt> BlocksApi for C {
 
     async fn get_block_hash(&self, block: BlockNumber) -> anyhow::Result<Option<BlockHash>> {
         info!(target: "aleph-client", "querying block hash for number #{}", block);
-        self.as_client()
+        self.as_connection()
+            .as_client()
             .rpc()
             .block_hash(Some(block.into()))
             .await
@@ -53,7 +54,8 @@ impl<C: ConnectionExt> BlocksApi for C {
     }
 
     async fn get_finalized_block_hash(&self) -> anyhow::Result<BlockHash> {
-        self.as_client()
+        self.as_connection()
+            .as_client()
             .rpc()
             .finalized_head()
             .await
@@ -64,7 +66,8 @@ impl<C: ConnectionExt> BlocksApi for C {
         &self,
         block: Option<BlockHash>,
     ) -> anyhow::Result<Option<BlockNumber>> {
-        self.as_client()
+        self.as_connection()
+            .as_client()
             .rpc()
             .header(block)
             .await

aleph-client/src/waiting.rs

@@ -38,12 +38,14 @@ impl<C: ConnectionExt> 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
+                .as_connection()
                 .as_client()
                 .blocks()
                 .subscribe_best()
                 .await
                 .expect("Failed to subscribe to the best block stream!"),
             BlockStatus::Finalized => self
+                .as_connection()
                 .as_client()
                 .blocks()
                 .subscribe_finalized()
@@ -65,12 +67,14 @@ impl<C: ConnectionExt> AlephWaiting for C {
     ) -> T {
         let mut block_sub = match status {
             BlockStatus::Best => self
+                .as_connection()
                 .as_client()
                 .blocks()
                 .subscribe_best()
                 .await
                 .expect("Failed to subscribe to the best block stream!"),
             BlockStatus::Finalized => self
+                .as_connection()
                 .as_client()
                 .blocks()
                 .subscribe_finalized()
@@ -102,6 +106,7 @@ impl<C: ConnectionExt> AlephWaiting for C {
     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
+            .as_connection()
             .as_client()
             .constants()
             .at(&addrs)

e2e-tests/src/transfer.rs

@@ -1,8 +1,8 @@
-use aleph_client::{create_connection, AccountId, Client, KeyPair, Pair, SignedConnection};
+use aleph_client::{create_connection, AccountId, Connection, KeyPair, Pair, SignedConnection};
 
 use crate::{accounts::get_validators_raw_keys, config::Config};
 
-async fn setup(config: &Config) -> (Client, KeyPair, AccountId) {
+async fn setup(config: &Config) -> (Connection, KeyPair, AccountId) {
     let accounts = get_validators_raw_keys(config);
     let (from, to) = (
         KeyPair::new(accounts[0].clone()),