Initial integration with session module (paritytech#137)

* Add new_era() in election

* Intergate new_session()

* Add reward proposal09

* Add TreasuryAccount trait to get accound id of Treasury Module in
Staking

* SimpleTreasuryAccount

* Start rewarding test

* Impl proposal09 reward distribution

* Impl asset mining reward

* Start session management test in staking

* Nits

* Fix tests

* Add pallet-session into runtime

* //blockauthor?

* .

Author: liuchengxu

Cargo.lock

@@ -6,8 +6,9 @@ use chainx_runtime::{
 };
 use chainx_runtime::{AccountId, AssetId, Balance, Runtime, Signature, WASM_BINARY};
 use chainx_runtime::{
-    AuraConfig, GenesisConfig, GrandpaConfig, SudoConfig, SystemConfig, XAssetsConfig,
-    XBridgeBitcoinConfig, XContractsConfig, XMiningStakingConfig, XSpotConfig, XSystemConfig,
+    AuraConfig, GenesisConfig, GrandpaConfig, SessionConfig, SessionKeys, SudoConfig, SystemConfig,
+    XAssetsConfig, XBridgeBitcoinConfig, XContractsConfig, XSpotConfig, XStakingConfig,
+    XSystemConfig,
 };
 
 use sc_service::ChainType;
@@ -40,8 +41,13 @@ where
 }
 
 /// Helper function to generate an authority key for Aura
-pub fn authority_keys_from_seed(s: &str) -> (AuraId, GrandpaId) {
-    (get_from_seed::<AuraId>(s), get_from_seed::<GrandpaId>(s))
+pub fn authority_keys_from_seed(seed: &str) -> (AccountId, AccountId, AuraId, GrandpaId) {
+    (
+        get_account_id_from_seed::<sr25519::Public>(&format!("{}//validator", seed)),
+        get_account_id_from_seed::<sr25519::Public>(&format!("{}//blockauthor", seed)),
+        get_from_seed::<AuraId>(seed),
+        get_from_seed::<GrandpaId>(seed),
+    )
 }
 
 #[inline]
@@ -156,8 +162,12 @@ fn testnet_assets() -> Vec<(AssetId, AssetInfo, AssetRestrictions, bool, bool)>
     assets
 }
 
+fn session_keys(aura: AuraId, grandpa: GrandpaId) -> SessionKeys {
+    SessionKeys { grandpa, aura }
+}
+
 fn testnet_genesis(
-    initial_authorities: Vec<(AuraId, GrandpaId)>,
+    initial_authorities: Vec<(AccountId, AccountId, AuraId, GrandpaId)>,
     root_key: AccountId,
     assets: Vec<(AssetId, AssetInfo, AssetRestrictions, bool, bool)>,
     endowed: BTreeMap<AssetId, Vec<(AccountId, Balance)>>,
@@ -169,14 +179,26 @@ fn testnet_genesis(
             changes_trie_config: Default::default(),
         }),
         pallet_aura: Some(AuraConfig {
-            authorities: initial_authorities.iter().map(|x| (x.0.clone())).collect(),
+            authorities: initial_authorities.iter().map(|x| (x.2.clone())).collect(),
         }),
         pallet_grandpa: Some(GrandpaConfig {
             authorities: initial_authorities
                 .iter()
-                .map(|x| (x.1.clone(), 1))
+                .map(|x| (x.3.clone(), 1))
                 .collect(),
         }),
+        pallet_session: Some(SessionConfig {
+            keys: initial_authorities
+                .iter()
+                .map(|x| {
+                    (
+                        x.0.clone(),
+                        x.1.clone(),
+                        session_keys(x.2.clone(), x.3.clone()),
+                    )
+                })
+                .collect::<Vec<_>>(),
+        }),
         pallet_sudo: Some(SudoConfig {
             key: root_key.clone(),
         }),

cli/src/chain_spec.rs

@@ -15,31 +15,38 @@ pub type UnbondedIndex = u32;
 /// Type for measuring the non-validator entity's mining power.
 pub type MiningPower = u128;
 
-///
-pub trait CollectAssetMiningInfo {
-    ///
-    fn collect_asset_mining_info() -> Vec<(AssetId, MiningPower)>;
-
-    ///
-    fn total_mining_power() -> MiningPower {
-        Self::collect_asset_mining_info()
+/// Trait to retrieve and operate on Asset Mining participants in Staking.
+pub trait AssetMining<Balance> {
+    /// Collects the mining power of all mining assets.
+    fn asset_mining_power() -> Vec<(AssetId, MiningPower)>;
+
+    /// Issues reward to the reward pot of an Asset.
+    fn reward(_asset_id: AssetId, _reward_value: Balance);
+
+    /// Returns the mining power of all mining assets.
+    fn total_asset_mining_power() -> MiningPower {
+        Self::asset_mining_power()
             .iter()
             .map(|(_, power)| power)
             .sum()
     }
 }
 
-impl CollectAssetMiningInfo for () {
-    fn collect_asset_mining_info() -> Vec<(AssetId, MiningPower)> {
+impl<Balance> AssetMining<Balance> for () {
+    fn asset_mining_power() -> Vec<(AssetId, MiningPower)> {
         Vec::new()
     }
+
+    fn reward(_: AssetId, _: Balance) {}
 }
 
-/// Issue the fresh PCX to the non-validator mining entities.
-pub trait OnMinting<MiningEntity, Balance> {
-    fn mint(_: &MiningEntity, _: Balance);
+/// This trait provides a simple way to get the treasury account.
+pub trait TreasuryAccount<AccountId> {
+    fn treasury_account() -> AccountId;
 }
 
-impl<MiningEntity, Balance> OnMinting<MiningEntity, Balance> for () {
-    fn mint(_: &MiningEntity, _: Balance) {}
+impl<AccountId: Default> TreasuryAccount<AccountId> for () {
+    fn treasury_account() -> AccountId {
+        Default::default()
+    }
 }

primitives/mining/staking/src/lib.rs

@@ -35,11 +35,13 @@ pallet-aura = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0
 pallet-grandpa = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4", default-features = false }
 pallet-randomness-collective-flip = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4", default-features = false }
 pallet-sudo = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4", default-features = false }
+pallet-session = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4", default-features = false }
 pallet-timestamp = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4", default-features = false }
 pallet-utility = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4", default-features = false }
 
 # ChainX primitives
 chainx-primitives = { path = "../primitives", default-features = false }
+xp-mining-staking = { path = "../primitives/mining/staking", default-features = false }
 
 # ChainX pallets
 xpallet-assets = { path = "../xpallets/assets", default-features = false }
@@ -88,9 +90,11 @@ std = [
     "pallet-randomness-collective-flip/std",
     "pallet-sudo/std",
     "pallet-timestamp/std",
+    "pallet-session/std",
     "pallet-utility/std",
 
     "chainx-primitives/std",
+    "xp-mining-staking/std",
 
     "xpallet-assets/std",
     "xpallet-assets-rpc-runtime-api/std",

runtime/Cargo.toml

@@ -16,8 +16,8 @@ use sp_core::{crypto::KeyTypeId, OpaqueMetadata};
 use sp_runtime::{
     create_runtime_str, generic, impl_opaque_keys,
     traits::{
-        BlakeTwo256, Block as BlockT, DispatchInfoOf, IdentityLookup, NumberFor, Saturating,
-        SignedExtension,
+        BlakeTwo256, Block as BlockT, DispatchInfoOf, IdentityLookup, NumberFor, OpaqueKeys,
+        Saturating, SignedExtension,
     },
     transaction_validity::{
         InvalidTransaction, TransactionSource, TransactionValidity, TransactionValidityError,
@@ -300,10 +300,17 @@ impl xpallet_contracts::Trait for Runtime {
     type WeightPrice = xpallet_transaction_payment::Module<Self>;
 }
 
+pub struct SimpleTreasuryAccount;
+impl xp_mining_staking::TreasuryAccount<AccountId> for SimpleTreasuryAccount {
+    fn treasury_account() -> AccountId {
+        todo!("Treasury::account_id()")
+    }
+}
+
 impl xpallet_mining_staking::Trait for Runtime {
     type Event = Event;
-    type CollectAssetMiningInfo = ();
-    type OnMinting = ();
+    type TreasuryAccount = SimpleTreasuryAccount;
+    type AssetMining = ();
     type DetermineRewardPotAccount =
         xpallet_mining_staking::SimpleValidatorRewardPotAccountDeterminer<Runtime>;
 }
@@ -328,6 +335,24 @@ impl xpallet_transaction_payment::Trait for Runtime {
         TargetedFeeAdjustment<Self, TargetBlockFullness, AdjustmentVariable, MinimumMultiplier>;
 }
 
+parameter_types! {
+    pub const Offset: BlockNumber = 0;
+    pub const Period: BlockNumber = 50;
+    pub const DisabledValidatorsThreshold: Perbill = Perbill::from_percent(17);
+}
+
+impl pallet_session::Trait for Runtime {
+    type Event = Event;
+    type ValidatorId = <Self as frame_system::Trait>::AccountId;
+    type ValidatorIdOf = ();
+    type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+    type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+    type SessionManager = XStaking;
+    type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
+    type Keys = SessionKeys;
+    type DisabledValidatorsThreshold = DisabledValidatorsThreshold;
+}
+
 construct_runtime!(
     pub enum Runtime where
         Block = Block,
@@ -340,13 +365,14 @@ construct_runtime!(
         Aura: pallet_aura::{Module, Config<T>, Inherent(Timestamp)},
         Grandpa: pallet_grandpa::{Module, Call, Storage, Config, Event},
         Utility: pallet_utility::{Module, Call, Event},
+        Session: pallet_session::{Module, Call, Storage, Event, Config<T>},
         Sudo: pallet_sudo::{Module, Call, Config<T>, Storage, Event<T>},
 
         XSystem: xpallet_system::{Module, Call, Storage, Event<T>, Config},
         XAssets: xpallet_assets::{Module, Call, Storage, Event<T>, Config<T>},
         XBridgeBitcoin: xpallet_bridge_bitcoin::{Module, Call, Storage, Event<T>, Config},
         XContracts: xpallet_contracts::{Module, Call, Config, Storage, Event<T>},
-        XMiningStaking: xpallet_mining_staking::{Module, Call, Storage, Event<T>, Config<T>},
+        XStaking: xpallet_mining_staking::{Module, Call, Storage, Event<T>, Config<T>},
         XMiningAsset: xpallet_mining_asset::{Module, Call, Storage, Event<T>},
         XTransactionPayment: xpallet_transaction_payment::{Module, Storage},
         XSpot: xpallet_dex_spot::{Module, Call, Storage, Event<T>, Config<T>},

runtime/src/lib.rs

@@ -110,12 +110,12 @@ impl<T: Trait> xpallet_assets::OnAssetChanged<T::AccountId, T::Balance> for Modu
 
 impl<T: Trait> Module<T> {
     fn allocate_dividend(
-        claimer: &T::AccountId,
-        claimee: &AssetId,
-        claimee_reward_pot: &T::AccountId,
-        dividend: T::Balance,
+        _claimer: &T::AccountId,
+        _claimee: &AssetId,
+        _claimee_reward_pot: &T::AccountId,
+        _dividend: T::Balance,
     ) -> Result<(), Error<T>> {
-        todo!("")
+        todo!("referral_or_treasury 10%, claimer 90%")
     }
 }
 
@@ -191,13 +191,16 @@ where
 {
     fn reward_pot_account_for(asset_id: &AssetId) -> T::AccountId {
         let id_hash = T::Hashing::hash(&asset_id.to_le_bytes()[..]);
-        let registered_time = <xpallet_assets::Module<T>>::asset_registered_block(asset_id);
-        let block_num_hash =
-            <T as frame_system::Trait>::Hashing::hash(registered_time.encode().as_ref());
+        let registered_block = <xpallet_assets::Module<T>>::asset_registered_block(asset_id);
+        let registered_block_hash =
+            <T as frame_system::Trait>::Hashing::hash(registered_block.encode().as_ref());
 
-        let mut buf = Vec::new();
-        buf.extend_from_slice(id_hash.as_ref());
-        buf.extend_from_slice(block_num_hash.as_ref());
+        let id_slice = id_hash.as_ref();
+        let registered_slice = registered_block_hash.as_ref();
+
+        let mut buf = Vec::with_capacity(id_slice.len() + registered_slice.len());
+        buf.extend_from_slice(id_slice);
+        buf.extend_from_slice(registered_slice);
 
         UncheckedFrom::unchecked_from(T::Hashing::hash(&buf[..]))
     }

xpallets/mining/asset/src/impls.rs

@@ -78,20 +78,11 @@ impl xpallet_assets::Trait for Test {
 
 impl xpallet_mining_staking::Trait for Test {
     type Event = ();
-    type OnMinting = ();
-    type CollectAssetMiningInfo = ();
+    type AssetMining = ();
+    type TreasuryAccount = ();
     type DetermineRewardPotAccount = ();
 }
 
-// This function basically just builds a genesis storage key/value store according to
-// our desired mockup.
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    system::GenesisConfig::default()
-        .build_storage::<Test>()
-        .unwrap()
-        .into()
-}
-
 thread_local! {
     static SESSION: RefCell<(Vec<AccountId>, HashSet<AccountId>)> = RefCell::new(Default::default());
     static SESSION_PER_ERA: RefCell<SessionIndex> = RefCell::new(3);

xpallets/mining/asset/src/mock.rs

@@ -32,6 +32,7 @@ xpallet-support = { path = "../../support", default-features = false }
 xpallet-protocol = { path = "../../protocol" }
 sp-core = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4" }
 sp-io = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4" }
+pallet-timestamp = { git = "https://github.com/paritytech/substrate.git", tag = "v2.0.0-rc4" }
 env_logger = "0.7.1"
 
 [features]