Staking support

Cargo.toml

@@ -17,6 +17,8 @@ keywords = ["parity", "substrate", "blockchain"]
 include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE"]
 
 [features]
+kusama = []
+default = ["kusama"]
 client = ["substrate-subxt-client"]
 
 # enable this feature to run tests which require a local dev chain node
@@ -31,14 +33,22 @@ num-traits = { version = "0.2.12", default-features = false }
 serde = { version = "1.0.115", features = ["derive"] }
 serde_json = "1.0.57"
 url = "2.1.1"
-codec = { package = "parity-scale-codec", version = "1.3.4", default-features = false, features = ["derive", "full"] }
+codec = { package = "parity-scale-codec", version = "1.3.5", default-features = false, features = ["derive", "full"] }
 
 frame-metadata = { version = "11.0.0-rc6", package = "frame-metadata" }
 frame-support = { version = "2.0.0-rc6", package = "frame-support" }
 sp-runtime = { version = "2.0.0-rc6", package = "sp-runtime" }
 sp-version = { version = "2.0.0-rc6", package = "sp-version" }
 pallet-indices = { version = "2.0.0-rc6", package = "pallet-indices" }
 hex = "0.4.2"
+sp-std = "2.0.0-rc6"
+application-crypto = { version = "2.0.0-rc6", package = "sp-application-crypto" }
+sp-finality-grandpa = "2.0.0-rc6"
+sp-consensus-babe = "0.8.0-rc6"
+pallet-im-online = "2.0.0-rc6"
+sp-authority-discovery = "2.0.0-rc6"
+pallet-staking = "2.0.0-rc6"
+
 sp-rpc = { version = "2.0.0-rc6", package = "sp-rpc" }
 sp-core = { version = "2.0.0-rc6", package = "sp-core" }
 sc-rpc-api = { version = "0.8.0-rc6", package = "sc-rpc-api" }

README.md

@@ -6,6 +6,9 @@ A library to **sub**mit e**xt**rinsics to a [substrate](https://github.com/parit
 
 See [examples](./examples).
 
+If you use `#[derive(Call)]` without `#[module]` in the same module, you will get errors
+complaining about an undefined method with a name starting with `with_`.
+
 **Alternatives**
 
 [substrate-api-client](https://github.com/scs/substrate-api-client) provides similar functionality.

src/extrinsic/signer.rs

@@ -54,6 +54,7 @@ pub trait Signer<T: Runtime> {
 }
 
 /// Extrinsic signer using a private key.
+#[derive(Debug)]
 pub struct PairSigner<T: Runtime, P: Pair> {
     account_id: T::AccountId,
     nonce: Option<T::Index>,

src/frame/mod.rs

@@ -31,6 +31,8 @@ use sp_core::storage::StorageKey;
 
 pub mod balances;
 pub mod contracts;
+pub mod session;
+pub mod staking;
 pub mod sudo;
 pub mod system;
 

src/frame/session.rs

@@ -0,0 +1,75 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of substrate-subxt.
+//
+// subxt is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// subxt is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with substrate-subxt.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Session support
+use crate::frame::system::{
+    System,
+    SystemEventsDecoder as _,
+};
+use codec::Encode;
+use frame_support::Parameter;
+use sp_runtime::traits::{
+    Member,
+    OpaqueKeys,
+};
+use std::{
+    fmt::Debug,
+    marker::PhantomData,
+};
+use substrate_subxt_proc_macro::Store;
+
+/// Impls `Default::default` for some types that have a `_runtime` field of type
+/// `PhantomData` as their only field.
+macro_rules! default_impl {
+    ($name:ident) => {
+        impl<T: Session> Default for $name<T> {
+            fn default() -> Self {
+                Self {
+                    _runtime: PhantomData,
+                }
+            }
+        }
+    };
+}
+
+/// The trait needed for this module.
+#[module]
+pub trait Session: System {
+    /// The validator account identifier type for the runtime.
+    type ValidatorId: Parameter + Debug + Ord + Default + Send + Sync + 'static;
+
+    /// The keys.
+    type Keys: OpaqueKeys + Member + Parameter + Default;
+}
+
+/// The current set of validators.
+#[derive(Encode, Store, Debug)]
+pub struct ValidatorsStore<T: Session> {
+    #[store(returns = Vec<<T as Session>::ValidatorId>)]
+    /// Marker for the runtime
+    pub _runtime: PhantomData<T>,
+}
+
+default_impl!(ValidatorsStore);
+
+/// Set the session keys for a validator.
+#[derive(Encode, Call, Debug)]
+pub struct SetKeysCall<T: Session> {
+    /// The keys
+    pub keys: T::Keys,
+    /// The proof. This is not currently used and can be set to an empty vector.
+    pub proof: Vec<u8>,
+}

src/frame/staking.rs

@@ -0,0 +1,252 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of substrate-subxt.
+//
+// subxt is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// subxt is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with substrate-subxt.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Implements support for the pallet_staking module.
+
+use super::balances::{
+    Balances,
+    BalancesEventsDecoder as _,
+};
+use codec::{
+    Decode,
+    Encode,
+};
+
+use std::{
+    collections::BTreeMap,
+    fmt::Debug,
+    marker::PhantomData,
+};
+
+pub use pallet_staking::{
+    ActiveEraInfo,
+    EraIndex,
+    Exposure,
+    Nominations,
+    RewardDestination,
+    RewardPoint,
+    StakingLedger,
+    ValidatorPrefs,
+};
+
+/// Rewards for the last `HISTORY_DEPTH` eras.
+/// If reward hasn't been set or has been removed then 0 reward is returned.
+#[derive(Clone, Encode, Decode, Debug, Store)]
+pub struct ErasRewardPointsStore<T: Staking> {
+    #[store(returns = EraRewardPoints<T::AccountId>)]
+    /// Era index
+    pub index: EraIndex,
+    /// Marker for the runtime
+    pub _phantom: PhantomData<T>,
+}
+
+/// Preference of what happens regarding validation.
+#[derive(Clone, Encode, Decode, Debug, Call)]
+pub struct SetPayeeCall<T: Staking> {
+    /// The payee
+    pub payee: RewardDestination,
+    /// Marker for the runtime
+    pub _runtime: PhantomData<T>,
+}
+
+/// The subset of the `frame::Trait` that a client must implement.
+#[module]
+pub trait Staking: Balances {}
+
+/// Number of eras to keep in history.
+///
+/// Information is kept for eras in `[current_era - history_depth; current_era]`.
+///
+/// Must be more than the number of eras delayed by session otherwise.
+/// I.e. active era must always be in history.
+/// I.e. `active_era > current_era - history_depth` must be guaranteed.
+#[derive(Encode, Decode, Copy, Clone, Debug, Default, Store)]
+pub struct HistoryDepthStore<T: Staking> {
+    #[store(returns = u32)]
+    /// Marker for the runtime
+    pub _runtime: PhantomData<T>,
+}
+
+/// Map from all locked "stash" accounts to the controller account.
+#[derive(Encode, Copy, Clone, Debug, Hash, PartialEq, Eq, Ord, PartialOrd, Store)]
+pub struct BondedStore<T: Staking> {
+    #[store(returns = Option<T::AccountId>)]
+    /// Tٗhe stash account
+    pub stash: T::AccountId,
+}
+
+/// Map from all (unlocked) "controller" accounts to the info regarding the staking.
+#[derive(Encode, Copy, Clone, Debug, Hash, PartialEq, Eq, Ord, PartialOrd, Store)]
+pub struct LedgerStore<T: Staking> {
+    #[store(returns = Option<StakingLedger<T::AccountId, T::Balance>>)]
+    /// The controller account
+    pub controller: T::AccountId,
+}
+
+/// Where the reward payment should be made. Keyed by stash.
+#[derive(Encode, Copy, Clone, Debug, Hash, PartialEq, Eq, Ord, PartialOrd, Store)]
+pub struct PayeeStore<T: Staking> {
+    #[store(returns = RewardDestination)]
+    /// Tٗhe stash account
+    pub stash: T::AccountId,
+}
+
+/// The map from (wannabe) validator stash key to the preferences of that validator.
+#[derive(Encode, Copy, Clone, Debug, Hash, PartialEq, Eq, Ord, PartialOrd, Store)]
+pub struct ValidatorsStore<T: Staking> {
+    #[store(returns = ValidatorPrefs)]
+    /// Tٗhe stash account
+    pub stash: T::AccountId,
+}
+
+/// The map from nominator stash key to the set of stash keys of all validators to nominate.
+#[derive(Encode, Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Store)]
+pub struct NominatorsStore<T: Staking> {
+    #[store(returns = Option<Nominations<T::AccountId>>)]
+    /// Tٗhe stash account
+    pub stash: T::AccountId,
+}
+
+/// The current era index.
+///
+/// This is the latest planned era, depending on how the Session pallet queues the validator
+/// set, it might be active or not.
+#[derive(Encode, Copy, Clone, Debug, Store)]
+pub struct CurrentEraStore<T: Staking> {
+    #[store(returns = Option<EraIndex>)]
+    /// Marker for the runtime
+    pub _runtime: PhantomData<T>,
+}
+
+/// Reward points of an era. Used to split era total payout between validators.
+///
+/// This points will be used to reward validators and their respective nominators.
+#[derive(PartialEq, Encode, Decode, Default, Debug)]
+pub struct EraRewardPoints<AccountId: Ord> {
+    /// Total number of points. Equals the sum of reward points for each validator.
+    pub total: RewardPoint,
+    /// The reward points earned by a given validator.
+    pub individual: BTreeMap<AccountId, RewardPoint>,
+}
+
+/// Declare no desire to either validate or nominate.
+///
+/// Effective at the beginning of the next era.
+///
+/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+/// Can only be called when [`EraElectionStatus`] is `Closed`.
+#[derive(Debug, Call, Encode)]
+pub struct ChillCall<T: Staking> {
+    /// Runtime marker
+    pub _runtime: PhantomData<T>,
+}
+
+impl<T: Staking> Default for ChillCall<T> {
+    fn default() -> Self {
+        Self {
+            _runtime: PhantomData,
+        }
+    }
+}
+impl<T: Staking> Clone for ChillCall<T> {
+    fn clone(&self) -> Self {
+        Self {
+            _runtime: self._runtime,
+        }
+    }
+}
+impl<T: Staking> Copy for ChillCall<T> {}
+
+/// Declare the desire to validate for the origin controller.
+///
+/// Effective at the beginning of the next era.
+///
+/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+/// Can only be called when [`EraElectionStatus`] is `Closed`.
+#[derive(Clone, Debug, PartialEq, Call, Encode)]
+pub struct ValidateCall<T: Staking> {
+    /// Runtime marker
+    pub _runtime: PhantomData<T>,
+    /// Validation preferences
+    pub prefs: ValidatorPrefs,
+}
+
+/// Declare the desire to nominate `targets` for the origin controller.
+///
+/// Effective at the beginning of the next era.
+///
+/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+/// Can only be called when [`EraElectionStatus`] is `Closed`.
+#[derive(Call, Encode, Debug)]
+pub struct NominateCall<T: Staking> {
+    /// The targets that are being nominated
+    pub targets: Vec<T::Address>,
+}
+
+#[cfg(all(test, feature = "integration-tests"))]
+mod tests {
+    use super::*;
+    use crate::{
+        extrinsic::PairSigner,
+        runtimes::KusamaRuntime as RT,
+        ClientBuilder,
+    };
+    // use sp_core::{sr25519::Pair, Pair as _};
+    use crate::{
+        extrinsic::Signer,
+        frame::{
+            balances::*,
+            system::*,
+        },
+    };
+    use sp_keyring::AccountKeyring;
+
+    #[async_std::test]
+    async fn test_nominate() {
+        env_logger::try_init().ok();
+        let alice = PairSigner::<RT, _>::new(AccountKeyring::Alice.pair());
+        let bob = PairSigner::<RT, _>::new(AccountKeyring::Bob.pair());
+
+        let client = ClientBuilder::<RT>::new().build().await.unwrap();
+        let current_era = client.current_era(None).await.unwrap();
+        println!("Current era: {:?}", current_era);
+        let hd = client.history_depth(None).await.unwrap();
+        println!("History depth: {:?}", hd);
+        let total_issuance = client.total_issuance(None).await.unwrap();
+        println!("total issuance: {:?}", total_issuance);
+        let alice_account = client.account(&alice.account_id(), None).await.unwrap();
+        println!("Alice's account info: {:?}", alice_account);
+        let o = client
+            .nominate(&alice, vec![bob.account_id().clone()])
+            .await
+            .unwrap();
+        println!("Nom nom: {:?}", o);
+        let o = client
+            .validate(&bob, ValidatorPrefs::default())
+            .await
+            .unwrap();
+        println!("Validator result: {:?}", o);
+        for &i in &[RewardDestination::Controller] {
+            for &j in &[&bob, &alice] {
+                println!(
+                    "Transaction result: {:?}",
+                    client.set_payee(j, i).await.unwrap()
+                );
+                client.chill(j).await.unwrap();
+            }
+        }
+    }
+}

src/frame/system.rs

@@ -101,6 +101,8 @@ pub trait System {
         + MaybeSerialize
         + Debug
         + MaybeDisplay
+        + Encode
+        + Decode
         + Ord
         + Default;