diff --git a/runtime/kusama/src/lib.rs b/runtime/kusama/src/lib.rs index 29d0633f26a9..8b484b4ab5d7 100644 --- a/runtime/kusama/src/lib.rs +++ b/runtime/kusama/src/lib.rs @@ -1777,10 +1777,13 @@ sp_api::impl_runtime_apis! { #[cfg(feature = "try-runtime")] impl frame_try_runtime::TryRuntime for Runtime { - fn on_runtime_upgrade() -> Result<(Weight, Weight), sp_runtime::RuntimeString> { + fn on_runtime_upgrade() -> (Weight, Weight) { log::info!("try-runtime::on_runtime_upgrade kusama."); - let weight = Executive::try_runtime_upgrade()?; - Ok((weight, BlockWeights::get().max_block)) + let weight = Executive::try_runtime_upgrade().unwrap(); + (weight, BlockWeights::get().max_block) + } + fn execute_block_no_check(block: Block) -> Weight { + Executive::execute_block_no_check(block) } } diff --git a/runtime/parachains/src/hrmp.rs b/runtime/parachains/src/hrmp.rs index 3596a5bc4cc4..fecee0fd0864 100644 --- a/runtime/parachains/src/hrmp.rs +++ b/runtime/parachains/src/hrmp.rs @@ -142,8 +142,9 @@ impl fmt::Debug for OutboundHrmpAcceptanceErr { "more HRMP messages than permitted by config ({} > {})", sent, permitted, ), - NotSorted { idx } => - write!(fmt, "the HRMP messages are not sorted (first unsorted is at index {})", idx,), + NotSorted { idx } => { + write!(fmt, "the HRMP messages are not sorted (first unsorted is at index {})", idx,) + }, NoSuchChannel { idx, channel_id } => write!( fmt, "the HRMP message at index {} is sent to a non existent channel {:?}->{:?}", diff --git a/runtime/polkadot/src/lib.rs b/runtime/polkadot/src/lib.rs index 1d7c62ebf267..1b89d3b1c6df 100644 --- a/runtime/polkadot/src/lib.rs +++ b/runtime/polkadot/src/lib.rs @@ -1407,10 +1407,14 @@ sp_api::impl_runtime_apis! { #[cfg(feature = "try-runtime")] impl frame_try_runtime::TryRuntime for Runtime { - fn on_runtime_upgrade() -> Result<(Weight, Weight), sp_runtime::RuntimeString> { + fn on_runtime_upgrade() -> (Weight, Weight) { log::info!("try-runtime::on_runtime_upgrade polkadot."); - let weight = Executive::try_runtime_upgrade()?; - Ok((weight, BlockWeights::get().max_block)) + let weight = Executive::try_runtime_upgrade().unwrap(); + (weight, BlockWeights::get().max_block) + } + + fn execute_block_no_check(block: Block) -> Weight { + Executive::execute_block_no_check(block) } } diff --git a/runtime/westend/src/lib.rs b/runtime/westend/src/lib.rs index 84e5ec68febd..5e074d6f6e66 100644 --- a/runtime/westend/src/lib.rs +++ b/runtime/westend/src/lib.rs @@ -1361,10 +1361,13 @@ sp_api::impl_runtime_apis! { #[cfg(feature = "try-runtime")] impl frame_try_runtime::TryRuntime for Runtime { - fn on_runtime_upgrade() -> Result<(Weight, Weight), sp_runtime::RuntimeString> { + fn on_runtime_upgrade() -> (Weight, Weight) { log::info!("try-runtime::on_runtime_upgrade westend."); - let weight = Executive::try_runtime_upgrade()?; - Ok((weight, BlockWeights::get().max_block)) + let weight = Executive::try_runtime_upgrade().unwrap(); + (weight, BlockWeights::get().max_block) + } + fn execute_block_no_check(block: Block) -> Weight { + Executive::execute_block_no_check(block) } } diff --git a/utils/remote-ext-tests/bags-list/src/voter_bags.rs b/utils/remote-ext-tests/bags-list/src/voter_bags.rs new file mode 100644 index 000000000000..4b7d7d6ec88d --- /dev/null +++ b/utils/remote-ext-tests/bags-list/src/voter_bags.rs @@ -0,0 +1,148 @@ +// Copyright 2021 Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Generic remote tests for the voter bags module. + +use frame_election_provider_support::SortedListProvider; +use frame_support::traits::Get; +use pallet_election_provider_multi_phase as EPM; +use pallet_staking::{BalanceOf, MinNominatorBond, Nominators}; +use remote_externalities::{Builder, Mode, OnlineConfig}; +use sp_runtime::traits::Block as BlockT; +use sp_std::convert::TryInto; +use sp_storage::well_known_keys; + +const LOG_TARGET: &'static str = "remote-ext-tests::bags-list"; + +/// Test voter bags migration. `currency_unit` is the number of planks per the +/// the runtimes `UNITS` (i.e. number of decimal places per DOT, KSM etc) +pub(crate) async fn test_voter_bags_migration< + Runtime: pallet_staking::Config + pallet_bags_list::Config + EPM::Config, + Block: BlockT, +>( + currency_unit: u64, + ws_url: String, +) { + sp_tracing::try_init_simple(); + + let mut ext = Builder::::new() + .mode(Mode::Online(OnlineConfig { + transport: ws_url.to_string().into(), + pallets: vec!["Staking".to_string()], + at: None, + state_snapshot: None, + })) + .inject_hashed_key(well_known_keys::CODE) + .build() + .await + .unwrap(); + + ext.execute_with(|| { + // set the ss58 prefix so addresses printed below are human friendly. + sp_core::crypto::set_default_ss58_version(Runtime::SS58Prefix::get().try_into().unwrap()); + + // get the nominator & validator count prior to migrating; these should be invariant. + let pre_migrate_nominator_count = >::iter().count() as u32; + log::info!(target: LOG_TARGET, "Nominator count: {}", pre_migrate_nominator_count); + + // run the actual migration, + let moved = ::SortedListProvider::regenerate( + pallet_staking::Nominators::::iter().map(|(n, _)| n), + pallet_staking::Pallet::::weight_of_fn(), + ); + log::info!(target: LOG_TARGET, "Moved {} nominators", moved); + + let voter_list_len = + ::SortedListProvider::iter().count() as u32; + let voter_list_count = ::SortedListProvider::count(); + // and confirm it is equal to the length of the `VoterList`. + assert_eq!(pre_migrate_nominator_count, voter_list_len); + assert_eq!(pre_migrate_nominator_count, voter_list_count); + + let min_nominator_bond = >::get(); + log::info!(target: LOG_TARGET, "min nominator bond is {:?}", min_nominator_bond); + + // go through every bag to track the total number of voters within bags + // and log some info about how voters are distributed within the bags. + let mut seen_in_bags = 0; + for vote_weight_thresh in ::BagThresholds::get() { + // threshold in terms of UNITS (e.g. KSM, DOT etc) + let vote_weight_thresh_as_unit = *vote_weight_thresh as f64 / currency_unit as f64; + let pretty_thresh = format!("Threshold: {}.", vote_weight_thresh_as_unit); + + let bag = match pallet_bags_list::Pallet::::list_bags_get(*vote_weight_thresh) + { + Some(bag) => bag, + None => { + log::info!(target: LOG_TARGET, "{} NO VOTERS.", pretty_thresh); + continue + }, + }; + + let voters_in_bag = bag.std_iter().count() as u32; + + // if this bag is below the min nominator bond print out all the members + let vote_weight_as_balance: BalanceOf = + (*vote_weight_thresh).try_into().map_err(|_| "should not fail").unwrap(); + if vote_weight_as_balance <= min_nominator_bond { + for id in bag.std_iter().map(|node| node.std_id().clone()) { + log::trace!( + target: LOG_TARGET, + "{} Account found below min bond: {:?}.", + pretty_thresh, + id + ); + } + } + + // update our overall counter + seen_in_bags += voters_in_bag; + + // percentage of all nominators + let percent_of_voters = percent(voters_in_bag, voter_list_count); + + log::info!( + target: LOG_TARGET, + "{} Nominators: {} [%{:.3}]", + pretty_thresh, + voters_in_bag, + percent_of_voters, + ); + } + + if seen_in_bags != voter_list_count { + log::error!( + target: LOG_TARGET, + "bags list population ({}) not on par whoever is voter_list ({})", + seen_in_bags, + voter_list_count, + ) + } + + // now let's test the process of a snapshot being created.. + EPM::Pallet::::create_snapshot().unwrap(); + + log::info!( + target: LOG_TARGET, + "a snapshot has been created using the new runtime and data, with metadata {:?}", + EPM::Pallet::::snapshot_metadata(), + ); + }); +} + +fn percent(portion: u32, total: u32) -> f64 { + (portion as f64 / total as f64) * 100f64 +} diff --git a/utils/staking-miner/src/main.rs b/utils/staking-miner/src/main.rs index 2aabe722150d..54394b037544 100644 --- a/utils/staking-miner/src/main.rs +++ b/utils/staking-miner/src/main.rs @@ -307,15 +307,15 @@ async fn create_election_ext( use frame_support::{storage::generator::StorageMap, traits::PalletInfo}; use sp_core::hashing::twox_128; - let mut modules = vec![::PalletInfo::name::>() + let mut pallets = vec![::PalletInfo::name::>() .expect("Pallet always has name; qed.") .to_string()]; - modules.extend(additional); + pallets.extend(additional); Builder::::new() .mode(Mode::Online(OnlineConfig { transport: uri.into(), at, - modules, + pallets, ..Default::default() })) .inject_hashed_prefix(&>::prefix_hash())