pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-14 04:01:10 +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-conversion-tx-payment/src/benchmarking.rs
-125
View File
@@ -1,125 +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 Conversion 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>
+ Into<ChargeAssetBalanceOf<T>>
+ Into<ChargeAssetLiquidityOf<T>>
+ From<ChargeAssetLiquidityOf<T>>,
ChargeAssetIdOf<T>: Send + Sync + Default,
<T::RuntimeCall as Dispatchable>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId> + Clone,
)]
mod benchmarks {
use super::*;
#[benchmark]
fn charge_asset_tx_payment_zero() {
let caller: T::AccountId = whitelisted_caller();
let ext: ChargeAssetTxPayment<T> = ChargeAssetTxPayment::from(0u64.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(10u64.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, caller.clone());
let tip = 10u64.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-conversion-tx-payment/src/lib.rs
+91 -150
View File
@@ -20,8 +20,8 @@
//!
//! ## Overview
//!
//! This pallet provides a `TransactionExtension` with an optional `AssetId` that specifies the
//! asset to be used for payment (defaulting to the native token on `None`). It expects an
//! This pallet provides a `SignedExtension` with an optional `AssetId` that specifies the asset
//! to be used for payment (defaulting to the native token on `None`). It expects an
//! [`OnChargeAssetTransaction`] implementation analogous to [`pallet-transaction-payment`]. The
//! included [`AssetConversionAdapter`] (implementing [`OnChargeAssetTransaction`]) determines the
//! fee amount by converting the fee calculated by [`pallet-transaction-payment`] in the native
@@ -31,7 +31,7 @@
//!
//! This pallet does not have any dispatchable calls or storage. It 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`]
//! your `construct_runtime` macro, but only include this pallet's [`SignedExtension`]
//! ([`ChargeAssetTxPayment`]).
//!
//! ## Terminology
@@ -53,29 +53,23 @@ use frame_support::{
},
DefaultNoBound,
};
use pallet_transaction_payment::{ChargeTransactionPayment, OnChargeTransaction};
use pallet_transaction_payment::OnChargeTransaction;
use scale_info::TypeInfo;
use sp_runtime::{
traits::{
AsSystemOriginSigner, DispatchInfoOf, Dispatchable, PostDispatchInfoOf,
TransactionExtension, TransactionExtensionBase, ValidateResult, Zero,
traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension, Zero},
transaction_validity::{
InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
},
transaction_validity::{InvalidTransaction, TransactionValidityError, ValidTransaction},
};
#[cfg(test)]
mod mock;
#[cfg(test)]
mod tests;
pub mod weights;
#[cfg(feature = "runtime-benchmarks")]
mod benchmarking;
mod payment;
use frame_support::{pallet_prelude::Weight, traits::tokens::AssetId};
use frame_support::traits::tokens::AssetId;
pub use payment::*;
pub use weights::WeightInfo;
/// Type aliases used for interaction with `OnChargeTransaction`.
pub(crate) type OnChargeTransactionOf<T> =
@@ -131,30 +125,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> {
@@ -204,8 +179,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))
@@ -249,30 +225,7 @@ 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>
+ Into<ChargeAssetBalanceOf<T>>
+ Into<ChargeAssetLiquidityOf<T>>
+ From<ChargeAssetLiquidityOf<T>>,
ChargeAssetIdOf<T>: Send + Sync,
{
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,
@@ -283,123 +236,111 @@ where
+ Into<ChargeAssetLiquidityOf<T>>
+ From<ChargeAssetLiquidityOf<T>>,
ChargeAssetIdOf<T>: Send + Sync,
<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,
) -> ValidateResult<Self::Val, T::RuntimeCall> {
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 validity = ValidTransaction { priority, ..Default::default() };
let val = (self.tip, who.clone(), fee);
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.clone()))
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) => {
debug_assert!(
asset_id.is_none(),
"For that payment type the `asset_id` should be None"
);
pallet_transaction_payment::ChargeTransactionPayment::<T>::post_dispatch(
(tip, who, already_withdrawn),
info,
post_info,
len,
result,
&(),
)?;
},
InitialPayment::Asset(already_withdrawn) => {
debug_assert!(
asset_id.is_some(),
"For that payment type the `asset_id` should be set"
);
let actual_fee = pallet_transaction_payment::Pallet::<T>::compute_actual_fee(
len as u32, info, post_info, tip,
);
if let Some(asset_id) = asset_id {
let (used_for_fee, received_exchanged, asset_consumed) = already_withdrawn;
let converted_fee = T::OnChargeAssetTransaction::correct_and_deposit_fee(
&who,
if let Some((tip, who, initial_payment, asset_id)) = pre {
match initial_payment {
InitialPayment::Native(already_withdrawn) => {
debug_assert!(
asset_id.is_none(),
"For that payment type the `asset_id` should be None"
);
pallet_transaction_payment::ChargeTransactionPayment::<T>::post_dispatch(
Some((tip, who, already_withdrawn)),
info,
post_info,
actual_fee.into(),
tip.into(),
used_for_fee.into(),
received_exchanged.into(),
asset_id.clone(),
asset_consumed.into(),
len,
result,
)?;
},
InitialPayment::Asset(already_withdrawn) => {
debug_assert!(
asset_id.is_some(),
"For that payment type the `asset_id` should be set"
);
let actual_fee = pallet_transaction_payment::Pallet::<T>::compute_actual_fee(
len as u32, info, post_info, tip,
);
Pallet::<T>::deposit_event(Event::<T>::AssetTxFeePaid {
who,
actual_fee: converted_fee,
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.");
},
if let Some(asset_id) = asset_id {
let (used_for_fee, received_exchanged, asset_consumed) = already_withdrawn;
let converted_fee = T::OnChargeAssetTransaction::correct_and_deposit_fee(
&who,
info,
post_info,
actual_fee.into(),
tip.into(),
used_for_fee.into(),
received_exchanged.into(),
asset_id.clone(),
asset_consumed.into(),
)?;
Pallet::<T>::deposit_event(Event::<T>::AssetTxFeePaid {
who,
actual_fee: converted_fee,
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-conversion-tx-payment/src/mock.rs
+1 -69
View File
@@ -168,12 +168,12 @@ impl OnUnbalanced<pallet_balances::NegativeImbalance<Runtime>> for DealWithFees
}
}
#[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, DealWithFees>;
type WeightToFee = WeightToFee;
type LengthToFee = TransactionByteFee;
type FeeMultiplierUpdate = ();
type OperationalFeeMultiplier = ConstU8<5>;
}
@@ -269,72 +269,4 @@ impl Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Fungibles = Assets;
type OnChargeAssetTransaction = AssetConversionAdapter<Balances, AssetConversion, Native>;
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, id)
}
fn setup_balances_and_pool(asset_id: u32, account: u64) {
use frame_support::{assert_ok, traits::fungibles::Mutate};
use sp_runtime::traits::StaticLookup;
assert_ok!(Assets::force_create(
RuntimeOrigin::root(),
asset_id.into(),
42, /* owner */
true, /* is_sufficient */
1,
));
let lp_provider = 12;
assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), lp_provider, u64::MAX / 2));
let lp_provider_account = <Runtime as system::Config>::Lookup::unlookup(lp_provider);
assert_ok!(Assets::mint_into(asset_id.into(), &lp_provider_account, u64::MAX / 2));
let token_1 = Box::new(NativeOrWithId::Native);
let token_2 = Box::new(NativeOrWithId::WithId(asset_id));
assert_ok!(AssetConversion::create_pool(
RuntimeOrigin::signed(lp_provider),
token_1.clone(),
token_2.clone()
));
assert_ok!(AssetConversion::add_liquidity(
RuntimeOrigin::signed(lp_provider),
token_1,
token_2,
(u32::MAX / 8).into(), // 1 desired
u32::MAX.into(), // 2 desired
1, // 1 min
1, // 2 min
lp_provider_account,
));
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-conversion-tx-payment/src/tests.rs
+94 -56
View File
@@ -28,10 +28,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 });
@@ -163,35 +160,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_5), len)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, None)
.pre_dispatch(&1, CALL, &info_from_weight(WEIGHT_5), 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_5),
&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_100), len)
let pre = ChargeAssetTxPayment::<Runtime>::from(5 /* tipped */, None)
.pre_dispatch(&2, CALL, &info_from_weight(WEIGHT_100), 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_100),
&post_info_from_weight(WEIGHT_50),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Balances::free_balance(2), initial_balance_for_2 - 5 - 10 - 50 - 5);
});
@@ -242,8 +237,8 @@ fn transaction_payment_in_asset_possible() {
let fee_in_asset = input_quote.unwrap();
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_5), len)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
.unwrap();
// assert that native balance is not used
assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
@@ -252,12 +247,11 @@ fn transaction_payment_in_asset_possible() {
assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(WEIGHT_5), // estimated tx weight
&default_post_info(), // weight actually used == estimated
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
@@ -295,8 +289,12 @@ fn transaction_payment_in_asset_fails_if_no_pool_for_that_asset() {
assert_eq!(Assets::balance(asset_id, caller), balance);
let len = 10;
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(Some(caller).into(), CALL, &info_from_weight(WEIGHT_5), len);
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id)).pre_dispatch(
&caller,
CALL,
&info_from_weight(WEIGHT_5),
len,
);
// As there is no pool in the dex set up for this asset, conversion should fail.
assert!(pre.is_err());
@@ -346,8 +344,8 @@ fn transaction_payment_without_fee() {
assert_eq!(input_quote, Some(201));
let fee_in_asset = input_quote.unwrap();
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(Some(caller).into(), CALL, &info_from_weight(WEIGHT_5), len)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
.unwrap();
// assert that native balance is not used
@@ -365,12 +363,11 @@ fn transaction_payment_without_fee() {
assert_eq!(refund, 199);
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(WEIGHT_5),
&post_info_from_pays(Pays::No),
len,
&Ok(()),
&()
&Ok(())
));
// caller should get refunded
@@ -422,8 +419,8 @@ fn asset_transaction_payment_with_tip_and_refund() {
assert_eq!(input_quote, Some(1206));
let fee_in_asset = input_quote.unwrap();
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(tip, Some(asset_id))
.validate_and_prepare(Some(caller).into(), CALL, &info_from_weight(WEIGHT_100), len)
let pre = ChargeAssetTxPayment::<Runtime>::from(tip, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_100), len)
.unwrap();
assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
@@ -438,12 +435,11 @@ fn asset_transaction_payment_with_tip_and_refund() {
.unwrap();
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(WEIGHT_100),
&post_info_from_weight(WEIGHT_50),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(TipUnbalancedAmount::get(), tip);
@@ -504,8 +500,8 @@ fn payment_from_account_with_only_assets() {
.unwrap();
assert_eq!(fee_in_asset, 301);
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.validate_and_prepare(Some(caller).into(), CALL, &info_from_weight(WEIGHT_5), len)
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
.unwrap();
assert_eq!(Balances::free_balance(caller), ed);
// check that fee was charged in the given asset
@@ -520,12 +516,11 @@ fn payment_from_account_with_only_assets() {
.unwrap();
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
pre,
Some(pre),
&info_from_weight(WEIGHT_5),
&default_post_info(),
len,
&Ok(()),
&()
&Ok(())
));
assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset + refund);
assert_eq!(Balances::free_balance(caller), 0);
@@ -570,19 +565,18 @@ fn converted_fee_is_never_zero_if_input_fee_is_not() {
// there will be no conversion when the fee is zero
{
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 there are 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);
}
@@ -597,23 +591,17 @@ fn converted_fee_is_never_zero_if_input_fee_is_not() {
)
.unwrap();
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!(Assets::balance(asset_id, caller), balance - fee_in_asset);
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_in_asset);
});
@@ -653,8 +641,8 @@ fn post_dispatch_fee_is_zero_if_pre_dispatch_fee_is_zero() {
// 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
@@ -670,12 +658,62 @@ 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 = 1000;
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-conversion-tx-payment/src/weights.rs
Generated
-150
View File
@@ -1,150 +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_conversion_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_conversion_tx_payment
// --no-storage-info
// --no-median-slopes
// --no-min-squares
// --extrinsic=*
// --wasm-execution=compiled
// --heap-pages=4096
// --output=./substrate/frame/transaction-payment/asset-conversion-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_conversion_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_conversion_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: 628_000 picoseconds.
Weight::from_parts(694_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: 34_410_000 picoseconds.
Weight::from_parts(35_263_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:2 w:2)
/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
/// Storage: `System::Account` (r:1 w:1)
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, 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: `888`
// Estimated: `6208`
// Minimum execution time: 112_432_000 picoseconds.
Weight::from_parts(113_992_000, 6208)
.saturating_add(T::DbWeight::get().reads(7_u64))
.saturating_add(T::DbWeight::get().writes(4_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: 628_000 picoseconds.
Weight::from_parts(694_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: 34_410_000 picoseconds.
Weight::from_parts(35_263_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:2 w:2)
/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
/// Storage: `System::Account` (r:1 w:1)
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, 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: `888`
// Estimated: `6208`
// Minimum execution time: 112_432_000 picoseconds.
Weight::from_parts(113_992_000, 6208)
.saturating_add(RocksDbWeight::get().reads(7_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
}
}