review part 2

aleph-client/src/lib.rs

@@ -35,8 +35,7 @@ pub type BlockHash = H256;
 pub(crate) type SubxtClient = OnlineClient<AlephConfig>;
 
 pub use connections::{
-    AsConnection, AsSigned, Connection, ConnectionApi, RootConnection, SignedConnection,
-    SignedConnectionApi, SudoCall,
+    Connection, ConnectionApi, RootConnection, SignedConnection, SignedConnectionApi, SudoCall,
 };
 
 #[derive(Copy, Clone)]

aleph-client/src/pallets/treasury.rs

@@ -38,8 +38,8 @@ pub trait TreasureApiExt {
 
 #[async_trait::async_trait]
 pub trait TreasurySudoApi {
-    async fn sudo_approve(&self, proposal_id: u32, status: TxStatus) -> anyhow::Result<BlockHash>;
-    async fn sudo_reject(&self, proposal_id: u32, status: TxStatus) -> anyhow::Result<BlockHash>;
+    async fn approve(&self, proposal_id: u32, status: TxStatus) -> anyhow::Result<BlockHash>;
+    async fn reject(&self, proposal_id: u32, status: TxStatus) -> anyhow::Result<BlockHash>;
 }
 
 #[async_trait::async_trait]
@@ -91,13 +91,13 @@ impl<S: SignedConnectionApi> TreasuryUserApi for S {
 
 #[async_trait::async_trait]
 impl TreasurySudoApi for RootConnection {
-    async fn sudo_approve(&self, proposal_id: u32, status: TxStatus) -> anyhow::Result<BlockHash> {
+    async fn approve(&self, proposal_id: u32, status: TxStatus) -> anyhow::Result<BlockHash> {
         let call = Treasury(approve_proposal { proposal_id });
 
         self.sudo_unchecked(call, status).await
     }
 
-    async fn sudo_reject(&self, proposal_id: u32, status: TxStatus) -> anyhow::Result<BlockHash> {
+    async fn reject(&self, proposal_id: u32, status: TxStatus) -> anyhow::Result<BlockHash> {
         let call = Treasury(reject_proposal { proposal_id });
 
         self.sudo_unchecked(call, status).await

bin/cliain/src/treasury.rs

@@ -18,16 +18,14 @@ pub async fn propose(connection: SignedConnection, amount_in_tokens: u64, benefi
 
 /// Delegates to `aleph_client::approve_treasury_proposal`.
 pub async fn approve(connection: RootConnection, proposal_id: u32) {
-    connection
-        .sudo_approve(proposal_id, TxStatus::Finalized)
+    TreasurySudoApi::approve(&connection, proposal_id, TxStatus::Finalized)
         .await
         .unwrap();
 }
 
 /// Delegates to `aleph_client::reject_treasury_proposal`.
 pub async fn reject(connection: RootConnection, proposal_id: u32) {
-    connection
-        .sudo_reject(proposal_id, TxStatus::Finalized)
+    TreasurySudoApi::reject(&connection, proposal_id, TxStatus::Finalized)
         .await
         .unwrap();
 }

e2e-tests/src/rewards.rs

@@ -12,7 +12,7 @@ use aleph_client::{
     primitives::{CommitteeSeats, EraValidators},
     utility::BlocksApi,
     waiting::{AlephWaiting, BlockStatus, WaitingExt},
-    AccountId, SignedConnection, TxStatus,
+    AccountId, SignedConnection, SignedConnectionApi, TxStatus,
 };
 use anyhow::anyhow;
 use log::{debug, info};
@@ -33,8 +33,8 @@ type RewardPoint = u32;
 
 /// Changes session_keys used by a given `controller` to some `zero`/invalid value,
 /// making it impossible to create new legal blocks.
-pub async fn set_invalid_keys_for_validator(
-    controller_connection: &SignedConnection,
+pub async fn set_invalid_keys_for_validator<S: SignedConnectionApi>(
+    controller_connection: &S,
 ) -> anyhow::Result<()> {
     let zero_session_keys = [0; 64].to_vec().into();
 
@@ -51,8 +51,8 @@ pub async fn set_invalid_keys_for_validator(
 }
 
 /// Rotates session_keys of a given `controller`, making it able to rejoin the `consensus`.
-pub(super) async fn reset_validator_keys(
-    controller_connection: &SignedConnection,
+pub(super) async fn reset_validator_keys<S: SignedConnectionApi>(
+    controller_connection: &S,
 ) -> anyhow::Result<()> {
     let validator_keys = controller_connection.author_rotate_keys().await?;
     controller_connection
@@ -68,8 +68,8 @@ pub(super) async fn reset_validator_keys(
     Ok(())
 }
 
-pub async fn download_exposure(
-    connection: &SignedConnection,
+pub async fn download_exposure<S: SignedConnectionApi>(
+    connection: &S,
     era: EraIndex,
     account_id: &AccountId,
     beginning_of_session_block_hash: BlockHash,
@@ -124,8 +124,8 @@ fn check_rewards(
     Ok(())
 }
 
-async fn get_node_performance(
-    connection: &SignedConnection,
+async fn get_node_performance<S: SignedConnectionApi>(
+    connection: &S,
     account_id: &AccountId,
     before_end_of_session_block_hash: BlockHash,
     blocks_to_produce_per_session: u32,
@@ -152,8 +152,8 @@ async fn get_node_performance(
     lenient_performance
 }
 
-pub async fn check_points(
-    connection: &SignedConnection,
+pub async fn check_points<S: SignedConnectionApi>(
+    connection: &S,
     session: SessionIndex,
     era: EraIndex,
     members: impl IntoIterator<Item = AccountId>,

e2e-tests/src/test/adder.rs

@@ -1,6 +1,8 @@
 use std::str::FromStr;
 
-use aleph_client::{contract::ContractInstance, AccountId, ConnectionApi, SignedConnection};
+use aleph_client::{
+    contract::ContractInstance, AccountId, Connection, ConnectionApi, SignedConnectionApi,
+};
 use anyhow::{Context, Result};
 use assert2::assert;
 
@@ -20,15 +22,20 @@ pub async fn adder() -> Result<()> {
 
     let increment = 10;
     let before = contract.get(&conn).await?;
-    contract.add(&account.sign(&conn), increment).await?;
+    let raw_connection = Connection::new(&config.node).await;
+    contract
+        .add(&account.sign(&raw_connection), increment)
+        .await?;
     let after = contract.get(&conn).await?;
     assert!(after == before + increment);
 
     let new_name = "test";
-    contract.set_name(&account.sign(&conn), None).await?;
+    contract
+        .set_name(&account.sign(&raw_connection), None)
+        .await?;
     assert!(contract.get_name(&conn).await?.is_none());
     contract
-        .set_name(&account.sign(&conn), Some(new_name))
+        .set_name(&account.sign(&raw_connection), Some(new_name))
         .await?;
     assert!(contract.get_name(&conn).await? == Some(new_name.to_string()));
 
@@ -69,13 +76,17 @@ impl AdderInstance {
         self.contract.contract_read0(conn, "get").await
     }
 
-    pub async fn add(&self, conn: &SignedConnection, value: u32) -> Result<()> {
+    pub async fn add<S: SignedConnectionApi>(&self, conn: &S, value: u32) -> Result<()> {
         self.contract
             .contract_exec(conn, "add", &[value.to_string()])
             .await
     }
 
-    pub async fn set_name(&self, conn: &SignedConnection, name: Option<&str>) -> Result<()> {
+    pub async fn set_name<S: SignedConnectionApi>(
+        &self,
+        conn: &S,
+        name: Option<&str>,
+    ) -> Result<()> {
         let name = name.map_or_else(
             || "None".to_string(),
             |name| {

e2e-tests/src/test/helpers.rs

@@ -1,8 +1,8 @@
 use std::ops::Deref;
 
 use aleph_client::{
-    pallets::balances::BalanceUserApi, AccountId, AsConnection, Connection, KeyPair, Pair,
-    SignedConnection, TxStatus,
+    pallets::balances::BalanceUserApi, AccountId, Connection, KeyPair, Pair, SignedConnection,
+    SignedConnectionApi, TxStatus,
 };
 use anyhow::Result;
 use primitives::Balance;
@@ -55,7 +55,11 @@ pub fn random_account() -> KeyPairWrapper {
 }
 
 /// Transfer `amount` from `from` to `to`
-pub async fn transfer(conn: &SignedConnection, to: &KeyPair, amount: Balance) -> Result<()> {
+pub async fn transfer<S: SignedConnectionApi>(
+    conn: &S,
+    to: &KeyPair,
+    amount: Balance,
+) -> Result<()> {
     conn.transfer(to.signer().public().into(), amount, TxStatus::InBlock)
         .await
         .map(|_| ())
@@ -69,12 +73,12 @@ pub fn alephs(basic_unit_amount: Balance) -> Balance {
 /// Prepares a `(conn, authority, account)` triple with some money in `account` for fees.
 pub async fn basic_test_context(
     config: &Config,
-) -> Result<(Connection, KeyPairWrapper, KeyPairWrapper)> {
+) -> Result<(SignedConnection, KeyPairWrapper, KeyPairWrapper)> {
     let conn = config.get_first_signed_connection().await;
     let authority = KeyPairWrapper(aleph_client::keypair_from_string(&config.sudo_seed));
     let account = random_account();
 
     transfer(&conn, &account, alephs(100)).await?;
 
-    Ok((conn.as_connection().clone(), authority, account))
+    Ok((conn.clone(), authority, account))
 }

e2e-tests/src/test/rewards.rs

@@ -6,7 +6,7 @@ use aleph_client::{
     primitives::{CommitteeSeats, EraValidators},
     utility::SessionEraApi,
     waiting::{AlephWaiting, BlockStatus, WaitingExt},
-    AccountId, SignedConnection, TxStatus,
+    AccountId, SignedConnection, SignedConnectionApi, TxStatus,
 };
 use log::info;
 use primitives::{staking::MIN_VALIDATOR_BOND, EraIndex, SessionIndex};
@@ -262,8 +262,8 @@ pub async fn change_stake_and_force_new_era() -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn check_points_after_force_new_era(
-    connection: &SignedConnection,
+async fn check_points_after_force_new_era<S: SignedConnectionApi>(
+    connection: &S,
     start_session: SessionIndex,
     start_era: EraIndex,
     era_validators: &EraValidators<AccountId>,

e2e-tests/src/test/staking.rs

@@ -11,7 +11,7 @@ use aleph_client::{
     primitives::CommitteeSeats,
     sp_core::bounded::bounded_vec::BoundedVec,
     waiting::{BlockStatus, WaitingExt},
-    AccountId, KeyPair, Pair, SignedConnection, TxStatus,
+    AccountId, KeyPair, Pair, SignedConnection, SignedConnectionApi, TxStatus,
 };
 use log::info;
 use primitives::{
@@ -240,8 +240,8 @@ pub async fn multi_bond(node: &str, bonders: &[KeyPair], stake: Balance) {
     }
 }
 
-async fn payout_stakers_and_assert_locked_balance(
-    stash_connection: &SignedConnection,
+async fn payout_stakers_and_assert_locked_balance<S: SignedConnectionApi>(
+    stash_connection: &S,
     accounts_to_check_balance: &[AccountId],
     stash_account: &AccountId,
     era: BlockNumber,