update

frame/nomination-pools/benchmarking/src/lib.rs

@@ -31,7 +31,7 @@ use pallet_nomination_pools::{
 	MaxPoolMembersPerPool, MaxPools, Metadata, MinCreateBond, MinJoinBond, Pallet as Pools,
 	PoolMembers, PoolRoles, PoolState, RewardPools, SubPoolsStorage,
 };
-use sp_runtime::traits::{Bounded, Zero};
+use sp_runtime::traits::{Bounded, Zero, StaticLookup};
 use sp_staking::{EraIndex, StakingInterface};
 // `frame_benchmarking::benchmarks!` macro needs this
 use pallet_nomination_pools::Call;
@@ -73,13 +73,14 @@ fn create_pool_account<T: pallet_nomination_pools::Config>(
 	let ed = CurrencyOf::<T>::minimum_balance();
 	let pool_creator: T::AccountId =
 		create_funded_user_with_balance::<T>("pool_creator", n, ed + balance * 2u32.into());
+    let pool_creator_lookup = T::Lookup::unlookup(pool_creator.clone());
 
 	Pools::<T>::create(
 		Origin::Signed(pool_creator.clone()).into(),
 		balance,
-		pool_creator.clone(),
-		pool_creator.clone(),
-		pool_creator.clone(),
+		pool_creator_lookup.clone(),
+		pool_creator_lookup.clone(),
+		pool_creator_lookup,
 	)
 	.unwrap();
 
@@ -310,9 +311,10 @@ frame_benchmarking::benchmarks! {
 
 		let scenario = scenario.add_joiner(amount);
 		let member_id = scenario.origin1_member.unwrap().clone();
+        let member_id_lookup = T::Lookup::unlookup(member_id.clone());
 		let all_points = PoolMembers::<T>::get(&member_id).unwrap().points;
 		whitelist_account!(member_id);
-	}: _(Origin::Signed(member_id.clone()), member_id.clone(), all_points)
+	}: _(Origin::Signed(member_id.clone()), member_id_lookup, all_points)
 	verify {
 		let bonded_after = T::StakingInterface::active_stake(&scenario.origin1).unwrap();
 		// We at least went down to the destination bag
@@ -382,6 +384,7 @@ frame_benchmarking::benchmarks! {
 		// Add a new member
 		let min_join_bond = MinJoinBond::<T>::get().max(CurrencyOf::<T>::minimum_balance());
 		let joiner = create_funded_user_with_balance::<T>("joiner", 0, min_join_bond * 2u32.into());
+        let joiner_lookup = T::Lookup::unlookup(joiner.clone());
 		Pools::<T>::join(Origin::Signed(joiner.clone()).into(), min_join_bond, 1)
 			.unwrap();
 
@@ -408,7 +411,7 @@ frame_benchmarking::benchmarks! {
 
 		pallet_staking::benchmarking::add_slashing_spans::<T>(&pool_account, s);
 		whitelist_account!(joiner);
-	}: withdraw_unbonded(Origin::Signed(joiner.clone()), joiner.clone(), s)
+	}: withdraw_unbonded(Origin::Signed(joiner.clone()), joiner_lookup, s)
 	verify {
 		assert_eq!(
 			CurrencyOf::<T>::free_balance(&joiner),
@@ -423,6 +426,7 @@ frame_benchmarking::benchmarks! {
 
 		let min_create_bond = min_create_bond::<T>();
 		let (depositor, pool_account) = create_pool_account::<T>(0, min_create_bond);
+        let depositor_lookup = T::Lookup::unlookup(depositor.clone());
 
 		// We set the pool to the destroying state so the depositor can leave
 		BondedPools::<T>::try_mutate(&1, |maybe_bonded_pool| {
@@ -465,7 +469,7 @@ frame_benchmarking::benchmarks! {
 		assert!(frame_system::Account::<T>::contains_key(&reward_account));
 
 		whitelist_account!(depositor);
-	}: withdraw_unbonded(Origin::Signed(depositor.clone()), depositor.clone(), s)
+	}: withdraw_unbonded(Origin::Signed(depositor.clone()), depositor_lookup, s)
 	verify {
 		// Pool removal worked
 		assert!(!pallet_staking::Ledger::<T>::contains_key(&pool_account));
@@ -487,6 +491,7 @@ frame_benchmarking::benchmarks! {
 	create {
 		let min_create_bond = min_create_bond::<T>();
 		let depositor: T::AccountId = account("depositor", USER_SEED, 0);
+        let depositor_lookup = T::Lookup::unlookup(depositor.clone());
 
 		// Give the depositor some balance to bond
 		CurrencyOf::<T>::make_free_balance_be(&depositor, min_create_bond * 2u32.into());
@@ -499,9 +504,9 @@ frame_benchmarking::benchmarks! {
 	}: _(
 			Origin::Signed(depositor.clone()),
 			min_create_bond,
-			depositor.clone(),
-			depositor.clone(),
-			depositor.clone()
+			depositor_lookup.clone(),
+			depositor_lookup.clone(),
+			depositor_lookup
 		)
 	verify {
 		assert_eq!(RewardPools::<T>::count(), 1);

frame/nomination-pools/src/lib.rs

@@ -320,7 +320,7 @@ use frame_support::{
 };
 use scale_info::TypeInfo;
 use sp_core::U256;
-use sp_runtime::traits::{AccountIdConversion, Bounded, CheckedSub, Convert, Saturating, Zero};
+use sp_runtime::traits::{AccountIdConversion, Bounded, CheckedSub, Convert, Saturating, Zero, StaticLookup};
 use sp_staking::{EraIndex, OnStakerSlash, StakingInterface};
 use sp_std::{collections::btree_map::BTreeMap, fmt::Debug, ops::Div, vec::Vec};
 
@@ -1551,10 +1551,11 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::unbond())]
 		pub fn unbond(
 			origin: OriginFor<T>,
-			member_account: T::AccountId,
+			member_account: <T::Lookup as StaticLookup>::Source,
 			#[pallet::compact] unbonding_points: BalanceOf<T>,
 		) -> DispatchResult {
 			let caller = ensure_signed(origin)?;
+            let member_account = T::Lookup::lookup(member_account)?;
 			let (mut member, mut bonded_pool, mut reward_pool) =
 				Self::get_member_with_pools(&member_account)?;
 
@@ -1664,10 +1665,11 @@ pub mod pallet {
 		)]
 		pub fn withdraw_unbonded(
 			origin: OriginFor<T>,
-			member_account: T::AccountId,
+			member_account: <T::Lookup as StaticLookup>::Source,
 			num_slashing_spans: u32,
 		) -> DispatchResultWithPostInfo {
 			let caller = ensure_signed(origin)?;
+            let member_account = T::Lookup::lookup(member_account)?;
 			let mut member =
 				PoolMembers::<T>::get(&member_account).ok_or(Error::<T>::PoolMemberNotFound)?;
 			let current_era = T::StakingInterface::current_era();
@@ -1790,11 +1792,14 @@ pub mod pallet {
 		pub fn create(
 			origin: OriginFor<T>,
 			#[pallet::compact] amount: BalanceOf<T>,
-			root: T::AccountId,
-			nominator: T::AccountId,
-			state_toggler: T::AccountId,
+			root: <T::Lookup as StaticLookup>::Source,
+			nominator: <T::Lookup as StaticLookup>::Source,
+			state_toggler: <T::Lookup as StaticLookup>::Source,
 		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
+            let root = T::Lookup::lookup(root)?;
+            let nominator = T::Lookup::lookup(nominator)?;
+            let state_toggler = T::Lookup::lookup(state_toggler)?;
 
 			ensure!(
 				amount >=
@@ -2432,7 +2437,8 @@ impl<T: Config> Pallet<T> {
 		member: T::AccountId,
 	) -> DispatchResult {
 		let points = PoolMembers::<T>::get(&member).map(|d| d.active_points()).unwrap_or_default();
-		Self::unbond(origin, member, points)
+        let member_lookup = T::Lookup::unlookup(member);
+		Self::unbond(origin, member_lookup, points)
 	}
 }
 

frame/proxy/src/benchmarking.rs

@@ -51,6 +51,7 @@ fn add_announcements<T: Config>(
 	maybe_real: Option<T::AccountId>,
 ) -> Result<(), &'static str> {
 	let caller = maybe_who.unwrap_or_else(|| account("caller", 0, SEED));
+    let caller_lookup = T::Lookup::unlookup(caller.clone());
 	T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
 	let real = if let Some(real) = maybe_real {
 		real
@@ -59,16 +60,17 @@ fn add_announcements<T: Config>(
 		T::Currency::make_free_balance_be(&real, BalanceOf::<T>::max_value() / 2u32.into());
 		Proxy::<T>::add_proxy(
 			RawOrigin::Signed(real.clone()).into(),
-			caller.clone(),
+			caller_lookup,
 			T::ProxyType::default(),
 			T::BlockNumber::zero(),
 		)?;
 		real
 	};
+    let real_lookup = T::Lookup::unlookup(real);
 	for _ in 0..n {
 		Proxy::<T>::announce(
 			RawOrigin::Signed(caller.clone()).into(),
-			real.clone(),
+			real_lookup.clone(),
 			T::CallHasher::hash_of(&("add_announcement", n)),
 		)?;
 	}
@@ -83,8 +85,9 @@ benchmarks! {
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
 		// ... and "real" is the traditional caller. This is not a typo.
 		let real: T::AccountId = whitelisted_caller();
+        let real_lookup = T::Lookup::unlookup(real);
 		let call: <T as Config>::Call = frame_system::Call::<T>::remark { remark: vec![] }.into();
-	}: _(RawOrigin::Signed(caller), real, Some(T::ProxyType::default()), Box::new(call))
+	}: _(RawOrigin::Signed(caller), real_lookup, Some(T::ProxyType::default()), Box::new(call))
 	verify {
 		assert_last_event::<T>(Event::ProxyExecuted { result: Ok(()) }.into())
 	}
@@ -95,17 +98,19 @@ benchmarks! {
 		// In this case the caller is the "target" proxy
 		let caller: T::AccountId = account("anonymous", 0, SEED);
 		let delegate: T::AccountId = account("target", p - 1, SEED);
+        let delegate_lookup = T::Lookup::unlookup(delegate.clone());
 		T::Currency::make_free_balance_be(&delegate, BalanceOf::<T>::max_value() / 2u32.into());
 		// ... and "real" is the traditional caller. This is not a typo.
 		let real: T::AccountId = whitelisted_caller();
+        let real_lookup = T::Lookup::unlookup(real);
 		let call: <T as Config>::Call = frame_system::Call::<T>::remark { remark: vec![] }.into();
 		Proxy::<T>::announce(
 			RawOrigin::Signed(delegate.clone()).into(),
-			real.clone(),
+			real_lookup.clone(),
 			T::CallHasher::hash_of(&call),
 		)?;
 		add_announcements::<T>(a, Some(delegate.clone()), None)?;
-	}: _(RawOrigin::Signed(caller), delegate, real, Some(T::ProxyType::default()), Box::new(call))
+	}: _(RawOrigin::Signed(caller), delegate_lookup, real_lookup, Some(T::ProxyType::default()), Box::new(call))
 	verify {
 		assert_last_event::<T>(Event::ProxyExecuted { result: Ok(()) }.into())
 	}
@@ -118,14 +123,15 @@ benchmarks! {
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
 		// ... and "real" is the traditional caller. This is not a typo.
 		let real: T::AccountId = whitelisted_caller();
+        let real_lookup = T::Lookup::unlookup(real);
 		let call: <T as Config>::Call = frame_system::Call::<T>::remark { remark: vec![] }.into();
 		Proxy::<T>::announce(
 			RawOrigin::Signed(caller.clone()).into(),
-			real.clone(),
+			real_lookup.clone(),
 			T::CallHasher::hash_of(&call),
 		)?;
 		add_announcements::<T>(a, Some(caller.clone()), None)?;
-	}: _(RawOrigin::Signed(caller.clone()), real, T::CallHasher::hash_of(&call))
+	}: _(RawOrigin::Signed(caller.clone()), real_lookup, T::CallHasher::hash_of(&call))
 	verify {
 		let (announcements, _) = Announcements::<T>::get(&caller);
 		assert_eq!(announcements.len() as u32, a);
@@ -136,17 +142,19 @@ benchmarks! {
 		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
 		// In this case the caller is the "target" proxy
 		let caller: T::AccountId = account("target", p - 1, SEED);
+        let caller_lookup = T::Lookup::unlookup(caller.clone());
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
 		// ... and "real" is the traditional caller. This is not a typo.
 		let real: T::AccountId = whitelisted_caller();
+        let real_lookup = T::Lookup::unlookup(real.clone());
 		let call: <T as Config>::Call = frame_system::Call::<T>::remark { remark: vec![] }.into();
 		Proxy::<T>::announce(
 			RawOrigin::Signed(caller.clone()).into(),
-			real.clone(),
+			real_lookup,
 			T::CallHasher::hash_of(&call),
 		)?;
 		add_announcements::<T>(a, Some(caller.clone()), None)?;
-	}: _(RawOrigin::Signed(real), caller.clone(), T::CallHasher::hash_of(&call))
+	}: _(RawOrigin::Signed(real), caller_lookup, T::CallHasher::hash_of(&call))
 	verify {
 		let (announcements, _) = Announcements::<T>::get(&caller);
 		assert_eq!(announcements.len() as u32, a);
@@ -160,10 +168,11 @@ benchmarks! {
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
 		// ... and "real" is the traditional caller. This is not a typo.
 		let real: T::AccountId = whitelisted_caller();
+        let real_lookup = T::Lookup::unlookup(real.clone());
 		add_announcements::<T>(a, Some(caller.clone()), None)?;
 		let call: <T as Config>::Call = frame_system::Call::<T>::remark { remark: vec![] }.into();
 		let call_hash = T::CallHasher::hash_of(&call);
-	}: _(RawOrigin::Signed(caller.clone()), real.clone(), call_hash)
+	}: _(RawOrigin::Signed(caller.clone()), real_lookup, call_hash)
 	verify {
 		assert_last_event::<T>(Event::Announced { real, proxy: caller, call_hash }.into());
 	}
@@ -228,6 +237,7 @@ benchmarks! {
 		let p in 0 .. (T::MaxProxies::get() - 2);
 
 		let caller: T::AccountId = whitelisted_caller();
+        let caller_lookup = T::Lookup::unlookup(caller.clone());
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 		Pallet::<T>::anonymous(
 			RawOrigin::Signed(whitelisted_caller()).into(),
@@ -241,7 +251,7 @@ benchmarks! {
 
 		add_proxies::<T>(p, Some(anon.clone()))?;
 		ensure!(Proxies::<T>::contains_key(&anon), "anon proxy not created");
-	}: _(RawOrigin::Signed(anon.clone()), caller.clone(), T::ProxyType::default(), 0, height, ext_index)
+	}: _(RawOrigin::Signed(anon.clone()), caller_lookup, T::ProxyType::default(), 0, height, ext_index)
 	verify {
 		assert!(!Proxies::<T>::contains_key(&anon));
 	}