fn min() -> Multiplier {

		Default::default()

	}

	fn max() -> Multiplier {

		<Multiplier as sp_runtime::traits::Bounded>::max_value()

	}

	fn target() -> Perquintill {

		Default::default()

	}

	fn variability() -> Multiplier {

		Default::default()

	}

	fn max() -> Multiplier {

		X::get()

	}

	fn variability() -> Multiplier {

		V::get()

	}

				(normal_block_weight.proof_size(), normal_max_weight.proof_size())

	fn min() -> Multiplier {

		M::get()

	}

	fn max() -> Multiplier {

		M::get()

	}

	fn target() -> Perquintill {

		Default::default()

	}

	fn variability() -> Multiplier {

		Default::default()

	}

	fn convert(_previous: Multiplier) -> Multiplier {

		Self::min()

	}

#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]

	/// Original version of the pallet.

	V1Ancient,

	/// One that bumps the usage to FixedU128 from FixedI128.

	V2,

	fn default() -> Self {

		Releases::V1Ancient

	}

#[frame_support::pallet]

pub mod pallet {

	use frame_support::pallet_prelude::*;

	use frame_system::pallet_prelude::*;

	use super::*;

	pub struct Pallet<T>(_);

	pub mod config_preludes {

		use super::*;

		use frame_support::derive_impl;

		/// Default prelude sensible to be used in a testing environment.

		pub struct TestDefaultConfig;

		#[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)]

		impl frame_system::DefaultConfig for TestDefaultConfig {}

		#[frame_support::register_default_impl(TestDefaultConfig)]

		impl DefaultConfig for TestDefaultConfig {

			#[inject_runtime_type]

			type RuntimeEvent = ();

			type FeeMultiplierUpdate = ();

			type OperationalFeeMultiplier = ();

		}

	}

	#[pallet::config(with_default)]

	pub trait Config: frame_system::Config {

		/// The overarching event type.

		#[pallet::no_default_bounds]

		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// Handler for withdrawing, refunding and depositing the transaction fee.

		/// Transaction fees are withdrawn before the transaction is executed.

		/// After the transaction was executed the transaction weight can be

		/// adjusted, depending on the used resources by the transaction. If the

		/// transaction weight is lower than expected, parts of the transaction fee

		/// might be refunded. In the end the fees can be deposited.

		#[pallet::no_default]

		type OnChargeTransaction: OnChargeTransaction<Self>;

		/// Convert a weight value into a deductible fee based on the currency type.

		#[pallet::no_default]

		type WeightToFee: WeightToFee<Balance = BalanceOf<Self>>;

		/// Convert a length value into a deductible fee based on the currency type.

		#[pallet::no_default]

		type LengthToFee: WeightToFee<Balance = BalanceOf<Self>>;

		/// Update the multiplier of the next block, based on the previous block's weight.

		type FeeMultiplierUpdate: MultiplierUpdate;

		/// A fee multiplier for `Operational` extrinsics to compute "virtual tip" to boost their

		/// `priority`

		///

		/// This value is multiplied by the `final_fee` to obtain a "virtual tip" that is later

		/// added to a tip component in regular `priority` calculations.

		/// It means that a `Normal` transaction can front-run a similarly-sized `Operational`

		/// extrinsic (with no tip), by including a tip value greater than the virtual tip.

		///

		/// ```rust,ignore

		/// // For `Normal`

		/// let priority = priority_calc(tip);

		///

		/// // For `Operational`

		/// let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier;

		/// let priority = priority_calc(tip + virtual_tip);

		/// ```

		///

		/// Note that since we use `final_fee` the multiplier applies also to the regular `tip`

		/// sent with the transaction. So, not only does the transaction get a priority bump based

		/// on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational`

		/// transactions.

		#[pallet::constant]

		type OperationalFeeMultiplier: Get<u8>;

	}

	#[pallet::type_value]

	pub fn NextFeeMultiplierOnEmpty() -> Multiplier {

		MULTIPLIER_DEFAULT_VALUE

	}

	#[pallet::getter(fn next_fee_multiplier)]

	pub type NextFeeMultiplier<T: Config> =

		StorageValue<_, Multiplier, ValueQuery, NextFeeMultiplierOnEmpty>;

	pub(super) type StorageVersion<T: Config> = StorageValue<_, Releases, ValueQuery>;

	#[pallet::genesis_config]

	pub struct GenesisConfig<T: Config> {

		pub multiplier: Multiplier,

		#[serde(skip)]

		pub _config: core::marker::PhantomData<T>,

	}

	impl<T: Config> Default for GenesisConfig<T> {

	}

	#[pallet::genesis_build]

	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

	}

	#[pallet::event]

	#[pallet::generate_deposit(pub(super) fn deposit_event)]

	pub enum Event<T: Config> {

		/// A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,

		/// has been paid by `who`.

		TransactionFeePaid { who: T::AccountId, actual_fee: BalanceOf<T>, tip: BalanceOf<T> },

	}

	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

		#[cfg(feature = "std")]

				// this is most likely because in a test setup we set everything to ()

				// or to `ConstFeeMultiplier`.

				return

				"The minimum bound of the multiplier is too low. When \

				block saturation is more than target by 1% and multiplier is minimal then \

				the multiplier doesn't increase."

			);

	}

}

	pub fn query_info<Extrinsic: sp_runtime::traits::Extrinsic + GetDispatchInfo>(

		unchecked_extrinsic: Extrinsic,

		len: u32,

	) -> RuntimeDispatchInfo<BalanceOf<T>>

	where

		T::RuntimeCall: Dispatchable<Info = DispatchInfo>,

	{

		// NOTE: we can actually make it understand `ChargeTransactionPayment`, but would be some

		// hassle for sure. We have to make it aware of the index of `ChargeTransactionPayment` in

		// `Extra`. Alternatively, we could actually execute the tx's per-dispatch and record the

		// balance of the sender before and after the pipeline.. but this is way too much hassle for

		// a very very little potential gain in the future.

		let dispatch_info = <Extrinsic as GetDispatchInfo>::get_dispatch_info(&unchecked_extrinsic);

		let partial_fee = if unchecked_extrinsic.is_signed().unwrap_or(false) {

			Self::compute_fee(len, &dispatch_info, 0u32.into())

			0u32.into()

		let DispatchInfo { weight, class, .. } = dispatch_info;

		RuntimeDispatchInfo { weight, class, partial_fee }

	}

	pub fn query_fee_details<Extrinsic: sp_runtime::traits::Extrinsic + GetDispatchInfo>(

		unchecked_extrinsic: Extrinsic,

		len: u32,

	) -> FeeDetails<BalanceOf<T>>

	where

		T::RuntimeCall: Dispatchable<Info = DispatchInfo>,

	{

		let dispatch_info = <Extrinsic as GetDispatchInfo>::get_dispatch_info(&unchecked_extrinsic);

		let tip = 0u32.into();

		if unchecked_extrinsic.is_signed().unwrap_or(false) {

			Self::compute_fee_details(len, &dispatch_info, tip)

			FeeDetails { inclusion_fee: None, tip }

	}

	pub fn query_call_info(call: T::RuntimeCall, len: u32) -> RuntimeDispatchInfo<BalanceOf<T>>

	where

		T::RuntimeCall: Dispatchable<Info = DispatchInfo> + GetDispatchInfo,

	{

		let dispatch_info = <T::RuntimeCall as GetDispatchInfo>::get_dispatch_info(&call);

		let DispatchInfo { weight, class, .. } = dispatch_info;

		RuntimeDispatchInfo {

			weight,

			class,

			partial_fee: Self::compute_fee(len, &dispatch_info, 0u32.into()),

		}

	}

	pub fn query_call_fee_details(call: T::RuntimeCall, len: u32) -> FeeDetails<BalanceOf<T>>

	where

		T::RuntimeCall: Dispatchable<Info = DispatchInfo> + GetDispatchInfo,

	{

		let dispatch_info = <T::RuntimeCall as GetDispatchInfo>::get_dispatch_info(&call);

		let tip = 0u32.into();

		Self::compute_fee_details(len, &dispatch_info, tip)

	}

	pub fn compute_fee(

		len: u32,

		info: &DispatchInfoOf<T::RuntimeCall>,

		tip: BalanceOf<T>,

	) -> BalanceOf<T>

	where

		T::RuntimeCall: Dispatchable<Info = DispatchInfo>,

	{

		Self::compute_fee_details(len, info, tip).final_fee()

	}

	pub fn compute_fee_details(

		len: u32,

		info: &DispatchInfoOf<T::RuntimeCall>,

		tip: BalanceOf<T>,

	) -> FeeDetails<BalanceOf<T>>

	where

		T::RuntimeCall: Dispatchable<Info = DispatchInfo>,

	{

		Self::compute_fee_raw(len, info.weight, tip, info.pays_fee, info.class)

	}

	pub fn compute_actual_fee(

		len: u32,

		info: &DispatchInfoOf<T::RuntimeCall>,

		post_info: &PostDispatchInfoOf<T::RuntimeCall>,

		tip: BalanceOf<T>,

	) -> BalanceOf<T>

	where

		T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

	{

		Self::compute_actual_fee_details(len, info, post_info, tip).final_fee()

	}

	pub fn compute_actual_fee_details(

		len: u32,

		info: &DispatchInfoOf<T::RuntimeCall>,

		post_info: &PostDispatchInfoOf<T::RuntimeCall>,

		tip: BalanceOf<T>,

	) -> FeeDetails<BalanceOf<T>>

	where

		T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

	{

		Self::compute_fee_raw(

			len,

			post_info.calc_actual_weight(info),

			tip,

			post_info.pays_fee(info),

			info.class,

		)

	}

	fn compute_fee_raw(

		len: u32,

		weight: Weight,

		tip: BalanceOf<T>,

		pays_fee: Pays,

		class: DispatchClass,

	) -> FeeDetails<BalanceOf<T>> {

		if pays_fee == Pays::Yes {

			let unadjusted_weight_fee = Self::weight_to_fee(weight);

			let multiplier = Self::next_fee_multiplier();

			// final adjusted weight fee.

			let adjusted_weight_fee = multiplier.saturating_mul_int(unadjusted_weight_fee);

			// length fee. this is adjusted via `LengthToFee`.

			let len_fee = Self::length_to_fee(len);

			let base_fee = Self::weight_to_fee(T::BlockWeights::get().get(class).base_extrinsic);

			FeeDetails {

				inclusion_fee: Some(InclusionFee { base_fee, len_fee, adjusted_weight_fee }),

				tip,

			}

			FeeDetails { inclusion_fee: None, tip }

	}

	pub fn length_to_fee(length: u32) -> BalanceOf<T> {

		T::LengthToFee::weight_to_fee(&Weight::from_parts(length as u64, 0))

	}

	pub fn weight_to_fee(weight: Weight) -> BalanceOf<T> {

		// cap the weight to the maximum defined in runtime, otherwise it will be the

		// `Bounded` maximum of its data type, which is not desired.

		let capped_weight = weight.min(T::BlockWeights::get().max_block);

		T::WeightToFee::weight_to_fee(&capped_weight)

	}

	fn convert(weight: Weight) -> BalanceOf<T> {

		<NextFeeMultiplier<T>>::get().saturating_mul_int(Self::weight_to_fee(weight))

	}

#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]

	pub fn from(fee: BalanceOf<T>) -> Self {

		Self(fee)

	}

	pub fn tip(&self) -> BalanceOf<T> {

		self.0

	}

	fn withdraw_fee(

		&self,

		who: &T::AccountId,

		call: &T::RuntimeCall,

		info: &DispatchInfoOf<T::RuntimeCall>,

		len: usize,

	) -> Result<

		(

			BalanceOf<T>,

			<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::LiquidityInfo,

		),

		TransactionValidityError,

	> {

		let tip = self.0;

		let fee = Pallet::<T>::compute_fee(len as u32, info, tip);

		<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::withdraw_fee(

			who, call, info, fee, tip,

		)

		.map(|i| (fee, i))

	}

	pub fn get_priority(

		info: &DispatchInfoOf<T::RuntimeCall>,

		len: usize,

		tip: BalanceOf<T>,

		final_fee: BalanceOf<T>,

	) -> TransactionPriority {

		// Calculate how many such extrinsics we could fit into an empty block and take the

		// limiting factor.

		let max_block_weight = T::BlockWeights::get().max_block;

		let max_block_length = *T::BlockLength::get().max.get(info.class) as u64;

		// bounded_weight is used as a divisor later so we keep it non-zero.

		let bounded_weight = info.weight.max(Weight::from_parts(1, 1)).min(max_block_weight);

		let bounded_length = (len as u64).clamp(1, max_block_length);

		// returns the scarce resource, i.e. the one that is limiting the number of transactions.

		let max_tx_per_block_weight = max_block_weight

			.checked_div_per_component(&bounded_weight)

			.defensive_proof("bounded_weight is non-zero; qed")

			.unwrap_or(1);

		let max_tx_per_block_length = max_block_length / bounded_length;

		// Given our current knowledge this value is going to be in a reasonable range - i.e.

		// less than 10^9 (2^30), so multiplying by the `tip` value is unlikely to overflow the

		// balance type. We still use saturating ops obviously, but the point is to end up with some

		// `priority` distribution instead of having all transactions saturate the priority.

		let max_tx_per_block = max_tx_per_block_length

			.min(max_tx_per_block_weight)

			.saturated_into::<BalanceOf<T>>();

		let max_reward = |val: BalanceOf<T>| val.saturating_mul(max_tx_per_block);

		let tip = tip.saturating_add(One::one());

		let scaled_tip = max_reward(tip);

		match info.class {

				scaled_tip

				scaled_tip

				let fee_multiplier = T::OperationalFeeMultiplier::get().saturated_into();

				let virtual_tip = final_fee.saturating_mul(fee_multiplier);

				let scaled_virtual_tip = max_reward(virtual_tip);

				scaled_tip.saturating_add(scaled_virtual_tip)

		.saturated_into::<TransactionPriority>()

	}

	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

		write!(f, "ChargeTransactionPayment<{:?}>", self.0)

	}

	fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {

		Ok(())

	}

	fn validate(

		&self,

		who: &Self::AccountId,

		call: &Self::Call,

		info: &DispatchInfoOf<Self::Call>,

		len: usize,

	) -> TransactionValidity {

		let (final_fee, _) = self.withdraw_fee(who, call, info, len)?;

		let tip = self.0;

		Ok(ValidTransaction {

			priority: Self::get_priority(info, len, tip, final_fee),

			..Default::default()

		})

	}

	fn pre_dispatch(

		self,

		who: &Self::AccountId,

		call: &Self::Call,

		info: &DispatchInfoOf<Self::Call>,

		len: usize,

	) -> Result<Self::Pre, TransactionValidityError> {

		let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;

		Ok((self.0, who.clone(), imbalance))

	}

			let actual_fee = Pallet::<T>::compute_actual_fee(len as u32, info, post_info, tip);

			T::OnChargeTransaction::correct_and_deposit_fee(

				&who, info, post_info, actual_fee, tip, imbalance,

			)?;

			Pallet::<T>::deposit_event(Event::<T>::TransactionFeePaid { who, actual_fee, tip });

	fn estimate_call_fee(call: &AnyCall, post_info: PostDispatchInfo) -> BalanceOf<T> {

		let len = call.encoded_size() as u32;

		let info = call.get_dispatch_info();

		Self::compute_actual_fee(len, &info, &post_info, Zero::zero())

	}