git.delta.rocks / unique-network / refs/commits / f9edb50d1095

5307 "pallet-common",5307 "pallet-common",
5308 "pallet-evm",5308 "pallet-evm",
5309 "pallet-evm-contract-helpers",5309 "pallet-evm-contract-helpers",
5310 "pallet-evm-migration",
5310 "pallet-randomness-collective-flip",5311 "pallet-randomness-collective-flip",
5311 "pallet-timestamp",5312 "pallet-timestamp",
5312 "pallet-unique",5313 "pallet-unique",

122default-features = false122default-features = false
123path =  "../evm-contract-helpers"123path =  "../evm-contract-helpers"
124
125[dev-dependencies]
126[dependencies.pallet-evm-migration]
127default-features = false
128path =  "../evm-migration"
129
130
124################################################################################131################################################################################

20use crate::Pallet as PromototionPallet;20use crate::Pallet as PromototionPallet;
2121
22use sp_runtime::traits::Bounded;22use sp_runtime::traits::Bounded;
23use sp_std::vec;
2324
24use frame_benchmarking::{benchmarks, account};25use frame_benchmarking::{benchmarks, account};
26
27use frame_system::{Origin, RawOrigin};
25use frame_support::traits::OnInitialize;28use pallet_unique::benchmarking::create_nft_collection;
26use frame_system::{Origin, RawOrigin};29use pallet_evm_migration::Pallet as EvmMigrationPallet;
30
31// trait BenchmarkingConfig: Config + pallet_unique::Config { }
32
33// impl<T: Config + pallet_unique::Config> BenchmarkingConfig for T { }
2734
28const SEED: u32 = 0;35const SEED: u32 = 0;
29benchmarks! {36benchmarks! {
30	where_clause{37	where_clause{
31		where T: Config38		where T:  Config + pallet_unique::Config + pallet_evm_migration::Config ,
32
33	}
34	on_initialize {
35		let block1: T::BlockNumber = T::BlockNumber::from(1u32);39		T::BlockNumber: From<u32>
40	}
41	start_app_promotion {
42
36		let block2: T::BlockNumber = T::BlockNumber::from(2u32);43	} : {PromototionPallet::<T>::start_app_promotion(RawOrigin::Root.into(), None)?}
44
45	stop_app_promotion{
37		PromototionPallet::<T>::on_initialize(block1); // Create Treasury account46		PromototionPallet::<T>::start_app_promotion(RawOrigin::Root.into(), Some(25.into()))?;
38	}: { PromototionPallet::<T>::on_initialize(block2); } // Benchmark deposit_into_existing path47	} : {PromototionPallet::<T>::stop_app_promotion(RawOrigin::Root.into())?}
3948
40	start_app_promotion {49	set_admin_address {
41		let caller = account::<T::AccountId>("caller", 0, SEED);50		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
4251		let _ = <T as Config>::Currency::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
43	} : {PromototionPallet::<T>::start_app_promotion(RawOrigin::Root.into(), T::BlockNumber::from(2u32))?}52	} : {PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin))?}
4453
45	set_admin_address {54	payout_stakers{
46		let caller = account::<T::AccountId>("caller", 0, SEED);55		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
56		let share = Perbill::from_rational(1u32, 10);
57		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
58		let _ = <T as Config>::Currency::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
59		let staker: T::AccountId = account("caller", 0, SEED);
47		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());60		let _ = <T as Config>::Currency::make_free_balance_be(&staker,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
61		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(staker.clone()).into(), share * <T as Config>::Currency::total_balance(&staker))?;
48	} : {PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), caller)?}62	} : {PromototionPallet::<T>::payout_stakers(RawOrigin::Signed(pallet_admin.clone()).into(), Some(1))?}
4963
50	stake {64	stake {
51		let caller = account::<T::AccountId>("caller", 0, SEED);65		let caller = account::<T::AccountId>("caller", 0, SEED);
52		let share = Perbill::from_rational(1u32, 10);66		let share = Perbill::from_rational(1u32, 10);
53		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());67		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
54	} : {PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?}68	} : {PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))?}
5569
56	unstake {70	unstake {
57		let caller = account::<T::AccountId>("caller", 0, SEED);71		let caller = account::<T::AccountId>("caller", 0, SEED);
58		let share = Perbill::from_rational(1u32, 10);72		let share = Perbill::from_rational(1u32, 10);
59		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());73		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
60		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?;74		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))?;
6175
62	} : {PromototionPallet::<T>::unstake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?}76	} : {PromototionPallet::<T>::unstake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))?}
6377
64	recalculate_stake {78	recalculate_stake {
65		let caller = account::<T::AccountId>("caller", 0, SEED);79		let caller = account::<T::AccountId>("caller", 0, SEED);
66		let share = Perbill::from_rational(1u32, 10);80		let share = Perbill::from_rational(1u32, 10);
67		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());81		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
68		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?;82		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))?;
69		let block = <T::BlockNumberProvider as BlockNumberProvider>::current_block_number();83		let block = <T::RelayBlockNumberProvider as BlockNumberProvider>::current_block_number();
70		let mut acc = <BalanceOf<T>>::default();84		let mut acc = <BalanceOf<T>>::default();
71	} : {PromototionPallet::<T>::recalculate_stake(&caller, block, share * T::Currency::total_balance(&caller), &mut acc)}85	} : {PromototionPallet::<T>::recalculate_stake(&caller, block, share * <T as Config>::Currency::total_balance(&caller), &mut acc)}
86
87	sponsor_collection {
88		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
89		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
90		let _ = <T as Config>::Currency::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
91		let caller: T::AccountId = account("caller", 0, SEED);
92		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
93		let collection = create_nft_collection::<T>(caller.clone())?;
94	} : {PromototionPallet::<T>::sponsor_collection(RawOrigin::Signed(pallet_admin.clone()).into(), collection)?}
95
96	stop_sponsoring_collection {
97		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
98		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
99		let _ = <T as Config>::Currency::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
100		let caller: T::AccountId = account("caller", 0, SEED);
101		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
102		let collection = create_nft_collection::<T>(caller.clone())?;
103		PromototionPallet::<T>::sponsor_collection(RawOrigin::Signed(pallet_admin.clone()).into(), collection)?;
104	} : {PromototionPallet::<T>::stop_sponsoring_collection(RawOrigin::Signed(pallet_admin.clone()).into(), collection)?}
105
106	sponsor_contract {
107		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
108		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
109
110		let _ = <T as Config>::Currency::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
111		let address = H160::from_low_u64_be(SEED as u64);
112		let data: Vec<u8> = (0..20 as u8).collect();
113		<EvmMigrationPallet<T>>::begin(RawOrigin::Root.into(), address)?;
114		<EvmMigrationPallet<T>>::finish(RawOrigin::Root.into(), address, data)?;
115	} : {PromototionPallet::<T>::sponsor_conract(RawOrigin::Signed(pallet_admin.clone()).into(), address)?}
116
117	stop_sponsoring_contract {
118		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
119		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
120
121		let _ = <T as Config>::Currency::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
122		let address = H160::from_low_u64_be(SEED as u64);
123		let data: Vec<u8> = (0..20 as u8).collect();
124		<EvmMigrationPallet<T>>::begin(RawOrigin::Root.into(), address)?;
125		<EvmMigrationPallet<T>>::finish(RawOrigin::Root.into(), address, data)?;
126		PromototionPallet::<T>::sponsor_conract(RawOrigin::Signed(pallet_admin.clone()).into(), address)?;
127	} : {PromototionPallet::<T>::stop_sponsoring_contract(RawOrigin::Signed(pallet_admin.clone()).into(), address)?}
72}128}
73129

132	#[pallet::generate_deposit(fn deposit_event)]132	#[pallet::generate_deposit(fn deposit_event)]
133	pub enum Event<T: Config> {133	pub enum Event<T: Config> {
134		StakingRecalculation(134		StakingRecalculation(
135			/// An recalculated staker
136			T::AccountId,
135			/// Base on which interest is calculated137			/// Base on which interest is calculated
136			BalanceOf<T>,138			BalanceOf<T>,
137			/// Amount of accrued interest139			/// Amount of accrued interest
164			Key<Blake2_128Concat, T::AccountId>,166			Key<Blake2_128Concat, T::AccountId>,
165			Key<Twox64Concat, T::BlockNumber>,167			Key<Twox64Concat, T::BlockNumber>,
166		),168		),
167		Value = BalanceOf<T>,169		Value = (BalanceOf<T>, T::BlockNumber),
168		QueryKind = ValueQuery,170		QueryKind = ValueQuery,
169	>;171	>;
170172
189	pub type NextInterestBlock<T: Config> =191	pub type NextInterestBlock<T: Config> =
190		StorageValue<Value = T::BlockNumber, QueryKind = ValueQuery>;192		StorageValue<Value = T::BlockNumber, QueryKind = ValueQuery>;
191193
194	/// Stores the address of the staker for which the last revenue recalculation was performed.
195	/// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.
196	#[pallet::storage]
197	#[pallet::getter(fn get_last_calculated_staker)]
198	pub type LastCalcucaltedStaker<T: Config> =
199		StorageValue<Value = T::AccountId, QueryKind = OptionQuery>;
200
192	#[pallet::hooks]201	#[pallet::hooks]
193	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {202	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
194		fn on_initialize(current_block: T::BlockNumber) -> Weight203		fn on_initialize(current_block: T::BlockNumber) -> Weight
195		where204		where
196			<T as frame_system::Config>::BlockNumber: From<u32>,205			<T as frame_system::Config>::BlockNumber: From<u32>,
197		{206		{
198			let mut consumed_weight = 0;207			let mut consumed_weight = 0;
199			let mut add_weight = |reads, writes, weight| {208			// let mut add_weight = |reads, writes, weight| {
200				consumed_weight += T::DbWeight::get().reads_writes(reads, writes);209			// 	consumed_weight += T::DbWeight::get().reads_writes(reads, writes);
201				consumed_weight += weight;210			// 	consumed_weight += weight;
202			};211			// };
203212
204			PendingUnstake::<T>::iter()213			PendingUnstake::<T>::iter()
205				.filter_map(|((staker, block), amount)| {214				.filter_map(|((staker, block), amount)| {
214					<PendingUnstake<T>>::remove((staker, block));223					<PendingUnstake<T>>::remove((staker, block));
215				});224				});
216225
217			let next_interest_block = Self::get_interest_block();226			// let next_interest_block = Self::get_interest_block();
218			let current_relay_block = T::RelayBlockNumberProvider::current_block_number();227			// let current_relay_block = T::RelayBlockNumberProvider::current_block_number();
219			if next_interest_block != 0.into() && current_relay_block >= next_interest_block {228			// if next_interest_block != 0.into() && current_relay_block >= next_interest_block {
220				let mut acc = <BalanceOf<T>>::default();229			// 	let mut acc = <BalanceOf<T>>::default();
221				let mut base_acc = <BalanceOf<T>>::default();230			// 	let mut base_acc = <BalanceOf<T>>::default();
222231
223				NextInterestBlock::<T>::set(232			// 	NextInterestBlock::<T>::set(
224					NextInterestBlock::<T>::get() + T::RecalculationInterval::get(),233			// 		NextInterestBlock::<T>::get() + T::RecalculationInterval::get(),
225				);234			// 	);
226				add_weight(0, 1, 0);235			// 	add_weight(0, 1, 0);
227236
228				Staked::<T>::iter()237			// 	Staked::<T>::iter()
229					.filter(|((_, block), _)| {238			// 		.filter(|((_, block), _)| {
230						*block + T::RecalculationInterval::get() <= current_relay_block239			// 			*block + T::RecalculationInterval::get() <= current_relay_block
231					})240			// 		})
232					.for_each(|((staker, block), amount)| {241			// 		.for_each(|((staker, block), amount)| {
233						Self::recalculate_stake(&staker, block, amount, &mut acc);242			// 			Self::recalculate_stake(&staker, block, amount, &mut acc);
234						add_weight(0, 0, T::WeightInfo::recalculate_stake());243			// 			add_weight(0, 0, T::WeightInfo::recalculate_stake());
235						base_acc += amount;244			// 			base_acc += amount;
236					});245			// 		});
237				<TotalStaked<T>>::get()246			// 	<TotalStaked<T>>::get()
238					.checked_add(&acc)247			// 		.checked_add(&acc)
239					.map(|res| <TotalStaked<T>>::set(res));248			// 		.map(|res| <TotalStaked<T>>::set(res));
240249
241				Self::deposit_event(Event::StakingRecalculation(base_acc, acc));250			// 	Self::deposit_event(Event::StakingRecalculation(base_acc, acc));
242				add_weight(0, 1, 0);251			// 	add_weight(0, 1, 0);
243			} else {252			// } else {
244				add_weight(1, 0, 0)253			// 	add_weight(1, 0, 0)
245			};254			// };
246			consumed_weight255			consumed_weight
247		}256		}
248	}257	}
249258
250	#[pallet::call]259	#[pallet::call]
251	impl<T: Config> Pallet<T> {260	impl<T: Config> Pallet<T>
261	where
262		T::BlockNumber: From<u32>,
263	{
252		#[pallet::weight(T::WeightInfo::set_admin_address())]264		#[pallet::weight(T::WeightInfo::set_admin_address())]
253		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {265		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {
254			ensure_root(origin)?;266			ensure_root(origin)?;
281			Ok(())293			Ok(())
282		}294		}
283295
284		#[pallet::weight(0)]296		#[pallet::weight(T::WeightInfo::stop_app_promotion())]
285		pub fn stop_app_promotion(origin: OriginFor<T>) -> DispatchResult297		pub fn stop_app_promotion(origin: OriginFor<T>) -> DispatchResult
286		where298		where
287			<T as frame_system::Config>::BlockNumber: From<u32>,299			<T as frame_system::Config>::BlockNumber: From<u32>,
317			Self::add_lock_balance(&staker_id, amount)?;329			Self::add_lock_balance(&staker_id, amount)?;
318330
319			let block_number = T::RelayBlockNumberProvider::current_block_number();331			let block_number = T::RelayBlockNumberProvider::current_block_number();
332			let recalc_block = (block_number / T::RecalculationInterval::get() + 2u32.into())
333				* T::RecalculationInterval::get();
320334
321			<Staked<T>>::insert(335			<Staked<T>>::insert((&staker_id, block_number), {
322				(&staker_id, block_number),
323				<Staked<T>>::get((&staker_id, block_number))336				let mut balance_and_recalc_block = <Staked<T>>::get((&staker_id, block_number));
337				balance_and_recalc_block.0 = balance_and_recalc_block
338					.0
324					.checked_add(&amount)339					.checked_add(&amount)
325					.ok_or(ArithmeticError::Overflow)?,340					.ok_or(ArithmeticError::Overflow)?;
341				balance_and_recalc_block.1 = recalc_block;
342				balance_and_recalc_block
326			);343			});
327344
328			<TotalStaked<T>>::set(345			// <TotalStaked<T>>::set(
329				<TotalStaked<T>>::get()346			// 	<TotalStaked<T>>::get()
330					.checked_add(&amount)347			// 		.checked_add(&amount)
331					.ok_or(ArithmeticError::Overflow)?,348			// 		.ok_or(ArithmeticError::Overflow)?,
332			);349			// );
333350
334			Ok(())351			Ok(())
335		}352		}
338		pub fn unstake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {355		pub fn unstake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
339			let staker_id = ensure_signed(staker)?;356			let staker_id = ensure_signed(staker)?;
340357
341			let mut stakes = Staked::<T>::iter_prefix((&staker_id,)).collect::<Vec<_>>();358			let mut stakes = Staked::<T>::drain_prefix((&staker_id,));
342359
343			let total_staked = stakes360			// let total_staked = stakes
344				.iter()361			// 	.iter()
345				.fold(<BalanceOf<T>>::default(), |acc, (_, amount)| acc + *amount);362			// 	.fold(<BalanceOf<T>>::default(), |acc, (_, amount)| acc + *amount);
346363
347			ensure!(total_staked >= amount, ArithmeticError::Underflow);364			// ensure!(total_staked >= amount, ArithmeticError::Underflow);
348365
349			<TotalStaked<T>>::set(366			// <TotalStaked<T>>::set(
350				<TotalStaked<T>>::get()367			// 	<TotalStaked<T>>::get()
351					.checked_sub(&amount)368			// 		.checked_sub(&amount)
352					.ok_or(ArithmeticError::Underflow)?,369			// 		.ok_or(ArithmeticError::Underflow)?,
353			);370			// );
354371
355			let block =372			// let block =
356				T::RelayBlockNumberProvider::current_block_number() + T::PendingInterval::get();373			// 	T::RelayBlockNumberProvider::current_block_number() + T::PendingInterval::get();
357			<PendingUnstake<T>>::insert(374			// <PendingUnstake<T>>::insert(
358				(&staker_id, block),375			// 	(&staker_id, block),
359				<PendingUnstake<T>>::get((&staker_id, block))376			// 	<PendingUnstake<T>>::get((&staker_id, block))
360					.checked_add(&amount)377			// 		.checked_add(&amount)
361					.ok_or(ArithmeticError::Overflow)?,378			// 		.ok_or(ArithmeticError::Overflow)?,
362			);379			// );
363380
364			stakes.sort_by_key(|(block, _)| *block);381			// stakes.sort_by_key(|(block, _)| *block);
365382
366			let mut acc_amount = amount;383			// let mut acc_amount = amount;
367			let new_state = stakes384			// let new_state = stakes
368				.into_iter()385			// 	.into_iter()
369				.map_while(|(block, balance_per_block)| {386			// 	.map_while(|(block, balance_per_block)| {
370					if acc_amount == <BalanceOf<T>>::default() {387			// 		if acc_amount == <BalanceOf<T>>::default() {
371						return None;388			// 			return None;
372					}389			// 		}
373					if acc_amount <= balance_per_block {390			// 		if acc_amount <= balance_per_block {
374						let res = (block, balance_per_block - acc_amount, acc_amount);391			// 			let res = (block, balance_per_block - acc_amount, acc_amount);
375						acc_amount = <BalanceOf<T>>::default();392			// 			acc_amount = <BalanceOf<T>>::default();
376						return Some(res);393			// 			return Some(res);
377					} else {394			// 		} else {
378						acc_amount -= balance_per_block;395			// 			acc_amount -= balance_per_block;
379						return Some((block, <BalanceOf<T>>::default(), acc_amount));396			// 			return Some((block, <BalanceOf<T>>::default(), acc_amount));
380					}397			// 		}
381				})398			// 	})
382				.collect::<Vec<_>>();399			// 	.collect::<Vec<_>>();
383400
384			new_state401			// new_state
385				.into_iter()402			// 	.into_iter()
386				.for_each(|(block, to_staked, _to_pending)| {403			// 	.for_each(|(block, to_staked, _to_pending)| {
387					if to_staked == <BalanceOf<T>>::default() {404			// 		if to_staked == <BalanceOf<T>>::default() {
388						<Staked<T>>::remove((&staker_id, block));405			// 			<Staked<T>>::remove((&staker_id, block));
389					} else {406			// 		} else {
390						<Staked<T>>::insert((&staker_id, block), to_staked);407			// 			<Staked<T>>::insert((&staker_id, block), to_staked);
391					}408			// 		}
392				});409			// 	});
393410
394			Ok(())411			Ok(())
412
413			// let staker_id = ensure_signed(staker)?;
414
415			// let mut stakes = Staked::<T>::iter_prefix((&staker_id,)).collect::<Vec<_>>();
416
417			// let total_staked = stakes
418			// 	.iter()
419			// 	.fold(<BalanceOf<T>>::default(), |acc, (_, amount)| acc + *amount);
420
421			// ensure!(total_staked >= amount, ArithmeticError::Underflow);
422
423			// <TotalStaked<T>>::set(
424			// 	<TotalStaked<T>>::get()
425			// 		.checked_sub(&amount)
426			// 		.ok_or(ArithmeticError::Underflow)?,
427			// );
428
429			// let block =
430			// 	T::RelayBlockNumberProvider::current_block_number() + T::PendingInterval::get();
431			// <PendingUnstake<T>>::insert(
432			// 	(&staker_id, block),
433			// 	<PendingUnstake<T>>::get((&staker_id, block))
434			// 		.checked_add(&amount)
435			// 		.ok_or(ArithmeticError::Overflow)?,
436			// );
437
438			// stakes.sort_by_key(|(block, _)| *block);
439
440			// let mut acc_amount = amount;
441			// let new_state = stakes
442			// 	.into_iter()
443			// 	.map_while(|(block, balance_per_block)| {
444			// 		if acc_amount == <BalanceOf<T>>::default() {
445			// 			return None;
446			// 		}
447			// 		if acc_amount <= balance_per_block {
448			// 			let res = (block, balance_per_block - acc_amount, acc_amount);
449			// 			acc_amount = <BalanceOf<T>>::default();
450			// 			return Some(res);
451			// 		} else {
452			// 			acc_amount -= balance_per_block;
453			// 			return Some((block, <BalanceOf<T>>::default(), acc_amount));
454			// 		}
455			// 	})
456			// 	.collect::<Vec<_>>();
457
458			// new_state
459			// 	.into_iter()
460			// 	.for_each(|(block, to_staked, _to_pending)| {
461			// 		if to_staked == <BalanceOf<T>>::default() {
462			// 			<Staked<T>>::remove((&staker_id, block));
463			// 		} else {
464			// 			<Staked<T>>::insert((&staker_id, block), to_staked);
465			// 		}
466			// 	});
467
468			// Ok(())
395		}469		}
396470
397		#[pallet::weight(0)]471		#[pallet::weight(T::WeightInfo::sponsor_collection())]
398		pub fn sponsor_collection(472		pub fn sponsor_collection(
399			admin: OriginFor<T>,473			admin: OriginFor<T>,
400			collection_id: CollectionId,474			collection_id: CollectionId,
407481
408			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)482			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)
409		}483		}
410		#[pallet::weight(0)]484		#[pallet::weight(T::WeightInfo::stop_sponsoring_collection())]
411		pub fn stop_sponsorign_collection(485		pub fn stop_sponsoring_collection(
412			admin: OriginFor<T>,486			admin: OriginFor<T>,
413			collection_id: CollectionId,487			collection_id: CollectionId,
414		) -> DispatchResult {488		) -> DispatchResult {
428			T::CollectionHandler::remove_collection_sponsor(collection_id)502			T::CollectionHandler::remove_collection_sponsor(collection_id)
429		}503		}
430504
431		#[pallet::weight(0)]505		#[pallet::weight(T::WeightInfo::sponsor_contract())]
432		pub fn sponsor_conract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {506		pub fn sponsor_conract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {
433			let admin_id = ensure_signed(admin)?;507			let admin_id = ensure_signed(admin)?;
434508
443			)517			)
444		}518		}
445519
446		#[pallet::weight(0)]520		#[pallet::weight(T::WeightInfo::stop_sponsoring_contract())]
447		pub fn stop_sponsorign_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {521		pub fn stop_sponsoring_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {
448			let admin_id = ensure_signed(admin)?;522			let admin_id = ensure_signed(admin)?;
449523
450			ensure!(524			ensure!(
459			);533			);
460			T::ContractHandler::remove_contract_sponsor(contract_id)534			T::ContractHandler::remove_contract_sponsor(contract_id)
461		}535		}
536
537		#[pallet::weight(0)]
538		pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {
539			let admin_id = ensure_signed(admin)?;
540
541			ensure!(
542				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,
543				Error::<T>::NoPermission
544			);
545
546			Ok(())
547		}
462	}548	}
463}549}
464550
501	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {587	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {
502		let staked = Staked::<T>::iter_prefix((staker,))588		let staked = Staked::<T>::iter_prefix((staker,))
503			.into_iter()589			.into_iter()
504			.fold(<BalanceOf<T>>::default(), |acc, (_, amount)| acc + amount);590			.fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {
591				acc + amount
592			});
505		if staked != <BalanceOf<T>>::default() {593		if staked != <BalanceOf<T>>::default() {
506			Some(staked)594			Some(staked)
507		} else {595		} else {
514	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {602	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {
515		let mut staked = Staked::<T>::iter_prefix((staker,))603		let mut staked = Staked::<T>::iter_prefix((staker,))
516			.into_iter()604			.into_iter()
517			.map(|(block, amount)| (block, amount))605			.map(|(block, (amount, _))| (block, amount))
518			.collect::<Vec<_>>();606			.collect::<Vec<_>>();
519		staked.sort_by_key(|(block, _)| *block);607		staked.sort_by_key(|(block, _)| *block);
520		if !staked.is_empty() {608		if !staked.is_empty() {
550		income_acc: &mut BalanceOf<T>,638		income_acc: &mut BalanceOf<T>,
551	) {639	) {
552		let income = Self::calculate_income(base);640		let income = Self::calculate_income(base);
553		base.checked_add(&income).map(|res| {641		// base.checked_add(&income).map(|res| {
554			<Staked<T>>::insert((staker, block), res);642		// 	<Staked<T>>::insert((staker, block), res);
555			*income_acc += income;643		// 	*income_acc += income;
556			<T::Currency as Currency<T::AccountId>>::transfer(644		// 	<T::Currency as Currency<T::AccountId>>::transfer(
557				&T::TreasuryAccountId::get(),645		// 		&T::TreasuryAccountId::get(),
558				staker,646		// 		staker,
559				income,647		// 		income,
560				ExistenceRequirement::KeepAlive,648		// 		ExistenceRequirement::KeepAlive,
561			)649		// 	)
562			.and_then(|_| Self::add_lock_balance(staker, income));650		// 	.and_then(|_| Self::add_lock_balance(staker, income));
563		});651		// });
564	}652	}
565653
566	fn calculate_income<I>(base: I) -> I654	fn calculate_income<I>(base: I) -> I

101101
102	fn set_sponsor(sponsor_id: Self::AccountId, contract_id: Self::ContractId) -> DispatchResult;102	fn set_sponsor(sponsor_id: Self::AccountId, contract_id: Self::ContractId) -> DispatchResult;
103103
104	fn remove_contract_sponsor(collection_id: Self::ContractId) -> DispatchResult;104	fn remove_contract_sponsor(contract_id: Self::ContractId) -> DispatchResult;
105105
106	fn get_sponsor(contract_id: Self::ContractId)106	fn get_sponsor(contract_id: Self::ContractId)
107		-> Result<Option<Self::AccountId>, DispatchError>;107		-> Result<Option<Self::AccountId>, DispatchError>;

3//! Autogenerated weights for pallet_app_promotion3//! Autogenerated weights for pallet_app_promotion
4//!4//!
5//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev5//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
6//! DATE: 2022-08-09, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`6//! DATE: 2022-08-30, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
7//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 10247//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
88
9// Executed Command:9// Executed Command:
3333
34/// Weight functions needed for pallet_app_promotion.34/// Weight functions needed for pallet_app_promotion.
35pub trait WeightInfo {35pub trait WeightInfo {
36	fn on_initialize() -> Weight;36	fn start_app_promotion() -> Weight;
37	fn start_app_promotion() -> Weight;37	fn stop_app_promotion() -> Weight;
38	fn set_admin_address() -> Weight;38	fn set_admin_address() -> Weight;
39	fn payout_stakers() -> Weight;
39	fn stake() -> Weight;40	fn stake() -> Weight;
40	fn unstake() -> Weight;41	fn unstake() -> Weight;
41	fn recalculate_stake() -> Weight;42	fn recalculate_stake() -> Weight;
43	fn sponsor_collection() -> Weight;
44	fn stop_sponsoring_collection() -> Weight;
45	fn sponsor_contract() -> Weight;
46	fn stop_sponsoring_contract() -> Weight;
42}47}
4348
44/// Weights for pallet_app_promotion using the Substrate node and recommended hardware.49/// Weights for pallet_app_promotion using the Substrate node and recommended hardware.
45pub struct SubstrateWeight<T>(PhantomData<T>);50pub struct SubstrateWeight<T>(PhantomData<T>);
46impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {51impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
47	// Storage: Promotion PendingUnstake (r:1 w:0)52	// Storage: Promotion StartBlock (r:1 w:1)
53	// Storage: ParachainSystem ValidationData (r:1 w:0)
48	// Storage: Promotion NextInterestBlock (r:1 w:0)54	// Storage: Promotion NextInterestBlock (r:0 w:1)
49	fn on_initialize() -> Weight {55	fn start_app_promotion() -> Weight {
50		(2_705_000 as Weight)56		(2_299_000 as Weight)
57			.saturating_add(T::DbWeight::get().reads(2 as Weight))
51			.saturating_add(T::DbWeight::get().reads(2 as Weight))58			.saturating_add(T::DbWeight::get().writes(2 as Weight))
52	}59	}
53	// Storage: Promotion StartBlock (r:1 w:1)60	// Storage: Promotion StartBlock (r:1 w:1)
54	// Storage: Promotion NextInterestBlock (r:0 w:1)61	// Storage: Promotion NextInterestBlock (r:0 w:1)
55	fn start_app_promotion() -> Weight {62	fn stop_app_promotion() -> Weight {
56		(1_436_000 as Weight)63		(1_733_000 as Weight)
57			.saturating_add(T::DbWeight::get().reads(1 as Weight))64			.saturating_add(T::DbWeight::get().reads(1 as Weight))
58			.saturating_add(T::DbWeight::get().writes(2 as Weight))65			.saturating_add(T::DbWeight::get().writes(2 as Weight))
59	}66	}
60	// Storage: Promotion Admin (r:0 w:1)67	// Storage: Promotion Admin (r:0 w:1)
61	fn set_admin_address() -> Weight {68	fn set_admin_address() -> Weight {
62		(516_000 as Weight)69		(553_000 as Weight)
63			.saturating_add(T::DbWeight::get().writes(1 as Weight))70			.saturating_add(T::DbWeight::get().writes(1 as Weight))
64	}71	}
72	// Storage: Promotion Admin (r:1 w:0)
73	fn payout_stakers() -> Weight {
74		(1_398_000 as Weight)
75			.saturating_add(T::DbWeight::get().reads(1 as Weight))
76	}
65	// Storage: System Account (r:1 w:1)77	// Storage: System Account (r:1 w:1)
66	// Storage: Balances Locks (r:1 w:1)78	// Storage: Balances Locks (r:1 w:1)
67	// Storage: ParachainSystem ValidationData (r:1 w:0)79	// Storage: ParachainSystem ValidationData (r:1 w:0)
68	// Storage: Promotion Staked (r:1 w:1)80	// Storage: Promotion Staked (r:1 w:1)
69	// Storage: Promotion TotalStaked (r:1 w:1)
70	fn stake() -> Weight {81	fn stake() -> Weight {
71		(10_019_000 as Weight)82		(9_506_000 as Weight)
72			.saturating_add(T::DbWeight::get().reads(5 as Weight))83			.saturating_add(T::DbWeight::get().reads(4 as Weight))
73			.saturating_add(T::DbWeight::get().writes(4 as Weight))84			.saturating_add(T::DbWeight::get().writes(3 as Weight))
74	}85	}
75	// Storage: System Account (r:1 w:1)86	// Storage: System Account (r:1 w:0)
87	fn unstake() -> Weight {
88		(2_529_000 as Weight)
89			.saturating_add(T::DbWeight::get().reads(1 as Weight))
90	}
76	// Storage: Balances Locks (r:1 w:1)91	// Storage: System Account (r:1 w:0)
92	fn recalculate_stake() -> Weight {
93		(2_203_000 as Weight)
94			.saturating_add(T::DbWeight::get().reads(1 as Weight))
95	}
77	// Storage: ParachainSystem ValidationData (r:1 w:0)96	// Storage: Promotion Admin (r:1 w:0)
97	// Storage: Common CollectionById (r:1 w:1)
98	fn sponsor_collection() -> Weight {
99		(10_882_000 as Weight)
100			.saturating_add(T::DbWeight::get().reads(2 as Weight))
101			.saturating_add(T::DbWeight::get().writes(1 as Weight))
102	}
78	// Storage: Promotion Staked (r:1 w:1)103	// Storage: Promotion Admin (r:1 w:0)
79	// Storage: Promotion TotalStaked (r:1 w:1)104	// Storage: Common CollectionById (r:1 w:1)
80	fn unstake() -> Weight {105	fn stop_sponsoring_collection() -> Weight {
81		(10_619_000 as Weight)106		(10_544_000 as Weight)
82			.saturating_add(T::DbWeight::get().reads(5 as Weight))107			.saturating_add(T::DbWeight::get().reads(2 as Weight))
83			.saturating_add(T::DbWeight::get().writes(4 as Weight))108			.saturating_add(T::DbWeight::get().writes(1 as Weight))
84	}109	}
85	// Storage: System Account (r:2 w:0)110	// Storage: Promotion Admin (r:1 w:0)
111	// Storage: EvmContractHelpers Sponsoring (r:0 w:1)
112	fn sponsor_contract() -> Weight {
113		(2_163_000 as Weight)
114			.saturating_add(T::DbWeight::get().reads(1 as Weight))
115			.saturating_add(T::DbWeight::get().writes(1 as Weight))
116	}
86	// Storage: Promotion Staked (r:0 w:1)117	// Storage: Promotion Admin (r:1 w:0)
118	// Storage: EvmContractHelpers Sponsoring (r:1 w:1)
87	fn recalculate_stake() -> Weight {119	fn stop_sponsoring_contract() -> Weight {
88		(4_932_000 as Weight)120		(3_511_000 as Weight)
89			.saturating_add(T::DbWeight::get().reads(2 as Weight))121			.saturating_add(T::DbWeight::get().reads(2 as Weight))
90			.saturating_add(T::DbWeight::get().writes(1 as Weight))122			.saturating_add(T::DbWeight::get().writes(1 as Weight))
91	}123	}
92}124}
93125
94// For backwards compatibility and tests126// For backwards compatibility and tests
95impl WeightInfo for () {127impl WeightInfo for () {
96	// Storage: Promotion PendingUnstake (r:1 w:0)128	// Storage: Promotion StartBlock (r:1 w:1)
129	// Storage: ParachainSystem ValidationData (r:1 w:0)
97	// Storage: Promotion NextInterestBlock (r:1 w:0)130	// Storage: Promotion NextInterestBlock (r:0 w:1)
98	fn on_initialize() -> Weight {131	fn start_app_promotion() -> Weight {
99		(2_705_000 as Weight)132		(2_299_000 as Weight)
133			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
100			.saturating_add(RocksDbWeight::get().reads(2 as Weight))134			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
101	}135	}
102	// Storage: Promotion StartBlock (r:1 w:1)136	// Storage: Promotion StartBlock (r:1 w:1)
103	// Storage: Promotion NextInterestBlock (r:0 w:1)137	// Storage: Promotion NextInterestBlock (r:0 w:1)
104	fn start_app_promotion() -> Weight {138	fn stop_app_promotion() -> Weight {
105		(1_436_000 as Weight)139		(1_733_000 as Weight)
106			.saturating_add(RocksDbWeight::get().reads(1 as Weight))140			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
107			.saturating_add(RocksDbWeight::get().writes(2 as Weight))141			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
108	}142	}
109	// Storage: Promotion Admin (r:0 w:1)143	// Storage: Promotion Admin (r:0 w:1)
110	fn set_admin_address() -> Weight {144	fn set_admin_address() -> Weight {
111		(516_000 as Weight)145		(553_000 as Weight)
112			.saturating_add(RocksDbWeight::get().writes(1 as Weight))146			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
113	}147	}
148	// Storage: Promotion Admin (r:1 w:0)
149	fn payout_stakers() -> Weight {
150		(1_398_000 as Weight)
151			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
152	}
114	// Storage: System Account (r:1 w:1)153	// Storage: System Account (r:1 w:1)
115	// Storage: Balances Locks (r:1 w:1)154	// Storage: Balances Locks (r:1 w:1)
116	// Storage: ParachainSystem ValidationData (r:1 w:0)155	// Storage: ParachainSystem ValidationData (r:1 w:0)
117	// Storage: Promotion Staked (r:1 w:1)156	// Storage: Promotion Staked (r:1 w:1)
118	// Storage: Promotion TotalStaked (r:1 w:1)
119	fn stake() -> Weight {157	fn stake() -> Weight {
120		(10_019_000 as Weight)158		(9_506_000 as Weight)
121			.saturating_add(RocksDbWeight::get().reads(5 as Weight))159			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
122			.saturating_add(RocksDbWeight::get().writes(4 as Weight))160			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
123	}161	}
124	// Storage: System Account (r:1 w:1)162	// Storage: System Account (r:1 w:0)
163	fn unstake() -> Weight {
164		(2_529_000 as Weight)
165			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
166	}
125	// Storage: Balances Locks (r:1 w:1)167	// Storage: System Account (r:1 w:0)
168	fn recalculate_stake() -> Weight {
169		(2_203_000 as Weight)
170			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
171	}
126	// Storage: ParachainSystem ValidationData (r:1 w:0)172	// Storage: Promotion Admin (r:1 w:0)
173	// Storage: Common CollectionById (r:1 w:1)
174	fn sponsor_collection() -> Weight {
175		(10_882_000 as Weight)
176			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
177			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
178	}
127	// Storage: Promotion Staked (r:1 w:1)179	// Storage: Promotion Admin (r:1 w:0)
128	// Storage: Promotion TotalStaked (r:1 w:1)180	// Storage: Common CollectionById (r:1 w:1)
129	fn unstake() -> Weight {181	fn stop_sponsoring_collection() -> Weight {
130		(10_619_000 as Weight)182		(10_544_000 as Weight)
131			.saturating_add(RocksDbWeight::get().reads(5 as Weight))183			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
132			.saturating_add(RocksDbWeight::get().writes(4 as Weight))184			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
133	}185	}
134	// Storage: System Account (r:2 w:0)186	// Storage: Promotion Admin (r:1 w:0)
187	// Storage: EvmContractHelpers Sponsoring (r:0 w:1)
188	fn sponsor_contract() -> Weight {
189		(2_163_000 as Weight)
190			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
191			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
192	}
135	// Storage: Promotion Staked (r:0 w:1)193	// Storage: Promotion Admin (r:1 w:0)
194	// Storage: EvmContractHelpers Sponsoring (r:1 w:1)
136	fn recalculate_stake() -> Weight {195	fn stop_sponsoring_contract() -> Weight {
137		(4_932_000 as Weight)196		(3_511_000 as Weight)
138			.saturating_add(RocksDbWeight::get().reads(2 as Weight))197			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
139			.saturating_add(RocksDbWeight::get().writes(1 as Weight))198			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
140	}199	}