git.delta.rocks / unique-network / refs/commits / 35a9f8c20edd

5304 "frame-support",5304 "frame-support",
5305 "frame-system",5305 "frame-system",
5306 "pallet-balances",5306 "pallet-balances",
5307 "pallet-common",
5307 "pallet-evm",5308 "pallet-evm",
5308 "pallet-randomness-collective-flip",5309 "pallet-randomness-collective-flip",
5309 "pallet-timestamp",5310 "pallet-timestamp",
5311 "pallet-unique",
5310 "parity-scale-codec 3.1.5",5312 "parity-scale-codec 3.1.5",
5311 "scale-info",5313 "scale-info",
5312 "serde",5314 "serde",
5313 "sp-core",5315 "sp-core",
5314 "sp-io",5316 "sp-io",
5315 "sp-runtime",5317 "sp-runtime",
5316 "sp-std",5318 "sp-std",
5319 "up-data-structs",
5317]5320]
53185321
5319[[package]]5322[[package]]

104git = "https://github.com/uniquenetwork/frontier"104git = "https://github.com/uniquenetwork/frontier"
105branch = "unique-polkadot-v0.9.27"105branch = "unique-polkadot-v0.9.27"
106
107################################################################################
108# local dependencies
109[dependencies.up-data-structs]
110default-features = false
111path =  "../../primitives/data-structs"
112
113[dependencies.pallet-common]
114default-features = false
115path =  "../common"
116
117[dependencies.pallet-unique]
118default-features = false
119path =  "../unique"
120
121################################################################################
106122
107[dependencies]123[dependencies]
108scale-info = { version = "2.0.1", default-features = false, features = [124scale-info = { version = "2.0.1", default-features = false, features = [

59		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());59		let _ = T::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))?;60		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?;
6161
62	} : {PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?}62	} : {PromototionPallet::<T>::unstake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?}
6363
64	recalculate_stake {64	recalculate_stake {
65		let caller = account::<T::AccountId>("caller", 0, SEED);65		let caller = account::<T::AccountId>("caller", 0, SEED);

36pub mod types;36pub mod types;
37pub mod weights;37pub mod weights;
3838
39use sp_std::{vec::Vec, iter::Sum};39use sp_std::{vec::Vec, iter::Sum, borrow::ToOwned};
40use codec::EncodeLike;40use codec::EncodeLike;
41use pallet_balances::BalanceLock;41use pallet_balances::BalanceLock;
42pub use types::ExtendedLockableCurrency;42pub use types::ExtendedLockableCurrency;
43
44// use up_common::constants::{DAYS, UNIQUE};
45use up_data_structs::CollectionId;
4346
44use frame_support::{47use frame_support::{
45	dispatch::{DispatchResult},48	dispatch::{DispatchResult},
55use pallet_evm::account::CrossAccountId;58use pallet_evm::account::CrossAccountId;
56use sp_runtime::{59use sp_runtime::{
57	Perbill,60	Perbill,
58	traits::{BlockNumberProvider, CheckedAdd, CheckedSub},61	traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion},
59	ArithmeticError,62	ArithmeticError,
60};63};
6164
62type BalanceOf<T> =65type BalanceOf<T> =
63	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;66	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
6467
65const SECONDS_TO_BLOCK: u32 = 6;68// const SECONDS_TO_BLOCK: u32 = 6;
66const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK;69// const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK;
67const WEEK: u32 = 7 * DAY;70// const WEEK: u32 = 7 * DAY;
68const TWO_WEEK: u32 = 2 * WEEK;71// const TWO_WEEK: u32 = 2 * WEEK;
69const YEAR: u32 = DAY * 365;72// const YEAR: u32 = DAY * 365;
7073
71pub const LOCK_IDENTIFIER: [u8; 8] = *b"appstake";74pub const LOCK_IDENTIFIER: [u8; 8] = *b"appstake";
7275
73#[frame_support::pallet]76#[frame_support::pallet]
74pub mod pallet {77pub mod pallet {
75	use super::*;78	use super::*;
76	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};79	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId};
77	use frame_system::pallet_prelude::*;80	use frame_system::pallet_prelude::*;
81	use types::CollectionHandler;
7882
79	#[pallet::config]83	#[pallet::config]
80	pub trait Config: frame_system::Config + pallet_evm::account::Config {84	pub trait Config: frame_system::Config + pallet_evm::account::Config {
81		type Currency: ExtendedLockableCurrency<Self::AccountId>;85		type Currency: ExtendedLockableCurrency<Self::AccountId>;
86
87		type CollectionHandler: CollectionHandler<
88			AccountId = Self::AccountId,
89			CollectionId = CollectionId,
90		>;
8291
83		type TreasuryAccountId: Get<Self::AccountId>;92		type TreasuryAccountId: Get<Self::AccountId>;
93
94		/// The app's pallet id, used for deriving its sovereign account ID.
95		#[pallet::constant]
96		type PalletId: Get<PalletId>;
97
98		/// In relay blocks.
99		#[pallet::constant]
100		type RecalculationInterval: Get<Self::BlockNumber>;
101		/// In chain blocks.
102		#[pallet::constant]
103		type PendingInterval: Get<Self::BlockNumber>;
104
105		/// In chain blocks.
106		#[pallet::constant]
107		type Day: Get<Self::BlockNumber>; // useless
108
109		#[pallet::constant]
110		type Nominal: Get<BalanceOf<Self>>;
111
112		#[pallet::constant]
113		type IntervalIncome: Get<Perbill>;
84114
85		/// Weight information for extrinsics in this pallet.115		/// Weight information for extrinsics in this pallet.
86		type WeightInfo: WeightInfo;116		type WeightInfo: WeightInfo;
87117
88		// The block number provider118		// The relay block number provider
89		type BlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;119		type RelayBlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;
120
121		/// Events compatible with [`frame_system::Config::Event`].
122		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;
90123
91		// /// Number of blocks that pass between treasury balance updates due to inflation124		// /// Number of blocks that pass between treasury balance updates due to inflation
92		// #[pallet::constant]125		// #[pallet::constant]
100	#[pallet::generate_store(pub(super) trait Store)]133	#[pallet::generate_store(pub(super) trait Store)]
101	pub struct Pallet<T>(_);134	pub struct Pallet<T>(_);
135
136	#[pallet::event]
137	#[pallet::generate_deposit(fn deposit_event)]
138	pub enum Event<T: Config> {
139		StakingRecalculation(
140			/// Base on which interest is calculated
141			BalanceOf<T>,
142			/// Amount of accrued interest
143			BalanceOf<T>,
144		),
145	}
146
147	#[pallet::error]
148	pub enum Error<T> {
149		AdminNotSet,
150		/// No permission to perform action
151		NoPermission,
152		/// Insufficient funds to perform an action
153		NotSufficientFounds,
154		InvalidArgument,
155		AlreadySponsored,
156	}
102157
103	#[pallet::storage]158	#[pallet::storage]
104	pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;159	pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;
164				});219				});
165220
166			let next_interest_block = Self::get_interest_block();221			let next_interest_block = Self::get_interest_block();
167222			let current_relay_block = T::RelayBlockNumberProvider::current_block_number();
168			if next_interest_block != 0.into() && current_block >= next_interest_block {223			if next_interest_block != 0.into() && current_relay_block >= next_interest_block {
169				let mut acc = <BalanceOf<T>>::default();224				let mut acc = <BalanceOf<T>>::default();
225				let mut base_acc = <BalanceOf<T>>::default();
170226
171				NextInterestBlock::<T>::set(current_block + DAY.into());227				NextInterestBlock::<T>::set(
228					NextInterestBlock::<T>::get() + T::RecalculationInterval::get(),
229				);
172				add_weight(0, 1, 0);230				add_weight(0, 1, 0);
173231
174				Staked::<T>::iter()232				Staked::<T>::iter()
175					.filter(|((_, block), _)| *block + DAY.into() <= current_block)233					.filter(|((_, block), _)| {
234						*block + T::RecalculationInterval::get() <= current_relay_block
235					})
176					.for_each(|((staker, block), amount)| {236					.for_each(|((staker, block), amount)| {
177						Self::recalculate_stake(&staker, block, amount, &mut acc);237						Self::recalculate_stake(&staker, block, amount, &mut acc);
178						add_weight(0, 0, T::WeightInfo::recalculate_stake());238						add_weight(0, 0, T::WeightInfo::recalculate_stake());
239						base_acc += amount;
179					});240					});
180				<TotalStaked<T>>::get()241				<TotalStaked<T>>::get()
181					.checked_add(&acc)242					.checked_add(&acc)
182					.map(|res| <TotalStaked<T>>::set(res));243					.map(|res| <TotalStaked<T>>::set(res));
244
245				Self::deposit_event(Event::StakingRecalculation(base_acc, acc));
183				add_weight(0, 1, 0);246				add_weight(0, 1, 0);
184			};247			} else {
248				add_weight(1, 0, 0)
249			};
185			consumed_weight250			consumed_weight
186		}251		}
187	}252	}
188253
189	#[pallet::call]254	#[pallet::call]
190	impl<T: Config> Pallet<T> {255	impl<T: Config> Pallet<T> {
191		#[pallet::weight(T::WeightInfo::set_admin_address())]256		#[pallet::weight(T::WeightInfo::set_admin_address())]
192		pub fn set_admin_address(origin: OriginFor<T>, admin: T::AccountId) -> DispatchResult {257		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {
193			ensure_root(origin)?;258			ensure_root(origin)?;
194			<Admin<T>>::set(Some(admin));259			<Admin<T>>::set(Some(admin.as_sub().to_owned()));
195260
196			Ok(())261			Ok(())
197		}262		}
198263
199		#[pallet::weight(T::WeightInfo::start_app_promotion())]264		#[pallet::weight(T::WeightInfo::start_app_promotion())]
200		pub fn start_app_promotion(265		pub fn start_app_promotion(
201			origin: OriginFor<T>,266			origin: OriginFor<T>,
202			promotion_start_relay_block: T::BlockNumber,267			promotion_start_relay_block: Option<T::BlockNumber>,
203		) -> DispatchResult268		) -> DispatchResult
204		where269		where
205			<T as frame_system::Config>::BlockNumber: From<u32>,270			<T as frame_system::Config>::BlockNumber: From<u32>,
208273
209			// Start app-promotion mechanics if it has not been yet initialized274			// Start app-promotion mechanics if it has not been yet initialized
210			if <StartBlock<T>>::get() == 0u32.into() {275			if <StartBlock<T>>::get() == 0u32.into() {
276				let start_block = promotion_start_relay_block
277					.unwrap_or(T::RelayBlockNumberProvider::current_block_number());
278
211				// Set promotion global start block279				// Set promotion global start block
212				<StartBlock<T>>::set(promotion_start_relay_block);280				<StartBlock<T>>::set(start_block);
213281
214				<NextInterestBlock<T>>::set(promotion_start_relay_block + DAY.into());282				<NextInterestBlock<T>>::set(start_block + T::RecalculationInterval::get());
215			}283			}
216284
217			Ok(())285			Ok(())
221		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {289		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
222			let staker_id = ensure_signed(staker)?;290			let staker_id = ensure_signed(staker)?;
291
292			ensure!(amount >= T::Nominal::get(), ArithmeticError::Underflow);
223293
224			let balance =294			let balance =
225				<<T as Config>::Currency as Currency<T::AccountId>>::free_balance(&staker_id);295				<<T as Config>::Currency as Currency<T::AccountId>>::free_balance(&staker_id);
235305
236			Self::add_lock_balance(&staker_id, amount)?;306			Self::add_lock_balance(&staker_id, amount)?;
237307
238			let block_number = frame_system::Pallet::<T>::block_number();308			let block_number = T::RelayBlockNumberProvider::current_block_number();
239309
240			<Staked<T>>::insert(310			<Staked<T>>::insert(
241				(&staker_id, block_number),311				(&staker_id, block_number),
271					.ok_or(ArithmeticError::Underflow)?,341					.ok_or(ArithmeticError::Underflow)?,
272			);342			);
273343
274			let block = frame_system::Pallet::<T>::block_number() + WEEK.into();344			let block = frame_system::Pallet::<T>::block_number() + T::PendingInterval::get();
275			<PendingUnstake<T>>::insert(345			<PendingUnstake<T>>::insert(
276				(&staker_id, block),346				(&staker_id, block),
277				<PendingUnstake<T>>::get((&staker_id, block))347				<PendingUnstake<T>>::get((&staker_id, block))
312			Ok(())382			Ok(())
313		}383		}
384
385		#[pallet::weight(0)]
386		pub fn sponsor_collection(
387			admin: OriginFor<T>,
388			collection_id: CollectionId,
389		) -> DispatchResult {
390			let admin_id = ensure_signed(admin)?;
391			ensure!(
392				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,
393				Error::<T>::NoPermission
394			);
395
396			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)
397		}
398		#[pallet::weight(0)]
399		pub fn stop_sponsorign_collection(
400			admin: OriginFor<T>,
401			collection_id: CollectionId,
402		) -> DispatchResult {
403			let admin_id = ensure_signed(admin)?;
404
405			ensure!(
406				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,
407				Error::<T>::NoPermission
408			);
409
410			ensure!(
411				T::CollectionHandler::get_sponsor(collection_id)?
412					.ok_or(<Error<T>>::InvalidArgument)?
413					== Self::account_id(),
414				<Error<T>>::NoPermission
415			);
416			T::CollectionHandler::remove_collection_sponsor(collection_id)
417		}
314	}418	}
315}419}
316420
396	// 	Ok(())500	// 	Ok(())
397	// }501	// }
398502
399	pub fn sponsor_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult {503	// pub fn sponsor_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult {
400		Ok(())504	// 	Ok(())
401	}505	// }
402506
403	pub fn stop_sponsorign_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult {507	// pub fn stop_sponsorign_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult {
404		Ok(())508	// 	Ok(())
405	}509	// }
406510
407	pub fn sponsor_conract(admin: T::AccountId, app_id: u32) -> DispatchResult {511	pub fn sponsor_conract(admin: T::AccountId, app_id: u32) -> DispatchResult {
408		Ok(())512		Ok(())
412		Ok(())516		Ok(())
413	}517	}
518
519	pub fn account_id() -> T::AccountId {
520		T::PalletId::get().into_account_truncating()
521	}
414}522}
415523
416impl<T: Config> Pallet<T> {524impl<T: Config> Pallet<T> {
514	where622	where
515		I: EncodeLike<BalanceOf<T>> + Balance,623		I: EncodeLike<BalanceOf<T>> + Balance,
516	{624	{
517		let day_rate = Perbill::from_rational(5u32, 1_0000);625		T::IntervalIncome::get() * base
518		day_rate * base
519	}626	}
520}627}
521628

28use sp_runtime::{28use sp_runtime::{
29	traits::{BlakeTwo256, BlockNumberProvider, IdentityLookup},29	traits::{BlakeTwo256, BlockNumberProvider, IdentityLookup},
30	testing::Header,30	testing::Header,
31	Perbill,31	Perbill, Perquintill,
32};32};
3333
34// type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;34// type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
127// 	} )127// 	} )
128// }128// }
129
130#[test]
131fn test_perbill() {
132	const ONE_UNIQE: u128 = 1_000_000_000_000_000_000;
133	const SECONDS_TO_BLOCK: u32 = 12;
134	const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK;
135	const RECALCULATION_INTERVAL: u32 = 10;
136	let day_rate = Perbill::from_rational(5u64, 10_000);
137	let interval_rate =
138		Perbill::from_rational::<u64>(RECALCULATION_INTERVAL.into(), DAY.into()) * day_rate;
139	println!("{:?}", interval_rate * ONE_UNIQE + ONE_UNIQE);
140	println!("{:?}", day_rate * ONE_UNIQE);
141	println!("{:?}", Perbill::one() * ONE_UNIQE);
142	println!("{:?}", ONE_UNIQE);
143	let mut next_iters = ONE_UNIQE + interval_rate * ONE_UNIQE;
144	next_iters += interval_rate * next_iters;
145	println!("{:?}", next_iters);
146	let day_income = day_rate * ONE_UNIQE;
147	let interval_income = interval_rate * ONE_UNIQE;
148	let ratio = day_income / interval_income;
149	println!("{:?} || {:?}", ratio, DAY / RECALCULATION_INTERVAL);
150}
129151

1use codec::EncodeLike;1use codec::EncodeLike;
2use frame_support::{traits::LockableCurrency, WeakBoundedVec, Parameter};2use frame_support::{
3	traits::LockableCurrency, WeakBoundedVec, Parameter, dispatch::DispatchResult, ensure,
4};
5use frame_system::Config;
3use pallet_balances::{BalanceLock, Config as BalancesConfig, Pallet as PalletBalances};6use pallet_balances::{BalanceLock, Config as BalancesConfig, Pallet as PalletBalances};
7use pallet_common::CollectionHandle;
8use pallet_unique::{Event as UniqueEvent, Error as UniqueError};
9use sp_runtime::DispatchError;
10use up_data_structs::{CollectionId, SponsorshipState};
11use sp_std::borrow::ToOwned;
412
5pub trait ExtendedLockableCurrency<AccountId: Parameter>: LockableCurrency<AccountId> {13pub trait ExtendedLockableCurrency<AccountId: Parameter>: LockableCurrency<AccountId> {
6	fn locks<KArg>(who: KArg) -> WeakBoundedVec<BalanceLock<Self::Balance>, Self::MaxLocks>14	fn locks<KArg>(who: KArg) -> WeakBoundedVec<BalanceLock<Self::Balance>, Self::MaxLocks>
19	}27	}
20}28}
29
30pub trait CollectionHandler {
31	type CollectionId;
32	type AccountId;
33
34	fn set_sponsor(
35		sponsor_id: Self::AccountId,
36		collection_id: Self::CollectionId,
37	) -> DispatchResult;
38
39	fn remove_collection_sponsor(collection_id: Self::CollectionId) -> DispatchResult;
40
41	fn get_sponsor(
42		collection_id: Self::CollectionId,
43	) -> Result<Option<Self::AccountId>, DispatchError>;
44}
45
46impl<T: pallet_unique::Config> CollectionHandler for pallet_unique::Pallet<T> {
47	type CollectionId = CollectionId;
48
49	type AccountId = T::AccountId;
50
51	fn set_sponsor(
52		sponsor_id: Self::AccountId,
53		collection_id: Self::CollectionId,
54	) -> DispatchResult {
55		let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
56		target_collection.check_is_internal()?;
57		target_collection.set_sponsor(sponsor_id.clone())?;
58
59		Self::deposit_event(UniqueEvent::<T>::CollectionSponsorSet(
60			collection_id,
61			sponsor_id.clone(),
62		));
63
64		ensure!(
65			target_collection.confirm_sponsorship(&sponsor_id)?,
66			UniqueError::<T>::ConfirmUnsetSponsorFail
67		);
68
69		Self::deposit_event(UniqueEvent::<T>::SponsorshipConfirmed(
70			collection_id,
71			sponsor_id,
72		));
73
74		target_collection.save()
75	}
76
77	fn remove_collection_sponsor(collection_id: Self::CollectionId) -> DispatchResult {
78		let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
79		target_collection.check_is_internal()?;
80		target_collection.sponsorship = SponsorshipState::Disabled;
81
82		Self::deposit_event(UniqueEvent::<T>::CollectionSponsorRemoved(collection_id));
83
84		target_collection.save()
85	}
86
87	fn get_sponsor(
88		collection_id: Self::CollectionId,
89	) -> Result<Option<Self::AccountId>, DispatchError> {
90		Ok(<CollectionHandle<T>>::try_get(collection_id)?
91			.sponsorship
92			.pending_sponsor()
93			.map(|acc| acc.to_owned()))
94	}
95}
2196

277	{277	{
278		type Error = Error<T>;278		type Error = Error<T>;
279279
280		fn deposit_event() = default;280		pub fn deposit_event() = default;
281281
282		fn on_initialize(_now: T::BlockNumber) -> Weight {282		fn on_initialize(_now: T::BlockNumber) -> Weight {
283			0283			0

1616
17use crate::{17use crate::{
18	runtime_common::config::pallets::{TreasuryAccountId, RelayChainBlockNumberProvider},18	runtime_common::config::pallets::{TreasuryAccountId, RelayChainBlockNumberProvider},
19	Runtime, Balances,19	Runtime, Balances, BlockNumber, Unique, Event,
20};20};
21
22use frame_support::{parameter_types, PalletId};
23use sp_arithmetic::Perbill;
24use up_common::{
25	constants::{DAYS, UNIQUE},
26	types::Balance,
27};
28
29parameter_types! {
30	pub const AppPromotionId: PalletId = PalletId(*b"appstake");
31	pub const RecalculationInterval: BlockNumber = 20;
32	pub const PendingInterval: BlockNumber = 10;
33	pub const Nominal: Balance = UNIQUE;
34	pub const Day: BlockNumber = DAYS;
35	pub IntervalIncome: Perbill = Perbill::from_rational(RecalculationInterval::get(), 2 * DAYS) * Perbill::from_rational(5u32, 10_000);
36}
2137
22impl pallet_app_promotion::Config for Runtime {38impl pallet_app_promotion::Config for Runtime {
39	type PalletId = AppPromotionId;
40	type CollectionHandler = Unique;
23	type Currency = Balances;41	type Currency = Balances;
24	type WeightInfo = pallet_app_promotion::weights::SubstrateWeight<Self>;42	type WeightInfo = pallet_app_promotion::weights::SubstrateWeight<Self>;
25	type TreasuryAccountId = TreasuryAccountId;43	type TreasuryAccountId = TreasuryAccountId;
26	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;44	type RelayBlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;
45	type RecalculationInterval = RecalculationInterval;
46	type PendingInterval = PendingInterval;
47	type Day = Day;
48	type Nominal = Nominal;
49	type IntervalIncome = IntervalIncome;
50	type Event = Event;
27}51}
2852

78                RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,78                RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,
7979
80                #[runtimes(opal)]80                #[runtimes(opal)]
81                Promotion: pallet_app_promotion::{Pallet, Call, Storage} = 73,81                Promotion: pallet_app_promotion::{Pallet, Call, Storage, Event<T>} = 73,
8282
83                // Frontier83                // Frontier
84                EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,84                EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,

4040
41import chai, {use} from 'chai';41import chai, {use} from 'chai';
42import chaiAsPromised from 'chai-as-promised';42import chaiAsPromised from 'chai-as-promised';
43import getBalance, {getBalanceSingle} from './substrate/get-balance';
44import {unique} from './interfaces/definitions';
45import {usingPlaygrounds} from './util/playgrounds';43import {usingPlaygrounds} from './util/playgrounds';
46import {default as waitNewBlocks} from './substrate/wait-new-blocks';44import {default as waitNewBlocks} from './substrate/wait-new-blocks';
4745
48import BN from 'bn.js';46import {encodeAddress, hdEthereum, mnemonicGenerate} from '@polkadot/util-crypto';
49import {mnemonicGenerate} from '@polkadot/util-crypto';47import {stringToU8a} from '@polkadot/util';
50import {UniqueHelper} from './util/playgrounds/unique';48import {UniqueHelper} from './util/playgrounds/unique';
49import {ApiPromise} from '@polkadot/api';
51chai.use(chaiAsPromised);50chai.use(chaiAsPromised);
52const expect = chai.expect;51const expect = chai.expect;
5352
54let alice: IKeyringPair;53let alice: IKeyringPair;
55let bob: IKeyringPair;54let bob: IKeyringPair;
56let palletAdmin: IKeyringPair;55let palletAdmin: IKeyringPair;
57let nominal: bigint; 56let nominal: bigint;
57let promotionStartBlock: number | null = null;
5858
59describe('integration test: AppPromotion', () => {59describe('app-promotions.stake extrinsic', () => {
60  before(async function() {60  before(async function() {
61    await usingPlaygrounds(async (helper, privateKeyWrapper) => {61    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
62      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();62      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
63      alice = privateKeyWrapper('//Alice');63      alice = privateKeyWrapper('//Alice');
64      bob = privateKeyWrapper('//Bob');64      bob = privateKeyWrapper('//Bob');
65      palletAdmin = privateKeyWrapper('//palletAdmin');65      palletAdmin = privateKeyWrapper('//palletAdmin');
66      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw));66      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
67      nominal = helper.balance.getOneTokenNominal();67      nominal = helper.balance.getOneTokenNominal();
68      await submitTransactionAsync(alice, tx);68      await helper.signTransaction(alice, tx);
69    });69    });
70  });70  });
71  it('will change balance state to "locked", add it to "staked" map, and increase "totalStaked" amount', async () => {71  it('will change balance state to "locked", add it to "staked" map, and increase "totalStaked" amount', async () => {
85      const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();85      const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();
86      const staker = await createUser();86      const staker = await createUser();
87   87   
88      const firstStakedBlock = await helper.chain.getLatestBlockNumber();
89      88      
90      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;89      
90      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(nominal / 2n))).to.be.eventually.rejected;
91      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
91      expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);92      expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);
92      expect(9n * nominal - await helper.balance.getSubstrate(staker.address) <= nominal / 2n).to.be.true;93      expect(9n * nominal - await helper.balance.getSubstrate(staker.address) <= nominal / 2n).to.be.true;
93      expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);94      expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);
94      expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + nominal);95      expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + nominal);
95      96      
96      await waitNewBlocks(helper.api!, 1);97      await waitNewBlocks(helper.api!, 1);
97      const secondStakedBlock = await helper.chain.getLatestBlockNumber();
98      98      
99      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;99      
100      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
100      expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(3n * nominal);101      expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(3n * nominal);
101      102      
102      const stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]);103      const stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]);
115      116      
116      const staker = await createUser();117      const staker = await createUser();
117      118      
118      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.rejected;119      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.rejected;
119      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(7n * nominal))).to.be.eventually.fulfilled;120      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(7n * nominal))).to.be.eventually.fulfilled;
120      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(4n * nominal))).to.be.eventually.rejected;121      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(4n * nominal))).to.be.eventually.rejected;
121      122      
122    });123    });
123  });124  });
128129
129    // assert:  query appPromotion.staked(Alice/Bob/Charlie/Dave) equal [100]130    // assert:  query appPromotion.staked(Alice/Bob/Charlie/Dave) equal [100]
130    await usingPlaygrounds(async helper => {131    await usingPlaygrounds(async helper => {
131      // const userOne = await createUser();
132      // const userTwo = await createUser();
133      // const userThree = await createUser();
134      // const userFour = await createUser();
135      const crowd = [];132      const crowd = [];
136      for(let i = 4; i--;) crowd.push(await createUser());133      for(let i = 4; i--;) crowd.push(await createUser());
137      // const crowd = await creteAccounts([10n, 10n, 10n, 10n], alice, helper);
138      // const crowd = [userOne, userTwo, userThree, userFour];
139      134      
140      135      const promises = crowd.map(async user => helper.signTransaction(user, helper.api!.tx.promotion.stake(nominal)));
141      const promises = crowd.map(async user => submitTransactionAsync(user, helper.api!.tx.promotion.stake(nominal)));
142      await expect(Promise.all(promises)).to.be.eventually.fulfilled;136      await expect(Promise.all(promises)).to.be.eventually.fulfilled;
143    137    
144      for (let i = 0; i < crowd.length; i++){138      for (let i = 0; i < crowd.length; i++){
156      alice = privateKeyWrapper('//Alice');150      alice = privateKeyWrapper('//Alice');
157      bob = privateKeyWrapper('//Bob');151      bob = privateKeyWrapper('//Bob');
158      palletAdmin = privateKeyWrapper('//palletAdmin');152      palletAdmin = privateKeyWrapper('//palletAdmin');
159      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw));153      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
160      nominal = helper.balance.getOneTokenNominal();154      nominal = helper.balance.getOneTokenNominal();
161      await submitTransactionAsync(alice, tx);155      await helper.signTransaction(alice, tx);
162    });156    });
163  });157  });
164  158  
174    await usingPlaygrounds(async helper => {168    await usingPlaygrounds(async helper => {
175      const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();169      const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();
176      const staker = await createUser();170      const staker = await createUser();
177      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(5n * nominal))).to.be.eventually.fulfilled;171      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(5n * nominal))).to.be.eventually.fulfilled;
178      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(3n * nominal))).to.be.eventually.fulfilled;172      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(3n * nominal))).to.be.eventually.fulfilled;
179      expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal);173      expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal);
180      expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(2n * nominal);174      expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(2n * nominal);
181      expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + 2n * nominal);175      expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + 2n * nominal);
204    await usingPlaygrounds(async helper => {198    await usingPlaygrounds(async helper => {
205      const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();199      const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();
206      const staker = await createUser();200      const staker = await createUser();
207      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;201      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
208      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;202      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
209      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(3n * nominal))).to.be.eventually.fulfilled;203      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(3n * nominal))).to.be.eventually.fulfilled;
210      let stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());204      let stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());
211      expect(stakedPerBlock).to.be.deep.equal([nominal, 2n * nominal, 3n * nominal]);205      expect(stakedPerBlock).to.be.deep.equal([nominal, 2n * nominal, 3n * nominal]);
212      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(3n * nominal / 10n))).to.be.eventually.fulfilled;206      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(3n * nominal / 10n))).to.be.eventually.fulfilled;
213      expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal / 10n);207      expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal / 10n);
214      stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());208      stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());
215      209      
216      expect(stakedPerBlock).to.be.deep.equal([7n * nominal / 10n, 2n * nominal, 3n * nominal]);210      expect(stakedPerBlock).to.be.deep.equal([7n * nominal / 10n, 2n * nominal, 3n * nominal]);
217      211      
218      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(17n * nominal / 10n))).to.be.eventually.fulfilled;212      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(17n * nominal / 10n))).to.be.eventually.fulfilled;
219      stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());213      stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());
220      expect(stakedPerBlock).to.be.deep.equal([nominal, 3n * nominal]);214      expect(stakedPerBlock).to.be.deep.equal([nominal, 3n * nominal]);
221      const unstakedPerBlock = (await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());215      const unstakedPerBlock = (await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());
222      216      
223      expect(unstakedPerBlock).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n]);217      expect(unstakedPerBlock).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n]);
224      218      
225      await waitNewBlocks(helper.api!, 1);219      await waitNewBlocks(helper.api!, 1);
226      await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(4n * nominal))).to.be.eventually.fulfilled;220      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(4n * nominal))).to.be.eventually.fulfilled;
227      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([]);221      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([]);
228      expect((await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n, 4n * nominal]);222      expect((await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n, 4n * nominal]);
229    });223    });
233227
228
229
230describe('Admin adress', () => {
231  before(async function () {
232    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
233      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
234      alice = privateKeyWrapper('//Alice');
235      bob = privateKeyWrapper('//Bob');
236      palletAdmin = privateKeyWrapper('//palletAdmin');
237      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());
238      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
239      
240      await helper.signTransaction(alice, tx);
241      
242      nominal = helper.balance.getOneTokenNominal();
243    });
244  });
245
246  it('can be set by sudo only', async () => {
247    // assert:  Sudo calls appPromotion.setAdminAddress(Alice) /// Sudo successfully sets Alice as admin
248    // assert:  Bob calls appPromotion.setAdminAddress(Bob) throws /// Random account can not set admin
249    // assert:  Alice calls appPromotion.setAdminAddress(Bob) throws /// Admin account can not set admin
250    await usingPlaygrounds(async (helper) => {
251      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(alice))))).to.be.eventually.fulfilled;
252      await expect(helper.signTransaction(bob, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.rejected;
253      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.fulfilled;
254    });
255    
256  });
257  
258  it('can be any valid CrossAccountId', async () => {
259    /// We are not going to set an eth address as a sponsor,
260    /// but we do want to check, it doesn't break anything;
261
262    // arrange: Charlie creates Punks
263    // arrange: Sudo calls appPromotion.setAdminAddress(0x0...) success
264    // arrange: Sudo calls appPromotion.setAdminAddress(Alice) success
265    
266    // assert:  Alice calls appPromotion.sponsorCollection(Punks.id) success
267    
268    await usingPlaygrounds(async (helper) => {
269      
270      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
271      
272      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(ethAcc)))).to.be.eventually.fulfilled;
273      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))))).to.be.eventually.fulfilled;
274      
275      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
276      
277      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
278    });
279    
280  });
281
282  it('can be reassigned', async () => {
283    // arrange: Charlie creates Punks
284    // arrange: Sudo calls appPromotion.setAdminAddress(Alice)
285    // act:     Sudo calls appPromotion.setAdminAddress(Bob)
286
287    // assert:  Alice calls appPromotion.sponsorCollection(Punks.id) throws /// Alice can not set collection sponsor
288    // assert:  Bob calls appPromotion.sponsorCollection(Punks.id) successful /// Bob can set collection sponsor
289
290    // act:     Sudo calls appPromotion.setAdminAddress(null) successful /// Sudo can set null as a sponsor
291    // assert:  Bob calls appPromotion.stopSponsoringCollection(Punks.id) throws /// Bob is no longer an admin
292    
293    await usingPlaygrounds(async (helper) => {
294      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
295      
296      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(alice))))).to.be.eventually.fulfilled;
297      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.fulfilled;
298      await expect(helper.signTransaction(alice, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
299      
300      await expect(helper.signTransaction(bob, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
301    });
302    
303  });
304
305});
306
307describe('App-promotion collection sponsoring', () => {
308  before(async function () {
309    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
310      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
311      alice = privateKeyWrapper('//Alice');
312      bob = privateKeyWrapper('//Bob');
313      palletAdmin = privateKeyWrapper('//palletAdmin');
314      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());
315      await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());
316       
317      
318      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
319      await helper.signTransaction(alice, tx);
320      
321      // const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock));
322      // await helper.signTransaction(alice, txStart);
323      
324      nominal = helper.balance.getOneTokenNominal();
325    });
326  });
327    
328  it('can not be set by non admin', async () => {
329    
330    
331    // arrange: Charlie creates Punks
332    // arrange: Sudo calls appPromotion.setAdminAddress(Alice)
333
334    // assert:  Random calls appPromotion.sponsorCollection(Punks.id) throws /// Random account can not set sponsoring
335    // assert:  Alice calls appPromotion.sponsorCollection(Punks.id) success /// Admin account can set sponsoring
336    
337    await usingPlaygrounds(async (helper) => {
338      const colletcion  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
339      
340      const collectionId = colletcion.collectionId;
341      
342      await expect(helper.signTransaction(bob, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.rejected;
343      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
344    });
345    
346  });
347
348  it('will set pallet address as confirmed admin for collection without sponsor', async () => {
349    // arrange: Charlie creates Punks
350
351    // act:     Admin calls appPromotion.sponsorCollection(Punks.id)
352
353    // assert:  query collectionById: Punks sponsoring is confirmed by PalleteAddress
354    
355    await usingPlaygrounds(async (helper) => {
356      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
357      const collectionId = collection.collectionId;
358
359      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
360      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
361    });
362    
363  });
364
365  it('will set pallet address as confirmed admin for collection with unconfirmed sponsor', async () => {
366    // arrange: Charlie creates Punks
367    // arrange: Charlie calls setCollectionSponsor(Punks.Id, Dave) /// Dave is unconfirmed sponsor
368
369    // act:     Admin calls appPromotion.sponsorCollection(Punks.id)
370
371    // assert:  query collectionById: Punks sponsoring is confirmed by PalleteAddress
372    
373    await usingPlaygrounds(async (helper) => {
374      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
375      await collection.setSponsor(alice, bob.address);
376      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});
377      
378      const collectionId = collection.collectionId;
379      
380      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
381      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
382    });
383    
384  });
385
386  it('will set pallet address as confirmed admin for collection with confirmed sponsor', async () => {
387    // arrange: Charlie creates Punks
388    // arrange: setCollectionSponsor(Punks.Id, Dave)
389    // arrange: confirmSponsorship(Punks.Id, Dave) /// Dave is confirmed sponsor
390
391    // act:     Admin calls appPromotion.sponsorCollection(Punks.id)
392
393    // assert:  query collectionById: Punks sponsoring is confirmed by PalleteAddress
394    
395    await usingPlaygrounds(async (helper) => {
396      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
397      await collection.setSponsor(alice, bob.address);
398  
399      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});
400      expect(await collection.confirmSponsorship(bob)).to.be.true;
401      
402      const collectionId = collection.collectionId;
403      
404      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
405      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
406    });
407  });
408
409  it('can be overwritten by collection owner', async () => {
410    // arrange: Charlie creates Punks
411    // arrange: appPromotion.sponsorCollection(Punks.Id)  /// Sponsor of Punks is pallete
412
413    // act:     Charlie calls unique.setCollectionLimits(limits) /// Charlie as owner can successfully change limits
414    // assert:  query collectionById(Punks.id) 1. sponsored by pallete, 2. limits has been changed
415
416    // act:     Charlie calls setCollectionSponsor(Dave) /// Collection owner reasignes sponsoring
417    // assert:  query collectionById: Punks sponsoring is unconfirmed by Dave
418    
419    await usingPlaygrounds(async (helper) => {
420      const collection  = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
421      const collectionId = collection.collectionId;
422      
423      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
424      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
425      
426      expect(await collection.setLimits(alice, {sponsorTransferTimeout: 0})).to.be.true;
427      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);
428      
429      expect((await collection.setSponsor(alice, bob.address))).to.be.true;
430      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});
431    });
432    
433  });
434  
435  it('will keep collection limits set by the owner earlier', async () => {
436    // arrange: const limits = {...all possible collection limits}
437    // arrange: Charlie creates Punks
438    // arrange: Charlie calls unique.setCollectionLimits(limits) /// Owner sets all possible limits
439
440    // act:     Admin calls appPromotion.sponsorCollection(Punks.id)
441    // assert:  query collectionById(Punks.id) returns limits
442    
443    await usingPlaygrounds(async (helper) => {
444      
445      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
446      expect(await collection.setLimits(alice, {sponsorTransferTimeout: 0})).to.be.true;
447      const limits = (await collection.getData())?.raw.limits;
448      
449      const collectionId = collection.collectionId;
450      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
451      expect((await collection.getData())?.raw.limits).to.be.deep.equal(limits);
452    });
453    
454  });
455  
456  it('will throw if collection doesn\'t exist', async () => {
457    // assert:  Admin calls appPromotion.sponsorCollection(999999999999999) throw 
458    await usingPlaygrounds(async (helper) => {
459      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(999999999))).to.be.eventually.rejected;
460    });
461  });
462
463  it('will throw if collection was burnt', async () => {
464    // arrange: Charlie creates Punks
465    // arrange: Charlie burns Punks
466
467    // assert:  Admin calls appPromotion.sponsorCollection(Punks.id) throw
468    
469    await usingPlaygrounds(async (helper) => {
470      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
471      const collectionId = collection.collectionId;
472      
473      expect((await collection.burn(alice))).to.be.true;
474      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.rejected;
475    });
476    
477  });
478});
479
480
481describe('app-promotion stopSponsoringCollection', () => {
482  before(async function () {
483    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
484      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
485      alice = privateKeyWrapper('//Alice');
486      bob = privateKeyWrapper('//Bob');
487      palletAdmin = privateKeyWrapper('//palletAdmin');
488      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());
489      await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());
490       
491      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
492      await helper.signTransaction(alice, tx);
493
494      nominal = helper.balance.getOneTokenNominal();
495    });
496  });
497  
498  it('can not be called by non-admin', async () => {
499    // arrange: Alice creates Punks
500    // arrange: appPromotion.sponsorCollection(Punks.Id)
501
502    // assert:  Random calls appPromotion.stopSponsoringCollection(Punks) throws
503    // assert:  query collectionById(Punks.id): sponsoring confirmed by PalleteAddress
504    
505    await usingPlaygrounds(async (helper) => {
506      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
507      const collectionId = collection.collectionId;
508      
509      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
510      
511      await expect(helper.signTransaction(bob, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;
512      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});
513    });
514  });
515
516  it('will set sponsoring as disabled', async () => {
517    // arrange: Alice creates Punks
518    // arrange: appPromotion.sponsorCollection(Punks.Id)
519
520    // act:     Admin calls appPromotion.stopSponsoringCollection(Punks)
521
522    // assert:  query collectionById(Punks.id): sponsoring unconfirmed
523    
524    await usingPlaygrounds(async (helper) => {
525      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
526      const collectionId = collection.collectionId;
527      
528      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
529      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.fulfilled;
530      
531      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');
532    });
533  });
534
535  it('will not affect collection which is not sponsored by pallete', async () => {
536    // arrange: Alice creates Punks
537    // arrange: Alice calls setCollectionSponsoring(Punks)
538    // arrange: Alice calls confirmSponsorship(Punks)
539
540    // act:     Admin calls appPromotion.stopSponsoringCollection(A)
541    // assert:  query collectionById(Punks): Sponsoring: {Confirmed: Alice} /// Alice still collection owner
542    
543    await usingPlaygrounds(async (helper) => {
544      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
545      const collectionId = collection.collectionId;
546      expect(await collection.setSponsor(alice, alice.address)).to.be.true;
547      expect(await collection.confirmSponsorship(alice)).to.be.true;
548      
549      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;
550      
551      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: alice.address});
552    });
553    
554  });
555
556  it('will throw if collection does not exist', async () => {
557    // arrange: Alice creates Punks
558    // arrange: Alice burns Punks
559
560    // assert:  Admin calls appPromotion.stopSponsoringCollection(Punks.id) throws
561    // assert:  Admin calls appPromotion.stopSponsoringCollection(999999999999999) throw
562    
563    await usingPlaygrounds(async (helper) => {
564      const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
565      const collectionId = collection.collectionId;
566      
567      expect((await collection.burn(alice))).to.be.true;
568      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;
569    });
570  });
571});
572
573describe('app-promotion contract sponsoring', () => {
574  it('will set contract sponsoring mode and set palletes address as a sponsor', async () => {
575    // arrange: Alice deploys Flipper
576    
577    // act:     Admin calls appPromotion.sponsorContract(Flipper.address)
578
579    // assert:  contract.sponsoringMode = TODO
580    // assert:  contract.sponsor to be PalleteAddress
581  });
582
583  it('will overwrite sponsoring mode and existed sponsor', async () => {
584    // arrange: Alice deploys Flipper
585    // arrange: Alice sets self sponsoring for Flipper
586
587    // act:     Admin calls appPromotion.sponsorContract(Flipper.address)
588
589    // assert:  contract.sponsoringMode = TODO
590    // assert:  contract.sponsor to be PalleteAddress
591  });
592
593  it('can be overwritten by contract owner', async () => {
594    // arrange: Alice deploys Flipper
595    // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)
596
597    // act:     Alice sets self sponsoring for Flipper
598
599    // assert:  contract.sponsoringMode = Self
600    // assert:  contract.sponsor to be contract
601  });
602
603  it('can not be set by non admin', async () => {
604    // arrange: Alice deploys Flipper
605    // arrange: Alice sets self sponsoring for Flipper
606
607    // assert:  Random calls appPromotion.sponsorContract(Flipper.address) throws
608    // assert:  contract.sponsoringMode = Self
609    // assert:  contract.sponsor to be contract
610  });
611
612  it('will return unused gas fee to app-promotion pallete', async () => {
613    // arrange: Alice deploys Flipper
614    // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)
615
616    // assert:  Bob calls Flipper - expect balances deposit event do not appears for Bob /// Unused gas fee returns to contract
617    // assert:  Bobs balance the same
618  });
619
620  it('will failed for non contract address', async () => {
621    // arrange: web3 creates new address - 0x0
622
623    // assert: Admin calls appPromotion.sponsorContract(0x0) throws
624    // assert: Admin calls appPromotion.sponsorContract(Substrate address) throws
625  });
626
627  it('will actually sponsor transactions', async () => {
628    // TODO test it because this is a new way of contract sponsoring
629  });
630});
631
632describe('app-promotion stopSponsoringContract', () => {
633  before(async function () {
634    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
635      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
636      alice = privateKeyWrapper('//Alice');
637      bob = privateKeyWrapper('//Bob');
638      palletAdmin = privateKeyWrapper('//palletAdmin');
639      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());
640      await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());
641       
642      const promotionStartBlock = await helper.chain.getLatestBlockNumber();
643      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
644      await helper.signTransaction(alice, tx);
645      
646      const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock));
647      await helper.signTransaction(alice, txStart);
648      
649      nominal = helper.balance.getOneTokenNominal();
650    });
651  });
652  
653  it('will set contract sponsoring mode as disabled', async () => {
654    // arrange: Alice deploys Flipper
655    // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)
656    
657    // act:     Admin calls appPromotion.stopSponsoringContract(Flipper.address)
658    // assert:  contract sponsoring mode = TODO
659
660    // act:     Bob calls Flipper
661
662    // assert:  PalleteAddress balance did not change
663    // assert:  Bobs balance less than before /// Bob payed some fee
664  });
665
666  it('can not be called by non-admin', async () => {
667    // arrange: Alice deploys Flipper
668    // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)
669
670    // assert:  Random calls appPromotion.stopSponsoringContract(Flipper.address) throws
671    // assert:  contract sponsor is PallereAddress
672  });
673
674  it('will not affect a contract which is not sponsored by pallete', async () => {
675    // arrange: Alice deploys Flipper
676    // arrange: Alice sets self sponsoring for Flipper
677    
678    // act:     Admin calls appPromotion.stopSponsoringContract(Flipper.address) throws
679
680    // assert:  contract.sponsoringMode = Self
681    // assert:  contract.sponsor to be contract
682  });
683
684  it('will failed for non contract address', async () => {
685    // arrange: web3 creates new address - 0x0
686
687    // expect stopSponsoringContract(0x0) throws
688  });
689});
690
691describe('app-promotion rewards', () => {
692  const DAY = 7200n;
693  
694  
695  before(async function () {
696    await usingPlaygrounds(async (helper, privateKeyWrapper) => {
697      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
698      alice = privateKeyWrapper('//Alice');
699      bob = privateKeyWrapper('//Bob');
700      palletAdmin = privateKeyWrapper('//palletAdmin');
701      if (promotionStartBlock == null) {
702        promotionStartBlock = (await helper.api!.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();
703      }
704      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));
705      await helper.signTransaction(alice, tx);
706      
707      const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock!));
708      await helper.signTransaction(alice, txStart);
709
710      nominal = helper.balance.getOneTokenNominal();
711    });
712  });
713  
714  it('will credit 0.05% for staking period', async () => {
715    // arrange: bob.stake(10000);
716    // arrange: bob.stake(20000);
717    // arrange: waitForRewards();
718
719    // assert:  bob.staked to equal [10005, 20010]
720    
721    await usingPlaygrounds(async helper => {
722      const staker = await createUser(50n * nominal);
723      await waitForRecalculationBlock(helper.api!);
724      
725      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;
726      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;
727      await waitForRelayBlock(helper.api!, 36);
728      
729      
730      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))
731        .map(([_, amount]) => amount.toBigInt()))
732        .to.be.deep.equal([calculateIncome(nominal, 10n), calculateIncome(2n * nominal, 10n)]);
733    });
734    
735  });
736  
737  it('will not be credited for unstaked (reserved) balance', async () => {
738    // arrange: bob.stake(10000);
739    // arrange: bob.unstake(5000);
740    // arrange: waitForRewards();
741
742    // assert:  bob.staked to equal [5002.5]
743    await usingPlaygrounds(async helper => {
744      const staker = await createUser(20n * nominal);
745      await waitForRecalculationBlock(helper.api!);
746      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;
747      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(5n * nominal))).to.be.eventually.fulfilled;
748      await waitForRelayBlock(helper.api!, 38);
749
750      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))
751        .map(([_, amount]) => amount.toBigInt()))
752        .to.be.deep.equal([calculateIncome(5n * nominal, 10n)]);
753      
754    });
755    
756  });
757  
758  it('will bring compound interest', async () => {
759    // arrange: bob balance = 30000
760    // arrange: bob.stake(10000);
761    // arrange: bob.stake(10000);
762    // arrange: waitForRewards();
763
764    // assert:  bob.staked() equal [10005, 10005, 10005] /// 10_000 * 1.0005
765    // act:     waitForRewards();
766
767    // assert:  bob.staked() equal [10010.0025, 10010.0025, 10010.0025] /// 10_005 * 1.0005
768    // act:     bob.unstake(10.0025)
769    // assert:  bob.staked() equal [10000, 10010.0025, 10010.0025] /// 10_005 * 1.0005
770
771    // act:     waitForRewards();
772    // assert:  bob.staked() equal [10005, 10015,00750125, 10015,00750125] ///
773    await usingPlaygrounds(async helper => {
774      const staker = await createUser(40n * nominal);
775      
776      await waitForRecalculationBlock(helper.api!);
777      // const foo = await helper.api!.registry.getChainProperties().
778
779      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;
780      // await waitNewBlocks(helper.api!, 1);
781      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;
782      // await waitNewBlocks(helper.api!, 1);
783      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;
784      // console.log(await helper.balance.getSubstrate(staker.address));
785      // await waitNewBlocks(helper.api!, 17);
786      await waitForRelayBlock(helper.api!, 34);
787      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))
788        .map(([_, amount]) => amount.toBigInt()))
789        .to.be.deep.equal([calculateIncome(10n * nominal, 10n), calculateIncome(10n * nominal, 10n), calculateIncome(10n * nominal, 10n)]);
790      
791      // console.log(await getBlockNumber(helper.api!));
792      // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]));
793      // console.log(`${calculateIncome(10n * nominal, 10n)} || ${calculateIncome(10n * nominal, 10n, 2)}`);
794      // await waitNewBlocks(helper.api!, 10);
795      await waitForRelayBlock(helper.api!, 20);
796      // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()));
797      // console.log(await helper.balance.getSubstrate(staker.address));
798      await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(calculateIncome(10n * nominal, 10n, 2) - 10n * nominal))).to.be.eventually.fulfilled;
799      // console.log(calculateIncome(10n * nominal, 10n, 2));
800      // console.log(calculateIncome(10n * nominal, 10n, 3));
801      // console.log(calculateIncome(10n * nominal, 10n, 4));
802      // console.log(calculateIncome(10n * nominal, 10n, 5));
803      expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))
804        .map(([_, amount]) => amount.toBigInt()))
805        .to.be.deep.equal([10n * nominal, calculateIncome(10n * nominal, 10n, 2), calculateIncome(10n * nominal, 10n, 2)]);
806      
807      // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()));
808      
809      // console.log(await helper.balance.getSubstrate(staker.address));
810    });
811    
812  });
813});
814
815
816function waitForRecalculationBlock(api: ApiPromise): Promise<void> {
817  return new Promise<void>(async (resolve, reject) => {
818    const unsubscribe = await  api.query.system.events((events) => {
819     
820      events.forEach((record) => {
821      
822        const {event, phase} = record;
823        const types = event.typeDef;
824        
825        if (event.section === 'promotion' && event.method === 'StakingRecalculation') {
826          unsubscribe();
827          resolve();
828        }
829      });
830    });
831  });
832}
833
834async function waitForRelayBlock(api: ApiPromise, blocks = 1): Promise<void> {
835  const current_block = (await api.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();
836  return new Promise<void>(async (resolve, reject) => {
837    const unsubscribe = await api.query.parachainSystem.validationData(async (data) => {
838      // console.log(`${current_block} || ${data.value.relayParentNumber.toNumber()}`);
839      if (data.value.relayParentNumber.toNumber() - current_block >= blocks) {
840        unsubscribe();
841        resolve();
842      }
843    });
844  });
845  
846}
847
848
849function calculatePalleteAddress(palletId: any) {
850  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));
851  return encodeAddress(address);
852}
853function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {
854  const DAY = 7200n;
855  const ACCURACY = 1_000_000_000n;
856  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;
857  
858  if (iter > 1) {
859    return calculateIncome(income, calcPeriod, iter - 1);
860  } else return income;
861}
234862
235async function createUser(amount?: bigint) {863async function createUser(amount?: bigint) {
236  return await usingPlaygrounds(async (helper, privateKeyWrapper) => {864  return await usingPlaygrounds(async helper => {
237    const user: IKeyringPair = privateKeyWrapper(`//Alice+${(new Date()).getTime()}`);865    const user: IKeyringPair = helper.util.fromSeed(mnemonicGenerate());
238    await helper.balance.transferToSubstrate(alice, user.address, amount ? amount : 10n * helper.balance.getOneTokenNominal());866    await helper.balance.transferToSubstrate(alice, user.address, amount ? amount : 10n * helper.balance.getOneTokenNominal());
239    return user;867    return user;
240  });868  });