wip

aleph-client/src/connections.rs

@@ -14,7 +14,16 @@ use subxt::{
 
 use crate::{api, sp_weights::weight_v2::Weight, BlockHash, Call, Client, KeyPair, TxStatus};
 
-pub type Connection = Client;
+#[derive(Clone)]
+pub struct Connection {
+    client: Client,
+}
+
+impl Connection {
+    pub(crate) fn as_client(&self) -> &Client {
+        &self.client
+    }
+}
 
 const DEFAULT_RETRIES: u32 = 10;
 const RETRY_WAIT_SECS: u64 = 1;
@@ -27,7 +36,7 @@ async fn create_connection_with_retries(address: &str, mut retries: u32) -> Conn
     loop {
         let client = Client::from_url(&address).await;
         match (retries, client) {
-            (_, Ok(client)) => return client,
+            (_, Ok(client)) => return Connection { client },
             (0, Err(e)) => panic!("{:?}", e),
             _ => {
                 sleep(Duration::from_secs(RETRY_WAIT_SECS));
@@ -141,7 +150,7 @@ 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_connection()
+        self.as_client()
             .storage()
             .fetch(addrs, at)
             .await
@@ -150,11 +159,7 @@ 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_connection()
-            .rpc()
-            .request(&func_name, params)
-            .await?;
+        let bytes: Bytes = self.as_client().rpc().request(&func_name, params).await?;
 
         Ok(R::decode(&mut bytes.as_ref())?)
     }
@@ -193,6 +198,7 @@ impl SignedConnection {
         }
         let progress = self
             .connection
+            .as_client()
             .tx()
             .sign_and_submit_then_watch(&tx, &self.signer, params)
             .await?;
@@ -214,10 +220,18 @@ impl RootConnection {
         RootConnection::try_from_connection(create_connection(address).await, root).await
     }
 
-    pub async fn try_from_connection(connection: Client, signer: KeyPair) -> anyhow::Result<Self> {
+    pub async fn try_from_connection(
+        connection: Connection,
+        signer: KeyPair,
+    ) -> anyhow::Result<Self> {
         let root_address = api::storage().sudo().key();
 
-        let root = match connection.storage().fetch(&root_address, None).await {
+        let root = match connection
+            .as_client()
+            .storage()
+            .fetch(&root_address, None)
+            .await
+        {
             Ok(Some(account)) => account,
             _ => return Err(anyhow!("Could not read sudo key from chain")),
         };

aleph-client/src/lib.rs

@@ -26,9 +26,10 @@ pub type AlephKeyPair = ed25519::Pair;
 pub type RawKeyPair = sr25519::Pair;
 pub type KeyPair = PairSigner<AlephConfig, sr25519::Pair>;
 pub type AccountId = subxt::ext::sp_core::crypto::AccountId32;
-pub type Client = OnlineClient<AlephConfig>;
 pub type BlockHash = H256;
 
+pub(crate) type Client = OnlineClient<AlephConfig>;
+
 pub use connections::{
     create_connection, AsConnection, Connection, ConnectionExt, RootConnection, SignedConnection,
     SudoCall,

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_connection().rpc().rotate_keys().await?;
+        let bytes = self.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,7 @@ impl<C: ConnectionExt> ElectionsApi for C {
 
     async fn get_session_period(&self) -> anyhow::Result<u32> {
         let addrs = api::constants().elections().session_period();
-        self.as_connection()
+        self.as_client()
             .constants()
             .at(&addrs)
             .map_err(|e| e.into())

aleph-client/src/pallets/staking.rs

@@ -183,7 +183,7 @@ 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_connection()
+        self.as_client()
             .constants()
             .at(&addrs)
             .map_err(|e| e.into())
@@ -306,7 +306,7 @@ 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_connection()
+        self.as_client()
             .storage()
             .fetch_keys(&key, 10, None, at)
             .await

aleph-client/src/utility.rs

@@ -41,7 +41,7 @@ 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_connection()
+        self.as_client()
             .rpc()
             .block_hash(Some(block.into()))
             .await
@@ -53,7 +53,7 @@ impl<C: ConnectionExt> BlocksApi for C {
     }
 
     async fn get_finalized_block_hash(&self) -> anyhow::Result<BlockHash> {
-        self.as_connection()
+        self.as_client()
             .rpc()
             .finalized_head()
             .await
@@ -64,7 +64,7 @@ impl<C: ConnectionExt> BlocksApi for C {
         &self,
         block: Option<BlockHash>,
     ) -> anyhow::Result<Option<BlockNumber>> {
-        self.as_connection()
+        self.as_client()
             .rpc()
             .header(block)
             .await

aleph-client/src/waiting.rs

@@ -38,13 +38,13 @@ 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()
                 .await
@@ -65,13 +65,13 @@ 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()
                 .await
@@ -102,7 +102,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)
             .expect("Failed to obtain sessions_per_era const!");