`5c283c1e8412`

8 files changed

modifiedpallets/collator-selection/Cargo.tomldiff before after both

55	"frame-system/std",55	"frame-system/std",
56	"log/std",56	"log/std",
57	"pallet-authorship/std",57	"pallet-authorship/std",
58	'pallet-aura/std',
59	'pallet-balances/std',
58	"pallet-session/std",60	"pallet-session/std",
59	"rand/std",61	"rand/std",
60	"scale-info/std",62	"scale-info/std",
63	"sp-consensus-aura/std",
61	"sp-runtime/std",64	"sp-runtime/std",
62	"sp-staking/std",65	"sp-staking/std",
63	"sp-std/std",66	"sp-std/std",

modifiedpallets/collator-selection/src/mock.rsdiff before after both

102parameter_types! {102parameter_types! {
103	pub const ExistentialDeposit: u64 = 5;103	pub const ExistentialDeposit: u64 = 5;
104	pub const MaxReserves: u32 = 50;104	pub const MaxReserves: u32 = 50;
105	pub const MaxHolds: u32 = 2;
106	pub const MaxFreezes: u32 = 2;
105}107}
106108
107impl pallet_balances::Config for Test {109impl pallet_balances::Config for Test {
114	type MaxLocks = ();116	type MaxLocks = ();
115	type MaxReserves = MaxReserves;117	type MaxReserves = MaxReserves;
116	type ReserveIdentifier = [u8; 8];118	type ReserveIdentifier = [u8; 8];
119	type HoldIdentifier = [u8; 16];
120	type FreezeIdentifier = [u8; 16];
121	type MaxHolds = MaxHolds;
122	type MaxFreezes = MaxFreezes;
117}123}
118124
119pub struct Author4;125pub struct Author4;
209	pub const MaxXcmAllowedLocations: u32 = 16;215	pub const MaxXcmAllowedLocations: u32 = 16;
210	pub AppPromotionDailyRate: Perbill = Perbill::from_rational(5u32, 10_000);216	pub AppPromotionDailyRate: Perbill = Perbill::from_rational(5u32, 10_000);
211	pub const DayRelayBlocks: u32 = 1;217	pub const DayRelayBlocks: u32 = 1;
218	pub const LicenceBondIdentifier: [u8; 16] = *b"licenceidentifie";
212}219}
213220
214impl pallet_configuration::Config for Test {221impl pallet_configuration::Config for Test {
257	type ValidatorId = <Self as frame_system::Config>::AccountId;264	type ValidatorId = <Self as frame_system::Config>::AccountId;
258	type ValidatorIdOf = IdentityCollator;265	type ValidatorIdOf = IdentityCollator;
259	type ValidatorRegistration = IsRegistered;266	type ValidatorRegistration = IsRegistered;
267	type LicenceBondIdentifier = LicenceBondIdentifier;
260	type WeightInfo = ();268	type WeightInfo = ();
261}269}
262270
267		.unwrap();275		.unwrap();
268	let invulnerables = vec![1, 2];276	let invulnerables = vec![1, 2];
277
278	let ed = <Test as pallet_balances::Config>::ExistentialDeposit::get();
269279
270	let balances = vec![(1, 100), (2, 100), (3, 100), (4, 100), (5, 100)];280	let balances = vec![(1, 100), (2, 100), (3, 100), (4, 100), (5, 100), (33, ed)];
271	let keys = balances281	let keys = balances
272		.iter()282		.iter()
273		.map(|&(i, _)| {283		.map(|&(i, _)| {

modifiedpallets/collator-selection/src/tests.rsdiff before after both

34use crate::{mock::*, Error};34use crate::{mock::*, Error};
35use frame_support::{35use frame_support::{
36	assert_noop, assert_ok,36	assert_noop, assert_ok,
37	traits::{Currency, GenesisBuild, OnInitialize},37	traits::{fungible, GenesisBuild, OnInitialize},
38};38};
39use frame_system::RawOrigin;39use frame_system::RawOrigin;
40use pallet_balances::Error as BalancesError;
41use sp_runtime::traits::BadOrigin;40use sp_runtime::{traits::BadOrigin, TokenError};
42use pallet_configuration::{41use pallet_configuration::{
43	CollatorSelectionDesiredCollatorsOverride as DesiredCollators,42	CollatorSelectionDesiredCollatorsOverride as DesiredCollators,
44	CollatorSelectionKickThresholdOverride as KickThreshold,43	CollatorSelectionKickThresholdOverride as KickThreshold,
45	CollatorSelectionLicenseBondOverride as LicenseBond,44	CollatorSelectionLicenseBondOverride as LicenseBond,
46};45};
46use scale_info::prelude::*;
4747
48fn get_license_and_onboard(account_id: <Test as frame_system::Config>::AccountId) {48fn get_license_and_onboard(account_id: <Test as frame_system::Config>::AccountId) {
49	assert_ok!(CollatorSelection::get_license(RuntimeOrigin::signed(49	assert_ok!(CollatorSelection::get_license(RuntimeOrigin::signed(
226#[test]226#[test]
227fn cannot_obtain_license_if_poor() {227fn cannot_obtain_license_if_poor() {
228	new_test_ext().execute_with(|| {228	new_test_ext().execute_with(|| {
229		let ed = <Test as pallet_balances::Config>::ExistentialDeposit::get();
229		assert_eq!(Balances::free_balance(&3), 100);230		assert_eq!(Balances::free_balance(&3), 100);
230		assert_eq!(Balances::free_balance(&33), 0);231		assert_eq!(Balances::free_balance(&33), ed);
231232
232		// works233		// works
233		assert_ok!(CollatorSelection::get_license(RuntimeOrigin::signed(3)));234		assert_ok!(CollatorSelection::get_license(RuntimeOrigin::signed(3)));
234235
235		// poor236		// poor
236		assert_noop!(237		assert_noop!(
237			CollatorSelection::get_license(RuntimeOrigin::signed(33)),238			CollatorSelection::get_license(RuntimeOrigin::signed(33)),
238			BalancesError::<Test>::InsufficientBalance,239			TokenError::FundsUnavailable,
239		);240		);
240	});241	});
241}242}
417fn authorship_event_handler() {418fn authorship_event_handler() {
418	new_test_ext().execute_with(|| {419	new_test_ext().execute_with(|| {
419		// put 100 in the pot + 5 for ED420		// put 100 in the pot + 5 for ED
420		<pallet_balances::Pallet<T> as fungible::Mutate<T::AccountId>>::set_balance(421		<Balances as fungible::Mutate<_>>::set_balance(&CollatorSelection::account_id(), 105);
421			&CollatorSelection::account_id(),
422			105,
423		);
444		// Nothing panics, no reward when no ED in balance442		// Nothing panics, no reward when no ED in balance
445		Authorship::on_initialize(1);443		Authorship::on_initialize(1);
446		// put some money into the pot at ED444		// put some money into the pot at ED
447		<pallet_balances::Pallet<T> as fungible::Mutate<T::AccountId>>::set_balance(445		<Balances as fungible::Mutate<_>>::set_balance(&CollatorSelection::account_id(), 5);
448			&CollatorSelection::account_id(),
449			5,
450		);

modifiedpallets/foreign-assets/Cargo.tomldiff before after both

42	"sp-runtime/std",42	"sp-runtime/std",
43	"sp-std/std",43	"sp-std/std",
44	"up-data-structs/std",44	"up-data-structs/std",
45	"xcm-executor/std"
45]46]
46try-runtime = ["frame-support/try-runtime"]47try-runtime = ["frame-support/try-runtime"]
4748

modifiedpallets/identity/Cargo.tomldiff before after both

46	"sp-io/std",46	"sp-io/std",
47	"sp-runtime/std",47	"sp-runtime/std",
48	"sp-std/std",48	"sp-std/std",
49	"pallet-balances/std",
49]50]
50try-runtime = ["frame-support/try-runtime"]51try-runtime = ["frame-support/try-runtime"]
5152

modifiedpallets/identity/src/tests.rsdiff before after both

106	type MaxReserves = ();106	type MaxReserves = ();
107	type ReserveIdentifier = [u8; 8];107	type ReserveIdentifier = [u8; 8];
108	type WeightInfo = ();108	type WeightInfo = ();
109	type HoldIdentifier = ();
110	type FreezeIdentifier = ();
111	type MaxHolds = ();
112	type MaxFreezes = ();
109}113}
110114
111parameter_types! {115parameter_types! {

modifiedpallets/inflation/src/lib.rsdiff before after both

187				<NextInflationBlock<T>>::set(inflation_start_relay_block + block_interval.into());187				<NextInflationBlock<T>>::set(inflation_start_relay_block + block_interval.into());
188188
189				// First time deposit - create Treasury account so that we can call deposit_into_existing everywhere else189				// First time deposit - create Treasury account so that we can call deposit_into_existing everywhere else
190				let imbalance = T::Currency::deposit(190				let _ = T::Currency::deposit(
191					&T::TreasuryAccountId::get(),191					&T::TreasuryAccountId::get(),
192					<BlockInflation<T>>::get(),192					<BlockInflation<T>>::get(),
193					Precision::Exact,193					Precision::Exact,
194				)?;194				)?;
195				debug_assert!(imbalance.peek().is_zero());
196			}195			}
197196
198			Ok(())197			Ok(())

modifiedpallets/inflation/src/tests.rsdiff before after both

2020
21use frame_support::{21use frame_support::{
22	assert_ok, parameter_types,22	assert_ok, parameter_types,
23	traits::{Currency, OnInitialize, Everything, ConstU32},23	traits::{fungible::{Balanced, Inspect}, OnInitialize, Everything, ConstU32, tokens::Precision},
24	weights::Weight,24	weights::Weight,
25};25};
26use frame_system::RawOrigin;26use frame_system::RawOrigin;
53	type MaxLocks = MaxLocks;53	type MaxLocks = MaxLocks;
54	type MaxReserves = ();54	type MaxReserves = ();
55	type ReserveIdentifier = ();55	type ReserveIdentifier = ();
56	type HoldIdentifier = ();
57	type FreezeIdentifier = ();
58	type MaxHolds = ();
59	type MaxFreezes = ();
56}60}
5761
58frame_support::construct_runtime!(62frame_support::construct_runtime!(
141fn uninitialized_inflation() {145fn uninitialized_inflation() {
142	new_test_ext().execute_with(|| {146	new_test_ext().execute_with(|| {
143		let initial_issuance: u64 = 1_000_000_000;147		let initial_issuance: u64 = 1_000_000_000;
144		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);148		let _ = <Balances as Balanced<_>>::deposit(&1234, initial_issuance, Precision::Exact);
145		assert_eq!(Balances::free_balance(1234), initial_issuance);149		assert_eq!(Balances::free_balance(1234), initial_issuance);
146150
147		// BlockInflation should be set after inflation is started151		// BlockInflation should be set after inflation is started
157	new_test_ext().execute_with(|| {161	new_test_ext().execute_with(|| {
158		// Total issuance = 1_000_000_000162		// Total issuance = 1_000_000_000
159		let initial_issuance: u64 = 1_000_000_000;163		let initial_issuance: u64 = 1_000_000_000;
160		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);164		let _ = <Balances as Balanced<_>>::deposit(&1234, initial_issuance, Precision::Exact);
161		assert_eq!(Balances::free_balance(1234), initial_issuance);165		assert_eq!(Balances::free_balance(1234), initial_issuance);
162166
163		// BlockInflation should be set after inflation is started167		// BlockInflation should be set after inflation is started
187	new_test_ext().execute_with(|| {191	new_test_ext().execute_with(|| {
188		// Total issuance = 1_000_000_000192		// Total issuance = 1_000_000_000
189		let initial_issuance: u64 = 1_000_000_000;193		let initial_issuance: u64 = 1_000_000_000;
190		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);194		let _ = <Balances as Balanced<_>>::deposit(&1234, initial_issuance, Precision::Exact);
191		assert_eq!(Balances::free_balance(1234), initial_issuance);195		assert_eq!(Balances::free_balance(1234), initial_issuance);
192		MockBlockNumberProvider::set(1);196		MockBlockNumberProvider::set(1);
193197
218	new_test_ext().execute_with(|| {222	new_test_ext().execute_with(|| {
219		// Total issuance = 1_000_000_000223		// Total issuance = 1_000_000_000
220		let initial_issuance: u64 = 1_000_000_000;224		let initial_issuance: u64 = 1_000_000_000;
221		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);225		let _ = <Balances as Balanced<_>>::deposit(&1234, initial_issuance, Precision::Exact);
222		assert_eq!(Balances::free_balance(1234), initial_issuance);226		assert_eq!(Balances::free_balance(1234), initial_issuance);
223		MockBlockNumberProvider::set(1);227		MockBlockNumberProvider::set(1);
224228
234		}238		}
235		assert_eq!(239		assert_eq!(
236			initial_issuance + (FIRST_YEAR_BLOCK_INFLATION * (YEAR / 100)),240			initial_issuance + (FIRST_YEAR_BLOCK_INFLATION * (YEAR / 100)),
237			<Balances as Currency<_>>::total_issuance()241			<Balances as Inspect<_>>::total_issuance()
238		);242		);
239243
240		MockBlockNumberProvider::set(YEAR + 1);244		MockBlockNumberProvider::set(YEAR + 1);
254		// Total issuance = 1_000_000_000258		// Total issuance = 1_000_000_000
255		let initial_issuance: u64 = 1_000_000_000;259		let initial_issuance: u64 = 1_000_000_000;
256		let start_block: u64 = 10457457;260		let start_block: u64 = 10457457;
257		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);261		let _ = <Balances as Balanced<_>>::deposit(&1234, initial_issuance, Precision::Exact);
258		assert_eq!(Balances::free_balance(1234), initial_issuance);262		assert_eq!(Balances::free_balance(1234), initial_issuance);
259		MockBlockNumberProvider::set(start_block);263		MockBlockNumberProvider::set(start_block);
260264
273		}277		}
274		assert_eq!(278		assert_eq!(
275			initial_issuance + (FIRST_YEAR_BLOCK_INFLATION * (YEAR / 100)),279			initial_issuance + (FIRST_YEAR_BLOCK_INFLATION * (YEAR / 100)),
276			<Balances as Currency<_>>::total_issuance()280			<Balances as Inspect<_>>::total_issuance()
277		);281		);
278282
279		MockBlockNumberProvider::set(start_block + YEAR + 1);283		MockBlockNumberProvider::set(start_block + YEAR + 1);
292	new_test_ext().execute_with(|| {296	new_test_ext().execute_with(|| {
293		// Total issuance = 1_000_000_000297		// Total issuance = 1_000_000_000
294		let initial_issuance: u64 = 1_000_000_000;298		let initial_issuance: u64 = 1_000_000_000;
295		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);299		let _ = <Balances as Balanced<_>>::deposit(&1234, initial_issuance, Precision::Exact);
296		assert_eq!(Balances::free_balance(1234), initial_issuance);300		assert_eq!(Balances::free_balance(1234), initial_issuance);
297		MockBlockNumberProvider::set(YEAR * 9 + 1);301		MockBlockNumberProvider::set(YEAR * 9 + 1);
298302
327331
328		// For accuracy total issuance = payout0 * payouts * 10;332		// For accuracy total issuance = payout0 * payouts * 10;
329		let initial_issuance: u64 = payout_by_year[0] * payouts * 10;333		let initial_issuance: u64 = payout_by_year[0] * payouts * 10;
330		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);334		let _ = <Balances as Balanced<_>>::deposit(&1234, initial_issuance, Precision::Exact);
331		assert_eq!(Balances::free_balance(1234), initial_issuance);335		assert_eq!(Balances::free_balance(1234), initial_issuance);
332336
333		// Start inflation as sudo337		// Start inflation as sudo