From 44c855833903299f12452e4c7ebd4574b310018d Mon Sep 17 00:00:00 2001 From: kozyrevdev <73348153+kozyrevdev@users.noreply.github.com> Date: Thu, 09 Dec 2021 08:31:16 +0000 Subject: [PATCH] Merge pull request #255 from UniqueNetwork/feature/CORE-247 Inflation pallet block provider added. Setted up to relay chain. --- --- a/Cargo.lock +++ b/Cargo.lock @@ -11679,6 +11679,7 @@ "pallet-evm-migration", "pallet-evm-transaction-payment", "pallet-fungible", + "pallet-inflation", "pallet-nonfungible", "pallet-randomness-collective-flip", "pallet-refungible", --- a/pallets/inflation/src/lib.rs +++ b/pallets/inflation/src/lib.rs @@ -3,13 +3,8 @@ // file 'LICENSE', which is part of this source code package. // -#![recursion_limit = "1024"] +// #![recursion_limit = "1024"] #![cfg_attr(not(feature = "std"), no_std)] - -#[cfg(feature = "std")] -pub use std::*; - -pub use serde::{Serialize, Deserialize}; #[cfg(feature = "runtime-benchmarks")] mod benchmarking; @@ -17,65 +12,74 @@ #[cfg(test)] mod tests; -pub use frame_support::{ - construct_runtime, decl_module, decl_storage, ensure, - traits::{ - Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced, - Randomness, IsSubType, WithdrawReasons, - }, - weights::{ - constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND}, - DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight, - WeightToFeePolynomial, DispatchClass, - }, - StorageValue, transactional, +use frame_support::{ + dispatch::{DispatchResult}, + traits::{Currency, Get}, }; - -// #[cfg(feature = "runtime-benchmarks")] -pub use frame_support::dispatch::DispatchResult; - +pub use pallet::*; use sp_runtime::{ Perbill, - traits::{Zero}, + traits::{BlockNumberProvider}, }; + use sp_std::convert::TryInto; - -use frame_system::{self as system}; -/// The balance type of this module. -pub type BalanceOf = +type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; -// pub const YEAR: u32 = 5_259_600; // 6-second block -pub const YEAR: u32 = 2_629_800; // 12-second block +pub const YEAR: u32 = 5_259_600; // 6-second block + // pub const YEAR: u32 = 2_629_800; // 12-second block pub const TOTAL_YEARS_UNTIL_FLAT: u32 = 9; pub const START_INFLATION_PERCENT: u32 = 10; pub const END_INFLATION_PERCENT: u32 = 4; -pub trait Config: system::Config { - type Currency: Currency; - type TreasuryAccountId: Get; - type InflationBlockInterval: Get; -} +#[frame_support::pallet] +pub mod pallet { + use super::*; + use frame_support::pallet_prelude::*; + use frame_system::pallet_prelude::*; -decl_storage! { - trait Store for Module as Inflation { - /// starting year total issuance - pub StartingYearTotalIssuance get(fn starting_year_total_issuance): BalanceOf; + #[pallet::config] + pub trait Config: frame_system::Config { + type Currency: Currency; + type TreasuryAccountId: Get; + + // The block number provider + type BlockNumberProvider: BlockNumberProvider; - /// Current block inflation - pub BlockInflation get(fn block_inflation): BalanceOf; + /// Number of blocks that pass between treasury balance updates due to inflation + #[pallet::constant] + type InflationBlockInterval: Get; } -} -decl_module! { - pub struct Module for enum Call - where - origin: T::Origin, - { - const InflationBlockInterval: T::BlockNumber = T::InflationBlockInterval::get(); + #[pallet::pallet] + #[pallet::generate_store(pub(super) trait Store)] + pub struct Pallet(_); + + /// starting year total issuance + #[pallet::storage] + pub type StartingYearTotalIssuance = + StorageValue, QueryKind = ValueQuery>; - fn on_initialize(now: T::BlockNumber) -> Weight + /// Current inflation for `InflationBlockInterval` number of blocks + #[pallet::storage] + pub type BlockInflation = StorageValue, QueryKind = ValueQuery>; + + /// Next target (relay) block when inflation will be applied + #[pallet::storage] + pub type NextInflationBlock = + StorageValue; + + /// Next target (relay) block when inflation is recalculated + #[pallet::storage] + pub type NextRecalculationBlock = + StorageValue; + + #[pallet::hooks] + impl Hooks> for Pallet { + fn on_initialize(_: T::BlockNumber) -> Weight + where + ::BlockNumber: From, { let mut consumed_weight = 0; let mut add_weight = |reads, writes, weight| { @@ -84,47 +88,108 @@ }; let block_interval: u32 = T::InflationBlockInterval::get().try_into().unwrap_or(0); + let current_relay_block = T::BlockNumberProvider::current_block_number(); + let next_inflation: T::BlockNumber = >::get(); + add_weight(1, 0, 5_000_000); - // TODO: Rewrite inflation to use block timestamp instead of block number - // let _now = >::get(); + // Apply inflation every InflationBlockInterval blocks + // If next_inflation == 0, this means inflation wasn't yet initialized + if (next_inflation != 0u32.into()) && (current_relay_block >= next_inflation) { + // Recalculate inflation on the first block of the year (or if it is not initialized yet) + // Do the "current_relay_block >= next_recalculation" check in the "current_relay_block >= next_inflation" + // block because it saves InflationBlockInterval DB reads for NextRecalculationBlock. + let next_recalculation: T::BlockNumber = >::get(); + add_weight(1, 0, 0); + if current_relay_block >= next_recalculation { + Self::recalculate_inflation(next_recalculation); + add_weight(0, 4, 5_000_000); + } - // Recalculate inflation on the first block of the year (or if it is not initialized yet) - if (now % T::BlockNumber::from(YEAR)).is_zero() || >::get().is_zero() { - let current_year: u32 = (now / T::BlockNumber::from(YEAR)).try_into().unwrap_or(0); + T::Currency::deposit_into_existing( + &T::TreasuryAccountId::get(), + >::get(), + ) + .ok(); - let one_percent = Perbill::from_percent(1); + // Update inflation block + >::set(next_inflation + block_interval.into()); - if current_year <= TOTAL_YEARS_UNTIL_FLAT { - let amount: BalanceOf = Perbill::from_rational( - block_interval * (START_INFLATION_PERCENT * TOTAL_YEARS_UNTIL_FLAT - current_year * (START_INFLATION_PERCENT - END_INFLATION_PERCENT)), - YEAR * TOTAL_YEARS_UNTIL_FLAT - ) * ( one_percent * T::Currency::total_issuance() ); - >::put(amount); - } - else { - let amount: BalanceOf = Perbill::from_rational( - block_interval * END_INFLATION_PERCENT, - YEAR - ) * (one_percent * T::Currency::total_issuance()); - >::put(amount); - } - >::set(T::Currency::total_issuance()); + add_weight(3, 3, 10_000_000); + } + + consumed_weight + } + } + + #[pallet::call] + impl Pallet { + /// This method sets the inflation start date. Can be only called once. + /// Inflation start block can be backdated and will catch up. The method will create Treasury + /// account if it does not exist and perform the first inflation deposit. + /// + /// # Permissions + /// + /// * Root + /// + /// # Arguments + /// + /// * inflation_start_relay_block: The relay chain block at which inflation should start + #[pallet::weight(0)] + pub fn start_inflation( + origin: OriginFor, + inflation_start_relay_block: T::BlockNumber, + ) -> DispatchResult + where + ::BlockNumber: From, + { + ensure_root(origin)?; - // First time deposit - T::Currency::deposit_creating(&T::TreasuryAccountId::get(), >::get()); + // Start inflation if it has not been yet initialized + let next_inflation: T::BlockNumber = >::get(); + if next_inflation == 0u32.into() { + // Recalculate inflation. This can be backdated and will catch up. + Self::recalculate_inflation(inflation_start_relay_block); + let block_interval: u32 = T::InflationBlockInterval::get().try_into().unwrap_or(0); + >::set(inflation_start_relay_block + block_interval.into()); - add_weight(7, 6, 28_300_000); + // First time deposit - create Treasury account so that we can call deposit_into_existing everywhere else + T::Currency::deposit_creating( + &T::TreasuryAccountId::get(), + >::get(), + ); } - // Apply inflation every InflationBlockInterval blocks and in the 1st block to initialize Treasury account - else if (now % T::BlockNumber::from(block_interval)).is_zero() { - T::Currency::deposit_into_existing(&T::TreasuryAccountId::get(), >::get()).ok(); + Ok(()) + } + } +} + +impl Pallet { + pub fn recalculate_inflation(recalculation_block: T::BlockNumber) { + let current_year: u32 = (recalculation_block / T::BlockNumber::from(YEAR)) + .try_into() + .unwrap_or(0); + let block_interval: u32 = T::InflationBlockInterval::get().try_into().unwrap_or(0); - add_weight(3, 2, 12_900_000); - } + let one_percent = Perbill::from_percent(1); - consumed_weight + if current_year <= TOTAL_YEARS_UNTIL_FLAT { + let amount: BalanceOf = Perbill::from_rational( + block_interval + * (START_INFLATION_PERCENT * TOTAL_YEARS_UNTIL_FLAT + - current_year * (START_INFLATION_PERCENT - END_INFLATION_PERCENT)), + YEAR * TOTAL_YEARS_UNTIL_FLAT, + ) * (one_percent * T::Currency::total_issuance()); + >::put(amount); + } else { + let amount: BalanceOf = + Perbill::from_rational(block_interval * END_INFLATION_PERCENT, YEAR) + * (one_percent * T::Currency::total_issuance()); + >::put(amount); } + >::set(T::Currency::total_issuance()); + // Update recalculation and inflation blocks + >::set(recalculation_block + YEAR.into()); } } --- a/pallets/inflation/src/tests.rs +++ b/pallets/inflation/src/tests.rs @@ -3,22 +3,23 @@ use crate as pallet_inflation; use frame_support::{ - traits::{Currency}, - parameter_types, -}; -use frame_support::{ - traits::{OnInitialize, Everything}, + assert_ok, parameter_types, + traits::{Currency, OnInitialize, Everything}, }; +use frame_system::RawOrigin; use sp_core::H256; use sp_runtime::{ - traits::{BlakeTwo256, IdentityLookup}, + traits::{BlakeTwo256, BlockNumberProvider, IdentityLookup}, testing::Header, }; type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; type Block = frame_system::mocking::MockBlock; -const YEAR: u64 = 2_629_800; +const YEAR: u64 = 5_259_600; // 6-second blocks + // const YEAR: u64 = 2_629_800; // 12-second blocks + // Expected 100-block inflation for year 1 is 100 * 100_000_000 / YEAR = FIRST_YEAR_BLOCK_INFLATION +const FIRST_YEAR_BLOCK_INFLATION: u64 = 1901; parameter_types! { pub const ExistentialDeposit: u64 = 1; @@ -85,12 +86,22 @@ parameter_types! { pub TreasuryAccountId: u64 = 1234; pub const InflationBlockInterval: u32 = 100; // every time per how many blocks inflation is applied + pub static MockBlockNumberProvider: u64 = 0; } +impl BlockNumberProvider for MockBlockNumberProvider { + type BlockNumber = u64; + + fn current_block_number() -> Self::BlockNumber { + Self::get() + } +} + impl pallet_inflation::Config for Test { type Currency = Balances; type TreasuryAccountId = TreasuryAccountId; type InflationBlockInterval = InflationBlockInterval; + type BlockNumberProvider = MockBlockNumberProvider; } pub fn new_test_ext() -> sp_io::TestExternalities { @@ -100,6 +111,29 @@ .into() } +macro_rules! block_inflation { + // Block inflation doesn't have any argumets + () => { + // Return BlockInflation state variable current value + >::get() + }; +} + +#[test] +fn uninitialized_inflation() { + new_test_ext().execute_with(|| { + let initial_issuance: u64 = 1_000_000_000; + let _ = >::deposit_creating(&1234, initial_issuance); + assert_eq!(Balances::free_balance(1234), initial_issuance); + + // BlockInflation should be set after inflation is started + // first inflation deposit should be equal to BlockInflation + MockBlockNumberProvider::set(1); + + assert_eq!(block_inflation!(), 0); + }); +} + #[test] fn inflation_works() { new_test_ext().execute_with(|| { @@ -108,16 +142,25 @@ let _ = >::deposit_creating(&1234, initial_issuance); assert_eq!(Balances::free_balance(1234), initial_issuance); - // BlockInflation should be set after 1st block and + // BlockInflation should be set after inflation is started // first inflation deposit should be equal to BlockInflation - Inflation::on_initialize(1); + MockBlockNumberProvider::set(1); - // Expected 100-block inflation for year 1 is 100 * 100_000_000 / YEAR = 3803 - assert_eq!(Inflation::block_inflation(), 3803); + // Start inflation as sudo + assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1)); + assert_eq!(block_inflation!(), FIRST_YEAR_BLOCK_INFLATION); assert_eq!( Balances::free_balance(1234) - initial_issuance, - Inflation::block_inflation() + block_inflation!() ); + + // Trigger inflation + MockBlockNumberProvider::set(102); + Inflation::on_initialize(0); + assert_eq!( + Balances::free_balance(1234) - initial_issuance, + 2 * block_inflation!() + ); }); } @@ -128,25 +171,27 @@ let initial_issuance: u64 = 1_000_000_000; let _ = >::deposit_creating(&1234, initial_issuance); assert_eq!(Balances::free_balance(1234), initial_issuance); - Inflation::on_initialize(1); + MockBlockNumberProvider::set(1); - // Next inflation deposit happens when block is multiple of InflationBlockInterval - let mut block: u32 = 2; + // Start inflation as sudo + assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1)); + + // Next inflation deposit happens when block is greater then or equal to NextInflationBlock + let mut block: u64 = 2; let balance_before: u64 = Balances::free_balance(1234); - while block % InflationBlockInterval::get() != 0 { - Inflation::on_initialize(block as u64); + while block < >::get() { + MockBlockNumberProvider::set(block as u64); + Inflation::on_initialize(0); block += 1; } let balance_just_before: u64 = Balances::free_balance(1234); assert_eq!(balance_before, balance_just_before); // The block with inflation - Inflation::on_initialize(block as u64); + MockBlockNumberProvider::set(block as u64); + Inflation::on_initialize(0); let balance_after: u64 = Balances::free_balance(1234); - assert_eq!( - balance_after - balance_just_before, - Inflation::block_inflation() - ); + assert_eq!(balance_after - balance_just_before, block_inflation!()); }); } @@ -157,59 +202,56 @@ let initial_issuance: u64 = 1_000_000_000; let _ = >::deposit_creating(&1234, initial_issuance); assert_eq!(Balances::free_balance(1234), initial_issuance); - Inflation::on_initialize(1); + MockBlockNumberProvider::set(1); + // Start inflation as sudo + assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1)); + // Go through all the block inflations for year 1, // total issuance will be updated accordingly - for block in (100..YEAR).step_by(100) { - Inflation::on_initialize(block); + // Inflation is set to start in block 1, so first iteration is block 101 + for block in (101..YEAR).step_by(100) { + MockBlockNumberProvider::set(block); + Inflation::on_initialize(0); } assert_eq!( - initial_issuance + (3803 * (YEAR / 100)), + initial_issuance + (FIRST_YEAR_BLOCK_INFLATION * (YEAR / 100)), >::total_issuance() ); - Inflation::on_initialize(YEAR); - let block_inflation_year_1 = Inflation::block_inflation(); - // Expected 100-block inflation for year 2: 100 * 9.33% * initial issuance * 110% / YEAR = 3904 - assert_eq!(block_inflation_year_1, 3904); + MockBlockNumberProvider::set(YEAR + 1); + Inflation::on_initialize(0); + let block_inflation_year_2 = block_inflation!(); + // Expected 100-block inflation for year 2: 100 * 9.33% * initial issuance * 110% / YEAR == 1951 + let expecter_year_2_inflation: u64 = (initial_issuance + + FIRST_YEAR_BLOCK_INFLATION * YEAR / 100) + * 933 * 100 / (10000 * YEAR); + assert_eq!(block_inflation_year_2 / 10, expecter_year_2_inflation / 10); // divide by 10 for approx. equality }); } #[test] -fn inflation_in_1_to_9_years() { +fn inflation_after_year_10_is_flat() { new_test_ext().execute_with(|| { // Total issuance = 1_000_000_000 let initial_issuance: u64 = 1_000_000_000; let _ = >::deposit_creating(&1234, initial_issuance); assert_eq!(Balances::free_balance(1234), initial_issuance); - Inflation::on_initialize(1); + MockBlockNumberProvider::set(YEAR * 9 + 1); - for year in 1..=9 { - let block_inflation_year_before = Inflation::block_inflation(); - Inflation::on_initialize(YEAR * year); - let block_inflation_year_after = Inflation::block_inflation(); + // Start inflation as sudo + assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1)); - // SBP M2 review: this is actually not true (not for the first few years) - // Assert that next year inflation is less than previous year inflation - assert!(block_inflation_year_before > block_inflation_year_after); + // Let inflation catch up + for _year in 1..=9 { + Inflation::on_initialize(0); } - }); -} -#[test] -fn inflation_after_year_10_is_flat() { - new_test_ext().execute_with(|| { - // Total issuance = 1_000_000_000 - let initial_issuance: u64 = 1_000_000_000; - let _ = >::deposit_creating(&1234, initial_issuance); - assert_eq!(Balances::free_balance(1234), initial_issuance); - Inflation::on_initialize(YEAR * 9); - for year in 10..=20 { - let block_inflation_year_before = Inflation::block_inflation(); - Inflation::on_initialize(YEAR * year); - let block_inflation_year_after = Inflation::block_inflation(); + let block_inflation_year_before = block_inflation!(); + MockBlockNumberProvider::set(YEAR * year + 1); + Inflation::on_initialize(0); + let block_inflation_year_after = block_inflation!(); // Assert that next year inflation is equal to previous year inflation assert_eq!(block_inflation_year_before, block_inflation_year_after); @@ -231,25 +273,32 @@ let _ = >::deposit_creating(&1234, initial_issuance); assert_eq!(Balances::free_balance(1234), initial_issuance); + // Start inflation as sudo + assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1)); + for year in 0..=10 { // Year first block - Inflation::on_initialize(year * YEAR); - let mut actual_payout = Inflation::block_inflation(); + MockBlockNumberProvider::set(YEAR * year + 1); + Inflation::on_initialize(0); + let mut actual_payout = block_inflation!(); assert_eq!(actual_payout, payout_by_year[year as usize]); // Year second block - Inflation::on_initialize(year * YEAR + 1); - actual_payout = Inflation::block_inflation(); + MockBlockNumberProvider::set(YEAR * year + 2); + Inflation::on_initialize(0); + actual_payout = block_inflation!(); assert_eq!(actual_payout, payout_by_year[year as usize]); // Year middle block - Inflation::on_initialize(year * YEAR + YEAR / 2); - actual_payout = Inflation::block_inflation(); + MockBlockNumberProvider::set(year * YEAR + YEAR / 2); + Inflation::on_initialize(0); + actual_payout = block_inflation!(); assert_eq!(actual_payout, payout_by_year[year as usize]); // Year last block - Inflation::on_initialize((year + 1) * YEAR - 1); - actual_payout = Inflation::block_inflation(); + MockBlockNumberProvider::set((year + 1) * YEAR); + Inflation::on_initialize(0); + actual_payout = block_inflation!(); assert_eq!(actual_payout, payout_by_year[year as usize]); } }); --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -33,7 +33,7 @@ 'pallet-refungible/runtime-benchmarks', 'pallet-nonfungible/runtime-benchmarks', 'pallet-unique/runtime-benchmarks', -# 'pallet-inflation/runtime-benchmarks', + 'pallet-inflation/runtime-benchmarks', 'pallet-xcm/runtime-benchmarks', 'sp-runtime/runtime-benchmarks', 'xcm-builder/runtime-benchmarks', @@ -75,7 +75,7 @@ 'fp-self-contained/std', 'parachain-info/std', 'serde', -# 'pallet-inflation/std', + 'pallet-inflation/std', 'pallet-common/std', 'pallet-fungible/std', 'pallet-refungible/std', @@ -380,7 +380,7 @@ pallet-unique = { path = '../pallets/unique', default-features = false } up-rpc = { path = "../primitives/rpc", default-features = false } up-evm-mapping = { path = "../primitives/evm-mapping", default-features = false } -# pallet-inflation = { path = '../pallets/inflation', default-features = false } +pallet-inflation = { path = '../pallets/inflation', default-features = false } up-data-structs = { path = '../primitives/data-structs', default-features = false } pallet-common = { default-features = false, path = "../pallets/common" } pallet-fungible = { default-features = false, path = "../pallets/fungible" } --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -785,17 +785,18 @@ type Event = Event; type WeightInfo = pallet_unique::weights::SubstrateWeight; } -/* + parameter_types! { pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied -} */ +} /// Used for the pallet inflation -/* impl pallet_inflation::Config for Runtime { +impl pallet_inflation::Config for Runtime { type Currency = Balances; type TreasuryAccountId = TreasuryAccountId; type InflationBlockInterval = InflationBlockInterval; -} */ + type BlockNumberProvider = RelayChainBlockNumberProvider; +} // parameter_types! { // pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) * @@ -882,7 +883,7 @@ DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event} = 53, // Unique Pallets - // Inflation: pallet_inflation::{Pallet, Call, Storage} = 60, + Inflation: pallet_inflation::{Pallet, Call, Storage} = 60, Unique: pallet_unique::{Pallet, Call, Storage, Event} = 61, // Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event} = 62, // free = 63 @@ -1367,7 +1368,7 @@ list_benchmark!(list, extra, pallet_evm_migration, EvmMigration); list_benchmark!(list, extra, pallet_unique, Unique); - //list_benchmark!(list, extra, pallet_inflation, Inflation); + list_benchmark!(list, extra, pallet_inflation, Inflation); list_benchmark!(list, extra, pallet_fungible, Fungible); list_benchmark!(list, extra, pallet_refungible, Refungible); list_benchmark!(list, extra, pallet_nonfungible, Nonfungible); @@ -1401,7 +1402,7 @@ add_benchmark!(params, batches, pallet_evm_migration, EvmMigration); add_benchmark!(params, batches, pallet_unique, Unique); - //add_benchmark!(params, batches, pallet_inflation, Inflation); + add_benchmark!(params, batches, pallet_inflation, Inflation); add_benchmark!(params, batches, pallet_fungible, Fungible); add_benchmark!(params, batches, pallet_refungible, Refungible); add_benchmark!(params, batches, pallet_nonfungible, Nonfungible); --- a/tests/src/creditFeesToTreasury.test.ts +++ b/tests/src/creditFeesToTreasury.test.ts @@ -34,7 +34,7 @@ // Skip the inflation block pauses if the block is close to inflation block // until the inflation happens /*eslint no-async-promise-executor: "off"*/ -/*function skipInflationBlock(api: ApiPromise): Promise { +function skipInflationBlock(api: ApiPromise): Promise { const promise = new Promise(async (resolve) => { const blockInterval = (await api.consts.inflation.inflationBlockInterval).toNumber(); const unsubscribe = await api.rpc.chain.subscribeNewHeads(head => { @@ -49,7 +49,7 @@ }); return promise; -}*/ +} describe('integration test: Fees must be credited to Treasury:', () => { before(async () => { @@ -61,7 +61,7 @@ it('Total issuance does not change', async () => { await usingApi(async (api) => { - //await skipInflationBlock(api); + await skipInflationBlock(api); await waitNewBlocks(api, 1); const totalBefore = (await api.query.balances.totalIssuance()).toBigInt(); @@ -81,7 +81,7 @@ it('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async () => { await usingApi(async (api) => { - //await skipInflationBlock(api); + await skipInflationBlock(api); await waitNewBlocks(api, 1); const alicePrivateKey = privateKey('//Alice'); @@ -125,7 +125,7 @@ it('NFT Transactions also send fees to Treasury', async () => { await usingApi(async (api) => { - //await skipInflationBlock(api); + await skipInflationBlock(api); await waitNewBlocks(api, 1); const treasuryBalanceBefore = (await api.query.system.account(TREASURY)).data.free.toBigInt(); @@ -144,7 +144,7 @@ it('Fees are sane', async () => { await usingApi(async (api) => { - //await skipInflationBlock(api); + await skipInflationBlock(api); await waitNewBlocks(api, 1); const aliceBalanceBefore: bigint = (await api.query.system.account(alicesPublicKey)).data.free.toBigInt(); @@ -161,7 +161,7 @@ it('NFT Transfer fee is close to 0.1 Unique', async () => { await usingApi(async (api) => { - //await skipInflationBlock(api); + await skipInflationBlock(api); await waitNewBlocks(api, 1); const collectionId = await createCollectionExpectSuccess(); --- a/tests/src/inflation.test.ts +++ b/tests/src/inflation.test.ts @@ -5,21 +5,32 @@ import chai from 'chai'; import chaiAsPromised from 'chai-as-promised'; -import {default as usingApi} from './substrate/substrate-api'; +import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api'; +import privateKey from './substrate/privateKey'; chai.use(chaiAsPromised); const expect = chai.expect; -describe.skip('integration test: Inflation', () => { +describe('integration test: Inflation', () => { it('First year inflation is 10%', async () => { await usingApi(async (api) => { + // Make sure non-sudo can't start inflation + const tx = api.tx.inflation.startInflation(1); + const bob = privateKey('//Bob'); + await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.rejected; + + // Start inflation on relay block 1 (Alice is sudo) + const alice = privateKey('//Alice'); + const sudoTx = api.tx.sudo.sudo(tx as any); + await submitTransactionAsync(alice, sudoTx); + const blockInterval = (api.consts.inflation.inflationBlockInterval).toBigInt(); const totalIssuanceStart = (await api.query.inflation.startingYearTotalIssuance()).toBigInt(); const blockInflation = (await api.query.inflation.blockInflation()).toBigInt(); - // const YEAR = 5259600n; // 6-second block. Blocks in one year - const YEAR = 2629800n; // 12-second block. Blocks in one year + const YEAR = 5259600n; // 6-second block. Blocks in one year + // const YEAR = 2629800n; // 12-second block. Blocks in one year const totalExpectedInflation = totalIssuanceStart / 10n; const totalActualInflation = blockInflation * YEAR / blockInterval; --- a/tests/src/pallet-presence.test.ts +++ b/tests/src/pallet-presence.test.ts @@ -34,7 +34,7 @@ 'polkadotxcm', 'cumulusxcm', 'dmpqueue', - //'inflation', + 'inflation', 'unique', 'nonfungible', 'refungible', -- gitstuff