pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-30 02:21:04 +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/asset-tx-payment/src/benchmarking.rs
-123
View File
@@ -1,123 +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 Asset Tx Payment Pallet's transaction extension
use super::*;
use crate::Pallet;
use frame_benchmarking::v2::*;
use frame_support::{
dispatch::{DispatchInfo, PostDispatchInfo},
pallet_prelude::*,
};
use frame_system::RawOrigin;
use sp_runtime::traits::{AsSystemOriginSigner, DispatchTransaction, Dispatchable};
#[benchmarks(where
T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
AssetBalanceOf<T>: Send + Sync,
BalanceOf<T>: Send + Sync + From<u64> + IsType<ChargeAssetBalanceOf<T>>,
ChargeAssetIdOf<T>: Send + Sync,
<T::RuntimeCall as Dispatchable>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId> + Clone,
Credit<T::AccountId, T::Fungibles>: IsType<ChargeAssetLiquidityOf<T>>,
)]
mod benchmarks {
use super::*;
#[benchmark]
fn charge_asset_tx_payment_zero() {
let caller: T::AccountId = whitelisted_caller();
let ext: ChargeAssetTxPayment<T> = ChargeAssetTxPayment::from(0u32.into(), None);
let inner = frame_system::Call::remark { remark: vec![] };
let call = T::RuntimeCall::from(inner);
let info = DispatchInfo {
weight: Weight::zero(),
class: DispatchClass::Normal,
pays_fee: Pays::No,
};
let post_info = PostDispatchInfo { actual_weight: None, pays_fee: Pays::No };
#[block]
{
assert!(ext
.test_run(RawOrigin::Signed(caller).into(), &call, &info, 0, |_| Ok(post_info))
.unwrap()
.is_ok());
}
}
#[benchmark]
fn charge_asset_tx_payment_native() {
let caller: T::AccountId = whitelisted_caller();
let (fun_asset_id, _) = <T as Config>::BenchmarkHelper::create_asset_id_parameter(1);
<T as Config>::BenchmarkHelper::setup_balances_and_pool(fun_asset_id, caller.clone());
let ext: ChargeAssetTxPayment<T> = ChargeAssetTxPayment::from(10u32.into(), None);
let inner = frame_system::Call::remark { remark: vec![] };
let call = T::RuntimeCall::from(inner);
let info = DispatchInfo {
weight: Weight::from_parts(10, 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).into(), &call, &info, 0, |_| Ok(post_info))
.unwrap()
.is_ok());
}
}
#[benchmark]
fn charge_asset_tx_payment_asset() {
let caller: T::AccountId = whitelisted_caller();
let (fun_asset_id, asset_id) = <T as Config>::BenchmarkHelper::create_asset_id_parameter(1);
<T as Config>::BenchmarkHelper::setup_balances_and_pool(
fun_asset_id.clone(),
caller.clone(),
);
let tip = 10u32.into();
let ext: ChargeAssetTxPayment<T> = ChargeAssetTxPayment::from(tip, Some(asset_id));
let inner = frame_system::Call::remark { remark: vec![] };
let call = T::RuntimeCall::from(inner);
let info = DispatchInfo {
weight: Weight::from_parts(10, 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, 0, |_| Ok(
post_info
))
.unwrap()
.is_ok());
}
}
impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Runtime);
}
substrate/frame/transaction-payment/asset-tx-payment/src/lib.rs
+74 -135
View File
@@ -31,7 +31,7 @@
//! This pallet wraps FRAME's transaction payment pallet and functions as a replacement. This means
//! you should include both pallets in your `construct_runtime` macro, but only include this
//! pallet's [`TransactionExtension`] ([`ChargeAssetTxPayment`]).
//! pallet's [`SignedExtension`] ([`ChargeAssetTxPayment`]).
#![cfg_attr(not(feature = "std"), no_std)]
@@ -40,7 +40,6 @@ use sp_std::prelude::*;
use codec::{Decode, Encode};
use frame_support::{
dispatch::{DispatchInfo, DispatchResult, PostDispatchInfo},
pallet_prelude::Weight,
traits::{
tokens::{
fungibles::{Balanced, Credit, Inspect},
@@ -53,11 +52,10 @@ use frame_support::{
use pallet_transaction_payment::OnChargeTransaction;
use scale_info::TypeInfo;
use sp_runtime::{
traits::{
AsSystemOriginSigner, DispatchInfoOf, Dispatchable, PostDispatchInfoOf,
TransactionExtension, TransactionExtensionBase, Zero,
traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension, Zero},
transaction_validity::{
InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
},
transaction_validity::{InvalidTransaction, TransactionValidityError, ValidTransaction},
};
#[cfg(test)]
@@ -65,14 +63,8 @@ mod mock;
#[cfg(test)]
mod tests;
#[cfg(feature = "runtime-benchmarks")]
mod benchmarking;
mod payment;
pub mod weights;
pub use payment::*;
pub use weights::WeightInfo;
/// Type aliases used for interaction with `OnChargeTransaction`.
pub(crate) type OnChargeTransactionOf<T> =
@@ -128,30 +120,11 @@ pub mod pallet {
type Fungibles: Balanced<Self::AccountId>;
/// The actual transaction charging logic that charges the fees.
type OnChargeAssetTransaction: OnChargeAssetTransaction<Self>;
/// The weight information of this pallet.
type WeightInfo: WeightInfo;
#[cfg(feature = "runtime-benchmarks")]
/// Benchmark helper
type BenchmarkHelper: BenchmarkHelperTrait<
Self::AccountId,
<<Self as Config>::Fungibles as Inspect<Self::AccountId>>::AssetId,
<<Self as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<Self>>::AssetId,
>;
}
#[pallet::pallet]
pub struct Pallet<T>(_);
#[cfg(feature = "runtime-benchmarks")]
/// Helper trait to benchmark the `ChargeAssetTxPayment` transaction extension.
pub trait BenchmarkHelperTrait<AccountId, FunAssetIdParameter, AssetIdParameter> {
/// Returns the `AssetId` to be used in the liquidity pool by the benchmarking code.
fn create_asset_id_parameter(id: u32) -> (FunAssetIdParameter, AssetIdParameter);
/// Create a liquidity pool for a given asset and sufficiently endow accounts to benchmark
/// the extension.
fn setup_balances_and_pool(asset_id: FunAssetIdParameter, account: AccountId);
}
#[pallet::event]
#[pallet::generate_deposit(pub(super) fn deposit_event)]
pub enum Event<T: Config> {
@@ -199,8 +172,9 @@ where
who: &T::AccountId,
call: &T::RuntimeCall,
info: &DispatchInfoOf<T::RuntimeCall>,
fee: BalanceOf<T>,
len: usize,
) -> Result<(BalanceOf<T>, InitialPayment<T>), TransactionValidityError> {
let fee = pallet_transaction_payment::Pallet::<T>::compute_fee(len as u32, info, self.tip);
debug_assert!(self.tip <= fee, "tip should be included in the computed fee");
if fee.is_zero() {
Ok((fee, InitialPayment::Nothing))
@@ -235,139 +209,104 @@ impl<T: Config> sp_std::fmt::Debug for ChargeAssetTxPayment<T> {
}
}
impl<T: Config> TransactionExtensionBase for ChargeAssetTxPayment<T>
where
AssetBalanceOf<T>: Send + Sync,
BalanceOf<T>: Send + Sync + From<u64> + IsType<ChargeAssetBalanceOf<T>>,
ChargeAssetIdOf<T>: Send + Sync,
Credit<T::AccountId, T::Fungibles>: IsType<ChargeAssetLiquidityOf<T>>,
{
const IDENTIFIER: &'static str = "ChargeAssetTxPayment";
type Implicit = ();
fn weight(&self) -> Weight {
if self.asset_id.is_some() {
<T as Config>::WeightInfo::charge_asset_tx_payment_asset()
} else {
<T as Config>::WeightInfo::charge_asset_tx_payment_native()
}
}
}
impl<T: Config, Context> TransactionExtension<T::RuntimeCall, Context> for ChargeAssetTxPayment<T>
impl<T: Config> SignedExtension for ChargeAssetTxPayment<T>
where
T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
AssetBalanceOf<T>: Send + Sync,
BalanceOf<T>: Send + Sync + From<u64> + IsType<ChargeAssetBalanceOf<T>>,
ChargeAssetIdOf<T>: Send + Sync,
Credit<T::AccountId, T::Fungibles>: IsType<ChargeAssetLiquidityOf<T>>,
<T::RuntimeCall as Dispatchable>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId> + Clone,
{
type Val = (
// tip
BalanceOf<T>,
// who paid the fee
T::AccountId,
// transaction fee
BalanceOf<T>,
);
const IDENTIFIER: &'static str = "ChargeAssetTxPayment";
type AccountId = T::AccountId;
type Call = T::RuntimeCall;
type AdditionalSigned = ();
type Pre = (
// tip
BalanceOf<T>,
// who paid the fee
T::AccountId,
Self::AccountId,
// imbalance resulting from withdrawing the fee
InitialPayment<T>,
// asset_id for the transaction payment
Option<ChargeAssetIdOf<T>>,
);
fn validate(
&self,
origin: <T::RuntimeCall as Dispatchable>::RuntimeOrigin,
_call: &T::RuntimeCall,
info: &DispatchInfoOf<T::RuntimeCall>,
len: usize,
_context: &mut Context,
_self_implicit: Self::Implicit,
_inherited_implication: &impl Encode,
) -> Result<
(ValidTransaction, Self::Val, <T::RuntimeCall as Dispatchable>::RuntimeOrigin),
TransactionValidityError,
> {
use pallet_transaction_payment::ChargeTransactionPayment;
let who = origin.as_system_origin_signer().ok_or(InvalidTransaction::BadSigner)?;
// Non-mutating call of `compute_fee` to calculate the fee used in the transaction priority.
let fee = pallet_transaction_payment::Pallet::<T>::compute_fee(len as u32, info, self.tip);
let priority = ChargeTransactionPayment::<T>::get_priority(info, len, self.tip, fee);
let val = (self.tip, who.clone(), fee);
let validity = ValidTransaction { priority, ..Default::default() };
Ok((validity, val, origin))
fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
Ok(())
}
fn prepare(
fn validate(
&self,
who: &Self::AccountId,
call: &Self::Call,
info: &DispatchInfoOf<Self::Call>,
len: usize,
) -> TransactionValidity {
use pallet_transaction_payment::ChargeTransactionPayment;
let (fee, _) = self.withdraw_fee(who, call, info, len)?;
let priority = ChargeTransactionPayment::<T>::get_priority(info, len, self.tip, fee);
Ok(ValidTransaction { priority, ..Default::default() })
}
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 of `withdraw_fee` to actually charge for the transaction.
let (_fee, initial_payment) = self.withdraw_fee(&who, call, info, fee)?;
Ok((tip, who, initial_payment, self.asset_id))
let (_fee, initial_payment) = self.withdraw_fee(who, call, info, len)?;
Ok((self.tip, who.clone(), initial_payment, self.asset_id))
}
fn post_dispatch(
pre: Self::Pre,
info: &DispatchInfoOf<T::RuntimeCall>,
post_info: &PostDispatchInfoOf<T::RuntimeCall>,
pre: Option<Self::Pre>,
info: &DispatchInfoOf<Self::Call>,
post_info: &PostDispatchInfoOf<Self::Call>,
len: usize,
result: &DispatchResult,
_context: &Context,
) -> Result<(), TransactionValidityError> {
let (tip, who, initial_payment, asset_id) = pre;
match initial_payment {
InitialPayment::Native(already_withdrawn) => {
pallet_transaction_payment::ChargeTransactionPayment::<T>::post_dispatch(
(tip, who, already_withdrawn),
info,
post_info,
len,
result,
&(),
)?;
},
InitialPayment::Asset(already_withdrawn) => {
let actual_fee = pallet_transaction_payment::Pallet::<T>::compute_actual_fee(
len as u32, info, post_info, tip,
);
let (converted_fee, converted_tip) =
T::OnChargeAssetTransaction::correct_and_deposit_fee(
&who,
if let Some((tip, who, initial_payment, asset_id)) = pre {
match initial_payment {
InitialPayment::Native(already_withdrawn) => {
pallet_transaction_payment::ChargeTransactionPayment::<T>::post_dispatch(
Some((tip, who, already_withdrawn)),
info,
post_info,
actual_fee.into(),
tip.into(),
already_withdrawn.into(),
len,
result,
)?;
Pallet::<T>::deposit_event(Event::<T>::AssetTxFeePaid {
who,
actual_fee: converted_fee,
tip: converted_tip,
asset_id,
});
},
InitialPayment::Nothing => {
// `actual_fee` should be zero here for any signed extrinsic. It would be
// non-zero here in case of unsigned extrinsics as they don't pay fees but
// `compute_actual_fee` is not aware of them. In both cases it's fine to just
// move ahead without adjusting the fee, though, so we do nothing.
debug_assert!(tip.is_zero(), "tip should be zero if initial fee was zero.");
},
},
InitialPayment::Asset(already_withdrawn) => {
let actual_fee = pallet_transaction_payment::Pallet::<T>::compute_actual_fee(
len as u32, info, post_info, tip,
);
let (converted_fee, converted_tip) =
T::OnChargeAssetTransaction::correct_and_deposit_fee(
&who,
info,
post_info,
actual_fee.into(),
tip.into(),
already_withdrawn.into(),
)?;
Pallet::<T>::deposit_event(Event::<T>::AssetTxFeePaid {
who,
actual_fee: converted_fee,
tip: converted_tip,
asset_id,
});
},
InitialPayment::Nothing => {
// `actual_fee` should be zero here for any signed extrinsic. It would be
// non-zero here in case of unsigned extrinsics as they don't pay fees but
// `compute_actual_fee` is not aware of them. In both cases it's fine to just
// move ahead without adjusting the fee, though, so we do nothing.
debug_assert!(tip.is_zero(), "tip should be zero if initial fee was zero.");
},
}
}
Ok(())
substrate/frame/transaction-payment/asset-tx-payment/src/mock.rs
+1 -53
View File
@@ -136,12 +136,12 @@ impl WeightToFeeT for TransactionByteFee {
}
}
#[derive_impl(pallet_transaction_payment::config_preludes::TestDefaultConfig as pallet_transaction_payment::DefaultConfig)]
impl pallet_transaction_payment::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
type WeightToFee = WeightToFee;
type LengthToFee = TransactionByteFee;
type FeeMultiplierUpdate = ();
type OperationalFeeMultiplier = ConstU8<5>;
}
@@ -205,56 +205,4 @@ impl Config for Runtime {
pallet_assets::BalanceToAssetBalance<Balances, Runtime, ConvertInto>,
CreditToBlockAuthor,
>;
type WeightInfo = ();
#[cfg(feature = "runtime-benchmarks")]
type BenchmarkHelper = Helper;
}
#[cfg(feature = "runtime-benchmarks")]
pub fn new_test_ext() -> sp_io::TestExternalities {
let base_weight = 5;
let balance_factor = 100;
crate::tests::ExtBuilder::default()
.balance_factor(balance_factor)
.base_weight(Weight::from_parts(base_weight, 0))
.build()
}
#[cfg(feature = "runtime-benchmarks")]
pub struct Helper;
#[cfg(feature = "runtime-benchmarks")]
impl BenchmarkHelperTrait<u64, u32, u32> for Helper {
fn create_asset_id_parameter(id: u32) -> (u32, u32) {
(id.into(), id.into())
}
fn setup_balances_and_pool(asset_id: u32, account: u64) {
use frame_support::{assert_ok, traits::fungibles::Mutate};
use sp_runtime::traits::StaticLookup;
let min_balance = 1;
assert_ok!(Assets::force_create(
RuntimeOrigin::root(),
asset_id.into(),
42, /* owner */
true, /* is_sufficient */
min_balance
));
// mint into the caller account
let caller = 2;
let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
let balance = 1000;
assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
assert_eq!(Assets::balance(asset_id, caller), balance);
use frame_support::traits::Currency;
let _ = Balances::deposit_creating(&account, u32::MAX.into());
let beneficiary = <Runtime as system::Config>::Lookup::unlookup(account);
let balance = 1000;
assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
assert_eq!(Assets::balance(asset_id, account), balance);
}
}
substrate/frame/transaction-payment/asset-tx-payment/src/tests.rs
+88 -96
View File
@@ -25,10 +25,7 @@ use frame_support::{
use frame_system as system;
use mock::{ExtrinsicBaseWeight, *};
use pallet_balances::Call as BalancesCall;
use sp_runtime::{
traits::{DispatchTransaction, StaticLookup},
BuildStorage,
};
use sp_runtime::{traits::StaticLookup, BuildStorage};
const CALL: &<Runtime as frame_system::Config>::RuntimeCall =
&RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
@@ -119,45 +116,33 @@ fn transaction_payment_in_native_possible() {
.build()
.execute_with(|| {
let len = 10;
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, None)
.validate_and_prepare(
Some(1).into(),
CALL,
&info_from_weight(Weight::from_parts(5, 0)),
len,
)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, None)
.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(5, 0)), len)
.unwrap();
let initial_balance = 10 * balance_factor;
assert_eq!(Balances::free_balance(1), initial_balance - 5 - 5 - 10);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(Weight::from_parts(5, 0)),
&default_post_info(),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Balances::free_balance(1), initial_balance - 5 - 5 - 10);
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(5 /* tipped */, None)
.validate_and_prepare(
Some(2).into(),
CALL,
&info_from_weight(Weight::from_parts(100, 0)),
len,
)
let pre = ChargeAssetTxPayment::<Runtime>::from(5 /* tipped */, None)
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
.unwrap();
let initial_balance_for_2 = 20 * balance_factor;
assert_eq!(Balances::free_balance(2), initial_balance_for_2 - 5 - 10 - 100 - 5);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(Weight::from_parts(100, 0)),
&post_info_from_weight(Weight::from_parts(50, 0)),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Balances::free_balance(2), initial_balance_for_2 - 5 - 10 - 50 - 5);
});
@@ -194,13 +179,8 @@ fn transaction_payment_in_asset_possible() {
// we convert the from weight to fee based on the ratio between asset min balance and
// existential deposit
let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(
Some(caller).into(),
CALL,
&info_from_weight(Weight::from_parts(weight, 0)),
len,
)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
.unwrap();
// assert that native balance is not used
assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
@@ -209,12 +189,11 @@ fn transaction_payment_in_asset_possible() {
assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), 0);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(Weight::from_parts(weight, 0)),
&default_post_info(),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Assets::balance(asset_id, caller), balance - fee);
// check that the block author gets rewarded
@@ -253,13 +232,8 @@ fn transaction_payment_without_fee() {
// we convert the from weight to fee based on the ratio between asset min balance and
// existential deposit
let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(
Some(caller).into(),
CALL,
&info_from_weight(Weight::from_parts(weight, 0)),
len,
)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
.unwrap();
// assert that native balance is not used
assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
@@ -268,12 +242,11 @@ fn transaction_payment_without_fee() {
assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), 0);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(Weight::from_parts(weight, 0)),
&post_info_from_pays(Pays::No),
len,
&Ok(()),
&()
&Ok(())
));
// caller should be refunded
assert_eq!(Assets::balance(asset_id, caller), balance);
@@ -314,24 +287,18 @@ fn asset_transaction_payment_with_tip_and_refund() {
// existential deposit
let fee_with_tip =
(base_weight + weight + len as u64 + tip) * min_balance / ExistentialDeposit::get();
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(tip, Some(asset_id))
.validate_and_prepare(
Some(caller).into(),
CALL,
&info_from_weight(Weight::from_parts(weight, 0)),
len,
)
let pre = ChargeAssetTxPayment::<Runtime>::from(tip, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
.unwrap();
assert_eq!(Assets::balance(asset_id, caller), balance - fee_with_tip);
let final_weight = 50;
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(Weight::from_parts(weight, 0)),
&post_info_from_weight(Weight::from_parts(final_weight, 0)),
len,
&Ok(()),
&()
&Ok(())
));
let final_fee =
fee_with_tip - (weight - final_weight) * min_balance / ExistentialDeposit::get();
@@ -372,25 +339,19 @@ fn payment_from_account_with_only_assets() {
// we convert the from weight to fee based on the ratio between asset min balance and
// existential deposit
let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(
Some(caller).into(),
CALL,
&info_from_weight(Weight::from_parts(weight, 0)),
len,
)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
.unwrap();
assert_eq!(Balances::free_balance(caller), 0);
// check that fee was charged in the given asset
assert_eq!(Assets::balance(asset_id, caller), balance - fee);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(Weight::from_parts(weight, 0)),
&default_post_info(),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Assets::balance(asset_id, caller), balance - fee);
assert_eq!(Balances::free_balance(caller), 0);
@@ -411,12 +372,7 @@ fn payment_only_with_existing_sufficient_asset() {
let len = 10;
// pre_dispatch fails for non-existent asset
assert!(ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(
Some(caller).into(),
CALL,
&info_from_weight(Weight::from_parts(weight, 0)),
len
)
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
.is_err());
// create the non-sufficient asset
@@ -430,12 +386,7 @@ fn payment_only_with_existing_sufficient_asset() {
));
// pre_dispatch fails for non-sufficient asset
assert!(ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(
Some(caller).into(),
CALL,
&info_from_weight(Weight::from_parts(weight, 0)),
len
)
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
.is_err());
});
}
@@ -473,40 +424,33 @@ fn converted_fee_is_never_zero_if_input_fee_is_not() {
// naive fee calculation would round down to zero
assert_eq!(fee, 0);
{
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(Some(caller).into(), CALL, &info_from_pays(Pays::No), len)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
.unwrap();
// `Pays::No` still implies no fees
assert_eq!(Assets::balance(asset_id, caller), balance);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_pays(Pays::No),
&post_info_from_pays(Pays::No),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Assets::balance(asset_id, caller), balance);
}
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(
Some(caller).into(),
CALL,
&info_from_weight(Weight::from_parts(weight, 0)),
len,
)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
.unwrap();
// check that at least one coin was charged in the given asset
assert_eq!(Assets::balance(asset_id, caller), balance - 1);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(Weight::from_parts(weight, 0)),
&default_post_info(),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Assets::balance(asset_id, caller), balance - 1);
});
@@ -544,8 +488,8 @@ fn post_dispatch_fee_is_zero_if_pre_dispatch_fee_is_zero() {
let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
// calculated fee is greater than 0
assert!(fee > 0);
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(Some(caller).into(), CALL, &info_from_pays(Pays::No), len)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
.unwrap();
// `Pays::No` implies no pre-dispatch fees
assert_eq!(Assets::balance(asset_id, caller), balance);
@@ -559,12 +503,60 @@ fn post_dispatch_fee_is_zero_if_pre_dispatch_fee_is_zero() {
// `Pays::Yes` on post-dispatch does not mean we pay (we never charge more than the
// initial fee)
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_pays(Pays::No),
&post_info_from_pays(Pays::Yes),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Assets::balance(asset_id, caller), balance);
});
}
#[test]
fn post_dispatch_fee_is_zero_if_unsigned_pre_dispatch_fee_is_zero() {
let base_weight = 1;
ExtBuilder::default()
.balance_factor(100)
.base_weight(Weight::from_parts(base_weight, 0))
.build()
.execute_with(|| {
// create the asset
let asset_id = 1;
let min_balance = 100;
assert_ok!(Assets::force_create(
RuntimeOrigin::root(),
asset_id.into(),
42, /* owner */
true, /* is_sufficient */
min_balance
));
// mint into the caller account
let caller = 333;
let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
let balance = 100;
assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
assert_eq!(Assets::balance(asset_id, caller), balance);
let weight = 1;
let len = 1;
ChargeAssetTxPayment::<Runtime>::pre_dispatch_unsigned(
CALL,
&info_from_weight(Weight::from_parts(weight, 0)),
len,
)
.unwrap();
assert_eq!(Assets::balance(asset_id, caller), balance);
// `Pays::Yes` on post-dispatch does not mean we pay (we never charge more than the
// initial fee)
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
None,
&info_from_weight(Weight::from_parts(weight, 0)),
&post_info_from_pays(Pays::Yes),
len,
&Ok(())
));
assert_eq!(Assets::balance(asset_id, caller), balance);
});
substrate/frame/transaction-payment/asset-tx-payment/src/weights.rs
Generated
-146
View File
@@ -1,146 +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_asset_tx_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_asset_tx_payment
// --no-storage-info
// --no-median-slopes
// --no-min-squares
// --extrinsic=*
// --wasm-execution=compiled
// --heap-pages=4096
// --output=./substrate/frame/transaction-payment/asset-tx-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_asset_tx_payment`.
pub trait WeightInfo {
fn charge_asset_tx_payment_zero() -> Weight;
fn charge_asset_tx_payment_native() -> Weight;
fn charge_asset_tx_payment_asset() -> Weight;
}
/// Weights for `pallet_asset_tx_payment` using the Substrate node and recommended hardware.
pub struct SubstrateWeight<T>(PhantomData<T>);
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
fn charge_asset_tx_payment_zero() -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
// Minimum execution time: 542_000 picoseconds.
Weight::from_parts(597_000, 0)
}
/// 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_asset_tx_payment_native() -> Weight {
// Proof Size summary in bytes:
// Measured: `248`
// Estimated: `1733`
// Minimum execution time: 33_162_000 picoseconds.
Weight::from_parts(34_716_000, 1733)
.saturating_add(T::DbWeight::get().reads(3_u64))
}
/// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
/// Storage: `Assets::Asset` (r:1 w:1)
/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
/// Storage: `Assets::Account` (r:1 w:1)
/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, 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_asset_tx_payment_asset() -> Weight {
// Proof Size summary in bytes:
// Measured: `747`
// Estimated: `3675`
// Minimum execution time: 44_230_000 picoseconds.
Weight::from_parts(45_297_000, 3675)
.saturating_add(T::DbWeight::get().reads(5_u64))
.saturating_add(T::DbWeight::get().writes(2_u64))
}
}
// For backwards compatibility and tests.
impl WeightInfo for () {
fn charge_asset_tx_payment_zero() -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
// Minimum execution time: 542_000 picoseconds.
Weight::from_parts(597_000, 0)
}
/// 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_asset_tx_payment_native() -> Weight {
// Proof Size summary in bytes:
// Measured: `248`
// Estimated: `1733`
// Minimum execution time: 33_162_000 picoseconds.
Weight::from_parts(34_716_000, 1733)
.saturating_add(RocksDbWeight::get().reads(3_u64))
}
/// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
/// Storage: `Assets::Asset` (r:1 w:1)
/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
/// Storage: `Assets::Account` (r:1 w:1)
/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, 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_asset_tx_payment_asset() -> Weight {
// Proof Size summary in bytes:
// Measured: `747`
// Estimated: `3675`
// Minimum execution time: 44_230_000 picoseconds.
Weight::from_parts(45_297_000, 3675)
.saturating_add(RocksDbWeight::get().reads(5_u64))
.saturating_add(RocksDbWeight::get().writes(2_u64))
}
}