A0-4159: Substrate v1.4.0 (#1650)

# Description

Updating Substrate to v1.4.0

## Type of change

- Breaking change (fix or feature that would cause existing
functionality to not work as expected)

# Checklist:

- I have bumped aleph-client version

---------

Co-authored-by: Damian Leśniak <[email protected]>

Author: lesniak43

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "aleph_client"
-version = "3.12.0"
+version = "3.13.0"
 edition = "2021"
 authors = ["Cardinal"]
 documentation = "https://docs.rs/aleph_client"
@@ -24,7 +24,7 @@ subxt = { version = "0.30.1", features = ["substrate-compat"] }
 futures = "0.3.25"
 serde = { version = "1.0", features = ["derive"] }
 
-pallet-contracts-primitives = { git = "https://github.com/Cardinal-Cryptography/polkadot-sdk.git", branch = "aleph-v1.3.0", default-features = false }
+pallet-contracts-primitives = { git = "https://github.com/Cardinal-Cryptography/polkadot-sdk.git", branch = "aleph-v1.4.0", default-features = false }
 
 primitives = { path = "../primitives" }
 

Cargo.toml

@@ -1,7 +1,7 @@
 use codec::Decode;
 use subxt::{ext::sp_core::Bytes, rpc_params};
 
-use crate::{aleph_runtime::SessionKeys, connections::AsConnection};
+use crate::{connections::AsConnection, primitives::AlephNodeSessionKeys as SessionKeys};
 
 /// Implements RPC calls for  [`author`](https://paritytech.github.io/substrate/master/sc_rpc/author/struct.Author.html) pallet
 #[async_trait::async_trait]

aleph-client/Cargo.lock

@@ -1,8 +1,8 @@
 use subxt::utils::Static;
 
 use crate::{
-    api, api::runtime_types::aleph_runtime::SessionKeys, connections::TxInfo, AccountId, BlockHash,
-    ConnectionApi, SessionIndex, SignedConnectionApi, TxStatus,
+    api, connections::TxInfo, primitives::AlephNodeSessionKeys as SessionKeys, AccountId,
+    BlockHash, ConnectionApi, SessionIndex, SignedConnectionApi, TxStatus,
 };
 
 /// Pallet session read-only api.

aleph-client/Cargo.toml

@@ -14,12 +14,12 @@ use crate::{
             ConfigOp,
             ConfigOp::{Noop, Set},
         },
-        EraRewardPoints, Exposure, IndividualExposure, RewardDestination, StakingLedger,
-        ValidatorPrefs,
+        EraRewardPoints, RewardDestination, StakingLedger, ValidatorPrefs,
     },
     pallet_sudo::pallet::Call::sudo_as,
     pallets::utility::UtilityApi,
     sp_arithmetic::per_things::Perbill,
+    sp_staking::{Exposure, IndividualExposure},
     AccountId, Balance, BlockHash,
     Call::{Staking, Sudo},
     ConnectionApi, EraIndex, RootConnection, SignedConnectionApi, SudoCall, TxStatus,
@@ -74,8 +74,20 @@ pub trait StakingApi {
     /// Returns [`minimum_validator_count`](https://paritytech.github.io/substrate/master/pallet_staking/struct.Pallet.html#method.minimum_validator_count).
     /// * `at` - optional hash of a block to query state from
     async fn get_minimum_validator_count(&self, at: Option<BlockHash>) -> u32;
+
     /// Returns [`SessionsPerEra`](https://paritytech.github.io/substrate/master/pallet_staking/trait.Config.html#associatedtype.SessionsPerEra) const.
     async fn get_session_per_era(&self) -> anyhow::Result<u32>;
+
+    /// Returns [`ClaimedRewards`](https://paritytech.github.io/polkadot-sdk/master/pallet_staking/type.ClaimedRewards.html) for a given era and validator.
+    /// * `era` - an era index
+    /// * `validator` - account ID of the validator
+    /// * `at` - optional hash of a block to query state from
+    async fn get_claimed_rewards(
+        &self,
+        era: u32,
+        validator: AccountId,
+        at: Option<BlockHash>,
+    ) -> Vec<u32>;
 }
 
 /// Pallet staking api
@@ -199,7 +211,7 @@ pub trait StakingSudoApi {
 /// Logic for retrieving raw storage keys or values from a pallet staking.
 #[async_trait::async_trait]
 pub trait StakingRawApi {
-    /// Returns all encoded [`eras_stakers`](https://paritytech.github.io/substrate/master/pallet_staking/struct.Pallet.html#method.eras_stakers).
+    /// Returns at most 10 encoded [`ErasStakers`](https://paritytech.github.io/substrate/master/pallet_staking/types.ErasStakers.html).
     /// storage keys for a given era
     /// * `era` - an era index
     /// * `at` - optional hash of a block to query state from
@@ -218,7 +230,7 @@ pub trait StakingRawApi {
         at: Option<BlockHash>,
     ) -> anyhow::Result<Vec<StorageKey>>;
 
-    /// Returns encoded [`eras_stakers`](https://paritytech.github.io/substrate/master/pallet_staking/struct.Pallet.html#method.eras_stakers).
+    /// Returns encoded [`ErasStakers`](https://paritytech.github.io/substrate/master/pallet_staking/types.ErasStakers).
     /// storage keys for a given era and given account ids
     /// * `era` - an era index
     /// * `accounts` - list of account ids
@@ -229,6 +241,37 @@ pub trait StakingRawApi {
         accounts: &[AccountId],
         at: Option<BlockHash>,
     ) -> Vec<StorageKey>;
+
+    /// Returns at most 10 encoded [`ErasStakersOverview`](https://paritytech.github.io/substrate/master/pallet_staking/types.ErasStakersOverview.html).
+    /// storage keys for a given era
+    /// * `era` - an era index
+    /// * `at` - optional hash of a block to query state from
+    ///
+    /// # Examples
+    /// ```ignore
+    /// let stakers = connection
+    ///         .get_stakers_overview_storage_keys(current_era, None)
+    ///         .await
+    ///         .into_iter()
+    ///         .map(|key| key.0);
+    /// ```
+    async fn get_stakers_overview_storage_keys(
+        &self,
+        era: EraIndex,
+        at: Option<BlockHash>,
+    ) -> anyhow::Result<Vec<StorageKey>>;
+
+    /// Returns encoded [`ErasStakersOverview`](https://paritytech.github.io/substrate/master/pallet_staking/types.ErasStakersOverview.html).
+    /// storage keys for a given era and given account ids
+    /// * `era` - an era index
+    /// * `accounts` - list of account ids
+    /// * `at` - optional hash of a block to query state from
+    async fn get_stakers_overview_storage_keys_from_accounts(
+        &self,
+        era: EraIndex,
+        accounts: &[AccountId],
+        at: Option<BlockHash>,
+    ) -> Vec<StorageKey>;
 }
 
 #[async_trait::async_trait]
@@ -269,11 +312,48 @@ impl<C: ConnectionApi + AsConnection> StakingApi for C {
         account_id: &AccountId,
         at: Option<BlockHash>,
     ) -> Exposure<AccountId, Balance> {
-        let addrs = api::storage()
-            .staking()
-            .eras_stakers(era, Static(account_id.clone()));
+        let overview = self
+            .get_storage_entry_maybe(
+                &api::storage()
+                    .staking()
+                    .eras_stakers_overview(era, Static(account_id.clone())),
+                at,
+            )
+            .await;
+
+        let exposure = match overview {
+            None => {
+                self.get_storage_entry(
+                    &api::storage()
+                        .staking()
+                        .eras_stakers(era, Static(account_id.clone())),
+                    at,
+                )
+                .await
+            }
+            Some(overview) => {
+                let mut others = Vec::with_capacity(overview.nominator_count as usize);
+                for page in 0..overview.page_count {
+                    let nominators = self
+                        .get_storage_entry_maybe(
+                            &api::storage().staking().eras_stakers_paged(
+                                era,
+                                Static(account_id.clone()),
+                                page,
+                            ),
+                            at,
+                        )
+                        .await;
+                    others.append(&mut nominators.map(|n| n.others).unwrap_or_default());
+                }
+                Exposure {
+                    total: overview.total,
+                    own: overview.own,
+                    others,
+                }
+            }
+        };
 
-        let exposure = self.get_storage_entry(&addrs, at).await;
         Exposure {
             total: exposure.total,
             own: exposure.own,
@@ -321,6 +401,18 @@ impl<C: ConnectionApi + AsConnection> StakingApi for C {
             .at(&addrs)
             .map_err(|e| e.into())
     }
+
+    async fn get_claimed_rewards(
+        &self,
+        era: u32,
+        validator: AccountId,
+        at: Option<BlockHash>,
+    ) -> Vec<u32> {
+        let addrs = api::storage()
+            .staking()
+            .claimed_rewards(era, Static(validator));
+        self.get_storage_entry(&addrs, at).await
+    }
 }
 
 #[async_trait::async_trait]
@@ -467,6 +559,43 @@ impl<C: AsConnection + Sync> StakingRawApi for C {
             })
             .collect()
     }
+
+    async fn get_stakers_overview_storage_keys(
+        &self,
+        era: EraIndex,
+        at: Option<BlockHash>,
+    ) -> anyhow::Result<Vec<StorageKey>> {
+        let key_addrs = api::storage().staking().eras_stakers_overview_root();
+        let mut key = key_addrs.to_root_bytes();
+        extend_with_twox64_concat_hash(&mut key, era);
+
+        let storage = self.as_connection().as_client().storage();
+        let block = match at {
+            Some(block_hash) => storage.at(block_hash),
+            None => storage.at_latest().await?,
+        };
+        block.fetch_keys(&key, 10, None).await.map_err(|e| e.into())
+    }
+
+    async fn get_stakers_overview_storage_keys_from_accounts(
+        &self,
+        era: EraIndex,
+        accounts: &[AccountId],
+        _: Option<BlockHash>,
+    ) -> Vec<StorageKey> {
+        let key_addrs = api::storage().staking().eras_stakers_overview_root();
+        let mut key = key_addrs.to_root_bytes();
+        extend_with_twox64_concat_hash(&mut key, era);
+        accounts
+            .iter()
+            .map(|account| {
+                let mut key = key.clone();
+                extend_with_twox64_concat_hash(&mut key, account);
+
+                StorageKey(key)
+            })
+            .collect()
+    }
 }
 
 #[async_trait::async_trait]

aleph-client/src/aleph_zero.rs

@@ -1,12 +1,12 @@
 pub use crate::aleph_zero::api::runtime_types::*;
 use crate::{
-    aleph_runtime::SessionKeys,
     api::runtime_types::{
         primitives::app::Public as AlephPublic,
         sp_consensus_aura::sr25519::app_sr25519::Public as AuraPublic,
         sp_core::{ed25519::Public as EdPublic, sr25519::Public as SrPublic},
     },
     pallet_staking::EraRewardPoints,
+    primitives::AlephNodeSessionKeys as SessionKeys,
     sp_weights::weight_v2::Weight,
 };