From 95d98e6d612db4e85ba2c71bbf37b5e606e31168 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Gil?= <michal.gil@parity.io>
Date: Wed, 13 Nov 2024 10:43:40 +0100
Subject: [PATCH] remove pallet::getter from pallet-staking (#6184)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
# Description
Part of https://github.com/paritytech/polkadot-sdk/issues/3326
Removes all pallet::getter occurrences from pallet-staking and replaces
them with explicit implementations.
Adds tests to verify that retrieval of affected entities works as
expected so via storage::getter.
## Review Notes
1. Traits added to the `derive` attribute are used in tests (either
directly or indirectly).
2. The getters had to be placed in a separate impl block since the other
one is annotated with `#[pallet::call]` and that requires
`#[pallet::call_index(0)]` annotation on each function in that block. So
I thought it's better to separate them.
---------
Co-authored-by: Dónal Murray <donal.murray@parity.io>
Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>
---
polkadot/runtime/westend/src/lib.rs | 2 +-
prdoc/pr_6184.prdoc | 24 +
substrate/frame/babe/src/mock.rs | 2 +-
substrate/frame/babe/src/tests.rs | 2 +-
substrate/frame/beefy/src/mock.rs | 2 +-
substrate/frame/beefy/src/tests.rs | 4 +-
.../test-staking-e2e/src/lib.rs | 2 +-
.../test-staking-e2e/src/mock.rs | 10 +-
substrate/frame/grandpa/src/mock.rs | 2 +-
substrate/frame/grandpa/src/tests.rs | 2 +-
.../test-delegate-stake/src/lib.rs | 18 +-
.../test-transfer-stake/src/lib.rs | 12 +-
substrate/frame/root-offences/src/lib.rs | 2 +-
substrate/frame/root-offences/src/mock.rs | 2 +-
substrate/frame/staking/src/benchmarking.rs | 2 +-
substrate/frame/staking/src/lib.rs | 4 +-
substrate/frame/staking/src/mock.rs | 18 +-
substrate/frame/staking/src/pallet/impls.rs | 53 +-
substrate/frame/staking/src/pallet/mod.rs | 177 ++++++-
substrate/frame/staking/src/testing_utils.rs | 2 +-
substrate/frame/staking/src/tests.rs | 480 +++++++++++++++---
21 files changed, 657 insertions(+), 165 deletions(-)
create mode 100644 prdoc/pr_6184.prdoc
diff --git a/polkadot/runtime/westend/src/lib.rs b/polkadot/runtime/westend/src/lib.rs
index 4c04af111f8..993010cbce6 100644
--- a/polkadot/runtime/westend/src/lib.rs
+++ b/polkadot/runtime/westend/src/lib.rs
@@ -543,7 +543,7 @@ impl Get<u32> for MaybeSignedPhase {
fn get() -> u32 {
// 1 day = 4 eras -> 1 week = 28 eras. We want to disable signed phase once a week to test
// the fallback unsigned phase is able to compute elections on Westend.
- if Staking::current_era().unwrap_or(1) % 28 == 0 {
+ if pallet_staking::CurrentEra::<Runtime>::get().unwrap_or(1) % 28 == 0 {
0
} else {
SignedPhase::get()
diff --git a/prdoc/pr_6184.prdoc b/prdoc/pr_6184.prdoc
new file mode 100644
index 00000000000..e05a5884e93
--- /dev/null
+++ b/prdoc/pr_6184.prdoc
@@ -0,0 +1,24 @@
+title: Remove pallet::getter from pallet-staking
+doc:
+ - audience: Runtime Dev
+ description: |
+ This PR removes all pallet::getter occurrences from pallet-staking and replaces them with explicit implementations.
+ It also adds tests to verify that retrieval of affected entities works as expected so via storage::getter.
+
+crates:
+ - name: pallet-babe
+ bump: patch
+ - name: pallet-beefy
+ bump: patch
+ - name: pallet-election-provider-multi-phase
+ bump: patch
+ - name: pallet-grandpa
+ bump: patch
+ - name: pallet-nomination-pools
+ bump: patch
+ - name: pallet-root-offences
+ bump: patch
+ - name: westend-runtime
+ bump: patch
+ - name: pallet-staking
+ bump: patch
\ No newline at end of file
diff --git a/substrate/frame/babe/src/mock.rs b/substrate/frame/babe/src/mock.rs
index c2e24c73a7b..23857470adc 100644
--- a/substrate/frame/babe/src/mock.rs
+++ b/substrate/frame/babe/src/mock.rs
@@ -239,7 +239,7 @@ pub fn start_session(session_index: SessionIndex) {
/// Progress to the first block at the given era
pub fn start_era(era_index: EraIndex) {
start_session((era_index * 3).into());
- assert_eq!(Staking::current_era(), Some(era_index));
+ assert_eq!(pallet_staking::CurrentEra::<Test>::get(), Some(era_index));
}
pub fn make_primary_pre_digest(
diff --git a/substrate/frame/babe/src/tests.rs b/substrate/frame/babe/src/tests.rs
index eca95816023..5210d9289bc 100644
--- a/substrate/frame/babe/src/tests.rs
+++ b/substrate/frame/babe/src/tests.rs
@@ -414,7 +414,7 @@ fn disabled_validators_cannot_author_blocks() {
// so we should still be able to author blocks
start_era(2);
- assert_eq!(Staking::current_era().unwrap(), 2);
+ assert_eq!(pallet_staking::CurrentEra::<Test>::get().unwrap(), 2);
// let's disable the validator at index 0
Session::disable_index(0);
diff --git a/substrate/frame/beefy/src/mock.rs b/substrate/frame/beefy/src/mock.rs
index 2b75c410741..7ae41c60918 100644
--- a/substrate/frame/beefy/src/mock.rs
+++ b/substrate/frame/beefy/src/mock.rs
@@ -366,5 +366,5 @@ pub fn start_session(session_index: SessionIndex) {
pub fn start_era(era_index: EraIndex) {
start_session((era_index * 3).into());
- assert_eq!(Staking::current_era(), Some(era_index));
+ assert_eq!(pallet_staking::CurrentEra::<Test>::get(), Some(era_index));
}
diff --git a/substrate/frame/beefy/src/tests.rs b/substrate/frame/beefy/src/tests.rs
index d75237205ca..89645d21f6b 100644
--- a/substrate/frame/beefy/src/tests.rs
+++ b/substrate/frame/beefy/src/tests.rs
@@ -313,7 +313,7 @@ fn report_equivocation_current_set_works(mut f: impl ReportEquivocationFn) {
let authorities = test_authorities();
ExtBuilder::default().add_authorities(authorities).build_and_execute(|| {
- assert_eq!(Staking::current_era(), Some(0));
+ assert_eq!(pallet_staking::CurrentEra::<Test>::get(), Some(0));
assert_eq!(Session::current_index(), 0);
start_era(1);
@@ -906,7 +906,7 @@ fn report_fork_voting_invalid_context() {
let mut era = 1;
let block_num = ext.execute_with(|| {
- assert_eq!(Staking::current_era(), Some(0));
+ assert_eq!(pallet_staking::CurrentEra::<Test>::get(), Some(0));
assert_eq!(Session::current_index(), 0);
start_era(era);
diff --git a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs
index 13514969438..41928905ed9 100644
--- a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs
+++ b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs
@@ -47,7 +47,7 @@ fn log_current_time() {
"block: {:?}, session: {:?}, era: {:?}, EPM phase: {:?} ts: {:?}",
System::block_number(),
Session::current_index(),
- Staking::current_era(),
+ pallet_staking::CurrentEra::<Runtime>::get(),
CurrentPhase::<Runtime>::get(),
Now::<Runtime>::get()
);
diff --git a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
index 360f14913fc..b182ddec77a 100644
--- a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
+++ b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
@@ -49,7 +49,7 @@ use pallet_election_provider_multi_phase::{
unsigned::MinerConfig, Call, CurrentPhase, ElectionCompute, GeometricDepositBase,
QueuedSolution, SolutionAccuracyOf,
};
-use pallet_staking::StakerStatus;
+use pallet_staking::{ActiveEra, CurrentEra, ErasStartSessionIndex, StakerStatus};
use parking_lot::RwLock;
use std::sync::Arc;
@@ -806,11 +806,11 @@ pub(crate) fn start_active_era(
}
pub(crate) fn active_era() -> EraIndex {
- Staking::active_era().unwrap().index
+ ActiveEra::<Runtime>::get().unwrap().index
}
pub(crate) fn current_era() -> EraIndex {
- Staking::current_era().unwrap()
+ CurrentEra::<Runtime>::get().unwrap()
}
// Fast forward until EPM signed phase.
@@ -862,11 +862,11 @@ pub(crate) fn on_offence_now(
>],
slash_fraction: &[Perbill],
) {
- let now = Staking::active_era().unwrap().index;
+ let now = ActiveEra::<Runtime>::get().unwrap().index;
let _ = Staking::on_offence(
offenders,
slash_fraction,
- Staking::eras_start_session_index(now).unwrap(),
+ ErasStartSessionIndex::<Runtime>::get(now).unwrap(),
);
}
diff --git a/substrate/frame/grandpa/src/mock.rs b/substrate/frame/grandpa/src/mock.rs
index cf4c29003a7..87369c23948 100644
--- a/substrate/frame/grandpa/src/mock.rs
+++ b/substrate/frame/grandpa/src/mock.rs
@@ -297,7 +297,7 @@ pub fn start_session(session_index: SessionIndex) {
pub fn start_era(era_index: EraIndex) {
start_session((era_index * 3).into());
- assert_eq!(Staking::current_era(), Some(era_index));
+ assert_eq!(pallet_staking::CurrentEra::<Test>::get(), Some(era_index));
}
pub fn initialize_block(number: u64, parent_hash: H256) {
diff --git a/substrate/frame/grandpa/src/tests.rs b/substrate/frame/grandpa/src/tests.rs
index e1e963ce564..383f77f00de 100644
--- a/substrate/frame/grandpa/src/tests.rs
+++ b/substrate/frame/grandpa/src/tests.rs
@@ -319,7 +319,7 @@ fn report_equivocation_current_set_works() {
let authorities = test_authorities();
new_test_ext_raw_authorities(authorities).execute_with(|| {
- assert_eq!(Staking::current_era(), Some(0));
+ assert_eq!(pallet_staking::CurrentEra::<Test>::get(), Some(0));
assert_eq!(Session::current_index(), 0);
start_era(1);
diff --git a/substrate/frame/nomination-pools/test-delegate-stake/src/lib.rs b/substrate/frame/nomination-pools/test-delegate-stake/src/lib.rs
index 7fee2a0bdb2..40025cdbb3c 100644
--- a/substrate/frame/nomination-pools/test-delegate-stake/src/lib.rs
+++ b/substrate/frame/nomination-pools/test-delegate-stake/src/lib.rs
@@ -41,7 +41,7 @@ use sp_staking::Agent;
fn pool_lifecycle_e2e() {
new_test_ext().execute_with(|| {
assert_eq!(Balances::minimum_balance(), 5);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
@@ -204,7 +204,7 @@ fn pool_lifecycle_e2e() {
fn pool_chill_e2e() {
new_test_ext().execute_with(|| {
assert_eq!(Balances::minimum_balance(), 5);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
@@ -330,7 +330,7 @@ fn pool_slash_e2e() {
new_test_ext().execute_with(|| {
ExistentialDeposit::set(1);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
@@ -540,7 +540,7 @@ fn pool_slash_proportional() {
ExistentialDeposit::set(1);
BondingDuration::set(28);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
@@ -758,7 +758,7 @@ fn pool_slash_non_proportional_only_bonded_pool() {
ExistentialDeposit::set(1);
BondingDuration::set(28);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
@@ -837,7 +837,7 @@ fn pool_slash_non_proportional_bonded_pool_and_chunks() {
ExistentialDeposit::set(1);
BondingDuration::set(28);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
@@ -914,7 +914,7 @@ fn pool_migration_e2e() {
new_test_ext().execute_with(|| {
LegacyAdapter::set(true);
assert_eq!(Balances::minimum_balance(), 5);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool with TransferStake strategy.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
@@ -1192,7 +1192,7 @@ fn disable_pool_operations_on_non_migrated() {
new_test_ext().execute_with(|| {
LegacyAdapter::set(true);
assert_eq!(Balances::minimum_balance(), 5);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool with TransferStake strategy.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
@@ -1369,7 +1369,7 @@ fn pool_no_dangling_delegation() {
new_test_ext().execute_with(|| {
ExistentialDeposit::set(1);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// pool creator
let alice = 10;
let bob = 20;
diff --git a/substrate/frame/nomination-pools/test-transfer-stake/src/lib.rs b/substrate/frame/nomination-pools/test-transfer-stake/src/lib.rs
index 28e978bba0e..cc39cfee91c 100644
--- a/substrate/frame/nomination-pools/test-transfer-stake/src/lib.rs
+++ b/substrate/frame/nomination-pools/test-transfer-stake/src/lib.rs
@@ -34,7 +34,7 @@ use sp_runtime::{bounded_btree_map, traits::Zero};
fn pool_lifecycle_e2e() {
new_test_ext().execute_with(|| {
assert_eq!(Balances::minimum_balance(), 5);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
@@ -286,7 +286,7 @@ fn destroy_pool_with_erroneous_consumer() {
fn pool_chill_e2e() {
new_test_ext().execute_with(|| {
assert_eq!(Balances::minimum_balance(), 5);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
@@ -412,7 +412,7 @@ fn pool_slash_e2e() {
new_test_ext().execute_with(|| {
ExistentialDeposit::set(1);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
@@ -622,7 +622,7 @@ fn pool_slash_proportional() {
ExistentialDeposit::set(1);
BondingDuration::set(28);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
@@ -759,7 +759,7 @@ fn pool_slash_non_proportional_only_bonded_pool() {
ExistentialDeposit::set(1);
BondingDuration::set(28);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
@@ -838,7 +838,7 @@ fn pool_slash_non_proportional_bonded_pool_and_chunks() {
ExistentialDeposit::set(1);
BondingDuration::set(28);
assert_eq!(Balances::minimum_balance(), 1);
- assert_eq!(Staking::current_era(), None);
+ assert_eq!(CurrentEra::<T>::get(), None);
// create the pool, we know this has id 1.
assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
diff --git a/substrate/frame/root-offences/src/lib.rs b/substrate/frame/root-offences/src/lib.rs
index 6531080b8d1..fd6ffc55e40 100644
--- a/substrate/frame/root-offences/src/lib.rs
+++ b/substrate/frame/root-offences/src/lib.rs
@@ -106,7 +106,7 @@ pub mod pallet {
fn get_offence_details(
offenders: Vec<(T::AccountId, Perbill)>,
) -> Result<Vec<OffenceDetails<T>>, DispatchError> {
- let now = Staking::<T>::active_era()
+ let now = pallet_staking::ActiveEra::<T>::get()
.map(|e| e.index)
.ok_or(Error::<T>::FailedToGetActiveEra)?;
diff --git a/substrate/frame/root-offences/src/mock.rs b/substrate/frame/root-offences/src/mock.rs
index af073d7672c..a27fb36f64a 100644
--- a/substrate/frame/root-offences/src/mock.rs
+++ b/substrate/frame/root-offences/src/mock.rs
@@ -296,5 +296,5 @@ pub(crate) fn run_to_block(n: BlockNumber) {
}
pub(crate) fn active_era() -> EraIndex {
- Staking::active_era().unwrap().index
+ pallet_staking::ActiveEra::<Test>::get().unwrap().index
}
diff --git a/substrate/frame/staking/src/benchmarking.rs b/substrate/frame/staking/src/benchmarking.rs
index 96bd3860542..d842186d502 100644
--- a/substrate/frame/staking/src/benchmarking.rs
+++ b/substrate/frame/staking/src/benchmarking.rs
@@ -708,7 +708,7 @@ mod benchmarks {
<ErasValidatorPrefs<T>>::insert(
current_era,
validator.clone(),
- <Staking<T>>::validators(&validator),
+ Validators::<T>::get(&validator),
);
let caller = whitelisted_caller();
diff --git a/substrate/frame/staking/src/lib.rs b/substrate/frame/staking/src/lib.rs
index 19d999109d8..a4a6e71af0d 100644
--- a/substrate/frame/staking/src/lib.rs
+++ b/substrate/frame/staking/src/lib.rs
@@ -996,7 +996,7 @@ impl<T: Config> Convert<T::AccountId, Option<Exposure<T::AccountId, BalanceOf<T>
for ExposureOf<T>
{
fn convert(validator: T::AccountId) -> Option<Exposure<T::AccountId, BalanceOf<T>>> {
- <Pallet<T>>::active_era()
+ ActiveEra::<T>::get()
.map(|active_era| <Pallet<T>>::eras_stakers(active_era.index, &validator))
}
}
@@ -1326,7 +1326,7 @@ impl<T: Config, const DISABLING_LIMIT_FACTOR: usize> DisablingStrategy<T>
log!(
debug,
"Won't disable: current_era {:?} > slash_era {:?}",
- Pallet::<T>::current_era().unwrap_or_default(),
+ CurrentEra::<T>::get().unwrap_or_default(),
slash_era
);
return None
diff --git a/substrate/frame/staking/src/mock.rs b/substrate/frame/staking/src/mock.rs
index 4a0209fc5b0..2d3446d2dab 100644
--- a/substrate/frame/staking/src/mock.rs
+++ b/substrate/frame/staking/src/mock.rs
@@ -568,11 +568,11 @@ impl ExtBuilder {
}
pub(crate) fn active_era() -> EraIndex {
- Staking::active_era().unwrap().index
+ pallet_staking::ActiveEra::<Test>::get().unwrap().index
}
pub(crate) fn current_era() -> EraIndex {
- Staking::current_era().unwrap()
+ pallet_staking::CurrentEra::<Test>::get().unwrap()
}
pub(crate) fn bond(who: AccountId, val: Balance) {
@@ -663,7 +663,7 @@ pub(crate) fn start_active_era(era_index: EraIndex) {
pub(crate) fn current_total_payout_for_duration(duration: u64) -> Balance {
let (payout, _rest) = <Test as Config>::EraPayout::era_payout(
- Staking::eras_total_stake(active_era()),
+ pallet_staking::ErasTotalStake::<Test>::get(active_era()),
pallet_balances::TotalIssuance::<Test>::get(),
duration,
);
@@ -673,7 +673,7 @@ pub(crate) fn current_total_payout_for_duration(duration: u64) -> Balance {
pub(crate) fn maximum_payout_for_duration(duration: u64) -> Balance {
let (payout, rest) = <Test as Config>::EraPayout::era_payout(
- Staking::eras_total_stake(active_era()),
+ pallet_staking::ErasTotalStake::<Test>::get(active_era()),
pallet_balances::TotalIssuance::<Test>::get(),
duration,
);
@@ -732,11 +732,11 @@ pub(crate) fn on_offence_in_era(
}
}
- if Staking::active_era().unwrap().index == era {
+ if pallet_staking::ActiveEra::<Test>::get().unwrap().index == era {
let _ = Staking::on_offence(
offenders,
slash_fraction,
- Staking::eras_start_session_index(era).unwrap(),
+ pallet_staking::ErasStartSessionIndex::<Test>::get(era).unwrap(),
);
} else {
panic!("cannot slash in era {}", era);
@@ -750,7 +750,7 @@ pub(crate) fn on_offence_now(
>],
slash_fraction: &[Perbill],
) {
- let now = Staking::active_era().unwrap().index;
+ let now = pallet_staking::ActiveEra::<Test>::get().unwrap().index;
on_offence_in_era(offenders, slash_fraction, now)
}
@@ -889,10 +889,10 @@ macro_rules! assert_session_era {
$session,
);
assert_eq!(
- Staking::current_era().unwrap(),
+ CurrentEra::<T>::get().unwrap(),
$era,
"wrong current era {} != {}",
- Staking::current_era().unwrap(),
+ CurrentEra::<T>::get().unwrap(),
$era,
);
};
diff --git a/substrate/frame/staking/src/pallet/impls.rs b/substrate/frame/staking/src/pallet/impls.rs
index d3423d82769..972d0f3d47b 100644
--- a/substrate/frame/staking/src/pallet/impls.rs
+++ b/substrate/frame/staking/src/pallet/impls.rs
@@ -193,7 +193,7 @@ impl<T: Config> Pallet<T> {
) -> Result<Weight, DispatchError> {
let mut ledger = Self::ledger(Controller(controller.clone()))?;
let (stash, old_total) = (ledger.stash.clone(), ledger.total);
- if let Some(current_era) = Self::current_era() {
+ if let Some(current_era) = CurrentEra::<T>::get() {
ledger = ledger.consolidate_unlocked(current_era)
}
let new_total = ledger.total;
@@ -450,9 +450,9 @@ impl<T: Config> Pallet<T> {
session_index: SessionIndex,
is_genesis: bool,
) -> Option<BoundedVec<T::AccountId, MaxWinnersOf<T>>> {
- if let Some(current_era) = Self::current_era() {
+ if let Some(current_era) = CurrentEra::<T>::get() {
// Initial era has been set.
- let current_era_start_session_index = Self::eras_start_session_index(current_era)
+ let current_era_start_session_index = ErasStartSessionIndex::<T>::get(current_era)
.unwrap_or_else(|| {
frame_support::print("Error: start_session_index must be set for current_era");
0
@@ -492,12 +492,12 @@ impl<T: Config> Pallet<T> {
/// Start a session potentially starting an era.
fn start_session(start_session: SessionIndex) {
- let next_active_era = Self::active_era().map(|e| e.index + 1).unwrap_or(0);
+ let next_active_era = ActiveEra::<T>::get().map(|e| e.index + 1).unwrap_or(0);
// This is only `Some` when current era has already progressed to the next era, while the
// active era is one behind (i.e. in the *last session of the active era*, or *first session
// of the new current era*, depending on how you look at it).
if let Some(next_active_era_start_session_index) =
- Self::eras_start_session_index(next_active_era)
+ ErasStartSessionIndex::<T>::get(next_active_era)
{
if next_active_era_start_session_index == start_session {
Self::start_era(start_session);
@@ -517,9 +517,9 @@ impl<T: Config> Pallet<T> {
/// End a session potentially ending an era.
fn end_session(session_index: SessionIndex) {
- if let Some(active_era) = Self::active_era() {
+ if let Some(active_era) = ActiveEra::<T>::get() {
if let Some(next_active_era_start_session_index) =
- Self::eras_start_session_index(active_era.index + 1)
+ ErasStartSessionIndex::<T>::get(active_era.index + 1)
{
if next_active_era_start_session_index == session_index + 1 {
Self::end_era(active_era, session_index);
@@ -577,7 +577,7 @@ impl<T: Config> Pallet<T> {
let era_duration = (now_as_millis_u64.defensive_saturating_sub(active_era_start))
.saturated_into::<u64>();
- let staked = Self::eras_total_stake(&active_era.index);
+ let staked = ErasTotalStake::<T>::get(&active_era.index);
let issuance = asset::total_issuance::<T>();
let (validator_payout, remainder) =
@@ -668,7 +668,7 @@ impl<T: Config> Pallet<T> {
};
let exposures = Self::collect_exposures(election_result);
- if (exposures.len() as u32) < Self::minimum_validator_count().max(1) {
+ if (exposures.len() as u32) < MinimumValidatorCount::<T>::get().max(1) {
// Session will panic if we ever return an empty validator set, thus max(1) ^^.
match CurrentEra::<T>::get() {
Some(current_era) if current_era > 0 => log!(
@@ -677,7 +677,7 @@ impl<T: Config> Pallet<T> {
elected, minimum is {})",
CurrentEra::<T>::get().unwrap_or(0),
exposures.len(),
- Self::minimum_validator_count(),
+ MinimumValidatorCount::<T>::get(),
),
None => {
// The initial era is allowed to have no exposures.
@@ -729,7 +729,7 @@ impl<T: Config> Pallet<T> {
// Collect the pref of all winners.
for stash in &elected_stashes {
- let pref = Self::validators(stash);
+ let pref = Validators::<T>::get(stash);
<ErasValidatorPrefs<T>>::insert(&new_planned_era, stash, pref);
}
@@ -854,7 +854,7 @@ impl<T: Config> Pallet<T> {
///
/// COMPLEXITY: Complexity is `number_of_validator_to_reward x current_elected_len`.
pub fn reward_by_ids(validators_points: impl IntoIterator<Item = (T::AccountId, u32)>) {
- if let Some(active_era) = Self::active_era() {
+ if let Some(active_era) = ActiveEra::<T>::get() {
<ErasRewardPoints<T>>::mutate(active_era.index, |era_rewards| {
for (validator, points) in validators_points.into_iter() {
*era_rewards.individual.entry(validator).or_default() += points;
@@ -1196,7 +1196,7 @@ impl<T: Config> ElectionDataProvider for Pallet<T> {
fn desired_targets() -> data_provider::Result<u32> {
Self::register_weight(T::DbWeight::get().reads(1));
- Ok(Self::validator_count())
+ Ok(ValidatorCount::<T>::get())
}
fn electing_voters(bounds: DataProviderBounds) -> data_provider::Result<Vec<VoterOf<Self>>> {
@@ -1229,10 +1229,10 @@ impl<T: Config> ElectionDataProvider for Pallet<T> {
}
fn next_election_prediction(now: BlockNumberFor<T>) -> BlockNumberFor<T> {
- let current_era = Self::current_era().unwrap_or(0);
- let current_session = Self::current_planned_session();
+ let current_era = CurrentEra::<T>::get().unwrap_or(0);
+ let current_session = CurrentPlannedSession::<T>::get();
let current_era_start_session_index =
- Self::eras_start_session_index(current_era).unwrap_or(0);
+ ErasStartSessionIndex::<T>::get(current_era).unwrap_or(0);
// Number of session in the current era or the maximum session per era if reached.
let era_progress = current_session
.saturating_sub(current_era_start_session_index)
@@ -1366,7 +1366,7 @@ impl<T: Config> historical::SessionManager<T::AccountId, Exposure<T::AccountId,
new_index: SessionIndex,
) -> Option<Vec<(T::AccountId, Exposure<T::AccountId, BalanceOf<T>>)>> {
<Self as pallet_session::SessionManager<_>>::new_session(new_index).map(|validators| {
- let current_era = Self::current_era()
+ let current_era = CurrentEra::<T>::get()
// Must be some as a new era has been created.
.unwrap_or(0);
@@ -1384,7 +1384,7 @@ impl<T: Config> historical::SessionManager<T::AccountId, Exposure<T::AccountId,
) -> Option<Vec<(T::AccountId, Exposure<T::AccountId, BalanceOf<T>>)>> {
<Self as pallet_session::SessionManager<_>>::new_session_genesis(new_index).map(
|validators| {
- let current_era = Self::current_era()
+ let current_era = CurrentEra::<T>::get()
// Must be some as a new era has been created.
.unwrap_or(0);
@@ -1449,7 +1449,7 @@ where
};
let active_era = {
- let active_era = Self::active_era();
+ let active_era = ActiveEra::<T>::get();
add_db_reads_writes(1, 0);
if active_era.is_none() {
// This offence need not be re-submitted.
@@ -1457,7 +1457,7 @@ where
}
active_era.expect("value checked not to be `None`; qed").index
};
- let active_era_start_session_index = Self::eras_start_session_index(active_era)
+ let active_era_start_session_index = ErasStartSessionIndex::<T>::get(active_era)
.unwrap_or_else(|| {
frame_support::print("Error: start_session_index must be set for current_era");
0
@@ -1486,7 +1486,7 @@ where
let slash_defer_duration = T::SlashDeferDuration::get();
- let invulnerables = Self::invulnerables();
+ let invulnerables = Invulnerables::<T>::get();
add_db_reads_writes(1, 0);
for (details, slash_fraction) in offenders.iter().zip(slash_fraction) {
@@ -1761,7 +1761,7 @@ impl<T: Config> StakingInterface for Pallet<T> {
}
fn current_era() -> EraIndex {
- Self::current_era().unwrap_or(Zero::zero())
+ CurrentEra::<T>::get().unwrap_or(Zero::zero())
}
fn stake(who: &Self::AccountId) -> Result<Stake<BalanceOf<T>>, DispatchError> {
@@ -1842,7 +1842,8 @@ impl<T: Config> StakingInterface for Pallet<T> {
}
fn force_unstake(who: Self::AccountId) -> sp_runtime::DispatchResult {
- let num_slashing_spans = Self::slashing_spans(&who).map_or(0, |s| s.iter().count() as u32);
+ let num_slashing_spans =
+ SlashingSpans::<T>::get(&who).map_or(0, |s| s.iter().count() as u32);
Self::force_unstake(RawOrigin::Root.into(), who.clone(), num_slashing_spans)
}
@@ -2142,7 +2143,7 @@ impl<T: Config> Pallet<T> {
/// * For each era exposed validator, check if the exposure total is sane (exposure.total =
/// exposure.own + exposure.own).
fn check_exposures() -> Result<(), TryRuntimeError> {
- let era = Self::active_era().unwrap().index;
+ let era = ActiveEra::<T>::get().unwrap().index;
ErasStakers::<T>::iter_prefix_values(era)
.map(|expo| {
ensure!(
@@ -2170,7 +2171,7 @@ impl<T: Config> Pallet<T> {
// Sanity check for the paged exposure of the active era.
let mut exposures: BTreeMap<T::AccountId, PagedExposureMetadata<BalanceOf<T>>> =
BTreeMap::new();
- let era = Self::active_era().unwrap().index;
+ let era = ActiveEra::<T>::get().unwrap().index;
let accumulator_default = PagedExposureMetadata {
total: Zero::zero(),
own: Zero::zero(),
@@ -2232,7 +2233,7 @@ impl<T: Config> Pallet<T> {
fn check_nominators() -> Result<(), TryRuntimeError> {
// a check per nominator to ensure their entire stake is correctly distributed. Will only
// kick-in if the nomination was submitted before the current era.
- let era = Self::active_era().unwrap().index;
+ let era = ActiveEra::<T>::get().unwrap().index;
// cache era exposures to avoid too many db reads.
let era_exposures = T::SessionInterface::validators()
diff --git a/substrate/frame/staking/src/pallet/mod.rs b/substrate/frame/staking/src/pallet/mod.rs
index 5210bef853b..d33b863a521 100644
--- a/substrate/frame/staking/src/pallet/mod.rs
+++ b/substrate/frame/staking/src/pallet/mod.rs
@@ -351,19 +351,16 @@ pub mod pallet {
/// The ideal number of active validators.
#[pallet::storage]
- #[pallet::getter(fn validator_count)]
pub type ValidatorCount<T> = StorageValue<_, u32, ValueQuery>;
/// Minimum number of staking participants before emergency conditions are imposed.
#[pallet::storage]
- #[pallet::getter(fn minimum_validator_count)]
pub type MinimumValidatorCount<T> = StorageValue<_, u32, ValueQuery>;
/// Any validators that may never be slashed or forcibly kicked. It's a Vec since they're
/// easy to initialize and the performance hit is minimal (we expect no more than four
/// invulnerables) and restricted to testnets.
#[pallet::storage]
- #[pallet::getter(fn invulnerables)]
#[pallet::unbounded]
pub type Invulnerables<T: Config> = StorageValue<_, Vec<T::AccountId>, ValueQuery>;
@@ -409,7 +406,6 @@ pub mod pallet {
///
/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
#[pallet::storage]
- #[pallet::getter(fn validators)]
pub type Validators<T: Config> =
CountedStorageMap<_, Twox64Concat, T::AccountId, ValidatorPrefs, ValueQuery>;
@@ -439,7 +435,6 @@ pub mod pallet {
///
/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
#[pallet::storage]
- #[pallet::getter(fn nominators)]
pub type Nominators<T: Config> =
CountedStorageMap<_, Twox64Concat, T::AccountId, Nominations<T>>;
@@ -463,7 +458,6 @@ pub mod pallet {
/// This is the latest planned era, depending on how the Session pallet queues the validator
/// set, it might be active or not.
#[pallet::storage]
- #[pallet::getter(fn current_era)]
pub type CurrentEra<T> = StorageValue<_, EraIndex>;
/// The active era information, it holds index and start.
@@ -471,7 +465,6 @@ pub mod pallet {
/// The active era is the era being currently rewarded. Validator set of this era must be
/// equal to [`SessionInterface::validators`].
#[pallet::storage]
- #[pallet::getter(fn active_era)]
pub type ActiveEra<T> = StorageValue<_, ActiveEraInfo>;
/// The session index at which the era start for the last [`Config::HistoryDepth`] eras.
@@ -479,7 +472,6 @@ pub mod pallet {
/// Note: This tracks the starting session (i.e. session index when era start being active)
/// for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.
#[pallet::storage]
- #[pallet::getter(fn eras_start_session_index)]
pub type ErasStartSessionIndex<T> = StorageMap<_, Twox64Concat, EraIndex, SessionIndex>;
/// Exposure of validator at era.
@@ -543,7 +535,6 @@ pub mod pallet {
/// Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.
#[pallet::storage]
#[pallet::unbounded]
- #[pallet::getter(fn eras_stakers_clipped)]
pub type ErasStakersClipped<T: Config> = StorageDoubleMap<
_,
Twox64Concat,
@@ -580,7 +571,6 @@ pub mod pallet {
///
/// It is removed after [`Config::HistoryDepth`] eras.
#[pallet::storage]
- #[pallet::getter(fn claimed_rewards)]
#[pallet::unbounded]
pub type ClaimedRewards<T: Config> = StorageDoubleMap<
_,
@@ -599,7 +589,6 @@ pub mod pallet {
/// Is it removed after [`Config::HistoryDepth`] eras.
// If prefs hasn't been set or has been removed then 0 commission is returned.
#[pallet::storage]
- #[pallet::getter(fn eras_validator_prefs)]
pub type ErasValidatorPrefs<T: Config> = StorageDoubleMap<
_,
Twox64Concat,
@@ -614,27 +603,23 @@ pub mod pallet {
///
/// Eras that haven't finished yet or has been removed doesn't have reward.
#[pallet::storage]
- #[pallet::getter(fn eras_validator_reward)]
pub type ErasValidatorReward<T: Config> = StorageMap<_, Twox64Concat, EraIndex, BalanceOf<T>>;
/// Rewards for the last [`Config::HistoryDepth`] eras.
/// If reward hasn't been set or has been removed then 0 reward is returned.
#[pallet::storage]
#[pallet::unbounded]
- #[pallet::getter(fn eras_reward_points)]
pub type ErasRewardPoints<T: Config> =
StorageMap<_, Twox64Concat, EraIndex, EraRewardPoints<T::AccountId>, ValueQuery>;
/// The total amount staked for the last [`Config::HistoryDepth`] eras.
/// If total hasn't been set or has been removed then 0 stake is returned.
#[pallet::storage]
- #[pallet::getter(fn eras_total_stake)]
pub type ErasTotalStake<T: Config> =
StorageMap<_, Twox64Concat, EraIndex, BalanceOf<T>, ValueQuery>;
/// Mode of era forcing.
#[pallet::storage]
- #[pallet::getter(fn force_era)]
pub type ForceEra<T> = StorageValue<_, Forcing, ValueQuery>;
/// Maximum staked rewards, i.e. the percentage of the era inflation that
@@ -647,13 +632,11 @@ pub mod pallet {
///
/// The rest of the slashed value is handled by the `Slash`.
#[pallet::storage]
- #[pallet::getter(fn slash_reward_fraction)]
pub type SlashRewardFraction<T> = StorageValue<_, Perbill, ValueQuery>;
/// The amount of currency given to reporters of a slash event which was
/// canceled by extraordinary circumstances (e.g. governance).
#[pallet::storage]
- #[pallet::getter(fn canceled_payout)]
pub type CanceledSlashPayout<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
/// All unapplied slashes that are queued for later.
@@ -695,7 +678,6 @@ pub mod pallet {
/// Slashing spans for stash accounts.
#[pallet::storage]
- #[pallet::getter(fn slashing_spans)]
#[pallet::unbounded]
pub type SlashingSpans<T: Config> =
StorageMap<_, Twox64Concat, T::AccountId, slashing::SlashingSpans>;
@@ -715,7 +697,6 @@ pub mod pallet {
///
/// This is basically in sync with the call to [`pallet_session::SessionManager::new_session`].
#[pallet::storage]
- #[pallet::getter(fn current_planned_session)]
pub type CurrentPlannedSession<T> = StorageValue<_, SessionIndex, ValueQuery>;
/// Indices of validators that have offended in the active era. The offenders are disabled for a
@@ -950,7 +931,7 @@ pub mod pallet {
fn on_finalize(_n: BlockNumberFor<T>) {
// Set the start of the first era.
- if let Some(mut active_era) = Self::active_era() {
+ if let Some(mut active_era) = ActiveEra::<T>::get() {
if active_era.start.is_none() {
let now_as_millis_u64 = T::UnixTime::now().as_millis().saturated_into::<u64>();
active_era.start = Some(now_as_millis_u64);
@@ -991,6 +972,156 @@ pub mod pallet {
}
}
+ impl<T: Config> Pallet<T> {
+ /// Get the ideal number of active validators.
+ pub fn validator_count() -> u32 {
+ ValidatorCount::<T>::get()
+ }
+
+ /// Get the minimum number of staking participants before emergency conditions are imposed.
+ pub fn minimum_validator_count() -> u32 {
+ MinimumValidatorCount::<T>::get()
+ }
+
+ /// Get the validators that may never be slashed or forcibly kicked out.
+ pub fn invulnerables() -> Vec<T::AccountId> {
+ Invulnerables::<T>::get()
+ }
+
+ /// Get the preferences of a given validator.
+ pub fn validators<EncodeLikeAccountId>(account_id: EncodeLikeAccountId) -> ValidatorPrefs
+ where
+ EncodeLikeAccountId: codec::EncodeLike<T::AccountId>,
+ {
+ Validators::<T>::get(account_id)
+ }
+
+ /// Get the nomination preferences of a given nominator.
+ pub fn nominators<EncodeLikeAccountId>(
+ account_id: EncodeLikeAccountId,
+ ) -> Option<Nominations<T>>
+ where
+ EncodeLikeAccountId: codec::EncodeLike<T::AccountId>,
+ {
+ Nominators::<T>::get(account_id)
+ }
+
+ /// Get the current era index.
+ pub fn current_era() -> Option<EraIndex> {
+ CurrentEra::<T>::get()
+ }
+
+ /// Get the active era information.
+ pub fn active_era() -> Option<ActiveEraInfo> {
+ ActiveEra::<T>::get()
+ }
+
+ /// Get the session index at which the era starts for the last [`Config::HistoryDepth`]
+ /// eras.
+ pub fn eras_start_session_index<EncodeLikeEraIndex>(
+ era_index: EncodeLikeEraIndex,
+ ) -> Option<SessionIndex>
+ where
+ EncodeLikeEraIndex: codec::EncodeLike<EraIndex>,
+ {
+ ErasStartSessionIndex::<T>::get(era_index)
+ }
+
+ /// Get the clipped exposure of a given validator at an era.
+ pub fn eras_stakers_clipped<EncodeLikeEraIndex, EncodeLikeAccountId>(
+ era_index: EncodeLikeEraIndex,
+ account_id: EncodeLikeAccountId,
+ ) -> Exposure<T::AccountId, BalanceOf<T>>
+ where
+ EncodeLikeEraIndex: codec::EncodeLike<EraIndex>,
+ EncodeLikeAccountId: codec::EncodeLike<T::AccountId>,
+ {
+ ErasStakersClipped::<T>::get(era_index, account_id)
+ }
+
+ /// Get the paged history of claimed rewards by era for given validator.
+ pub fn claimed_rewards<EncodeLikeEraIndex, EncodeLikeAccountId>(
+ era_index: EncodeLikeEraIndex,
+ account_id: EncodeLikeAccountId,
+ ) -> Vec<Page>
+ where
+ EncodeLikeEraIndex: codec::EncodeLike<EraIndex>,
+ EncodeLikeAccountId: codec::EncodeLike<T::AccountId>,
+ {
+ ClaimedRewards::<T>::get(era_index, account_id)
+ }
+
+ /// Get the preferences of given validator at given era.
+ pub fn eras_validator_prefs<EncodeLikeEraIndex, EncodeLikeAccountId>(
+ era_index: EncodeLikeEraIndex,
+ account_id: EncodeLikeAccountId,
+ ) -> ValidatorPrefs
+ where
+ EncodeLikeEraIndex: codec::EncodeLike<EraIndex>,
+ EncodeLikeAccountId: codec::EncodeLike<T::AccountId>,
+ {
+ ErasValidatorPrefs::<T>::get(era_index, account_id)
+ }
+
+ /// Get the total validator era payout for the last [`Config::HistoryDepth`] eras.
+ pub fn eras_validator_reward<EncodeLikeEraIndex>(
+ era_index: EncodeLikeEraIndex,
+ ) -> Option<BalanceOf<T>>
+ where
+ EncodeLikeEraIndex: codec::EncodeLike<EraIndex>,
+ {
+ ErasValidatorReward::<T>::get(era_index)
+ }
+
+ /// Get the rewards for the last [`Config::HistoryDepth`] eras.
+ pub fn eras_reward_points<EncodeLikeEraIndex>(
+ era_index: EncodeLikeEraIndex,
+ ) -> EraRewardPoints<T::AccountId>
+ where
+ EncodeLikeEraIndex: codec::EncodeLike<EraIndex>,
+ {
+ ErasRewardPoints::<T>::get(era_index)
+ }
+
+ /// Get the total amount staked for the last [`Config::HistoryDepth`] eras.
+ pub fn eras_total_stake<EncodeLikeEraIndex>(era_index: EncodeLikeEraIndex) -> BalanceOf<T>
+ where
+ EncodeLikeEraIndex: codec::EncodeLike<EraIndex>,
+ {
+ ErasTotalStake::<T>::get(era_index)
+ }
+
+ /// Get the mode of era forcing.
+ pub fn force_era() -> Forcing {
+ ForceEra::<T>::get()
+ }
+
+ /// Get the percentage of the slash that is distributed to reporters.
+ pub fn slash_reward_fraction() -> Perbill {
+ SlashRewardFraction::<T>::get()
+ }
+
+ /// Get the amount of canceled slash payout.
+ pub fn canceled_payout() -> BalanceOf<T> {
+ CanceledSlashPayout::<T>::get()
+ }
+
+ /// Get the slashing spans for given account.
+ pub fn slashing_spans<EncodeLikeAccountId>(
+ account_id: EncodeLikeAccountId,
+ ) -> Option<slashing::SlashingSpans>
+ where
+ EncodeLikeAccountId: codec::EncodeLike<T::AccountId>,
+ {
+ SlashingSpans::<T>::get(account_id)
+ }
+
+ /// Get the last planned session scheduled by the session pallet.
+ pub fn current_planned_session() -> SessionIndex {
+ CurrentPlannedSession::<T>::get()
+ }
+ }
+
#[pallet::call]
impl<T: Config> Pallet<T> {
/// Take the origin account as a stash and lock up `value` of its balance. `controller` will
@@ -1107,7 +1238,7 @@ pub mod pallet {
let maybe_withdraw_weight = {
if unlocking == T::MaxUnlockingChunks::get() as usize {
let real_num_slashing_spans =
- Self::slashing_spans(&controller).map_or(0, |s| s.iter().count());
+ SlashingSpans::<T>::get(&controller).map_or(0, |s| s.iter().count());
Some(Self::do_withdraw_unbonded(&controller, real_num_slashing_spans as u32)?)
} else {
None
@@ -1147,7 +1278,7 @@ pub mod pallet {
ensure!(ledger.active >= min_active_bond, Error::<T>::InsufficientBond);
// Note: in case there is no current era it is fine to bond one era more.
- let era = Self::current_era()
+ let era = CurrentEra::<T>::get()
.unwrap_or(0)
.defensive_saturating_add(T::BondingDuration::get());
if let Some(chunk) = ledger.unlocking.last_mut().filter(|chunk| chunk.era == era) {
@@ -1317,7 +1448,7 @@ pub mod pallet {
let nominations = Nominations {
targets,
// Initial nominations are considered submitted at era 0. See `Nominations` doc.
- submitted_in: Self::current_era().unwrap_or(0),
+ submitted_in: CurrentEra::<T>::get().unwrap_or(0),
suppressed: false,
};
diff --git a/substrate/frame/staking/src/testing_utils.rs b/substrate/frame/staking/src/testing_utils.rs
index efd4a40f1ab..81337710aa9 100644
--- a/substrate/frame/staking/src/testing_utils.rs
+++ b/substrate/frame/staking/src/testing_utils.rs
@@ -236,5 +236,5 @@ pub fn create_validators_with_nominators_for_era<T: Config>(
/// get the current era.
pub fn current_era<T: Config>() -> EraIndex {
- <Pallet<T>>::current_era().unwrap_or(0)
+ CurrentEra::<T>::get().unwrap_or(0)
}
diff --git a/substrate/frame/staking/src/tests.rs b/substrate/frame/staking/src/tests.rs
index d1dc6c3db65..ffa317618f1 100644
--- a/substrate/frame/staking/src/tests.rs
+++ b/substrate/frame/staking/src/tests.rs
@@ -200,7 +200,7 @@ fn basic_setup_works() {
legacy_claimed_rewards: bounded_vec![],
}
);
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
assert_eq!(
Staking::eras_stakers(active_era(), &11),
@@ -220,10 +220,10 @@ fn basic_setup_works() {
);
// initial total stake = 1125 + 1375
- assert_eq!(Staking::eras_total_stake(active_era()), 2500);
+ assert_eq!(ErasTotalStake::<Test>::get(active_era()), 2500);
// The number of validators required.
- assert_eq!(Staking::validator_count(), 2);
+ assert_eq!(ValidatorCount::<Test>::get(), 2);
// Initial Era and session
assert_eq!(active_era(), 0);
@@ -233,7 +233,7 @@ fn basic_setup_works() {
assert_eq!(asset::stakeable_balance::<Test>(&10), 1);
// New era is not being forced
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
});
}
@@ -336,7 +336,7 @@ fn rewards_should_work() {
assert_eq!(asset::total_balance::<Test>(&21), init_balance_21);
assert_eq!(asset::total_balance::<Test>(&101), init_balance_101);
assert_eq!(
- Staking::eras_reward_points(active_era()),
+ ErasRewardPoints::<Test>::get(active_era()),
EraRewardPoints {
total: 50 * 3,
individual: vec![(11, 100), (21, 50)].into_iter().collect(),
@@ -530,8 +530,8 @@ fn less_than_needed_candidates_works() {
.validator_count(4)
.nominate(false)
.build_and_execute(|| {
- assert_eq!(Staking::validator_count(), 4);
- assert_eq!(Staking::minimum_validator_count(), 1);
+ assert_eq!(ValidatorCount::<Test>::get(), 4);
+ assert_eq!(MinimumValidatorCount::<Test>::get(), 1);
assert_eq_uvec!(validator_controllers(), vec![31, 21, 11]);
mock::start_active_era(1);
@@ -1096,7 +1096,7 @@ fn reward_destination_works() {
);
// (era 0, page 0) is claimed
- assert_eq!(Staking::claimed_rewards(0, &11), vec![0]);
+ assert_eq!(ClaimedRewards::<Test>::get(0, &11), vec![0]);
// Change RewardDestination to Stash
<Payee<Test>>::insert(&11, RewardDestination::Stash);
@@ -1127,7 +1127,7 @@ fn reward_destination_works() {
);
// (era 1, page 0) is claimed
- assert_eq!(Staking::claimed_rewards(1, &11), vec![0]);
+ assert_eq!(ClaimedRewards::<Test>::get(1, &11), vec![0]);
// Change RewardDestination to Account
<Payee<Test>>::insert(&11, RewardDestination::Account(11));
@@ -1159,7 +1159,7 @@ fn reward_destination_works() {
);
// (era 2, page 0) is claimed
- assert_eq!(Staking::claimed_rewards(2, &11), vec![0]);
+ assert_eq!(ClaimedRewards::<Test>::get(2, &11), vec![0]);
});
}
@@ -1852,7 +1852,7 @@ fn reward_to_stake_works() {
.set_stake(21, 2000)
.try_state(false)
.build_and_execute(|| {
- assert_eq!(Staking::validator_count(), 2);
+ assert_eq!(ValidatorCount::<Test>::get(), 2);
// Confirm account 10 and 20 are validators
assert!(<Validators<Test>>::contains_key(&11) && <Validators<Test>>::contains_key(&21));
@@ -2281,7 +2281,7 @@ fn bond_with_duplicate_vote_should_be_ignored_by_election_provider_elected() {
#[test]
fn new_era_elects_correct_number_of_validators() {
ExtBuilder::default().nominate(true).validator_count(1).build_and_execute(|| {
- assert_eq!(Staking::validator_count(), 1);
+ assert_eq!(ValidatorCount::<Test>::get(), 1);
assert_eq!(validator_controllers().len(), 1);
Session::on_initialize(System::block_number());
@@ -2431,11 +2431,11 @@ fn era_is_always_same_length() {
let session_per_era = <SessionsPerEra as Get<SessionIndex>>::get();
mock::start_active_era(1);
- assert_eq!(Staking::eras_start_session_index(current_era()).unwrap(), session_per_era);
+ assert_eq!(ErasStartSessionIndex::<Test>::get(current_era()).unwrap(), session_per_era);
mock::start_active_era(2);
assert_eq!(
- Staking::eras_start_session_index(current_era()).unwrap(),
+ ErasStartSessionIndex::<Test>::get(current_era()).unwrap(),
session_per_era * 2u32
);
@@ -2444,11 +2444,11 @@ fn era_is_always_same_length() {
advance_session();
advance_session();
assert_eq!(current_era(), 3);
- assert_eq!(Staking::eras_start_session_index(current_era()).unwrap(), session + 2);
+ assert_eq!(ErasStartSessionIndex::<Test>::get(current_era()).unwrap(), session + 2);
mock::start_active_era(4);
assert_eq!(
- Staking::eras_start_session_index(current_era()).unwrap(),
+ ErasStartSessionIndex::<Test>::get(current_era()).unwrap(),
session + 2u32 + session_per_era
);
});
@@ -2465,7 +2465,7 @@ fn offence_doesnt_force_new_era() {
&[Perbill::from_percent(5)],
);
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
});
}
@@ -2473,7 +2473,7 @@ fn offence_doesnt_force_new_era() {
fn offence_ensures_new_era_without_clobbering() {
ExtBuilder::default().build_and_execute(|| {
assert_ok!(Staking::force_new_era_always(RuntimeOrigin::root()));
- assert_eq!(Staking::force_era(), Forcing::ForceAlways);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::ForceAlways);
on_offence_now(
&[OffenceDetails {
@@ -2483,7 +2483,7 @@ fn offence_ensures_new_era_without_clobbering() {
&[Perbill::from_percent(5)],
);
- assert_eq!(Staking::force_era(), Forcing::ForceAlways);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::ForceAlways);
});
}
@@ -2507,7 +2507,7 @@ fn offence_deselects_validator_even_when_slash_is_zero() {
&[Perbill::from_percent(0)],
);
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
assert!(is_disabled(11));
mock::start_active_era(1);
@@ -2557,14 +2557,14 @@ fn validator_is_not_disabled_for_an_offence_in_previous_era() {
&[Perbill::from_percent(0)],
);
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
assert!(is_disabled(11));
mock::start_active_era(2);
// the validator is not disabled in the new era
Staking::validate(RuntimeOrigin::signed(11), Default::default()).unwrap();
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
assert!(<Validators<Test>>::contains_key(11));
assert!(Session::validators().contains(&11));
@@ -2585,7 +2585,7 @@ fn validator_is_not_disabled_for_an_offence_in_previous_era() {
assert!(!is_disabled(11));
// and we are not forcing a new era
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
on_offence_in_era(
&[OffenceDetails {
@@ -2601,7 +2601,7 @@ fn validator_is_not_disabled_for_an_offence_in_previous_era() {
assert!(Validators::<Test>::iter().any(|(stash, _)| stash == 11));
assert!(!is_disabled(11));
// and we are still not forcing a new era
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
});
}
@@ -2733,7 +2733,7 @@ fn dont_slash_if_fraction_is_zero() {
// The validator hasn't been slashed. The new era is not forced.
assert_eq!(asset::stakeable_balance::<Test>(&11), 1000);
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
});
}
@@ -2754,7 +2754,7 @@ fn only_slash_for_max_in_era() {
// The validator has been slashed and has been force-chilled.
assert_eq!(asset::stakeable_balance::<Test>(&11), 500);
- assert_eq!(Staking::force_era(), Forcing::NotForcing);
+ assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
on_offence_now(
&[OffenceDetails {
@@ -3033,7 +3033,7 @@ fn deferred_slashes_are_deferred() {
);
// nominations are not removed regardless of the deferring.
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
assert_eq!(asset::stakeable_balance::<Test>(&11), 1000);
assert_eq!(asset::stakeable_balance::<Test>(&101), 2000);
@@ -3078,7 +3078,7 @@ fn retroactive_deferred_slashes_two_eras_before() {
mock::start_active_era(3);
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
System::reset_events();
on_offence_in_era(
@@ -3169,7 +3169,7 @@ fn staker_cannot_bail_deferred_slash() {
assert_ok!(Staking::chill(RuntimeOrigin::signed(101)));
assert_ok!(Staking::unbond(RuntimeOrigin::signed(101), 500));
- assert_eq!(Staking::current_era().unwrap(), 1);
+ assert_eq!(CurrentEra::<Test>::get().unwrap(), 1);
assert_eq!(active_era(), 1);
assert_eq!(
@@ -3191,14 +3191,14 @@ fn staker_cannot_bail_deferred_slash() {
mock::start_active_era(2);
assert_eq!(asset::stakeable_balance::<Test>(&11), 1000);
assert_eq!(asset::stakeable_balance::<Test>(&101), 2000);
- assert_eq!(Staking::current_era().unwrap(), 2);
+ assert_eq!(CurrentEra::<Test>::get().unwrap(), 2);
assert_eq!(active_era(), 2);
// no slash yet.
mock::start_active_era(3);
assert_eq!(asset::stakeable_balance::<Test>(&11), 1000);
assert_eq!(asset::stakeable_balance::<Test>(&101), 2000);
- assert_eq!(Staking::current_era().unwrap(), 3);
+ assert_eq!(CurrentEra::<Test>::get().unwrap(), 3);
assert_eq!(active_era(), 3);
// and cannot yet unbond:
@@ -3378,7 +3378,7 @@ fn slash_kicks_validators_not_nominators_and_disables_nominator_for_kicked_valid
assert_eq!(asset::stakeable_balance::<Test>(&101), 2000);
// 100 has approval for 11 as of now
- assert!(Staking::nominators(101).unwrap().targets.contains(&11));
+ assert!(Nominators::<Test>::get(101).unwrap().targets.contains(&11));
// 11 and 21 both have the support of 100
let exposure_11 = Staking::eras_stakers(active_era(), &11);
@@ -3443,8 +3443,8 @@ fn non_slashable_offence_disables_validator() {
mock::start_active_era(1);
assert_eq_uvec!(Session::validators(), vec![11, 21, 31, 41, 51, 201, 202]);
- let exposure_11 = Staking::eras_stakers(Staking::active_era().unwrap().index, &11);
- let exposure_21 = Staking::eras_stakers(Staking::active_era().unwrap().index, &21);
+ let exposure_11 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &11);
+ let exposure_21 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &21);
// offence with no slash associated
on_offence_now(
@@ -3453,7 +3453,7 @@ fn non_slashable_offence_disables_validator() {
);
// it does NOT affect the nominator.
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
// offence that slashes 25% of the bond
on_offence_now(
@@ -3462,7 +3462,7 @@ fn non_slashable_offence_disables_validator() {
);
// it DOES NOT affect the nominator.
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
assert_eq!(
staking_events_since_last_call(),
@@ -3501,10 +3501,10 @@ fn slashing_independent_of_disabling_validator() {
mock::start_active_era(1);
assert_eq_uvec!(Session::validators(), vec![11, 21, 31, 41, 51]);
- let exposure_11 = Staking::eras_stakers(Staking::active_era().unwrap().index, &11);
- let exposure_21 = Staking::eras_stakers(Staking::active_era().unwrap().index, &21);
+ let exposure_11 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &11);
+ let exposure_21 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &21);
- let now = Staking::active_era().unwrap().index;
+ let now = ActiveEra::<Test>::get().unwrap().index;
// offence with no slash associated
on_offence_in_era(
@@ -3514,7 +3514,7 @@ fn slashing_independent_of_disabling_validator() {
);
// nomination remains untouched.
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
// offence that slashes 25% of the bond
on_offence_in_era(
@@ -3524,7 +3524,7 @@ fn slashing_independent_of_disabling_validator() {
);
// nomination remains untouched.
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
assert_eq!(
staking_events_since_last_call(),
@@ -3572,9 +3572,9 @@ fn offence_threshold_doesnt_trigger_new_era() {
// we have 4 validators and an offending validator threshold of 1/3,
// even if the third validator commits an offence a new era should not be forced
- let exposure_11 = Staking::eras_stakers(Staking::active_era().unwrap().index, &11);
- let exposure_21 = Staking::eras_stakers(Staking::active_era().unwrap().index, &21);
- let exposure_31 = Staking::eras_stakers(Staking::active_era().unwrap().index, &31);
+ let exposure_11 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &11);
+ let exposure_21 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &21);
+ let exposure_31 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &31);
on_offence_now(
&[OffenceDetails { offender: (11, exposure_11.clone()), reporters: vec![] }],
@@ -3622,8 +3622,8 @@ fn disabled_validators_are_kept_disabled_for_whole_era() {
assert_eq_uvec!(Session::validators(), vec![11, 21, 31, 41, 51, 201, 202]);
assert_eq!(<Test as Config>::SessionsPerEra::get(), 3);
- let exposure_11 = Staking::eras_stakers(Staking::active_era().unwrap().index, &11);
- let exposure_21 = Staking::eras_stakers(Staking::active_era().unwrap().index, &21);
+ let exposure_11 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &11);
+ let exposure_21 = Staking::eras_stakers(ActiveEra::<Test>::get().unwrap().index, &21);
on_offence_now(
&[OffenceDetails { offender: (21, exposure_21.clone()), reporters: vec![] }],
@@ -3631,7 +3631,7 @@ fn disabled_validators_are_kept_disabled_for_whole_era() {
);
// nominations are not updated.
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
// validator 21 gets disabled since it got slashed
assert!(is_disabled(21));
@@ -3648,7 +3648,7 @@ fn disabled_validators_are_kept_disabled_for_whole_era() {
);
// nominations are not updated.
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
advance_session();
@@ -3713,7 +3713,7 @@ fn claim_reward_at_the_last_era_and_no_double_claim_and_invalid_claim() {
let active_era = active_era();
// This is the latest planned era in staking, not the active era
- let current_era = Staking::current_era().unwrap();
+ let current_era = CurrentEra::<Test>::get().unwrap();
// Last kept is 1:
assert!(current_era - HistoryDepth::get() == 1);
@@ -3777,7 +3777,7 @@ fn zero_slash_keeps_nominators() {
assert!(Validators::<Test>::iter().any(|(stash, _)| stash == 11));
assert!(is_disabled(11));
// and their nominations are kept.
- assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+ assert_eq!(Nominators::<Test>::get(101).unwrap().targets, vec![11, 21]);
});
}
@@ -3836,8 +3836,8 @@ fn six_session_delay() {
assert_eq!(active_era(), init_active_era + 2);
// That reward are correct
- assert_eq!(Staking::eras_reward_points(init_active_era).total, 1);
- assert_eq!(Staking::eras_reward_points(init_active_era + 1).total, 2);
+ assert_eq!(ErasRewardPoints::<Test>::get(init_active_era).total, 1);
+ assert_eq!(ErasRewardPoints::<Test>::get(init_active_era + 1).total, 2);
});
}
@@ -4082,7 +4082,7 @@ fn test_multi_page_payout_stakers_by_page() {
}
}
- assert_eq!(Staking::claimed_rewards(14, &11), vec![0, 1]);
+ assert_eq!(ClaimedRewards::<Test>::get(14, &11), vec![0, 1]);
let last_era = 99;
let history_depth = HistoryDepth::get();
@@ -4097,7 +4097,7 @@ fn test_multi_page_payout_stakers_by_page() {
// verify we clean up history as we go
for era in 0..15 {
- assert_eq!(Staking::claimed_rewards(era, &11), Vec::<sp_staking::Page>::new());
+ assert_eq!(ClaimedRewards::<Test>::get(era, &11), Vec::<sp_staking::Page>::new());
}
// verify only page 0 is marked as claimed
@@ -4107,7 +4107,7 @@ fn test_multi_page_payout_stakers_by_page() {
first_claimable_reward_era,
0
));
- assert_eq!(Staking::claimed_rewards(first_claimable_reward_era, &11), vec![0]);
+ assert_eq!(ClaimedRewards::<Test>::get(first_claimable_reward_era, &11), vec![0]);
// verify page 0 and 1 are marked as claimed
assert_ok!(Staking::payout_stakers_by_page(
@@ -4116,7 +4116,7 @@ fn test_multi_page_payout_stakers_by_page() {
first_claimable_reward_era,
1
));
- assert_eq!(Staking::claimed_rewards(first_claimable_reward_era, &11), vec![0, 1]);
+ assert_eq!(ClaimedRewards::<Test>::get(first_claimable_reward_era, &11), vec![0, 1]);
// verify only page 0 is marked as claimed
assert_ok!(Staking::payout_stakers_by_page(
@@ -4125,7 +4125,7 @@ fn test_multi_page_payout_stakers_by_page() {
last_reward_era,
0
));
- assert_eq!(Staking::claimed_rewards(last_reward_era, &11), vec![0]);
+ assert_eq!(ClaimedRewards::<Test>::get(last_reward_era, &11), vec![0]);
// verify page 0 and 1 are marked as claimed
assert_ok!(Staking::payout_stakers_by_page(
@@ -4134,15 +4134,15 @@ fn test_multi_page_payout_stakers_by_page() {
last_reward_era,
1
));
- assert_eq!(Staking::claimed_rewards(last_reward_era, &11), vec![0, 1]);
+ assert_eq!(ClaimedRewards::<Test>::get(last_reward_era, &11), vec![0, 1]);
// Out of order claims works.
assert_ok!(Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, 69, 0));
- assert_eq!(Staking::claimed_rewards(69, &11), vec![0]);
+ assert_eq!(ClaimedRewards::<Test>::get(69, &11), vec![0]);
assert_ok!(Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, 23, 1));
- assert_eq!(Staking::claimed_rewards(23, &11), vec![1]);
+ assert_eq!(ClaimedRewards::<Test>::get(23, &11), vec![1]);
assert_ok!(Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, 42, 0));
- assert_eq!(Staking::claimed_rewards(42, &11), vec![0]);
+ assert_eq!(ClaimedRewards::<Test>::get(42, &11), vec![0]);
});
}
@@ -4293,7 +4293,7 @@ fn test_multi_page_payout_stakers_backward_compatible() {
}
}
- assert_eq!(Staking::claimed_rewards(14, &11), vec![0, 1]);
+ assert_eq!(ClaimedRewards::<Test>::get(14, &11), vec![0, 1]);
let last_era = 99;
let history_depth = HistoryDepth::get();
@@ -4308,7 +4308,7 @@ fn test_multi_page_payout_stakers_backward_compatible() {
// verify we clean up history as we go
for era in 0..15 {
- assert_eq!(Staking::claimed_rewards(era, &11), Vec::<sp_staking::Page>::new());
+ assert_eq!(ClaimedRewards::<Test>::get(era, &11), Vec::<sp_staking::Page>::new());
}
// verify only page 0 is marked as claimed
@@ -4317,7 +4317,7 @@ fn test_multi_page_payout_stakers_backward_compatible() {
11,
first_claimable_reward_era
));
- assert_eq!(Staking::claimed_rewards(first_claimable_reward_era, &11), vec![0]);
+ assert_eq!(ClaimedRewards::<Test>::get(first_claimable_reward_era, &11), vec![0]);
// verify page 0 and 1 are marked as claimed
assert_ok!(Staking::payout_stakers(
@@ -4325,7 +4325,7 @@ fn test_multi_page_payout_stakers_backward_compatible() {
11,
first_claimable_reward_era,
));
- assert_eq!(Staking::claimed_rewards(first_claimable_reward_era, &11), vec![0, 1]);
+ assert_eq!(ClaimedRewards::<Test>::get(first_claimable_reward_era, &11), vec![0, 1]);
// change order and verify only page 1 is marked as claimed
assert_ok!(Staking::payout_stakers_by_page(
@@ -4334,12 +4334,12 @@ fn test_multi_page_payout_stakers_backward_compatible() {
last_reward_era,
1
));
- assert_eq!(Staking::claimed_rewards(last_reward_era, &11), vec![1]);
+ assert_eq!(ClaimedRewards::<Test>::get(last_reward_era, &11), vec![1]);
// verify page 0 is claimed even when explicit page is not passed
assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, last_reward_era,));
- assert_eq!(Staking::claimed_rewards(last_reward_era, &11), vec![1, 0]);
+ assert_eq!(ClaimedRewards::<Test>::get(last_reward_era, &11), vec![1, 0]);
// cannot claim any more pages
assert_noop!(
@@ -4363,10 +4363,10 @@ fn test_multi_page_payout_stakers_backward_compatible() {
// Out of order claims works.
assert_ok!(Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, test_era, 2));
- assert_eq!(Staking::claimed_rewards(test_era, &11), vec![2]);
+ assert_eq!(ClaimedRewards::<Test>::get(test_era, &11), vec![2]);
assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, test_era));
- assert_eq!(Staking::claimed_rewards(test_era, &11), vec![2, 0]);
+ assert_eq!(ClaimedRewards::<Test>::get(test_era, &11), vec![2, 0]);
// cannot claim page 2 again
assert_noop!(
@@ -4375,10 +4375,10 @@ fn test_multi_page_payout_stakers_backward_compatible() {
);
assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, test_era));
- assert_eq!(Staking::claimed_rewards(test_era, &11), vec![2, 0, 1]);
+ assert_eq!(ClaimedRewards::<Test>::get(test_era, &11), vec![2, 0, 1]);
assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, test_era));
- assert_eq!(Staking::claimed_rewards(test_era, &11), vec![2, 0, 1, 3]);
+ assert_eq!(ClaimedRewards::<Test>::get(test_era, &11), vec![2, 0, 1, 3]);
});
}
@@ -7009,7 +7009,8 @@ mod staking_interface {
Error::<Test>::IncorrectSlashingSpans
);
- let num_slashing_spans = Staking::slashing_spans(&11).map_or(0, |s| s.iter().count());
+ let num_slashing_spans =
+ SlashingSpans::<Test>::get(&11).map_or(0, |s| s.iter().count());
assert_ok!(Staking::withdraw_unbonded(
RuntimeOrigin::signed(11),
num_slashing_spans as u32
@@ -8337,3 +8338,338 @@ mod byzantine_threshold_disabling_strategy {
});
}
}
+
+mod getters {
+ use crate::{
+ mock::{self},
+ pallet::pallet::{Invulnerables, MinimumValidatorCount, ValidatorCount},
+ slashing,
+ tests::{Staking, Test},
+ ActiveEra, ActiveEraInfo, BalanceOf, CanceledSlashPayout, ClaimedRewards, CurrentEra,
+ CurrentPlannedSession, EraRewardPoints, ErasRewardPoints, ErasStakersClipped,
+ ErasStartSessionIndex, ErasTotalStake, ErasValidatorPrefs, ErasValidatorReward, ForceEra,
+ Forcing, Nominations, Nominators, Perbill, SlashRewardFraction, SlashingSpans,
+ ValidatorPrefs, Validators,
+ };
+ use sp_staking::{EraIndex, Exposure, IndividualExposure, Page, SessionIndex};
+
+ #[test]
+ fn get_validator_count_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let v: u32 = 12;
+ ValidatorCount::<Test>::put(v);
+
+ // when
+ let result = Staking::validator_count();
+
+ // then
+ assert_eq!(result, v);
+ });
+ }
+
+ #[test]
+ fn get_minimum_validator_count_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let v: u32 = 12;
+ MinimumValidatorCount::<Test>::put(v);
+
+ // when
+ let result = Staking::minimum_validator_count();
+
+ // then
+ assert_eq!(result, v);
+ });
+ }
+
+ #[test]
+ fn get_invulnerables_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let v: Vec<mock::AccountId> = vec![1, 2, 3];
+ Invulnerables::<Test>::put(v.clone());
+
+ // when
+ let result = Staking::invulnerables();
+
+ // then
+ assert_eq!(result, v);
+ });
+ }
+
+ #[test]
+ fn get_validators_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let account_id: mock::AccountId = 1;
+ let validator_prefs = ValidatorPrefs::default();
+
+ Validators::<Test>::insert(account_id, validator_prefs.clone());
+
+ // when
+ let result = Staking::validators(&account_id);
+
+ // then
+ assert_eq!(result, validator_prefs);
+ });
+ }
+
+ #[test]
+ fn get_nominators_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let account_id: mock::AccountId = 1;
+ let nominations: Nominations<Test> = Nominations {
+ targets: Default::default(),
+ submitted_in: Default::default(),
+ suppressed: false,
+ };
+
+ Nominators::<Test>::insert(account_id, nominations.clone());
+
+ // when
+ let result = Staking::nominators(account_id);
+
+ // then
+ assert_eq!(result, Some(nominations));
+ });
+ }
+
+ #[test]
+ fn get_current_era_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era: EraIndex = 12;
+ CurrentEra::<Test>::put(era);
+
+ // when
+ let result = Staking::current_era();
+
+ // then
+ assert_eq!(result, Some(era));
+ });
+ }
+
+ #[test]
+ fn get_active_era_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era = ActiveEraInfo { index: 2, start: None };
+ ActiveEra::<Test>::put(era);
+
+ // when
+ let result: Option<ActiveEraInfo> = Staking::active_era();
+
+ // then
+ if let Some(era_info) = result {
+ assert_eq!(era_info.index, 2);
+ assert_eq!(era_info.start, None);
+ } else {
+ panic!("Expected Some(era_info), got None");
+ };
+ });
+ }
+
+ #[test]
+ fn get_eras_start_session_index_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era: EraIndex = 12;
+ let session_index: SessionIndex = 14;
+ ErasStartSessionIndex::<Test>::insert(era, session_index);
+
+ // when
+ let result = Staking::eras_start_session_index(era);
+
+ // then
+ assert_eq!(result, Some(session_index));
+ });
+ }
+
+ #[test]
+ fn get_eras_stakers_clipped_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era: EraIndex = 12;
+ let account_id: mock::AccountId = 1;
+ let exposure: Exposure<mock::AccountId, BalanceOf<Test>> = Exposure {
+ total: 1125,
+ own: 1000,
+ others: vec![IndividualExposure { who: 101, value: 125 }],
+ };
+ ErasStakersClipped::<Test>::insert(era, account_id, exposure.clone());
+
+ // when
+ let result = Staking::eras_stakers_clipped(era, &account_id);
+
+ // then
+ assert_eq!(result, exposure);
+ });
+ }
+
+ #[test]
+ fn get_claimed_rewards_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era: EraIndex = 12;
+ let account_id: mock::AccountId = 1;
+ let rewards = Vec::<Page>::new();
+ ClaimedRewards::<Test>::insert(era, account_id, rewards.clone());
+
+ // when
+ let result = Staking::claimed_rewards(era, &account_id);
+
+ // then
+ assert_eq!(result, rewards);
+ });
+ }
+
+ #[test]
+ fn get_eras_validator_prefs_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era: EraIndex = 12;
+ let account_id: mock::AccountId = 1;
+ let validator_prefs = ValidatorPrefs::default();
+
+ ErasValidatorPrefs::<Test>::insert(era, account_id, validator_prefs.clone());
+
+ // when
+ let result = Staking::eras_validator_prefs(era, &account_id);
+
+ // then
+ assert_eq!(result, validator_prefs);
+ });
+ }
+
+ #[test]
+ fn get_eras_validator_reward_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era: EraIndex = 12;
+ let balance_of = BalanceOf::<Test>::default();
+
+ ErasValidatorReward::<Test>::insert(era, balance_of);
+
+ // when
+ let result = Staking::eras_validator_reward(era);
+
+ // then
+ assert_eq!(result, Some(balance_of));
+ });
+ }
+
+ #[test]
+ fn get_eras_reward_points_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era: EraIndex = 12;
+ let reward_points = EraRewardPoints::<mock::AccountId> {
+ total: 1,
+ individual: vec![(11, 1)].into_iter().collect(),
+ };
+ ErasRewardPoints::<Test>::insert(era, reward_points);
+
+ // when
+ let result = Staking::eras_reward_points(era);
+
+ // then
+ assert_eq!(result.total, 1);
+ });
+ }
+
+ #[test]
+ fn get_eras_total_stake_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let era: EraIndex = 12;
+ let balance_of = BalanceOf::<Test>::default();
+
+ ErasTotalStake::<Test>::insert(era, balance_of);
+
+ // when
+ let result = Staking::eras_total_stake(era);
+
+ // then
+ assert_eq!(result, balance_of);
+ });
+ }
+
+ #[test]
+ fn get_force_era_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let forcing = Forcing::NotForcing;
+ ForceEra::<Test>::put(forcing);
+
+ // when
+ let result = Staking::force_era();
+
+ // then
+ assert_eq!(result, forcing);
+ });
+ }
+
+ #[test]
+ fn get_slash_reward_fraction_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let perbill = Perbill::one();
+ SlashRewardFraction::<Test>::put(perbill);
+
+ // when
+ let result = Staking::slash_reward_fraction();
+
+ // then
+ assert_eq!(result, perbill);
+ });
+ }
+
+ #[test]
+ fn get_canceled_payout_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let balance_of = BalanceOf::<Test>::default();
+ CanceledSlashPayout::<Test>::put(balance_of);
+
+ // when
+ let result = Staking::canceled_payout();
+
+ // then
+ assert_eq!(result, balance_of);
+ });
+ }
+
+ #[test]
+ fn get_slashing_spans_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let account_id: mock::AccountId = 1;
+ let spans = slashing::SlashingSpans::new(2);
+ SlashingSpans::<Test>::insert(account_id, spans);
+
+ // when
+ let result: Option<slashing::SlashingSpans> = Staking::slashing_spans(&account_id);
+
+ // then
+ // simple check so as not to add extra macros to slashing::SlashingSpans struct
+ assert!(result.is_some());
+ });
+ }
+
+ #[test]
+ fn get_current_planned_session_returns_value_from_storage() {
+ sp_io::TestExternalities::default().execute_with(|| {
+ // given
+ let session_index = SessionIndex::default();
+ CurrentPlannedSession::<Test>::put(session_index);
+
+ // when
+ let result = Staking::current_planned_session();
+
+ // then
+ assert_eq!(result, session_index);
+ });
+ }
+}
--
GitLab