git.delta.rocks / unique-network / refs/commits / 25b82cffb2c3

1#![allow(dead_code)]
2
1use darling::FromMeta;3use darling::FromMeta;
2use inflector::cases;4use inflector::cases;

1#![allow(dead_code)]
2
1use quote::quote;3use quote::quote;
2use darling::FromMeta;4use darling::FromMeta;
545				#(547				#(
546					#call_inner548					#call_inner
547				)*549				)*
550				#[allow(unreachable_code)] // In case of no inner calls
548				fn call(&mut self, c: Msg<#call_name>) -> ::core::result::Result<::evm_coder::abi::AbiWriter, Self::Error> {551				fn call(&mut self, c: Msg<#call_name>) -> ::core::result::Result<::evm_coder::abi::AbiWriter, Self::Error> {
549					use ::evm_coder::abi::AbiWrite;552					use ::evm_coder::abi::AbiWrite;
550					type InternalCall = #call_name;553					type InternalCall = #call_name;

1#![allow(dead_code)] // This test only checks that macros is not panicking
2
1use evm_coder::{solidity_interface, types::*, ToLog};3use evm_coder::{solidity_interface, types::*, ToLog};
2use evm_coder_macros::solidity;4use evm_coder_macros::solidity;

no syntactic changes

64		// ID64		// ID
65		"dev",65		"dev",
66		ChainType::Local,66		ChainType::Local,
67		move || testnet_genesis(67		move || {
68			testnet_genesis(
68			// Sudo account69				// Sudo account
69			get_account_id_from_seed::<sr25519::Public>("Alice"),70				get_account_id_from_seed::<sr25519::Public>("Alice"),
78			],79				],
79			id,80				id,
80		),81			)
82		},
81		// Bootnodes83		// Bootnodes
82		vec![],84		vec![],
83		// Telemetry85		// Telemetry
101		// ID103		// ID
102		"local_testnet",104		"local_testnet",
103		ChainType::Local,105		ChainType::Local,
104		move || testnet_genesis(106		move || {
107			testnet_genesis(
105			// Sudo account108				// Sudo account
106			get_account_id_from_seed::<sr25519::Public>("Alice"),109				get_account_id_from_seed::<sr25519::Public>("Alice"),
125			],128				],
126			id,129				id,
127		),130			)
131		},
128		// Bootnodes132		// Bootnodes
129		vec![],133		vec![],
130		// Telemetry134		// Telemetry
190					offchain_schema: vec![],191					offchain_schema: vec![],
191					schema_version: SchemaVersion::default(),192					schema_version: SchemaVersion::default(),
192                    sponsorship: SponsorshipState::Confirmed(get_account_id_from_seed::<sr25519::Public>("Alice")),193					sponsorship: SponsorshipState::Confirmed(get_account_id_from_seed::<
194						sr25519::Public,
195					>("Alice")),
193                    const_on_chain_schema: vec![],196					const_on_chain_schema: vec![],
194					variable_on_chain_schema: vec![],197					variable_on_chain_schema: vec![],
195					limits: CollectionLimits::default()198					limits: CollectionLimits::default(),
196                },199				},
197            )],200			)],
198            nft_item_id: vec![],201			nft_item_id: vec![],

18use crate::{18use crate::{
19	chain_spec,19	chain_spec,
20	cli::{Cli, RelayChainCli, Subcommand},20	cli::{Cli, RelayChainCli, Subcommand},
21	service::{new_partial, ParachainRuntimeExecutor}21	service::{new_partial, ParachainRuntimeExecutor},
22};22};
23use codec::Encode;23use codec::Encode;
24use cumulus_primitives_core::ParaId;24use cumulus_primitives_core::ParaId;
31	NetworkParams, Result, RuntimeVersion, SharedParams, SubstrateCli,31	NetworkParams, Result, RuntimeVersion, SharedParams, SubstrateCli,
32};32};
33use sc_service::{33use sc_service::{
34	config::{BasePath, PrometheusConfig}34	config::{BasePath, PrometheusConfig},
35};35};
36use sp_core::hexdisplay::HexDisplay;36use sp_core::hexdisplay::HexDisplay;
37use sp_runtime::traits::Block as BlockT;37use sp_runtime::traits::Block as BlockT;
251			}251			}
252252
253			Ok(())253			Ok(())
254		},254		}
255		Some(Subcommand::Benchmark(cmd)) => {255		Some(Subcommand::Benchmark(cmd)) => {
256			if cfg!(feature = "runtime-benchmarks") {256			if cfg!(feature = "runtime-benchmarks") {
257				let runner = cli.create_runner(cmd)?;257				let runner = cli.create_runner(cmd)?;
262				You can enable it with `--features runtime-benchmarks`.".into())262				You can enable it with `--features runtime-benchmarks`."
263					.into())
263			}264			}
264		},265		}
265		None => {266		None => {
266			let runner = cli.create_runner(&cli.run.normalize())?;267			let runner = cli.create_runner(&cli.run.normalize())?;
267268

1616
17// Cumulus Imports17// Cumulus Imports
18use cumulus_client_consensus_aura::{18use cumulus_client_consensus_aura::{build_aura_consensus, BuildAuraConsensusParams, SlotProportion};
19	build_aura_consensus, BuildAuraConsensusParams, SlotProportion,
20};
21use cumulus_client_consensus_common::ParachainConsensus;19use cumulus_client_consensus_common::ParachainConsensus;
22use cumulus_client_network::build_block_announce_validator;20use cumulus_client_network::build_block_announce_validator;
71		source: fc_db::DatabaseSettingsSrc::RocksDb {71			source: fc_db::DatabaseSettingsSrc::RocksDb {
72			path: database_dir,72				path: database_dir,
73			cache_size: 0,73				cache_size: 0,
74		}74			},
75	})?))75		},
76	)?))
76}77}
7778
85///86///
86/// Use this macro if you don't actually need the full service, but just the builder in order to87/// Use this macro if you don't actually need the full service, but just the builder in order to
87/// be able to perform chain operations.88/// be able to perform chain operations.
89#[allow(clippy::type_complexity)]
88pub fn new_partial<BIQ>(90pub fn new_partial<BIQ>(
89	config: &Configuration,91	config: &Configuration,
90	build_import_queue: BIQ,92	build_import_queue: BIQ,
102			PendingTransactions,
103			Option<FilterPool>,
104			Arc<fc_db::Backend<Block>>,
105			Option<TelemetryWorkerHandle>,
106		),
99	>,107	>,
100	sc_service::Error,108	sc_service::Error,
109		&TaskManager,117		&TaskManager,
110	) -> Result<118	) -> Result<sp_consensus::DefaultImportQueue<Block, FullClient>, sc_service::Error>,
111		sp_consensus::DefaultImportQueue<Block, FullClient>,
112		sc_service::Error,
113	>,
114{119{
115	let telemetry = config120	let _telemetry = config
116		.telemetry_endpoints121		.telemetry_endpoints
117		.clone()122		.clone()
118		.filter(|x| !x.is_empty())123		.filter(|x| !x.is_empty())
189			pending_transactions,
190			filter_pool,
191			frontier_backend,
192			telemetry_worker_handle,
193		),
182	};194	};
183195
206		&TaskManager,218		&TaskManager,
207	) -> Result<219	) -> Result<sp_consensus::DefaultImportQueue<Block, FullClient>, sc_service::Error>,
208		sp_consensus::DefaultImportQueue<Block, FullClient>,
209		sc_service::Error,
210	>,
211	BIC: FnOnce(220	BIC: FnOnce(
212		Arc<FullClient>,221		Arc<FullClient>,
241		pending_transactions,
242		filter_pool,
243		frontier_backend,
244		telemetry_worker_handle,
245	) = params.other;
231246
232	let relay_chain_full_node = cumulus_client_service::build_polkadot_full_node(247	let relay_chain_full_node = cumulus_client_service::build_polkadot_full_node(
283			network: rpc_network.clone(),298			network: rpc_network.clone(),
284			pending_transactions: pending_transactions.clone(),299			pending_transactions: pending_transactions.clone(),
285			select_chain: select_chain.clone(),300			select_chain: select_chain.clone(),
286			is_authority: is_authority.clone(),301			is_authority,
287			// TODO: Unhardcode302			// TODO: Unhardcode
288			max_past_logs: 10000,303			max_past_logs: 10000,
289		};304		};
367) -> Result<382) -> Result<sp_consensus::DefaultImportQueue<Block, FullClient>, sc_service::Error> {
368	sp_consensus::DefaultImportQueue<
369		Block,
370		FullClient,
371	>,
372	sc_service::Error,
373> {
374	let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;383	let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;
375
396404
397			Ok((time, slot))405			Ok((time, slot))
398		},406		},
399		registry: config.prometheus_registry().clone(),407		registry: config.prometheus_registry(),
400		can_author_with: sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),408		can_author_with: sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),
401		spawner: &task_manager.spawn_essential_handle(),409		spawner: &task_manager.spawn_essential_handle(),
402		telemetry,410		telemetry,
432				task_manager.spawn_handle(),440				task_manager.spawn_handle(),
433				client.clone(),441				client.clone(),
434				transaction_pool,442				transaction_pool,
435				prometheus_registry.clone(),443				prometheus_registry,
436				telemetry.clone(),444				telemetry.clone(),
437			);445			);
438446
480				block_import: client.clone(),488				block_import: client.clone(),
481				relay_chain_client: relay_chain_node.client.clone(),489				relay_chain_client: relay_chain_node.client.clone(),
482				relay_chain_backend: relay_chain_node.backend.clone(),490				relay_chain_backend: relay_chain_node.backend.clone(),
483				para_client: client.clone(),491				para_client: client,
484				backoff_authoring_blocks: Option::<()>::None,492				backoff_authoring_blocks: Option::<()>::None,
485				sync_oracle,493				sync_oracle,
486				keystore,494				keystore,

189		pool.clone(),189		pool.clone(),
190		nft_runtime::TransactionConverter,190		nft_runtime::TransactionConverter,
191		network.clone(),191		network.clone(),
192		pending_transactions.clone(),192		pending_transactions,
193		signers,193		signers,
194		overrides.clone(),194		overrides.clone(),
195		backend,195		backend,
200	if let Some(filter_pool) = filter_pool {200	if let Some(filter_pool) = filter_pool {
201		io.extend_with(EthFilterApiServer::to_delegate(EthFilterApi::new(201		io.extend_with(EthFilterApiServer::to_delegate(EthFilterApi::new(
202			client.clone(),202			client.clone(),
203			filter_pool.clone(),203			filter_pool,
204			500 as usize, // max stored filters204			500_usize, // max stored filters
205			overrides.clone(),205			overrides.clone(),
206			max_past_logs,206			max_past_logs,
207		)));207		)));
217	io.extend_with(Web3ApiServer::to_delegate(Web3Api::new(client.clone())));217	io.extend_with(Web3ApiServer::to_delegate(Web3Api::new(client.clone())));
218218
219	io.extend_with(EthPubSubApiServer::to_delegate(EthPubSubApi::new(219	io.extend_with(EthPubSubApiServer::to_delegate(EthPubSubApi::new(
220		pool.clone(),220		pool,
221		client.clone(),221		client,
222		network.clone(),222		network,
223		SubscriptionManager::<HexEncodedIdProvider>::with_id_provider(223		SubscriptionManager::<HexEncodedIdProvider>::with_id_provider(
224			HexEncodedIdProvider::default(),224			HexEncodedIdProvider::default(),
225			Arc::new(subscription_task_executor),225			Arc::new(subscription_task_executor),

174			_info: &DispatchInfoOf<Self::Call>,186			_info: &DispatchInfoOf<Self::Call>,
175			_len: usize,187			_len: usize,
176		) -> transaction_validity::TransactionValidity {188		) -> transaction_validity::TransactionValidity {
177			match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {
178				Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {189			if let Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) =
190				IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call)
191			{
179					let called_contract: T::AccountId =192				let called_contract: T::AccountId =
180						T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());193					T::Lookup::lookup((*dest).clone()).unwrap_or_default();
181					if <AllowlistEnabled<T>>::get(&called_contract) {194				if <AllowlistEnabled<T>>::get(&called_contract)
182						if !<Allowlist<T>>::get(&called_contract, who)195					&& !<Allowlist<T>>::get(&called_contract, who)
183							&& &<Owner<T>>::get(&called_contract) != who196					&& &<Owner<T>>::get(&called_contract) != who
184						{197				{
185							return Err(transaction_validity::InvalidTransaction::Call.into());198					return Err(transaction_validity::InvalidTransaction::Call.into());
186						}199				}
187					}
188				}200			}
189				_ => {}
190			}
191			Ok(transaction_validity::ValidTransaction::default())201			Ok(transaction_validity::ValidTransaction::default())
192		}202		}
193203
200		) -> Result<Self::Pre, TransactionValidityError> {210		) -> Result<Self::Pre, TransactionValidityError> {
201			match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {211			match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {
202				Some(pallet_contracts::Call::instantiate(_, _, code_hash, _, salt)) => {212				Some(pallet_contracts::Call::instantiate(_, _, code_hash, _, salt)) => {
203					Ok(Some((who.clone(), code_hash.clone(), salt.clone())))213					Ok(Some((who.clone(), *code_hash, salt.clone())))
204				}214				}
205				Some(pallet_contracts::Call::instantiate_with_code(_, _, code, _, salt)) => {215				Some(pallet_contracts::Call::instantiate_with_code(_, _, code, _, salt)) => {
206					let code_hash = &T::Hashing::hash(&code);216					let code_hash = &T::Hashing::hash(&code);
207					Ok(Some((who.clone(), code_hash.clone(), salt.clone())))217					Ok(Some((who.clone(), *code_hash, salt.clone())))
208				}218				}
209				_ => Ok(None),219				_ => Ok(None),
210			}220			}
236		T::AccountId: AsRef<[u8]>,246		T::AccountId: AsRef<[u8]>,
237	{247	{
238		fn get_sponsor(who: &T::AccountId, call: &C) -> Option<T::AccountId> {248		fn get_sponsor(who: &T::AccountId, call: &C) -> Option<T::AccountId> {
239			match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {
240				Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {249			if let Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) =
250				IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call)
251			{
241					let called_contract: T::AccountId =252				let called_contract: T::AccountId =
253						}263					}
254					}264				}
255				}265			}
256				_ => {}
257			}
258			None266			None
259		}267		}
260	}268	}

no syntactic changes

3936
40use sp_runtime::{37use sp_runtime::{
41	Perbill,38	Perbill,
42	traits::{Zero}39	traits::{Zero},
43};40};
44use sp_std::convert::TryInto;41use sp_std::convert::TryInto;
4542

1#[cfg(test)]1#![cfg(test)]
2mod tests {2#![allow(clippy::from_over_into)]
3	use crate as pallet_inflation;3use crate as pallet_inflation;
44
5	use frame_system;5use frame_support::{
6	use frame_support::{traits::{Currency}, parameter_types};6	traits::{Currency},
7	use frame_support::{traits::OnInitialize};7	parameter_types,
8	use sp_core::H256;8};
9	use sp_runtime::{traits::{BlakeTwo256, IdentityLookup}, testing::Header};9use frame_support::{traits::OnInitialize};
1010use sp_core::H256;
11	type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;11use sp_runtime::{
12	type Block = frame_system::mocking::MockBlock<Test>;12	traits::{BlakeTwo256, IdentityLookup},
1313	testing::Header,
14	const YEAR: u64 = 5_259_600;14};
1515
16	parameter_types! {16type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
17		pub const ExistentialDeposit: u64 = 1;17type Block = frame_system::mocking::MockBlock<Test>;
18		pub const MaxLocks: u32 = 50;18
19	}19const YEAR: u64 = 5_259_600;
20	20
21	impl pallet_balances::Config for Test {21parameter_types! {
22		type AccountStore = System;22	pub const ExistentialDeposit: u64 = 1;
23		type Balance = u64;23	pub const MaxLocks: u32 = 50;
24		type DustRemoval = ();24}
25		type Event = ();25
26		type ExistentialDeposit = ExistentialDeposit;26impl pallet_balances::Config for Test {
27		type WeightInfo = ();27	type AccountStore = System;
28		type MaxLocks = MaxLocks;28	type Balance = u64;
29	}29	type DustRemoval = ();
30	30	type Event = ();
31	frame_support::construct_runtime!(31	type ExistentialDeposit = ExistentialDeposit;
32		pub enum Test where32	type WeightInfo = ();
33			Block = Block,33	type MaxLocks = MaxLocks;
34			NodeBlock = Block,34}
35			UncheckedExtrinsic = UncheckedExtrinsic,35
36		{36frame_support::construct_runtime!(
37			Balances: pallet_balances::{Pallet, Call, Storage},37	pub enum Test where
38			System: frame_system::{Pallet, Call, Config, Storage, Event<T>},38		Block = Block,
39			Inflation: pallet_inflation::{Pallet, Call, Storage},39		NodeBlock = Block,
40		}40		UncheckedExtrinsic = UncheckedExtrinsic,
41	);41	{
4242		Balances: pallet_balances::{Pallet, Call, Storage},
43	parameter_types! {43		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
44		pub const BlockHashCount: u64 = 250;44		Inflation: pallet_inflation::{Pallet, Call, Storage},
45		pub BlockWeights: frame_system::limits::BlockWeights =45	}
46			frame_system::limits::BlockWeights::simple_max(1024);46);
47		pub const SS58Prefix: u8 = 42;47
48	}48parameter_types! {
4949	pub const BlockHashCount: u64 = 250;
50	impl frame_system::Config for Test {50	pub BlockWeights: frame_system::limits::BlockWeights =
51		type BaseCallFilter = ();51		frame_system::limits::BlockWeights::simple_max(1024);
52		type BlockWeights = ();52	pub const SS58Prefix: u8 = 42;
53		type BlockLength = ();53}
54		type DbWeight = ();54
55		type Origin = Origin;55impl frame_system::Config for Test {
56		type Call = Call;56	type BaseCallFilter = ();
57		type Index = u64;57	type BlockWeights = ();
58		type BlockNumber = u64;58	type BlockLength = ();
59		type Hash = H256;59	type DbWeight = ();
60		type Hashing = BlakeTwo256;60	type Origin = Origin;
61		type AccountId = u64;61	type Call = Call;
62		type Lookup = IdentityLookup<Self::AccountId>;62	type Index = u64;
63		type Header = Header;63	type BlockNumber = u64;
64		type Event = ();64	type Hash = H256;
65		type BlockHashCount = BlockHashCount;65	type Hashing = BlakeTwo256;
66		type Version = ();66	type AccountId = u64;
67		type PalletInfo = PalletInfo;67	type Lookup = IdentityLookup<Self::AccountId>;
68		type AccountData = pallet_balances::AccountData<u64>;68	type Header = Header;
69		type OnNewAccount = ();69	type Event = ();
70		type OnKilledAccount = ();70	type BlockHashCount = BlockHashCount;
71		type SystemWeightInfo = ();71	type Version = ();
72		type SS58Prefix = SS58Prefix;72	type PalletInfo = PalletInfo;
73        type OnSetCode = ();73	type AccountData = pallet_balances::AccountData<u64>;
74	}74	type OnNewAccount = ();
7575	type OnKilledAccount = ();
76	parameter_types! {76	type SystemWeightInfo = ();
77		pub TreasuryAccountId: u64 = 1234;77	type SS58Prefix = SS58Prefix;
78		pub const InflationBlockInterval: u32 = 100; // every time per how many blocks inflation is applied78	type OnSetCode = ();
79	}79}
80		80
81	impl pallet_inflation::Config for Test {81parameter_types! {
82		type Currency = Balances;82	pub TreasuryAccountId: u64 = 1234;
83		type TreasuryAccountId = TreasuryAccountId;83	pub const InflationBlockInterval: u32 = 100; // every time per how many blocks inflation is applied
84		type InflationBlockInterval = InflationBlockInterval;84}
85	}85
8686impl pallet_inflation::Config for Test {
87	// Build genesis storage according to the mock runtime.87	type Currency = Balances;
88	pub fn new_test_ext() -> sp_io::TestExternalities {88	type TreasuryAccountId = TreasuryAccountId;
89		frame_system::GenesisConfig::default().build_storage::<Test>().unwrap().into()89	type InflationBlockInterval = InflationBlockInterval;
90	}90}
91
92// Build genesis storage according to the mock runtime.
93pub fn new_test_ext() -> sp_io::TestExternalities {
94	frame_system::GenesisConfig::default()
95		.build_storage::<Test>()
96		.unwrap()
97		.into()
98}
99
100#[test]
101fn inflation_works() {
102	new_test_ext().execute_with(|| {
103		// Total issuance = 1_000_000_000
104		let initial_issuance: u64 = 1_000_000_000;
105		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
106		assert_eq!(Balances::free_balance(1234), initial_issuance);
107
108		// BlockInflation should be set after 1st block and
109		// first inflation deposit should be equal to BlockInflation
110		Inflation::on_initialize(1);
111		assert!(Inflation::block_inflation() > 0);
112		assert_eq!(
113			Balances::free_balance(1234) - initial_issuance,
114			Inflation::block_inflation()
115		);
116	});
117}
118
119#[test]
120fn inflation_second_deposit() {
121	new_test_ext().execute_with(|| {
122		// Total issuance = 1_000_000_000
123		let initial_issuance: u64 = 1_000_000_000;
124		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
125		assert_eq!(Balances::free_balance(1234), initial_issuance);
126		Inflation::on_initialize(1);
127
128		// Next inflation deposit happens when block is multiple of InflationBlockInterval
129		let mut block: u32 = 2;
130		let balance_before: u64 = Balances::free_balance(1234);
131		while block % InflationBlockInterval::get() != 0 {
132			Inflation::on_initialize(block as u64);
133			block += 1;
134		}
135		let balance_just_before: u64 = Balances::free_balance(1234);
136		assert_eq!(balance_before, balance_just_before);
137
138		// The block with inflation
139		Inflation::on_initialize(block as u64);
140		let balance_after: u64 = Balances::free_balance(1234);
141		assert_eq!(
142			balance_after - balance_just_before,
143			Inflation::block_inflation()
144		);
145	});
146}
147
148#[test]
149fn inflation_in_1_year() {
150	new_test_ext().execute_with(|| {
151		// Total issuance = 1_000_000_000
152		let initial_issuance: u64 = 1_000_000_000;
153		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
154		assert_eq!(Balances::free_balance(1234), initial_issuance);
155		Inflation::on_initialize(1);
156		let block_inflation_year_0 = Inflation::block_inflation();
157
158		Inflation::on_initialize(YEAR);
159		let block_inflation_year_1 = Inflation::block_inflation();
160
161		// Assert that year 1 inflation is less than year 0
162		assert!(block_inflation_year_0 > block_inflation_year_1);
163	});
164}
165
166#[test]
167fn inflation_in_1_to_9_years() {
168	new_test_ext().execute_with(|| {
169		// Total issuance = 1_000_000_000
170		let initial_issuance: u64 = 1_000_000_000;
171		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
172		assert_eq!(Balances::free_balance(1234), initial_issuance);
173		Inflation::on_initialize(1);
174
175		for year in 1..=9 {
176			let block_inflation_year_before = Inflation::block_inflation();
177			Inflation::on_initialize(YEAR * year);
178			let block_inflation_year_after = Inflation::block_inflation();
179
180			// Assert that next year inflation is less than previous year inflation
181			assert!(block_inflation_year_before > block_inflation_year_after);
182		}
183	});
184}
185
186#[test]
187fn inflation_after_year_10_is_flat() {
188	new_test_ext().execute_with(|| {
189		// Total issuance = 1_000_000_000
190		let initial_issuance: u64 = 1_000_000_000;
191		let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
192		assert_eq!(Balances::free_balance(1234), initial_issuance);
193		Inflation::on_initialize(YEAR * 9);
194
195		for year in 10..=20 {
196			let block_inflation_year_before = Inflation::block_inflation();
197			Inflation::on_initialize(YEAR * year);
198			let block_inflation_year_after = Inflation::block_inflation();
199
200			// Assert that next year inflation is equal to previous year inflation
201			assert_eq!(block_inflation_year_before, block_inflation_year_after);
202		}
203	});
204}
91205
92	#[test]206#[test]
93	fn inflation_works() {207fn inflation_rate_by_year() {
94		new_test_ext().execute_with(|| {
95			// Total issuance = 1_000_000_000
96			let initial_issuance: u64 = 1_000_000_000;
97			let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
98			assert_eq!(Balances::free_balance(1234), initial_issuance);
99
100			// BlockInflation should be set after 1st block and 
101			// first inflation deposit should be equal to BlockInflation
102			Inflation::on_initialize(1);
103			assert!(Inflation::block_inflation() > 0);
104			assert_eq!(Balances::free_balance(1234) - initial_issuance, Inflation::block_inflation());
105		});
106	}
107
108	#[test]
109	fn inflation_second_deposit() {
110		new_test_ext().execute_with(|| {
111			// Total issuance = 1_000_000_000
112			let initial_issuance: u64 = 1_000_000_000;
113			let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
114			assert_eq!(Balances::free_balance(1234), initial_issuance);
115			Inflation::on_initialize(1);
116
117			// Next inflation deposit happens when block is multiple of InflationBlockInterval
118			let mut block: u32 = 2;
119			let balance_before: u64 = Balances::free_balance(1234);
120			while block % InflationBlockInterval::get() != 0 {
121				Inflation::on_initialize(block as u64);
122				block += 1;
123			}
124			let balance_just_before: u64 = Balances::free_balance(1234);
125			assert_eq!(balance_before, balance_just_before);
126
127			// The block with inflation
128			Inflation::on_initialize(block as u64);
129			let balance_after: u64 = Balances::free_balance(1234);
130			assert_eq!(balance_after - balance_just_before, Inflation::block_inflation());
131		});
132	}
133
134	#[test]
135	fn inflation_in_1_year() {
136		new_test_ext().execute_with(|| {
137			// Total issuance = 1_000_000_000
138			let initial_issuance: u64 = 1_000_000_000;
139			let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
140			assert_eq!(Balances::free_balance(1234), initial_issuance);
141			Inflation::on_initialize(1);
142			let block_inflation_year_0 = Inflation::block_inflation();
143
144			Inflation::on_initialize(YEAR);
145			let block_inflation_year_1 = Inflation::block_inflation();
146
147			// Assert that year 1 inflation is less than year 0
148			assert!(block_inflation_year_0 > block_inflation_year_1);
149		});
150	}
151
152	#[test]
153	fn inflation_in_1_to_9_years() {
154		new_test_ext().execute_with(|| {
155			// Total issuance = 1_000_000_000
156			let initial_issuance: u64 = 1_000_000_000;
157			let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
158			assert_eq!(Balances::free_balance(1234), initial_issuance);
159			Inflation::on_initialize(1);
160
161			for year in 1..=9 {
162				let block_inflation_year_before = Inflation::block_inflation();
163				Inflation::on_initialize(YEAR * year);
164				let block_inflation_year_after = Inflation::block_inflation();
165
166				// Assert that next year inflation is less than previous year inflation
167				assert!(block_inflation_year_before > block_inflation_year_after);
168			}
169
170		});
171	}
172
173	#[test]
174	fn inflation_after_year_10_is_flat() {
175		new_test_ext().execute_with(|| {
176			// Total issuance = 1_000_000_000
177			let initial_issuance: u64 = 1_000_000_000;
178			let _ = <Balances as Currency<_>>::deposit_creating(&1234, initial_issuance);
179			assert_eq!(Balances::free_balance(1234), initial_issuance);
180			Inflation::on_initialize(YEAR * 9);
181
182			for year in 10..=20 {
183				let block_inflation_year_before = Inflation::block_inflation();
184				Inflation::on_initialize(YEAR * year);
185				let block_inflation_year_after = Inflation::block_inflation();
186
187				// Assert that next year inflation is equal to previous year inflation
188				assert_eq!(block_inflation_year_before, block_inflation_year_after);
189			}
190		});
191	}
192
193	#[test]
194	fn inflation_rate_by_year() {
195		new_test_ext().execute_with(|| {208	new_test_ext().execute_with(|| {
196			let payouts: u64 = YEAR / InflationBlockInterval::get() as u64;209		let payouts: u64 = YEAR / InflationBlockInterval::get() as u64;
197210
198			// Inflation starts at 10% and does down by 2/3% every year until year 9 (included), 211		// Inflation starts at 10% and does down by 2/3% every year until year 9 (included),
199			// then it is flat.212		// then it is flat.
200			let payout_by_year: [u64; 11] = [213		let payout_by_year: [u64; 11] = [1000, 933, 867, 800, 733, 667, 600, 533, 467, 400, 400];
201				1000,
239			}240		}
240		});241	});
241	}242}
242}
243243

11#[cfg(feature = "std")]11#[cfg(feature = "std")]
12pub use serde::*;12pub use serde::*;
13
14#[cfg(feature = "runtime-benchmarks")]
15mod benchmarking;
1613
17use codec::{Decode, Encode};14use codec::{Decode, Encode};
18use frame_support::traits::Get;15use frame_support::traits::Get;
19use frame_support::{16use frame_support::{
20	decl_module, decl_storage,17	decl_module, decl_storage,
21	weights::{18	weights::{DispatchInfo, PostDispatchInfo, DispatchClass},
22		DispatchInfo, PostDispatchInfo, DispatchClass
23	}
24};19};
29	transaction_validity::{ 25	transaction_validity::{
30		TransactionPriority, TransactionValidity, TransactionValidityError, ValidTransaction,26		TransactionPriority, TransactionValidity, TransactionValidityError, ValidTransaction,
31	},27	},
32	FixedPointOperand, DispatchResult28	FixedPointOperand, DispatchResult,
33};29};
34use pallet_transaction_payment::OnChargeTransaction;30use pallet_transaction_payment::OnChargeTransaction;
35use sp_std::prelude::*;31use sp_std::prelude::*;
102            .saturated_into::<TransactionPriority>()95			.saturated_into::<TransactionPriority>()
103    }96	}
10497
98	#[allow(clippy::type_complexity)]
105    fn withdraw_fee(99    fn withdraw_fee(
106        &self,100        &self,
107        who: &T::AccountId,101        who: &T::AccountId,
126        }120		}
127121
128        // Determine who is paying transaction fee based on ecnomic model122		// Determine who is paying transaction fee based on ecnomic model
129		// Parse call to extract collection ID and access collection sponsor	123		// Parse call to extract collection ID and access collection sponsor
130		let sponsor = <pallet_nft_transaction_payment::Module<T>>::withdraw_type(who, call);124		let sponsor = <pallet_nft_transaction_payment::Module<T>>::withdraw_type(who, call);
131125
132        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());126		let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());