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());
 	}
 }

--- 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<Test>;
 type Block = frame_system::mocking::MockBlock<Test>;
 
-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
+		<pallet_inflation::BlockInflation<Test>>::get()
+	};
+}
+
+#[test]
+fn uninitialized_inflation() {
+	new_test_ext().execute_with(|| {
+		let initial_issuance: u64 = 1_000_000_000;
+		let _ = <Balances as Currency<_>>::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 _ = <Balances as Currency<_>>::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 _ = <Balances as Currency<_>>::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 < <pallet_inflation::NextInflationBlock<Test>>::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 _ = <Balances as Currency<_>>::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)),
 			<Balances as Currency<_>>::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 _ = <Balances as Currency<_>>::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 _ = <Balances as Currency<_>>::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 _ = <Balances as Currency<_>>::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/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',