pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-25 23:27:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

extract ShiftSessionManager into separate pallet (#342)

Browse Source
This commit is contained in:
Svyatoslav Nikolsky
2020-09-09 12:06:26 +03:00
committed by Bastian Köcher
parent 858940050a
commit 6df0341064
4 changed files with 289 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bridges/bin/node/runtime/Cargo.toml
+6
View File
@@ -78,6 +78,11 @@ tag = 'v2.0.0-rc6'
default-features = false
git = "https://github.com/paritytech/substrate/"
[dependencies.pallet-shift-session-manager]
version = "0.1.0"
default-features = false
path = "../../../modules/shift-session-manager"
[dependencies.pallet-sudo]
version = "2.0.0-rc6"
tag = 'v2.0.0-rc6'
@@ -264,6 +269,7 @@ std = [
"pallet-bridge-eth-poa/std",
"pallet-grandpa/std",
"pallet-randomness-collective-flip/std",
"pallet-shift-session-manager/std",
"pallet-sudo/std",
"pallet-timestamp/std",
"pallet-transaction-payment/std",
bridges/bin/node/runtime/src/lib.rs
+3 -92
View File
@@ -35,7 +35,6 @@ pub mod benches;
pub mod kovan;
pub mod rialto;
use codec::{Decode, Encode};
use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList};
use sp_api::impl_runtime_apis;
use sp_consensus_aura::sr25519::AuthorityId as AuraId;
@@ -401,63 +400,14 @@ impl pallet_session::Trait for Runtime {
type ValidatorIdOf = ();
type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
type SessionManager = ShiftSessionManager;
type SessionManager = pallet_shift_session_manager::Module<Runtime>;
type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
type Keys = SessionKeys;
type DisabledValidatorsThreshold = ();
type WeightInfo = ();
}
pub struct ShiftSessionManager;
impl ShiftSessionManager {
/// Select validators for session.
fn select_validators(
session_index: sp_staking::SessionIndex,
available_validators: &[AccountId],
) -> Vec<AccountId> {
let available_validators_count = available_validators.len();
let count = sp_std::cmp::max(1, 2 * available_validators_count / 3);
let offset = session_index as usize % available_validators_count;
let end = offset + count;
let session_validators = match end.overflowing_sub(available_validators_count) {
(wrapped_end, false) if wrapped_end != 0 => available_validators[offset..]
.iter()
.chain(available_validators[..wrapped_end].iter())
.cloned()
.collect(),
_ => available_validators[offset..end].to_vec(),
};
session_validators
}
}
impl pallet_session::SessionManager<AccountId> for ShiftSessionManager {
fn end_session(_: sp_staking::SessionIndex) {}
fn start_session(_: sp_staking::SessionIndex) {}
fn new_session(session_index: sp_staking::SessionIndex) -> Option<Vec<AccountId>> {
// can't access genesis config here :/
if session_index == 0 || session_index == 1 {
return None;
}
// the idea that on first call (i.e. when session 1 ends) we're reading current
// set of validators from session module (they are initial validators) and save
// in our 'local storage'.
// then for every session we select (deterministically) 2/3 of these initial
// validators to serve validators of new session
let available_validators = sp_io::storage::get(b":available_validators")
.and_then(|validators| Decode::decode(&mut &validators[..]).ok())
.unwrap_or_else(|| {
let validators = <pallet_session::Module<Runtime>>::validators();
sp_io::storage::set(b":available_validators", &validators.encode());
validators
});
Some(Self::select_validators(session_index, &available_validators))
}
}
impl pallet_shift_session_manager::Trait for Runtime {}
construct_runtime!(
pub enum Runtime where
@@ -479,6 +429,7 @@ construct_runtime!(
TransactionPayment: pallet_transaction_payment::{Module, Storage},
Sudo: pallet_sudo::{Module, Call, Config<T>, Storage, Event<T>},
Session: pallet_session::{Module, Call, Storage, Event, Config<T>},
ShiftSessionManager: pallet_shift_session_manager::{Module},
}
);
@@ -771,46 +722,6 @@ mod tests {
use super::*;
use bp_currency_exchange::DepositInto;
#[test]
fn shift_session_manager_works() {
let acc1 = AccountId::from([1u8; 32]);
let acc2 = AccountId::from([2u8; 32]);
let acc3 = AccountId::from([3u8; 32]);
let acc4 = AccountId::from([4u8; 32]);
let acc5 = AccountId::from([5u8; 32]);
let all_accs = vec![acc1.clone(), acc2.clone(), acc3.clone(), acc4.clone(), acc5.clone()];
// at least 1 validator is selected
assert_eq!(
ShiftSessionManager::select_validators(0, &[acc1.clone()]),
vec![acc1.clone()],
);
// at session#0, shift is also 0
assert_eq!(
ShiftSessionManager::select_validators(0, &all_accs),
vec![acc1.clone(), acc2.clone(), acc3.clone()],
);
// at session#1, shift is also 1
assert_eq!(
ShiftSessionManager::select_validators(1, &all_accs),
vec![acc2.clone(), acc3.clone(), acc4.clone()],
);
// at session#3, we're wrapping
assert_eq!(
ShiftSessionManager::select_validators(3, &all_accs),
vec![acc4, acc5, acc1.clone()],
);
// at session#5, we're starting from the beginning again
assert_eq!(
ShiftSessionManager::select_validators(5, &all_accs),
vec![acc1, acc2, acc3],
);
}
fn run_deposit_into_test(test: impl Fn(AccountId) -> Balance) {
let mut ext: sp_io::TestExternalities = SystemConfig::default().build_storage::<Runtime>().unwrap().into();
ext.execute_with(|| {
bridges/modules/shift-session-manager/Cargo.toml
+67
View File
@@ -0,0 +1,67 @@
[package]
name = "pallet-shift-session-manager"
description = "A Substrate Runtime module that selects 2/3 of initial validators for every session"
version = "0.1.0"
authors = ["Parity Technologies <admin@parity.io>"]
edition = "2018"
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
[dependencies]
codec = { package = "parity-scale-codec", version = "1.3.1", default-features = false }
# Substrate Based Dependencies
[dependencies.frame-support]
version = "2.0.0-rc6"
tag = 'v2.0.0-rc6'
default-features = false
git = "https://github.com/paritytech/substrate/"
[dependencies.frame-system]
version = "2.0.0-rc6"
tag = 'v2.0.0-rc6'
default-features = false
git = "https://github.com/paritytech/substrate/"
[dependencies.pallet-session]
version = "2.0.0-rc6"
tag = 'v2.0.0-rc6'
default-features = false
git = "https://github.com/paritytech/substrate/"
[dependencies.sp-core]
version = "2.0.0-rc6"
tag = 'v2.0.0-rc6'
default-features = false
git = "https://github.com/paritytech/substrate/"
[dependencies.sp-runtime]
version = "2.0.0-rc6"
tag = 'v2.0.0-rc6'
default-features = false
git = "https://github.com/paritytech/substrate/"
[dependencies.sp-staking]
version = "2.0.0-rc6"
tag = 'v2.0.0-rc6'
default-features = false
git = "https://github.com/paritytech/substrate/"
[dependencies.sp-std]
version = "2.0.0-rc6"
tag = 'v2.0.0-rc6'
default-features = false
git = "https://github.com/paritytech/substrate/"
[features]
default = ["std"]
std = [
"codec/std",
"frame-support/std",
"frame-system/std",
"pallet-session/std",
"sp-core/std",
"sp-runtime/std",
"sp-staking/std",
"sp-std/std",
]
bridges/modules/shift-session-manager/src/lib.rs
+213
View File
@@ -0,0 +1,213 @@
// Copyright 2019-2020 Parity Technologies (UK) Ltd.
// This file is part of Parity Bridges Common.
// Parity Bridges Common 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.
// Parity Bridges Common 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 Parity Bridges Common. If not, see <http://www.gnu.org/licenses/>.
//! Substrate session manager that selects 2/3 validators from initial set,
//! starting from session 2.
#![cfg_attr(not(feature = "std"), no_std)]
use frame_support::{decl_module, decl_storage};
use sp_std::prelude::*;
/// The module configuration trait.
pub trait Trait: pallet_session::Trait {}
decl_module! {
/// Shift session manager pallet.
pub struct Module<T: Trait> for enum Call where origin: T::Origin {}
}
decl_storage! {
trait Store for Module<T: Trait> as ShiftSessionManager {
/// Validators of first two sessions.
InitialValidators: Option<Vec<T::ValidatorId>>;
}
}
impl<T: Trait> pallet_session::SessionManager<T::ValidatorId> for Module<T> {
fn end_session(_: sp_staking::SessionIndex) {}
fn start_session(_: sp_staking::SessionIndex) {}
fn new_session(session_index: sp_staking::SessionIndex) -> Option<Vec<T::ValidatorId>> {
// we don't want to add even more fields to genesis config => just return None
if session_index == 0 || session_index == 1 {
return None;
}
// the idea that on first call (i.e. when session 1 ends) we're reading current
// set of validators from session module (they are initial validators) and save
// in our 'local storage'.
// then for every session we select (deterministically) 2/3 of these initial
// validators to serve validators of new session
let available_validators = InitialValidators::<T>::get().unwrap_or_else(|| {
let validators = <pallet_session::Module<T>>::validators();
InitialValidators::<T>::put(validators.clone());
validators
});
Some(Self::select_validators(session_index, &available_validators))
}
}
impl<T: Trait> Module<T> {
/// Select validators for session.
fn select_validators(
session_index: sp_staking::SessionIndex,
available_validators: &[T::ValidatorId],
) -> Vec<T::ValidatorId> {
let available_validators_count = available_validators.len();
let count = sp_std::cmp::max(1, 2 * available_validators_count / 3);
let offset = session_index as usize % available_validators_count;
let end = offset + count;
let session_validators = match end.overflowing_sub(available_validators_count) {
(wrapped_end, false) if wrapped_end != 0 => available_validators[offset..]
.iter()
.chain(available_validators[..wrapped_end].iter())
.cloned()
.collect(),
_ => available_validators[offset..end].to_vec(),
};
session_validators
}
}
#[cfg(test)]
mod tests {
use super::*;
use frame_support::sp_io::TestExternalities;
use frame_support::sp_runtime::{
testing::{Header, UintAuthorityId},
traits::{BlakeTwo256, ConvertInto, IdentityLookup},
Perbill, RuntimeAppPublic,
};
use frame_support::{impl_outer_origin, parameter_types, weights::Weight};
use sp_core::H256;
type AccountId = u64;
#[derive(Clone, Eq, PartialEq)]
pub struct TestRuntime;
impl_outer_origin! {
pub enum Origin for TestRuntime {}
}
parameter_types! {
pub const BlockHashCount: u64 = 250;
pub const MaximumBlockWeight: Weight = 1024;
pub const MaximumBlockLength: u32 = 2 * 1024;
pub const AvailableBlockRatio: Perbill = Perbill::one();
}
impl frame_system::Trait for TestRuntime {
type Origin = Origin;
type Index = u64;
type Call = ();
type BlockNumber = u64;
type Hash = H256;
type Hashing = BlakeTwo256;
type AccountId = AccountId;
type Lookup = IdentityLookup<Self::AccountId>;
type Header = Header;
type Event = ();
type BlockHashCount = BlockHashCount;
type MaximumBlockWeight = MaximumBlockWeight;
type DbWeight = ();
type BlockExecutionWeight = ();
type ExtrinsicBaseWeight = ();
type MaximumExtrinsicWeight = ();
type AvailableBlockRatio = AvailableBlockRatio;
type MaximumBlockLength = MaximumBlockLength;
type Version = ();
type ModuleToIndex = ();
type AccountData = ();
type OnNewAccount = ();
type OnKilledAccount = ();
type BaseCallFilter = ();
type SystemWeightInfo = ();
}
parameter_types! {
pub const Period: u64 = 1;
pub const Offset: u64 = 0;
}
impl pallet_session::Trait for TestRuntime {
type Event = ();
type ValidatorId = <Self as frame_system::Trait>::AccountId;
type ValidatorIdOf = ConvertInto;
type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
type SessionManager = ();
type SessionHandler = TestSessionHandler;
type Keys = UintAuthorityId;
type DisabledValidatorsThreshold = ();
type WeightInfo = ();
}
impl Trait for TestRuntime {}
pub struct TestSessionHandler;
impl pallet_session::SessionHandler<AccountId> for TestSessionHandler {
const KEY_TYPE_IDS: &'static [sp_runtime::KeyTypeId] = &[UintAuthorityId::ID];
fn on_genesis_session<Ks: sp_runtime::traits::OpaqueKeys>(_validators: &[(AccountId, Ks)]) {}
fn on_new_session<Ks: sp_runtime::traits::OpaqueKeys>(_: bool, _: &[(AccountId, Ks)], _: &[(AccountId, Ks)]) {}
fn on_disabled(_: usize) {}
}
fn new_test_ext() -> TestExternalities {
let mut t = frame_system::GenesisConfig::default()
.build_storage::<TestRuntime>()
.unwrap();
pallet_session::GenesisConfig::<TestRuntime> {
keys: vec![
(1, 1, UintAuthorityId(1)),
(2, 2, UintAuthorityId(2)),
(3, 3, UintAuthorityId(3)),
(4, 4, UintAuthorityId(4)),
(5, 5, UintAuthorityId(5)),
],
}
.assimilate_storage(&mut t)
.unwrap();
TestExternalities::new(t)
}
#[test]
fn shift_session_manager_works() {
new_test_ext().execute_with(|| {
let all_accs = vec![1, 2, 3, 4, 5];
// at least 1 validator is selected
assert_eq!(Module::<TestRuntime>::select_validators(0, &[1]), vec![1],);
// at session#0, shift is also 0
assert_eq!(Module::<TestRuntime>::select_validators(0, &all_accs), vec![1, 2, 3],);
// at session#1, shift is also 1
assert_eq!(Module::<TestRuntime>::select_validators(1, &all_accs), vec![2, 3, 4],);
// at session#3, we're wrapping
assert_eq!(Module::<TestRuntime>::select_validators(3, &all_accs), vec![4, 5, 1],);
// at session#5, we're starting from the beginning again
assert_eq!(Module::<TestRuntime>::select_validators(5, &all_accs), vec![1, 2, 3],);
});
}
}