pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-13 18:41:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "FRAME: Create TransactionExtension as a replacement for SignedExtension (#2280)" (#3665)

Browse Source 
This PR reverts #2280 which introduced `TransactionExtension` to replace
`SignedExtension`.

As a result of the discussion
[here](https://github.com/paritytech/polkadot-sdk/pull/3623#issuecomment-1986789700),
the changes will be reverted for now with plans to reintroduce the
concept in the future.

---------

Signed-off-by: georgepisaltu <george.pisaltu@parity.io>
This commit is contained in:
georgepisaltu
2024-03-13 16:10:59 +02:00
committed by GitHub
parent 60ac5a723c
commit bbd51ce867
350 changed files with 15826 additions and 24304 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/transaction-payment/src/benchmarking.rs
-81
View File
@@ -1,81 +0,0 @@
// 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.
//! Benchmarks for Transaction Payment Pallet's transaction extension
use super::*;
use crate::Pallet;
use frame_benchmarking::v2::*;
use frame_support::dispatch::{DispatchInfo, PostDispatchInfo};
use frame_system::{EventRecord, RawOrigin};
use sp_runtime::traits::{DispatchTransaction, Dispatchable};
fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
let events = frame_system::Pallet::<T>::events();
let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
// compare to the last event record
let EventRecord { event, .. } = &events[events.len() - 1];
assert_eq!(event, &system_event);
}
#[benchmarks(where
T: Config,
T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
BalanceOf<T>: Send + Sync + From<u64>,
)]
mod benchmarks {
use super::*;
#[benchmark]
fn charge_transaction_payment() {
let caller: T::AccountId = whitelisted_caller();
<T::OnChargeTransaction as OnChargeTransaction<T>>::endow_account(
&caller,
<T::OnChargeTransaction as OnChargeTransaction<T>>::minimum_balance() * 1000.into(),
);
let tip = <T::OnChargeTransaction as OnChargeTransaction<T>>::minimum_balance();
let ext: ChargeTransactionPayment<T> = ChargeTransactionPayment::from(tip);
let inner = frame_system::Call::remark { remark: vec![] };
let call = T::RuntimeCall::from(inner);
let info = DispatchInfo {
weight: Weight::from_parts(100, 0),
class: DispatchClass::Operational,
pays_fee: Pays::Yes,
};
let post_info = PostDispatchInfo {
actual_weight: Some(Weight::from_parts(10, 0)),
pays_fee: Pays::Yes,
};
#[block]
{
assert!(ext
.test_run(RawOrigin::Signed(caller.clone()).into(), &call, &info, 10, |_| Ok(
post_info
))
.unwrap()
.is_ok());
}
let actual_fee = Pallet::<T>::compute_actual_fee(10, &info, &post_info, tip);
assert_last_event::<T>(
Event::<T>::TransactionFeePaid { who: caller, actual_fee, tip }.into(),
);
}
impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Runtime);
}
substrate/frame/transaction-payment/src/lib.rs
+48 -98
View File
@@ -62,28 +62,23 @@ pub use payment::*;
use sp_runtime::{
traits::{
Convert, DispatchInfoOf, Dispatchable, One, PostDispatchInfoOf, SaturatedConversion,
Saturating, TransactionExtension, TransactionExtensionBase, Zero,
Saturating, SignedExtension, Zero,
},
transaction_validity::{
InvalidTransaction, TransactionPriority, TransactionValidityError, ValidTransaction,
TransactionPriority, TransactionValidity, TransactionValidityError, ValidTransaction,
},
FixedPointNumber, FixedU128, Perbill, Perquintill, RuntimeDebug,
};
use sp_std::prelude::*;
pub use types::{FeeDetails, InclusionFee, RuntimeDispatchInfo};
pub use weights::WeightInfo;
#[cfg(test)]
mod mock;
#[cfg(test)]
mod tests;
#[cfg(feature = "runtime-benchmarks")]
mod benchmarking;
mod payment;
mod types;
pub mod weights;
/// Fee multiplier.
pub type Multiplier = FixedU128;
@@ -340,7 +335,6 @@ pub mod pallet {
type RuntimeEvent = ();
type FeeMultiplierUpdate = ();
type OperationalFeeMultiplier = ();
type WeightInfo = ();
}
}
@@ -393,9 +387,6 @@ pub mod pallet {
/// transactions.
#[pallet::constant]
type OperationalFeeMultiplier: Get<u8>;
/// The weight information of this pallet.
type WeightInfo: WeightInfo;
}
#[pallet::type_value]
@@ -516,11 +507,11 @@ impl<T: Config> Pallet<T> {
// 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_bare() {
// Bare extrinsics have no partial fee.
0u32.into()
} else {
let partial_fee = if unchecked_extrinsic.is_signed().unwrap_or(false) {
Self::compute_fee(len, &dispatch_info, 0u32.into())
} else {
// Unsigned extrinsics have no partial fee.
0u32.into()
};
let DispatchInfo { weight, class, .. } = dispatch_info;
@@ -540,11 +531,11 @@ impl<T: Config> Pallet<T> {
let tip = 0u32.into();
if unchecked_extrinsic.is_bare() {
// Bare extrinsics have no inclusion fee.
FeeDetails { inclusion_fee: None, tip }
} else {
if unchecked_extrinsic.is_signed().unwrap_or(false) {
Self::compute_fee_details(len, &dispatch_info, tip)
} else {
// Unsigned extrinsics have no inclusion fee.
FeeDetails { inclusion_fee: None, tip }
}
}
@@ -723,7 +714,7 @@ where
who: &T::AccountId,
call: &T::RuntimeCall,
info: &DispatchInfoOf<T::RuntimeCall>,
fee: BalanceOf<T>,
len: usize,
) -> Result<
(
BalanceOf<T>,
@@ -732,6 +723,7 @@ where
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,
@@ -739,22 +731,6 @@ where
.map(|i| (fee, i))
}
fn can_withdraw_fee(
&self,
who: &T::AccountId,
call: &T::RuntimeCall,
info: &DispatchInfoOf<T::RuntimeCall>,
len: usize,
) -> Result<BalanceOf<T>, TransactionValidityError> {
let tip = self.0;
let fee = Pallet::<T>::compute_fee(len as u32, info, tip);
<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::can_withdraw_fee(
who, call, info, fee, tip,
)?;
Ok(fee)
}
/// Get an appropriate priority for a transaction with the given `DispatchInfo`, encoded length
/// and user-included tip.
///
@@ -841,93 +817,67 @@ impl<T: Config> sp_std::fmt::Debug for ChargeTransactionPayment<T> {
}
}
impl<T: Config> TransactionExtensionBase for ChargeTransactionPayment<T> {
const IDENTIFIER: &'static str = "ChargeTransactionPayment";
type Implicit = ();
fn weight(&self) -> Weight {
T::WeightInfo::charge_transaction_payment()
}
}
impl<T: Config, Context> TransactionExtension<T::RuntimeCall, Context>
for ChargeTransactionPayment<T>
impl<T: Config> SignedExtension for ChargeTransactionPayment<T>
where
BalanceOf<T>: Send + Sync + From<u64>,
T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
{
type Val = (
// tip
BalanceOf<T>,
// who paid the fee
T::AccountId,
// computed fee
BalanceOf<T>,
);
const IDENTIFIER: &'static str = "ChargeTransactionPayment";
type AccountId = T::AccountId;
type Call = T::RuntimeCall;
type AdditionalSigned = ();
type Pre = (
// tip
BalanceOf<T>,
// who paid the fee
T::AccountId,
// who paid the fee - this is an option to allow for a Default impl.
Self::AccountId,
// imbalance resulting from withdrawing the fee
<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::LiquidityInfo,
);
fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
Ok(())
}
fn validate(
&self,
origin: <T::RuntimeCall as Dispatchable>::RuntimeOrigin,
call: &T::RuntimeCall,
info: &DispatchInfoOf<T::RuntimeCall>,
who: &Self::AccountId,
call: &Self::Call,
info: &DispatchInfoOf<Self::Call>,
len: usize,
_context: &mut Context,
_: (),
_implication: &impl Encode,
) -> Result<
(ValidTransaction, Self::Val, <T::RuntimeCall as Dispatchable>::RuntimeOrigin),
TransactionValidityError,
> {
let who = frame_system::ensure_signed(origin.clone())
.map_err(|_| InvalidTransaction::BadSigner)?;
let final_fee = self.can_withdraw_fee(&who, call, info, len)?;
) -> 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()
},
(self.0, who, final_fee),
origin,
))
Ok(ValidTransaction {
priority: Self::get_priority(info, len, tip, final_fee),
..Default::default()
})
}
fn prepare(
fn pre_dispatch(
self,
val: Self::Val,
_origin: &<T::RuntimeCall as Dispatchable>::RuntimeOrigin,
call: &T::RuntimeCall,
info: &DispatchInfoOf<T::RuntimeCall>,
_len: usize,
_context: &Context,
who: &Self::AccountId,
call: &Self::Call,
info: &DispatchInfoOf<Self::Call>,
len: usize,
) -> Result<Self::Pre, TransactionValidityError> {
let (tip, who, fee) = val;
// Mutating call to `withdraw_fee` to actually charge for the transaction.
let (_final_fee, imbalance) = self.withdraw_fee(&who, call, info, fee)?;
Ok((tip, who, imbalance))
let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;
Ok((self.0, who.clone(), imbalance))
}
fn post_dispatch(
(tip, who, imbalance): Self::Pre,
info: &DispatchInfoOf<T::RuntimeCall>,
post_info: &PostDispatchInfoOf<T::RuntimeCall>,
maybe_pre: Option<Self::Pre>,
info: &DispatchInfoOf<Self::Call>,
post_info: &PostDispatchInfoOf<Self::Call>,
len: usize,
_result: &DispatchResult,
_context: &Context,
) -> Result<(), TransactionValidityError> {
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 });
if let Some((tip, who, imbalance)) = maybe_pre {
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 });
}
Ok(())
}
}
substrate/frame/transaction-payment/src/mock.rs
-10
View File
@@ -157,14 +157,4 @@ impl Config for Runtime {
type WeightToFee = WeightToFee;
type LengthToFee = TransactionByteFee;
type FeeMultiplierUpdate = ();
type WeightInfo = ();
}
#[cfg(feature = "runtime-benchmarks")]
pub fn new_test_ext() -> sp_io::TestExternalities {
crate::tests::ExtBuilder::default()
.base_weight(Weight::from_parts(100, 0))
.byte_fee(10)
.balance_factor(0)
.build()
}
substrate/frame/transaction-payment/src/payment.rs
+1 -55
View File
@@ -20,7 +20,7 @@ use crate::Config;
use core::marker::PhantomData;
use sp_runtime::{
traits::{CheckedSub, DispatchInfoOf, PostDispatchInfoOf, Saturating, Zero},
traits::{DispatchInfoOf, PostDispatchInfoOf, Saturating, Zero},
transaction_validity::InvalidTransaction,
};
@@ -51,17 +51,6 @@ pub trait OnChargeTransaction<T: Config> {
tip: Self::Balance,
) -> Result<Self::LiquidityInfo, TransactionValidityError>;
/// Check if the predicted fee from the transaction origin can be withdrawn.
///
/// Note: The `fee` already includes the `tip`.
fn can_withdraw_fee(
who: &T::AccountId,
call: &T::RuntimeCall,
dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
fee: Self::Balance,
tip: Self::Balance,
) -> Result<(), TransactionValidityError>;
/// After the transaction was executed the actual fee can be calculated.
/// This function should refund any overpaid fees and optionally deposit
/// the corrected amount.
@@ -75,12 +64,6 @@ pub trait OnChargeTransaction<T: Config> {
tip: Self::Balance,
already_withdrawn: Self::LiquidityInfo,
) -> Result<(), TransactionValidityError>;
#[cfg(feature = "runtime-benchmarks")]
fn endow_account(who: &T::AccountId, amount: Self::Balance);
#[cfg(feature = "runtime-benchmarks")]
fn minimum_balance() -> Self::Balance;
}
/// Implements the transaction payment for a pallet implementing the `Currency`
@@ -138,33 +121,6 @@ where
}
}
/// Check if the predicted fee from the transaction origin can be withdrawn.
///
/// Note: The `fee` already includes the `tip`.
fn can_withdraw_fee(
who: &T::AccountId,
_call: &T::RuntimeCall,
_info: &DispatchInfoOf<T::RuntimeCall>,
fee: Self::Balance,
tip: Self::Balance,
) -> Result<(), TransactionValidityError> {
if fee.is_zero() {
return Ok(())
}
let withdraw_reason = if tip.is_zero() {
WithdrawReasons::TRANSACTION_PAYMENT
} else {
WithdrawReasons::TRANSACTION_PAYMENT | WithdrawReasons::TIP
};
let new_balance =
C::free_balance(who).checked_sub(&fee).ok_or(InvalidTransaction::Payment)?;
C::ensure_can_withdraw(who, fee, withdraw_reason, new_balance)
.map(|_| ())
.map_err(|_| InvalidTransaction::Payment.into())
}
/// Hand the fee and the tip over to the `[OnUnbalanced]` implementation.
/// Since the predicted fee might have been too high, parts of the fee may
/// be refunded.
@@ -197,14 +153,4 @@ where
}
Ok(())
}
#[cfg(feature = "runtime-benchmarks")]
fn endow_account(who: &T::AccountId, amount: Self::Balance) {
let _ = C::deposit_creating(who, amount);
}
#[cfg(feature = "runtime-benchmarks")]
fn minimum_balance() -> Self::Balance {
C::minimum_balance()
}
}
substrate/frame/transaction-payment/src/tests.rs
+249 -181
View File
@@ -21,14 +21,11 @@ use crate as pallet_transaction_payment;
use codec::Encode;
use sp_runtime::{
generic::UncheckedExtrinsic,
traits::{DispatchTransaction, One},
transaction_validity::InvalidTransaction,
BuildStorage,
testing::TestXt, traits::One, transaction_validity::InvalidTransaction, BuildStorage,
};
use frame_support::{
assert_ok,
assert_noop, assert_ok,
dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, PostDispatchInfo},
traits::Currency,
weights::Weight,
@@ -131,37 +128,44 @@ fn default_post_info() -> PostDispatchInfo {
PostDispatchInfo { actual_weight: None, pays_fee: Default::default() }
}
type Ext = ChargeTransactionPayment<Runtime>;
#[test]
fn transaction_extension_transaction_payment_work() {
fn signed_extension_transaction_payment_work() {
ExtBuilder::default()
.balance_factor(10)
.base_weight(Weight::from_parts(5, 0))
.build()
.execute_with(|| {
let info = info_from_weight(Weight::from_parts(5, 0));
Ext::from(0)
.test_run(Some(1).into(), CALL, &info, 10, |_| {
assert_eq!(Balances::free_balance(1), 100 - 5 - 5 - 10);
Ok(default_post_info())
})
.unwrap()
let len = 10;
let pre = ChargeTransactionPayment::<Runtime>::from(0)
.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(5, 0)), len)
.unwrap();
assert_eq!(Balances::free_balance(1), 100 - 5 - 5 - 10);
assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
Some(pre),
&info_from_weight(Weight::from_parts(5, 0)),
&default_post_info(),
len,
&Ok(())
));
assert_eq!(Balances::free_balance(1), 100 - 5 - 5 - 10);
assert_eq!(FeeUnbalancedAmount::get(), 5 + 5 + 10);
assert_eq!(TipUnbalancedAmount::get(), 0);
FeeUnbalancedAmount::mutate(|a| *a = 0);
let info = info_from_weight(Weight::from_parts(100, 0));
Ext::from(5 /* tipped */)
.test_run(Some(2).into(), CALL, &info, 10, |_| {
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
Ok(post_info_from_weight(Weight::from_parts(50, 0)))
})
.unwrap()
let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
.unwrap();
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
Some(pre),
&info_from_weight(Weight::from_parts(100, 0)),
&post_info_from_weight(Weight::from_parts(50, 0)),
len,
&Ok(())
));
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 50 - 5);
assert_eq!(FeeUnbalancedAmount::get(), 5 + 10 + 50);
assert_eq!(TipUnbalancedAmount::get(), 5);
@@ -169,37 +173,43 @@ fn transaction_extension_transaction_payment_work() {
}
#[test]
fn transaction_extension_transaction_payment_multiplied_refund_works() {
fn signed_extension_transaction_payment_multiplied_refund_works() {
ExtBuilder::default()
.balance_factor(10)
.base_weight(Weight::from_parts(5, 0))
.build()
.execute_with(|| {
let len = 10;
<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(3, 2));
let len = 10;
let origin = Some(2).into();
let info = info_from_weight(Weight::from_parts(100, 0));
Ext::from(5 /* tipped */)
.test_run(origin, CALL, &info, len, |_| {
// 5 base fee, 10 byte fee, 3/2 * 100 weight fee, 5 tip
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 150 - 5);
Ok(post_info_from_weight(Weight::from_parts(50, 0)))
})
.unwrap()
let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
.unwrap();
// 5 base fee, 10 byte fee, 3/2 * 100 weight fee, 5 tip
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 150 - 5);
assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
Some(pre),
&info_from_weight(Weight::from_parts(100, 0)),
&post_info_from_weight(Weight::from_parts(50, 0)),
len,
&Ok(())
));
// 75 (3/2 of the returned 50 units of weight) is refunded
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 75 - 5);
});
}
#[test]
fn transaction_extension_transaction_payment_is_bounded() {
fn signed_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));
assert_ok!(ChargeTransactionPayment::<Runtime>::from(0).pre_dispatch(
&1,
CALL,
&info_from_weight(Weight::MAX),
10
));
// fee will be proportional to what is the actual maximum weight in the runtime.
assert_eq!(
Balances::free_balance(&1),
@@ -210,7 +220,7 @@ fn transaction_extension_transaction_payment_is_bounded() {
}
#[test]
fn transaction_extension_allows_free_transactions() {
fn signed_extension_allows_free_transactions() {
ExtBuilder::default()
.base_weight(Weight::from_parts(100, 0))
.balance_factor(0)
@@ -222,28 +232,38 @@ fn transaction_extension_allows_free_transactions() {
let len = 100;
// This is a completely free (and thus wholly insecure/DoS-ridden) transaction.
let op_tx = DispatchInfo {
let operational_transaction = DispatchInfo {
weight: Weight::from_parts(0, 0),
class: DispatchClass::Operational,
pays_fee: Pays::No,
};
assert_ok!(Ext::from(0).validate_only(Some(1).into(), CALL, &op_tx, len));
assert_ok!(ChargeTransactionPayment::<Runtime>::from(0).validate(
&1,
CALL,
&operational_transaction,
len
));
// like a InsecureFreeNormal
let free_tx = DispatchInfo {
let free_transaction = DispatchInfo {
weight: Weight::from_parts(0, 0),
class: DispatchClass::Normal,
pays_fee: Pays::Yes,
};
assert_eq!(
Ext::from(0).validate_only(Some(1).into(), CALL, &free_tx, len).unwrap_err(),
assert_noop!(
ChargeTransactionPayment::<Runtime>::from(0).validate(
&1,
CALL,
&free_transaction,
len
),
TransactionValidityError::Invalid(InvalidTransaction::Payment),
);
});
}
#[test]
fn transaction_ext_length_fee_is_also_updated_per_congestion() {
fn signed_ext_length_fee_is_also_updated_per_congestion() {
ExtBuilder::default()
.base_weight(Weight::from_parts(5, 0))
.balance_factor(10)
@@ -252,15 +272,16 @@ fn transaction_ext_length_fee_is_also_updated_per_congestion() {
// 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));
assert_ok!(ChargeTransactionPayment::<Runtime>::from(10) // tipped
.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(3, 0)), len));
assert_eq!(
Balances::free_balance(1),
100 // original
- 10 // tip
- 5 // base
- 10 // len
- (3 * 3 / 2) // adjusted weight
- 10 // tip
- 5 // base
- 10 // len
- (3 * 3 / 2) // adjusted weight
);
})
}
@@ -270,62 +291,62 @@ 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 xt = TestXt::new(call.clone(), Some((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 = TestXt::<_, ()>::new(call, None);
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));
.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.weight,
class: info.class,
partial_fee: 5 * 2 /* base * weight_fee */
+ len as u64 /* len * 1 */
+ info.weight.min(BlockWeights::get().max_block).ref_time() as u64 * 2 * 3 / 2 /* weight */
},
);
assert_eq!(
TransactionPayment::query_info(xt.clone(), len),
RuntimeDispatchInfo {
weight: info.weight,
class: info.class,
partial_fee: 5 * 2 /* base * weight_fee */
+ len as u64 /* len * 1 */
+ info.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.weight,
class: unsigned_xt_info.class,
partial_fee: 0,
},
);
assert_eq!(
TransactionPayment::query_info(unsigned_xt.clone(), len),
RuntimeDispatchInfo {
weight: unsigned_xt_info.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
.weight
.min(BlockWeights::get().max_block)
.ref_time() as u64 * 2 * 3 / 2
}),
tip: 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
.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 },
);
});
assert_eq!(
TransactionPayment::query_fee_details(unsigned_xt, len),
FeeDetails { inclusion_fee: None, tip: 0 },
);
});
}
#[test]
@@ -336,39 +357,39 @@ fn query_call_info_and_fee_details_works() {
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));
.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.weight,
class: info.class,
partial_fee: 5 * 2 /* base * weight_fee */
+ len as u64 /* len * 1 */
+ info.weight.min(BlockWeights::get().max_block).ref_time() as u64 * 2 * 3 / 2 /* weight */
},
);
assert_eq!(
TransactionPayment::query_call_info(call.clone(), len),
RuntimeDispatchInfo {
weight: info.weight,
class: info.class,
partial_fee: 5 * 2 /* base * weight_fee */
+ len as u64 /* len * 1 */
+ info.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
.weight
.min(BlockWeights::get().max_block)
.ref_time() as u64 * 2 * 3 / 2 /* weight * weight_fee * multipler */
}),
tip: 0,
},
);
});
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
.weight
.min(BlockWeights::get().max_block)
.ref_time() as u64 * 2 * 3 / 2 /* weight * weight_fee * multipler */
}),
tip: 0,
},
);
});
}
#[test]
@@ -505,23 +526,27 @@ fn refund_does_not_recreate_account() {
.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, |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()
let len = 10;
let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
.unwrap();
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(
Some(2).into(),
3,
Balances::free_balance(2)
));
assert_eq!(Balances::free_balance(2), 0);
assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
Some(pre),
&info_from_weight(Weight::from_parts(100, 0)),
&post_info_from_weight(Weight::from_parts(50, 0)),
len,
&Ok(())
));
assert_eq!(Balances::free_balance(2), 0);
// Transfer Event
System::assert_has_event(RuntimeEvent::Balances(pallet_balances::Event::Transfer {
@@ -543,15 +568,20 @@ fn actual_weight_higher_than_max_refunds_nothing() {
.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, |_| {
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
Ok(post_info_from_weight(Weight::from_parts(101, 0)))
})
.unwrap()
let len = 10;
let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
.unwrap();
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
Some(pre),
&info_from_weight(Weight::from_parts(100, 0)),
&post_info_from_weight(Weight::from_parts(101, 0)),
len,
&Ok(())
));
assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
});
}
@@ -564,20 +594,25 @@ fn zero_transfer_on_free_transaction() {
.execute_with(|| {
// So events are emitted
System::set_block_number(10);
let info = DispatchInfo {
let len = 10;
let dispatch_info = DispatchInfo {
weight: Weight::from_parts(100, 0),
pays_fee: Pays::No,
class: DispatchClass::Normal,
};
let user = 69;
Ext::from(0)
.test_run(Some(user).into(), CALL, &info, 10, |_| {
assert_eq!(Balances::total_balance(&user), 0);
Ok(default_post_info())
})
.unwrap()
let pre = ChargeTransactionPayment::<Runtime>::from(0)
.pre_dispatch(&user, CALL, &dispatch_info, len)
.unwrap();
assert_eq!(Balances::total_balance(&user), 0);
assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
Some(pre),
&dispatch_info,
&default_post_info(),
len,
&Ok(())
));
assert_eq!(Balances::total_balance(&user), 0);
// TransactionFeePaid Event
System::assert_has_event(RuntimeEvent::TransactionPayment(
pallet_transaction_payment::Event::TransactionFeePaid {
@@ -604,11 +639,19 @@ fn refund_consistent_with_actual_weight() {
<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(5, 4));
Ext::from(tip)
.test_run(Some(2).into(), CALL, &info, len, |_| Ok(post_info))
.unwrap()
let pre = ChargeTransactionPayment::<Runtime>::from(tip)
.pre_dispatch(&2, CALL, &info, len)
.unwrap();
ChargeTransactionPayment::<Runtime>::post_dispatch(
Some(pre),
&info,
&post_info,
len,
&Ok(()),
)
.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);
@@ -630,13 +673,18 @@ fn should_alter_operational_priority() {
class: DispatchClass::Normal,
pays_fee: Pays::Yes,
};
let priority = ChargeTransactionPayment::<Runtime>(tip)
.validate(&2, CALL, &normal, len)
.unwrap()
.priority;
let ext = Ext::from(tip);
let priority = ext.validate_only(Some(2).into(), CALL, &normal, len).unwrap().0.priority;
assert_eq!(priority, 60);
let ext = Ext::from(2 * tip);
let priority = ext.validate_only(Some(2).into(), CALL, &normal, len).unwrap().0.priority;
let priority = ChargeTransactionPayment::<Runtime>(2 * tip)
.validate(&2, CALL, &normal, len)
.unwrap()
.priority;
assert_eq!(priority, 110);
});
@@ -646,13 +694,16 @@ fn should_alter_operational_priority() {
class: DispatchClass::Operational,
pays_fee: Pays::Yes,
};
let ext = Ext::from(tip);
let priority = ext.validate_only(Some(2).into(), CALL, &op, len).unwrap().0.priority;
let priority = ChargeTransactionPayment::<Runtime>(tip)
.validate(&2, CALL, &op, len)
.unwrap()
.priority;
assert_eq!(priority, 5810);
let ext = Ext::from(2 * tip);
let priority = ext.validate_only(Some(2).into(), CALL, &op, len).unwrap().0.priority;
let priority = ChargeTransactionPayment::<Runtime>(2 * tip)
.validate(&2, CALL, &op, len)
.unwrap()
.priority;
assert_eq!(priority, 6110);
});
}
@@ -668,8 +719,11 @@ fn no_tip_has_some_priority() {
class: DispatchClass::Normal,
pays_fee: Pays::Yes,
};
let ext = Ext::from(tip);
let priority = ext.validate_only(Some(2).into(), CALL, &normal, len).unwrap().0.priority;
let priority = ChargeTransactionPayment::<Runtime>(tip)
.validate(&2, CALL, &normal, len)
.unwrap()
.priority;
assert_eq!(priority, 10);
});
@@ -679,8 +733,10 @@ fn no_tip_has_some_priority() {
class: DispatchClass::Operational,
pays_fee: Pays::Yes,
};
let ext = Ext::from(tip);
let priority = ext.validate_only(Some(2).into(), CALL, &op, len).unwrap().0.priority;
let priority = ChargeTransactionPayment::<Runtime>(tip)
.validate(&2, CALL, &op, len)
.unwrap()
.priority;
assert_eq!(priority, 5510);
});
}
@@ -688,8 +744,8 @@ fn no_tip_has_some_priority() {
#[test]
fn higher_tip_have_higher_priority() {
let get_priorities = |tip: u64| {
let mut pri1 = 0;
let mut pri2 = 0;
let mut priority1 = 0;
let mut priority2 = 0;
let len = 10;
ExtBuilder::default().balance_factor(100).build().execute_with(|| {
let normal = DispatchInfo {
@@ -697,8 +753,10 @@ fn higher_tip_have_higher_priority() {
class: DispatchClass::Normal,
pays_fee: Pays::Yes,
};
let ext = Ext::from(tip);
pri1 = ext.validate_only(Some(2).into(), CALL, &normal, len).unwrap().0.priority;
priority1 = ChargeTransactionPayment::<Runtime>(tip)
.validate(&2, CALL, &normal, len)
.unwrap()
.priority;
});
ExtBuilder::default().balance_factor(100).build().execute_with(|| {
@@ -707,11 +765,13 @@ fn higher_tip_have_higher_priority() {
class: DispatchClass::Operational,
pays_fee: Pays::Yes,
};
let ext = Ext::from(tip);
pri2 = ext.validate_only(Some(2).into(), CALL, &op, len).unwrap().0.priority;
priority2 = ChargeTransactionPayment::<Runtime>(tip)
.validate(&2, CALL, &op, len)
.unwrap()
.priority;
});
(pri1, pri2)
(priority1, priority2)
};
let mut prev_priorities = get_priorities(0);
@@ -739,11 +799,19 @@ fn post_info_can_change_pays_fee() {
<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(5, 4));
let post_info = ChargeTransactionPayment::<Runtime>::from(tip)
.test_run(Some(2).into(), CALL, &info, len, |_| Ok(post_info))
.unwrap()
let pre = ChargeTransactionPayment::<Runtime>::from(tip)
.pre_dispatch(&2, CALL, &info, len)
.unwrap();
ChargeTransactionPayment::<Runtime>::post_dispatch(
Some(pre),
&info,
&post_info,
len,
&Ok(()),
)
.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);
substrate/frame/transaction-payment/src/types.rs
+1 -1
View File
@@ -112,7 +112,7 @@ pub struct RuntimeDispatchInfo<Balance, Weight = frame_support::weights::Weight>
/// The inclusion fee of this dispatch.
///
/// This does not include a tip or anything else that
/// depends on the signature (i.e. depends on a `TransactionExtension`).
/// depends on the signature (i.e. depends on a `SignedExtension`).
#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
pub partial_fee: Balance,
}
substrate/frame/transaction-payment/src/weights.rs
Generated
-92
View File
@@ -1,92 +0,0 @@
// 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.
//! Autogenerated weights for `pallet_transaction_payment`
//!
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
//! DATE: 2024-03-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! WORST CASE MAP SIZE: `1000000`
//! HOSTNAME: `runner-bn-ce5rx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
// Executed Command:
// ./target/production/substrate-node
// benchmark
// pallet
// --chain=dev
// --steps=50
// --repeat=20
// --pallet=pallet_transaction_payment
// --no-storage-info
// --no-median-slopes
// --no-min-squares
// --extrinsic=*
// --wasm-execution=compiled
// --heap-pages=4096
// --output=./substrate/frame/transaction-payment/src/weights.rs
// --header=./substrate/HEADER-APACHE2
// --template=./substrate/.maintain/frame-weight-template.hbs
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(unused_parens)]
#![allow(unused_imports)]
#![allow(missing_docs)]
use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
use core::marker::PhantomData;
/// Weight functions needed for `pallet_transaction_payment`.
pub trait WeightInfo {
fn charge_transaction_payment() -> Weight;
}
/// Weights for `pallet_transaction_payment` using the Substrate node and recommended hardware.
pub struct SubstrateWeight<T>(PhantomData<T>);
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
/// Storage: `Authorship::Author` (r:1 w:0)
/// Proof: `Authorship::Author` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
/// Storage: `System::Digest` (r:1 w:0)
/// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
fn charge_transaction_payment() -> Weight {
// Proof Size summary in bytes:
// Measured: `248`
// Estimated: `1733`
// Minimum execution time: 40_506_000 picoseconds.
Weight::from_parts(41_647_000, 1733)
.saturating_add(T::DbWeight::get().reads(3_u64))
}
}
// For backwards compatibility and tests.
impl WeightInfo for () {
/// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
/// Storage: `Authorship::Author` (r:1 w:0)
/// Proof: `Authorship::Author` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
/// Storage: `System::Digest` (r:1 w:0)
/// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
fn charge_transaction_payment() -> Weight {
// Proof Size summary in bytes:
// Measured: `248`
// Estimated: `1733`
// Minimum execution time: 40_506_000 picoseconds.
Weight::from_parts(41_647_000, 1733)
.saturating_add(RocksDbWeight::get().reads(3_u64))
}
}