git.delta.rocks / unique-network / refs/commits / 44c855833903

--- 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<T> =
+type BalanceOf<T> =
 	<<T as Config>::Currency as Currency<<T as frame_system::Config>::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<Self::AccountId>;
-	type TreasuryAccountId: Get<Self::AccountId>;
-	type InflationBlockInterval: Get<Self::BlockNumber>;
-}
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
 
-decl_storage! {
-	trait Store for Module<T: Config> as Inflation {
-		/// starting year total issuance
-		pub StartingYearTotalIssuance get(fn starting_year_total_issuance): BalanceOf<T>;
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Currency: Currency<Self::AccountId>;
+		type TreasuryAccountId: Get<Self::AccountId>;
+
+		// The block number provider
+		type BlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;
 
-		/// Current block inflation
-		pub BlockInflation get(fn block_inflation): BalanceOf<T>;
+		/// Number of blocks that pass between treasury balance updates due to inflation
+		#[pallet::constant]
+		type InflationBlockInterval: Get<Self::BlockNumber>;
 	}
-}
 
-decl_module! {
-	pub struct Module<T: Config> 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<T>(_);
+
+	/// starting year total issuance
+	#[pallet::storage]
+	pub type StartingYearTotalIssuance<T: Config> =
+		StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;
 
-		fn on_initialize(now: T::BlockNumber) -> Weight
+	/// Current inflation for `InflationBlockInterval` number of blocks
+	#[pallet::storage]
+	pub type BlockInflation<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;
+
+	/// Next target (relay) block when inflation will be applied
+	#[pallet::storage]
+	pub type NextInflationBlock<T: Config> =
+		StorageValue<Value = T::BlockNumber, QueryKind = ValueQuery>;
+
+	/// Next target (relay) block when inflation is recalculated
+	#[pallet::storage]
+	pub type NextRecalculationBlock<T: Config> =
+		StorageValue<Value = T::BlockNumber, QueryKind = ValueQuery>;
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(_: T::BlockNumber) -> Weight
+		where
+			<T as frame_system::Config>::BlockNumber: From<u32>,
 		{
 			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 = <NextInflationBlock<T>>::get();
+			add_weight(1, 0, 5_000_000);
 
-			// TODO: Rewrite inflation to use block timestamp instead of block number
-			// let _now = <timestamp::Module<T>>::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 = <NextRecalculationBlock<T>>::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() || <BlockInflation<T>>::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(),
+					<BlockInflation<T>>::get(),
+				)
+				.ok();
 
-				let one_percent = Perbill::from_percent(1);
+				// Update inflation block
+				<NextInflationBlock<T>>::set(next_inflation + block_interval.into());
 
-				if current_year <= TOTAL_YEARS_UNTIL_FLAT {
-					let amount: BalanceOf<T> = 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() );
-					<BlockInflation<T>>::put(amount);
-				}
-				else {
-					let amount: BalanceOf<T> = Perbill::from_rational(
-						block_interval * END_INFLATION_PERCENT,
-						YEAR
-					) * (one_percent * T::Currency::total_issuance());
-					<BlockInflation<T>>::put(amount);
-				}
-				<StartingYearTotalIssuance<T>>::set(T::Currency::total_issuance());
+				add_weight(3, 3, 10_000_000);
+			}
+
+			consumed_weight
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// 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<T>,
+			inflation_start_relay_block: T::BlockNumber,
+		) -> DispatchResult
+		where
+			<T as frame_system::Config>::BlockNumber: From<u32>,
+		{
+			ensure_root(origin)?;
 
-				// First time deposit
-				T::Currency::deposit_creating(&T::TreasuryAccountId::get(), <BlockInflation<T>>::get());
+			// Start inflation if it has not been yet initialized
+			let next_inflation: T::BlockNumber = <NextInflationBlock<T>>::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);
+				<NextInflationBlock<T>>::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(),
+					<BlockInflation<T>>::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(), <BlockInflation<T>>::get()).ok();
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	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<T> = 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());
+			<BlockInflation<T>>::put(amount);
+		} else {
+			let amount: BalanceOf<T> =
+				Perbill::from_rational(block_interval * END_INFLATION_PERCENT, YEAR)
+					* (one_percent * T::Currency::total_issuance());
+			<BlockInflation<T>>::put(amount);
 		}
+		<StartingYearTotalIssuance<T>>::set(T::Currency::total_issuance());
 
+		// Update recalculation and inflation blocks
+		<NextRecalculationBlock<T>>::set(recalculation_block + YEAR.into());
 	}
 }

3use crate as pallet_inflation;3use crate as pallet_inflation;
44
5use frame_support::{5use frame_support::{
6	assert_ok, parameter_types,
6	traits::{Currency},7	traits::{Currency, OnInitialize, Everything},
7	parameter_types,
8};8};
9use frame_support::{9use frame_system::RawOrigin;
10	traits::{OnInitialize, Everything},
11};
12use sp_core::H256;10use sp_core::H256;
13use sp_runtime::{11use sp_runtime::{
14	traits::{BlakeTwo256, IdentityLookup},12	traits::{BlakeTwo256, BlockNumberProvider, IdentityLookup},
15	testing::Header,13	testing::Header,
16};14};
1715
18type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;16type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
19type Block = frame_system::mocking::MockBlock<Test>;17type Block = frame_system::mocking::MockBlock<Test>;
2018
21const YEAR: u64 = 2_629_800;19const YEAR: u64 = 5_259_600; // 6-second blocks
20							 // const YEAR: u64 = 2_629_800; // 12-second blocks
21							 // Expected 100-block inflation for year 1 is 100 * 100_000_000 / YEAR = FIRST_YEAR_BLOCK_INFLATION
22const FIRST_YEAR_BLOCK_INFLATION: u64 = 1901;
2223
23parameter_types! {24parameter_types! {
24	pub const ExistentialDeposit: u64 = 1;25	pub const ExistentialDeposit: u64 = 1;
85parameter_types! {86parameter_types! {
86	pub TreasuryAccountId: u64 = 1234;87	pub TreasuryAccountId: u64 = 1234;
87	pub const InflationBlockInterval: u32 = 100; // every time per how many blocks inflation is applied88	pub const InflationBlockInterval: u32 = 100; // every time per how many blocks inflation is applied
89	pub static MockBlockNumberProvider: u64 = 0;
88}90}
91
92impl BlockNumberProvider for MockBlockNumberProvider {
93	type BlockNumber = u64;
94
95	fn current_block_number() -> Self::BlockNumber {
96		Self::get()
97	}
98}
8999
90impl pallet_inflation::Config for Test {100impl pallet_inflation::Config for Test {
91	type Currency = Balances;101	type Currency = Balances;
92	type TreasuryAccountId = TreasuryAccountId;102	type TreasuryAccountId = TreasuryAccountId;
93	type InflationBlockInterval = InflationBlockInterval;103	type InflationBlockInterval = InflationBlockInterval;
104	type BlockNumberProvider = MockBlockNumberProvider;
94}105}
95106
96pub fn new_test_ext() -> sp_io::TestExternalities {107pub fn new_test_ext() -> sp_io::TestExternalities {
100		.into()111		.into()
101}112}
113
114macro_rules! block_inflation {
115	// Block inflation doesn't have any argumets
116	() => {
117		// Return BlockInflation state variable current value
118		<pallet_inflation::BlockInflation<Test>>::get()
119	};
120}
121
122#[test]
123fn uninitialized_inflation() {
124	new_test_ext().execute_with(|| {
125		let initial_issuance: u64 = 1_000_000_000;
126		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
127		assert_eq!(Balances::free_balance(1234), initial_issuance);
128
129		// BlockInflation should be set after inflation is started
130		// first inflation deposit should be equal to BlockInflation
131		MockBlockNumberProvider::set(1);
132
133		assert_eq!(block_inflation!(), 0);
134	});
135}
102136
103#[test]137#[test]
104fn inflation_works() {138fn inflation_works() {
108		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);142		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
109		assert_eq!(Balances::free_balance(1234), initial_issuance);143		assert_eq!(Balances::free_balance(1234), initial_issuance);
110144
111		// BlockInflation should be set after 1st block and145		// BlockInflation should be set after inflation is started
112		// first inflation deposit should be equal to BlockInflation146		// first inflation deposit should be equal to BlockInflation
113		Inflation::on_initialize(1);147		MockBlockNumberProvider::set(1);
114148
115		// Expected 100-block inflation for year 1 is 100 * 100_000_000 / YEAR = 3803149		// Start inflation as sudo
150		assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1));
151		assert_eq!(block_inflation!(), FIRST_YEAR_BLOCK_INFLATION);
116		assert_eq!(Inflation::block_inflation(), 3803);152		assert_eq!(
153			Balances::free_balance(1234) - initial_issuance,
154			block_inflation!()
155		);
156
157		// Trigger inflation
158		MockBlockNumberProvider::set(102);
159		Inflation::on_initialize(0);
117		assert_eq!(160		assert_eq!(
118			Balances::free_balance(1234) - initial_issuance,161			Balances::free_balance(1234) - initial_issuance,
119			Inflation::block_inflation()162			2 * block_inflation!()
120		);163		);
121	});164	});
122}165}
128		let initial_issuance: u64 = 1_000_000_000;171		let initial_issuance: u64 = 1_000_000_000;
129		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);172		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
130		assert_eq!(Balances::free_balance(1234), initial_issuance);173		assert_eq!(Balances::free_balance(1234), initial_issuance);
131		Inflation::on_initialize(1);174		MockBlockNumberProvider::set(1);
175
176		// Start inflation as sudo
177		assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1));
132178
133		// Next inflation deposit happens when block is multiple of InflationBlockInterval179		// Next inflation deposit happens when block is greater then or equal to NextInflationBlock
134		let mut block: u32 = 2;180		let mut block: u64 = 2;
135		let balance_before: u64 = Balances::free_balance(1234);181		let balance_before: u64 = Balances::free_balance(1234);
136		while block % InflationBlockInterval::get() != 0 {182		while block < <pallet_inflation::NextInflationBlock<Test>>::get() {
137			Inflation::on_initialize(block as u64);183			MockBlockNumberProvider::set(block as u64);
184			Inflation::on_initialize(0);
138			block += 1;185			block += 1;
139		}186		}
140		let balance_just_before: u64 = Balances::free_balance(1234);187		let balance_just_before: u64 = Balances::free_balance(1234);
141		assert_eq!(balance_before, balance_just_before);188		assert_eq!(balance_before, balance_just_before);
142189
143		// The block with inflation190		// The block with inflation
144		Inflation::on_initialize(block as u64);191		MockBlockNumberProvider::set(block as u64);
192		Inflation::on_initialize(0);
145		let balance_after: u64 = Balances::free_balance(1234);193		let balance_after: u64 = Balances::free_balance(1234);
146		assert_eq!(194		assert_eq!(balance_after - balance_just_before, block_inflation!());
147			balance_after - balance_just_before,
148			Inflation::block_inflation()
149		);
150	});195	});
151}196}
157		let initial_issuance: u64 = 1_000_000_000;202		let initial_issuance: u64 = 1_000_000_000;
158		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);203		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
159		assert_eq!(Balances::free_balance(1234), initial_issuance);204		assert_eq!(Balances::free_balance(1234), initial_issuance);
160		Inflation::on_initialize(1);205		MockBlockNumberProvider::set(1);
206
207		// Start inflation as sudo
208		assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1));
161209
162		// Go through all the block inflations for year 1,210		// Go through all the block inflations for year 1,
163		// total issuance will be updated accordingly211		// total issuance will be updated accordingly
212		// Inflation is set to start in block 1, so first iteration is block 101
164		for block in (100..YEAR).step_by(100) {213		for block in (101..YEAR).step_by(100) {
214			MockBlockNumberProvider::set(block);
165			Inflation::on_initialize(block);215			Inflation::on_initialize(0);
166		}216		}
167		assert_eq!(217		assert_eq!(
168			initial_issuance + (3803 * (YEAR / 100)),218			initial_issuance + (FIRST_YEAR_BLOCK_INFLATION * (YEAR / 100)),
169			<Balances as Currency<_>>::total_issuance()219			<Balances as Currency<_>>::total_issuance()
170		);220		);
171221
222		MockBlockNumberProvider::set(YEAR + 1);
172		Inflation::on_initialize(YEAR);223		Inflation::on_initialize(0);
173		let block_inflation_year_1 = Inflation::block_inflation();224		let block_inflation_year_2 = block_inflation!();
174		// Expected 100-block inflation for year 2: 100 * 9.33% * initial issuance * 110% / YEAR = 3904225		// Expected 100-block inflation for year 2: 100 * 9.33% * initial issuance * 110% / YEAR == 1951
226		let expecter_year_2_inflation: u64 = (initial_issuance
227			+ FIRST_YEAR_BLOCK_INFLATION * YEAR / 100)
228			* 933 * 100 / (10000 * YEAR);
175		assert_eq!(block_inflation_year_1, 3904);229		assert_eq!(block_inflation_year_2 / 10, expecter_year_2_inflation / 10); // divide by 10 for approx. equality
176	});230	});
177}231}
178
179#[test]
180fn inflation_in_1_to_9_years() {
181	new_test_ext().execute_with(|| {
182		// Total issuance = 1_000_000_000
183		let initial_issuance: u64 = 1_000_000_000;
184		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
185		assert_eq!(Balances::free_balance(1234), initial_issuance);
186		Inflation::on_initialize(1);
187
188		for year in 1..=9 {
189			let block_inflation_year_before = Inflation::block_inflation();
190			Inflation::on_initialize(YEAR * year);
191			let block_inflation_year_after = Inflation::block_inflation();
192
193			// SBP M2 review: this is actually not true (not for the first few years)
194			// Assert that next year inflation is less than previous year inflation
195			assert!(block_inflation_year_before > block_inflation_year_after);
196		}
197	});
198}
199232
200#[test]233#[test]
201fn inflation_after_year_10_is_flat() {234fn inflation_after_year_10_is_flat() {
204		let initial_issuance: u64 = 1_000_000_000;237		let initial_issuance: u64 = 1_000_000_000;
205		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);238		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
206		assert_eq!(Balances::free_balance(1234), initial_issuance);239		assert_eq!(Balances::free_balance(1234), initial_issuance);
207		Inflation::on_initialize(YEAR * 9);240		MockBlockNumberProvider::set(YEAR * 9 + 1);
241
242		// Start inflation as sudo
243		assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1));
244
245		// Let inflation catch up
246		for _year in 1..=9 {
247			Inflation::on_initialize(0);
248		}
208249
209		for year in 10..=20 {250		for year in 10..=20 {
210			let block_inflation_year_before = Inflation::block_inflation();251			let block_inflation_year_before = block_inflation!();
211			Inflation::on_initialize(YEAR * year);252			MockBlockNumberProvider::set(YEAR * year + 1);
253			Inflation::on_initialize(0);
212			let block_inflation_year_after = Inflation::block_inflation();254			let block_inflation_year_after = block_inflation!();
213255
214			// Assert that next year inflation is equal to previous year inflation256			// Assert that next year inflation is equal to previous year inflation
215			assert_eq!(block_inflation_year_before, block_inflation_year_after);257			assert_eq!(block_inflation_year_before, block_inflation_year_after);
231		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);273		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
232		assert_eq!(Balances::free_balance(1234), initial_issuance);274		assert_eq!(Balances::free_balance(1234), initial_issuance);
275
276		// Start inflation as sudo
277		assert_ok!(Inflation::start_inflation(RawOrigin::Root.into(), 1));
233278
234		for year in 0..=10 {279		for year in 0..=10 {
235			// Year first block280			// Year first block
281			MockBlockNumberProvider::set(YEAR * year + 1);
236			Inflation::on_initialize(year * YEAR);282			Inflation::on_initialize(0);
237			let mut actual_payout = Inflation::block_inflation();283			let mut actual_payout = block_inflation!();
238			assert_eq!(actual_payout, payout_by_year[year as usize]);284			assert_eq!(actual_payout, payout_by_year[year as usize]);
239285
240			// Year second block286			// Year second block
241			Inflation::on_initialize(year * YEAR + 1);287			MockBlockNumberProvider::set(YEAR * year + 2);
288			Inflation::on_initialize(0);
242			actual_payout = Inflation::block_inflation();289			actual_payout = block_inflation!();
243			assert_eq!(actual_payout, payout_by_year[year as usize]);290			assert_eq!(actual_payout, payout_by_year[year as usize]);
244291
245			// Year middle block292			// Year middle block
246			Inflation::on_initialize(year * YEAR + YEAR / 2);293			MockBlockNumberProvider::set(year * YEAR + YEAR / 2);
294			Inflation::on_initialize(0);
247			actual_payout = Inflation::block_inflation();295			actual_payout = block_inflation!();
248			assert_eq!(actual_payout, payout_by_year[year as usize]);296			assert_eq!(actual_payout, payout_by_year[year as usize]);
249297
250			// Year last block298			// Year last block
251			Inflation::on_initialize((year + 1) * YEAR - 1);299			MockBlockNumberProvider::set((year + 1) * YEAR);
300			Inflation::on_initialize(0);
252			actual_payout = Inflation::block_inflation();301			actual_payout = block_inflation!();
253			assert_eq!(actual_payout, payout_by_year[year as usize]);302			assert_eq!(actual_payout, payout_by_year[year as usize]);
254		}303		}
255	});304	});

--- 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<Self>;
 }
-/*
+
 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<Runtime>;
+}
 
 // parameter_types! {
 // 	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *
@@ -882,7 +883,7 @@
 		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,
 
 		// Unique Pallets
-		// Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,
+		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,
 		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,
 		// Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 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<void> {
+function skipInflationBlock(api: ApiPromise): Promise<void> {
   const promise = new Promise<void>(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',