feat: initialize Kurdistan SDK - independent fork of Polkadot SDK

2025-12-13 15:44:15 +03:00
commit e4778b4576
6838 changed files with 1847450 additions and 0 deletions
@@ -0,0 +1,917 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::*;
+use crate as pallet_transaction_payment;
+
+use codec::Encode;
+
+use sp_runtime::{
+	generic::UncheckedExtrinsic,
+	traits::{DispatchTransaction, One},
+	transaction_validity::{InvalidTransaction, TransactionSource::External},
+	BuildStorage,
+};
+
+use frame_support::{
+	assert_ok,
+	dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, PostDispatchInfo},
+	traits::{Currency, OriginTrait},
+	weights::Weight,
+};
+use frame_system as system;
+use mock::*;
+use pallet_balances::Call as BalancesCall;
+
+pub struct ExtBuilder {
+	balance_factor: u64,
+	base_weight: Weight,
+	byte_fee: u64,
+	weight_to_fee: u64,
+	initial_multiplier: Option<Multiplier>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			balance_factor: 1,
+			base_weight: Weight::zero(),
+			byte_fee: 1,
+			weight_to_fee: 1,
+			initial_multiplier: None,
+		}
+	}
+}
+
+impl ExtBuilder {
+	pub fn base_weight(mut self, base_weight: Weight) -> Self {
+		self.base_weight = base_weight;
+		self
+	}
+	pub fn byte_fee(mut self, byte_fee: u64) -> Self {
+		self.byte_fee = byte_fee;
+		self
+	}
+	pub fn weight_fee(mut self, weight_to_fee: u64) -> Self {
+		self.weight_to_fee = weight_to_fee;
+		self
+	}
+	pub fn balance_factor(mut self, factor: u64) -> Self {
+		self.balance_factor = factor;
+		self
+	}
+	pub fn with_initial_multiplier(mut self, multiplier: Multiplier) -> Self {
+		self.initial_multiplier = Some(multiplier);
+		self
+	}
+	fn set_constants(&self) {
+		ExtrinsicBaseWeight::mutate(|v| *v = self.base_weight);
+		TRANSACTION_BYTE_FEE.with(|v| *v.borrow_mut() = self.byte_fee);
+		WEIGHT_TO_FEE.with(|v| *v.borrow_mut() = self.weight_to_fee);
+	}
+	pub fn build(self) -> sp_io::TestExternalities {
+		self.set_constants();
+		let mut t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Runtime> {
+			balances: if self.balance_factor > 0 {
+				vec![
+					(1, 10 * self.balance_factor),
+					(2, 20 * self.balance_factor),
+					(3, 30 * self.balance_factor),
+					(4, 40 * self.balance_factor),
+					(5, 50 * self.balance_factor),
+					(6, 60 * self.balance_factor),
+				]
+			} else {
+				vec![]
+			},
+			..Default::default()
+		}
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+		if let Some(multiplier) = self.initial_multiplier {
+			pallet::GenesisConfig::<Runtime> { multiplier, ..Default::default() }
+				.assimilate_storage(&mut t)
+				.unwrap();
+		}
+
+		t.into()
+	}
+}
+
+/// create a transaction info struct from weight. Handy to avoid building the whole struct.
+pub fn info_from_weight(w: Weight) -> DispatchInfo {
+	// pays_fee: Pays::Yes -- class: DispatchClass::Normal
+	DispatchInfo { call_weight: w, ..Default::default() }
+}
+
+fn post_info_from_weight(w: Weight) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: Some(w), pays_fee: Default::default() }
+}
+
+fn post_info_from_pays(p: Pays) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: None, pays_fee: p }
+}
+
+fn default_post_info() -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: None, pays_fee: Default::default() }
+}
+
+type Ext = ChargeTransactionPayment<Runtime>;
+
+#[test]
+fn transaction_extension_transaction_payment_work() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			let mut info = info_from_weight(Weight::from_parts(5, 0));
+			let ext = Ext::from(0);
+			let ext_weight = ext.weight(CALL);
+			info.extension_weight = ext_weight;
+			ext.test_run(Some(1).into(), CALL, &info, 10, 0, |_| {
+				assert_eq!(Balances::free_balance(1), 100 - 5 - 5 - 10 - 10);
+				Ok(default_post_info())
+			})
+			.unwrap()
+			.unwrap();
+			assert_eq!(Balances::free_balance(1), 100 - 5 - 5 - 10 - 10);
+			assert_eq!(FeeUnbalancedAmount::get(), 5 + 5 + 10 + 10);
+			assert_eq!(TipUnbalancedAmount::get(), 0);
+
+			FeeUnbalancedAmount::mutate(|a| *a = 0);
+
+			let mut info = info_from_weight(Weight::from_parts(100, 0));
+			info.extension_weight = ext_weight;
+			Ext::from(5 /* tipped */)
+				.test_run(Some(2).into(), CALL, &info, 10, 0, |_| {
+					assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 10 - 5);
+					Ok(post_info_from_weight(Weight::from_parts(50, 0)))
+				})
+				.unwrap()
+				.unwrap();
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 50 - 10 - 5);
+			assert_eq!(FeeUnbalancedAmount::get(), 5 + 10 + 50 + 10);
+			assert_eq!(TipUnbalancedAmount::get(), 5);
+		});
+}
+
+#[test]
+fn transaction_extension_transaction_payment_multiplied_refund_works() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			NextFeeMultiplier::<Runtime>::put(Multiplier::saturating_from_rational(3, 2));
+
+			let len = 10;
+			let origin = Some(2).into();
+			let mut info = info_from_weight(Weight::from_parts(100, 0));
+			let ext = Ext::from(5 /* tipped */);
+			let ext_weight = ext.weight(CALL);
+			info.extension_weight = ext_weight;
+			ext.test_run(origin, CALL, &info, len, 0, |_| {
+				// 5 base fee, 10 byte fee, 3/2 * (100 call weight fee + 10 ext weight fee), 5
+				// tip
+				assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 165 - 5);
+				Ok(post_info_from_weight(Weight::from_parts(50, 0)))
+			})
+			.unwrap()
+			.unwrap();
+
+			// 75 (3/2 of the returned 50 units of call weight, 0 returned of ext weight) is
+			// refunded
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - (165 - 75) - 5);
+		});
+}
+
+#[test]
+fn transaction_extension_transaction_payment_is_bounded() {
+	ExtBuilder::default().balance_factor(1000).byte_fee(0).build().execute_with(|| {
+		// maximum weight possible
+		let info = info_from_weight(Weight::MAX);
+		assert_ok!(Ext::from(0).validate_and_prepare(Some(1).into(), CALL, &info, 10, 0));
+		// fee will be proportional to what is the actual maximum weight in the runtime.
+		assert_eq!(
+			Balances::free_balance(&1),
+			(10000 - <Runtime as frame_system::Config>::BlockWeights::get().max_block.ref_time())
+				as u64
+		);
+	});
+}
+
+#[test]
+fn transaction_extension_allows_free_transactions() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// 1 ain't have a penny.
+			assert_eq!(Balances::free_balance(1), 0);
+
+			let len = 100;
+
+			// This is a completely free (and thus wholly insecure/DoS-ridden) transaction.
+			let op_tx = DispatchInfo {
+				call_weight: Weight::from_parts(0, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::No,
+			};
+			assert_ok!(Ext::from(0).validate_only(Some(1).into(), CALL, &op_tx, len, External, 0));
+
+			// like a InsecureFreeNormal
+			let free_tx = DispatchInfo {
+				call_weight: Weight::from_parts(0, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Normal,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(
+				Ext::from(0)
+					.validate_only(Some(1).into(), CALL, &free_tx, len, External, 0)
+					.unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Payment),
+			);
+		});
+}
+
+#[test]
+fn transaction_ext_length_fee_is_also_updated_per_congestion() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(5, 0))
+		.balance_factor(10)
+		.build()
+		.execute_with(|| {
+			// all fees should be x1.5
+			NextFeeMultiplier::<Runtime>::put(Multiplier::saturating_from_rational(3, 2));
+			let len = 10;
+			let info = info_from_weight(Weight::from_parts(3, 0));
+			assert_ok!(Ext::from(10).validate_and_prepare(Some(1).into(), CALL, &info, len, 0));
+			assert_eq!(
+				Balances::free_balance(1),
+				100 // original
+			- 10 // tip
+			- 5 // base
+			- 10 // len
+			- (3 * 3 / 2) // adjusted weight
+			);
+		})
+}
+
+#[test]
+fn query_info_and_fee_details_works() {
+	let call = RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
+	let origin = 111111;
+	let extra = ();
+	let xt = UncheckedExtrinsic::new_signed(call.clone(), origin, (), extra);
+	let info = xt.get_dispatch_info();
+	let ext = xt.encode();
+	let len = ext.len() as u32;
+
+	let unsigned_xt = UncheckedExtrinsic::<u64, _, (), ()>::new_bare(call);
+	let unsigned_xt_info = unsigned_xt.get_dispatch_info();
+
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(5, 0))
+		.weight_fee(2)
+		.build()
+		.execute_with(|| {
+			// all fees should be x1.5
+			NextFeeMultiplier::<Runtime>::put(Multiplier::saturating_from_rational(3, 2));
+
+			assert_eq!(
+				TransactionPayment::query_info(xt.clone(), len),
+				RuntimeDispatchInfo {
+					weight: info.total_weight(),
+					class: info.class,
+					partial_fee: 5 * 2 /* base * weight_fee */
+					+ len as u64  /* len * 1 */
+					+ info.total_weight().min(BlockWeights::get().max_block).ref_time() as u64 * 2 * 3 / 2 /* weight */
+				},
+			);
+
+			assert_eq!(
+				TransactionPayment::query_info(unsigned_xt.clone(), len),
+				RuntimeDispatchInfo {
+					weight: unsigned_xt_info.call_weight,
+					class: unsigned_xt_info.class,
+					partial_fee: 0,
+				},
+			);
+
+			assert_eq!(
+				TransactionPayment::query_fee_details(xt, len),
+				FeeDetails {
+					inclusion_fee: Some(InclusionFee {
+						base_fee: 5 * 2,
+						len_fee: len as u64,
+						adjusted_weight_fee: info
+							.total_weight()
+							.min(BlockWeights::get().max_block)
+							.ref_time() as u64 * 2 * 3 / 2
+					}),
+					tip: 0,
+				},
+			);
+
+			assert_eq!(
+				TransactionPayment::query_fee_details(unsigned_xt, len),
+				FeeDetails { inclusion_fee: None, tip: 0 },
+			);
+		});
+}
+
+#[test]
+fn query_call_info_and_fee_details_works() {
+	let call = RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
+	let info = call.get_dispatch_info();
+	let encoded_call = call.encode();
+	let len = encoded_call.len() as u32;
+
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(5, 0))
+		.weight_fee(2)
+		.build()
+		.execute_with(|| {
+			// all fees should be x1.5
+			NextFeeMultiplier::<Runtime>::put(Multiplier::saturating_from_rational(3, 2));
+
+			assert_eq!(
+				TransactionPayment::query_call_info(call.clone(), len),
+				RuntimeDispatchInfo {
+					weight: info.total_weight(),
+					class: info.class,
+					partial_fee: 5 * 2 /* base * weight_fee */
+					+ len as u64  /* len * 1 */
+					+ info.total_weight().min(BlockWeights::get().max_block).ref_time() as u64 * 2 * 3 / 2 /* weight */
+				},
+			);
+
+			assert_eq!(
+				TransactionPayment::query_call_fee_details(call, len),
+				FeeDetails {
+					inclusion_fee: Some(InclusionFee {
+						base_fee: 5 * 2,     /* base * weight_fee */
+						len_fee: len as u64, /* len * 1 */
+						adjusted_weight_fee: info
+							.total_weight()
+							.min(BlockWeights::get().max_block)
+							.ref_time() as u64 * 2 * 3 / 2  /* weight * weight_fee * multipler */
+					}),
+					tip: 0,
+				},
+			);
+		});
+}
+
+#[test]
+fn compute_fee_works_without_multiplier() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.byte_fee(10)
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// Next fee multiplier is zero
+			assert_eq!(NextFeeMultiplier::<Runtime>::get(), Multiplier::one());
+
+			// Tip only, no fees works
+			let dispatch_info = DispatchInfo {
+				call_weight: Weight::from_parts(0, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::No,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 10), 10);
+			// No tip, only base fee works
+			let dispatch_info = DispatchInfo {
+				call_weight: Weight::from_parts(0, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 0), 100);
+			// Tip + base fee works
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 69), 169);
+			// Len (byte fee) + base fee works
+			assert_eq!(Pallet::<Runtime>::compute_fee(42, &dispatch_info, 0), 520);
+			// Weight fee + base fee works
+			let dispatch_info = DispatchInfo {
+				call_weight: Weight::from_parts(1000, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 0), 1100);
+		});
+}
+
+#[test]
+fn compute_fee_works_with_multiplier() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.byte_fee(10)
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// Add a next fee multiplier. Fees will be x3/2.
+			NextFeeMultiplier::<Runtime>::put(Multiplier::saturating_from_rational(3, 2));
+			// Base fee is unaffected by multiplier
+			let dispatch_info = DispatchInfo {
+				call_weight: Weight::from_parts(0, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 0), 100);
+
+			// Everything works together :)
+			let dispatch_info = DispatchInfo {
+				call_weight: Weight::from_parts(123, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			// 123 weight, 456 length, 100 base
+			assert_eq!(
+				Pallet::<Runtime>::compute_fee(456, &dispatch_info, 789),
+				100 + (3 * 123 / 2) + 4560 + 789,
+			);
+		});
+}
+
+#[test]
+fn compute_fee_works_with_negative_multiplier() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.byte_fee(10)
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// Add a next fee multiplier. All fees will be x1/2.
+			NextFeeMultiplier::<Runtime>::put(Multiplier::saturating_from_rational(1, 2));
+
+			// Base fee is unaffected by multiplier.
+			let dispatch_info = DispatchInfo {
+				call_weight: Weight::from_parts(0, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 0), 100);
+
+			// Everything works together.
+			let dispatch_info = DispatchInfo {
+				call_weight: Weight::from_parts(123, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			// 123 weight, 456 length, 100 base
+			assert_eq!(
+				Pallet::<Runtime>::compute_fee(456, &dispatch_info, 789),
+				100 + (123 / 2) + 4560 + 789,
+			);
+		});
+}
+
+#[test]
+fn compute_fee_does_not_overflow() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.byte_fee(10)
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// Overflow is handled
+			let dispatch_info = DispatchInfo {
+				call_weight: Weight::MAX,
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(
+				Pallet::<Runtime>::compute_fee(u32::MAX, &dispatch_info, u64::MAX),
+				u64::MAX
+			);
+		});
+}
+
+#[test]
+fn refund_does_not_recreate_account() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			// So events are emitted
+			System::set_block_number(10);
+			let info = info_from_weight(Weight::from_parts(100, 0));
+			Ext::from(5 /* tipped */)
+				.test_run(Some(2).into(), CALL, &info, 10, 0, |origin| {
+					assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
+
+					// kill the account between pre and post dispatch
+					assert_ok!(Balances::transfer_allow_death(
+						origin,
+						3,
+						Balances::free_balance(2)
+					));
+					assert_eq!(Balances::free_balance(2), 0);
+
+					Ok(post_info_from_weight(Weight::from_parts(50, 0)))
+				})
+				.unwrap()
+				.unwrap();
+			assert_eq!(Balances::free_balance(2), 0);
+			// Transfer Event
+			System::assert_has_event(RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+				from: 2,
+				to: 3,
+				amount: 80,
+			}));
+			// Killed Event
+			System::assert_has_event(RuntimeEvent::System(system::Event::KilledAccount {
+				account: 2,
+			}));
+		});
+}
+
+#[test]
+fn actual_weight_higher_than_max_refunds_nothing() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			let info = info_from_weight(Weight::from_parts(100, 0));
+			Ext::from(5 /* tipped */)
+				.test_run(Some(2).into(), CALL, &info, 10, 0, |_| {
+					assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
+					Ok(post_info_from_weight(Weight::from_parts(101, 0)))
+				})
+				.unwrap()
+				.unwrap();
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
+		});
+}
+
+#[test]
+fn zero_transfer_on_free_transaction() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			// So events are emitted
+			System::set_block_number(10);
+			let info = DispatchInfo {
+				call_weight: Weight::from_parts(100, 0),
+				extension_weight: Weight::zero(),
+				pays_fee: Pays::No,
+				class: DispatchClass::Normal,
+			};
+			let user = 69;
+			Ext::from(0)
+				.test_run(Some(user).into(), CALL, &info, 10, 0, |_| {
+					assert_eq!(Balances::total_balance(&user), 0);
+					Ok(default_post_info())
+				})
+				.unwrap()
+				.unwrap();
+			assert_eq!(Balances::total_balance(&user), 0);
+			// TransactionFeePaid Event
+			System::assert_has_event(RuntimeEvent::TransactionPayment(
+				pallet_transaction_payment::Event::TransactionFeePaid {
+					who: user,
+					actual_fee: 0,
+					tip: 0,
+				},
+			));
+		});
+}
+
+#[test]
+fn refund_consistent_with_actual_weight() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(7, 0))
+		.build()
+		.execute_with(|| {
+			let mut info = info_from_weight(Weight::from_parts(100, 0));
+			let tip = 5;
+			let ext = Ext::from(tip);
+			let ext_weight = ext.weight(CALL);
+			info.extension_weight = ext_weight;
+			let mut post_info = post_info_from_weight(Weight::from_parts(33, 0));
+			let prev_balance = Balances::free_balance(2);
+			let len = 10;
+
+			NextFeeMultiplier::<Runtime>::put(Multiplier::saturating_from_rational(5, 4));
+
+			let actual_post_info = ext
+				.test_run(Some(2).into(), CALL, &info, len, 0, |_| Ok(post_info))
+				.unwrap()
+				.unwrap();
+			post_info
+				.actual_weight
+				.as_mut()
+				.map(|w| w.saturating_accrue(Ext::from(tip).weight(CALL)));
+			assert_eq!(post_info, actual_post_info);
+
+			let refund_based_fee = prev_balance - Balances::free_balance(2);
+			let actual_fee =
+				Pallet::<Runtime>::compute_actual_fee(len as u32, &info, &actual_post_info, tip);
+
+			// 33 call weight, 10 ext weight, 10 length, 7 base, 5 tip
+			assert_eq!(actual_fee, 7 + 10 + ((33 + 10) * 5 / 4) + 5);
+			assert_eq!(refund_based_fee, actual_fee);
+		});
+}
+
+#[test]
+fn should_alter_operational_priority() {
+	let tip = 5;
+	let len = 10;
+
+	ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+		let normal = DispatchInfo {
+			call_weight: Weight::from_parts(100, 0),
+			extension_weight: Weight::zero(),
+			class: DispatchClass::Normal,
+			pays_fee: Pays::Yes,
+		};
+
+		let ext = Ext::from(tip);
+		let priority = ext
+			.validate_only(Some(2).into(), CALL, &normal, len, External, 0)
+			.unwrap()
+			.0
+			.priority;
+		assert_eq!(priority, 60);
+
+		let ext = Ext::from(2 * tip);
+		let priority = ext
+			.validate_only(Some(2).into(), CALL, &normal, len, External, 0)
+			.unwrap()
+			.0
+			.priority;
+		assert_eq!(priority, 110);
+	});
+
+	ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+		let op = DispatchInfo {
+			call_weight: Weight::from_parts(100, 0),
+			extension_weight: Weight::zero(),
+			class: DispatchClass::Operational,
+			pays_fee: Pays::Yes,
+		};
+
+		let ext = Ext::from(tip);
+		let priority = ext
+			.validate_only(Some(2).into(), CALL, &op, len, External, 0)
+			.unwrap()
+			.0
+			.priority;
+		assert_eq!(priority, 5810);
+
+		let ext = Ext::from(2 * tip);
+		let priority = ext
+			.validate_only(Some(2).into(), CALL, &op, len, External, 0)
+			.unwrap()
+			.0
+			.priority;
+		assert_eq!(priority, 6110);
+	});
+}
+
+#[test]
+fn no_tip_has_some_priority() {
+	let tip = 0;
+	let len = 10;
+
+	ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+		let normal = DispatchInfo {
+			call_weight: Weight::from_parts(100, 0),
+			extension_weight: Weight::zero(),
+			class: DispatchClass::Normal,
+			pays_fee: Pays::Yes,
+		};
+		let ext = Ext::from(tip);
+		let priority = ext
+			.validate_only(Some(2).into(), CALL, &normal, len, External, 0)
+			.unwrap()
+			.0
+			.priority;
+		assert_eq!(priority, 10);
+	});
+
+	ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+		let op = DispatchInfo {
+			call_weight: Weight::from_parts(100, 0),
+			extension_weight: Weight::zero(),
+			class: DispatchClass::Operational,
+			pays_fee: Pays::Yes,
+		};
+		let ext = Ext::from(tip);
+		let priority = ext
+			.validate_only(Some(2).into(), CALL, &op, len, External, 0)
+			.unwrap()
+			.0
+			.priority;
+		assert_eq!(priority, 5510);
+	});
+}
+
+#[test]
+fn higher_tip_have_higher_priority() {
+	let get_priorities = |tip: u64| {
+		let mut pri1 = 0;
+		let mut pri2 = 0;
+		let len = 10;
+		ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+			let normal = DispatchInfo {
+				call_weight: Weight::from_parts(100, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Normal,
+				pays_fee: Pays::Yes,
+			};
+			let ext = Ext::from(tip);
+
+			pri1 = ext
+				.validate_only(Some(2).into(), CALL, &normal, len, External, 0)
+				.unwrap()
+				.0
+				.priority;
+		});
+
+		ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+			let op = DispatchInfo {
+				call_weight: Weight::from_parts(100, 0),
+				extension_weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			let ext = Ext::from(tip);
+			pri2 = ext
+				.validate_only(Some(2).into(), CALL, &op, len, External, 0)
+				.unwrap()
+				.0
+				.priority;
+		});
+
+		(pri1, pri2)
+	};
+
+	let mut prev_priorities = get_priorities(0);
+
+	for tip in 1..3 {
+		let priorities = get_priorities(tip);
+		assert!(prev_priorities.0 < priorities.0);
+		assert!(prev_priorities.1 < priorities.1);
+		prev_priorities = priorities;
+	}
+}
+
+#[test]
+fn post_info_can_change_pays_fee() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(7, 0))
+		.build()
+		.execute_with(|| {
+			let info = info_from_weight(Weight::from_parts(100, 0));
+			let post_info = post_info_from_pays(Pays::No);
+			let prev_balance = Balances::free_balance(2);
+			let len = 10;
+			let tip = 5;
+
+			NextFeeMultiplier::<Runtime>::put(Multiplier::saturating_from_rational(5, 4));
+
+			let post_info = ChargeTransactionPayment::<Runtime>::from(tip)
+				.test_run(Some(2).into(), CALL, &info, len, 0, |_| Ok(post_info))
+				.unwrap()
+				.unwrap();
+
+			let refund_based_fee = prev_balance - Balances::free_balance(2);
+			let actual_fee =
+				Pallet::<Runtime>::compute_actual_fee(len as u32, &info, &post_info, tip);
+
+			// Only 5 tip is paid
+			assert_eq!(actual_fee, 5);
+			assert_eq!(refund_based_fee, actual_fee);
+		});
+}
+
+#[test]
+fn genesis_config_works() {
+	ExtBuilder::default()
+		.with_initial_multiplier(Multiplier::from_u32(100))
+		.build()
+		.execute_with(|| {
+			assert_eq!(
+				NextFeeMultiplier::<Runtime>::get(),
+				Multiplier::saturating_from_integer(100)
+			);
+		});
+}
+
+#[test]
+fn genesis_default_works() {
+	ExtBuilder::default().build().execute_with(|| {
+		assert_eq!(NextFeeMultiplier::<Runtime>::get(), Multiplier::saturating_from_integer(1));
+	});
+}
+
+#[test]
+fn no_fee_and_no_weight_for_other_origins() {
+	ExtBuilder::default().build().execute_with(|| {
+		let ext = Ext::from(0);
+
+		let mut info = CALL.get_dispatch_info();
+		info.extension_weight = ext.weight(CALL);
+
+		// Ensure we test the refund.
+		assert!(info.extension_weight != Weight::zero());
+
+		let len = CALL.encoded_size();
+
+		let origin = frame_system::RawOrigin::Root.into();
+		let (pre, origin) = ext.validate_and_prepare(origin, CALL, &info, len, 0).unwrap();
+
+		assert!(origin.as_system_ref().unwrap().is_root());
+
+		let pd_res = Ok(());
+		let mut post_info = frame_support::dispatch::PostDispatchInfo {
+			actual_weight: Some(info.total_weight()),
+			pays_fee: Default::default(),
+		};
+
+		<Ext as TransactionExtension<RuntimeCall>>::post_dispatch(
+			pre,
+			&info,
+			&mut post_info,
+			len,
+			&pd_res,
+		)
+		.unwrap();
+
+		assert_eq!(post_info.actual_weight, Some(info.call_weight));
+	})
+}
+
+#[test]
+fn fungible_adapter_no_zero_refund_action() {
+	type FungibleAdapterT = payment::FungibleAdapter<Balances, DealWithFees>;
+
+	ExtBuilder::default().balance_factor(10).build().execute_with(|| {
+		System::set_block_number(10);
+
+		let dummy_acc = 1;
+		let (actual_fee, no_tip) = (10, 0);
+		let already_paid = <FungibleAdapterT as OnChargeTransaction<Runtime>>::withdraw_fee(
+			&dummy_acc,
+			CALL,
+			&CALL.get_dispatch_info(),
+			actual_fee,
+			no_tip,
+		).expect("Account must have enough funds.");
+
+		// Correction action with no expected side effect.
+		assert!(<FungibleAdapterT as OnChargeTransaction<Runtime>>::correct_and_deposit_fee(
+			&dummy_acc,
+			&CALL.get_dispatch_info(),
+			&default_post_info(),
+			actual_fee,
+			no_tip,
+			already_paid,
+		).is_ok());
+
+		// Ensure no zero amount deposit event is emitted.
+		let events = System::events();
+		assert!(!events
+			.iter()
+			.any(|record| matches!(record.event, RuntimeEvent::Balances(pallet_balances::Event::Deposit { amount, .. }) if amount.is_zero())),
+    		"No zero amount deposit amount event should be emitted.",
+		);
+	});
+}