mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-11-19 09:06:10 +00:00
FRAME: Create TransactionExtension as a replacement for SignedExtension (#2280)
Closes #2160 First part of [Extrinsic Horizon](https://github.com/paritytech/polkadot-sdk/issues/2415) Introduces a new trait `TransactionExtension` to replace `SignedExtension`. Introduce the idea of transactions which obey the runtime's extensions and have according Extension data (né Extra data) yet do not have hard-coded signatures. Deprecate the terminology of "Unsigned" when used for transactions/extrinsics owing to there now being "proper" unsigned transactions which obey the extension framework and "old-style" unsigned which do not. Instead we have __*General*__ for the former and __*Bare*__ for the latter. (Ultimately, the latter will be phased out as a type of transaction, and Bare will only be used for Inherents.) Types of extrinsic are now therefore: - Bare (no hardcoded signature, no Extra data; used to be known as "Unsigned") - Bare transactions (deprecated): Gossiped, validated with `ValidateUnsigned` (deprecated) and the `_bare_compat` bits of `TransactionExtension` (deprecated). - Inherents: Not gossiped, validated with `ProvideInherent`. - Extended (Extra data): Gossiped, validated via `TransactionExtension`. - Signed transactions (with a hardcoded signature). - General transactions (without a hardcoded signature). `TransactionExtension` differs from `SignedExtension` because: - A signature on the underlying transaction may validly not be present. - It may alter the origin during validation. - `pre_dispatch` is renamed to `prepare` and need not contain the checks present in `validate`. - `validate` and `prepare` is passed an `Origin` rather than a `AccountId`. - `validate` may pass arbitrary information into `prepare` via a new user-specifiable type `Val`. - `AdditionalSigned`/`additional_signed` is renamed to `Implicit`/`implicit`. It is encoded *for the entire transaction* and passed in to each extension as a new argument to `validate`. This facilitates the ability of extensions to acts as underlying crypto. There is a new `DispatchTransaction` trait which contains only default function impls and is impl'ed for any `TransactionExtension` impler. It provides several utility functions which reduce some of the tedium from using `TransactionExtension` (indeed, none of its regular functions should now need to be called directly). Three transaction version discriminator ("versions") are now permissible: - 0b000000100: Bare (used to be called "Unsigned"): contains Signature or Extra (extension data). After bare transactions are no longer supported, this will strictly identify an Inherents only. - 0b100000100: Old-school "Signed" Transaction: contains Signature and Extra (extension data). - 0b010000100: New-school "General" Transaction: contains Extra (extension data), but no Signature. For the New-school General Transaction, it becomes trivial for authors to publish extensions to the mechanism for authorizing an Origin, e.g. through new kinds of key-signing schemes, ZK proofs, pallet state, mutations over pre-authenticated origins or any combination of the above. ## Code Migration ### NOW: Getting it to build Wrap your `SignedExtension`s in `AsTransactionExtension`. This should be accompanied by renaming your aggregate type in line with the new terminology. E.g. Before: ```rust /// The SignedExtension to the basic transaction logic. pub type SignedExtra = ( /* snip */ MySpecialSignedExtension, ); /// Unchecked extrinsic type as expected by this runtime. pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>; ``` After: ```rust /// The extension to the basic transaction logic. pub type TxExtension = ( /* snip */ AsTransactionExtension<MySpecialSignedExtension>, ); /// Unchecked extrinsic type as expected by this runtime. pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, TxExtension>; ``` You'll also need to alter any transaction building logic to add a `.into()` to make the conversion happen. E.g. Before: ```rust fn construct_extrinsic( /* snip */ ) -> UncheckedExtrinsic { let extra: SignedExtra = ( /* snip */ MySpecialSignedExtension::new(/* snip */), ); let payload = SignedPayload::new(call.clone(), extra.clone()).unwrap(); let signature = payload.using_encoded(|e| sender.sign(e)); UncheckedExtrinsic::new_signed( /* snip */ Signature::Sr25519(signature), extra, ) } ``` After: ```rust fn construct_extrinsic( /* snip */ ) -> UncheckedExtrinsic { let tx_ext: TxExtension = ( /* snip */ MySpecialSignedExtension::new(/* snip */).into(), ); let payload = SignedPayload::new(call.clone(), tx_ext.clone()).unwrap(); let signature = payload.using_encoded(|e| sender.sign(e)); UncheckedExtrinsic::new_signed( /* snip */ Signature::Sr25519(signature), tx_ext, ) } ``` ### SOON: Migrating to `TransactionExtension` Most `SignedExtension`s can be trivially converted to become a `TransactionExtension`. There are a few things to know. - Instead of a single trait like `SignedExtension`, you should now implement two traits individually: `TransactionExtensionBase` and `TransactionExtension`. - Weights are now a thing and must be provided via the new function `fn weight`. #### `TransactionExtensionBase` This trait takes care of anything which is not dependent on types specific to your runtime, most notably `Call`. - `AdditionalSigned`/`additional_signed` is renamed to `Implicit`/`implicit`. - Weight must be returned by implementing the `weight` function. If your extension is associated with a pallet, you'll probably want to do this via the pallet's existing benchmarking infrastructure. #### `TransactionExtension` Generally: - `pre_dispatch` is now `prepare` and you *should not reexecute the `validate` functionality in there*! - You don't get an account ID any more; you get an origin instead. If you need to presume an account ID, then you can use the trait function `AsSystemOriginSigner::as_system_origin_signer`. - You get an additional ticket, similar to `Pre`, called `Val`. This defines data which is passed from `validate` into `prepare`. This is important since you should not be duplicating logic from `validate` to `prepare`, you need a way of passing your working from the former into the latter. This is it. - This trait takes two type parameters: `Call` and `Context`. `Call` is the runtime call type which used to be an associated type; you can just move it to become a type parameter for your trait impl. `Context` is not currently used and you can safely implement over it as an unbounded type. - There's no `AccountId` associated type any more. Just remove it. Regarding `validate`: - You get three new parameters in `validate`; all can be ignored when migrating from `SignedExtension`. - `validate` returns a tuple on success; the second item in the tuple is the new ticket type `Self::Val` which gets passed in to `prepare`. If you use any information extracted during `validate` (off-chain and on-chain, non-mutating) in `prepare` (on-chain, mutating) then you can pass it through with this. For the tuple's last item, just return the `origin` argument. Regarding `prepare`: - This is renamed from `pre_dispatch`, but there is one change: - FUNCTIONALITY TO VALIDATE THE TRANSACTION NEED NOT BE DUPLICATED FROM `validate`!! - (This is different to `SignedExtension` which was required to run the same checks in `pre_dispatch` as in `validate`.) Regarding `post_dispatch`: - Since there are no unsigned transactions handled by `TransactionExtension`, `Pre` is always defined, so the first parameter is `Self::Pre` rather than `Option<Self::Pre>`. If you make use of `SignedExtension::validate_unsigned` or `SignedExtension::pre_dispatch_unsigned`, then: - Just use the regular versions of these functions instead. - Have your logic execute in the case that the `origin` is `None`. - Ensure your transaction creation logic creates a General Transaction rather than a Bare Transaction; this means having to include all `TransactionExtension`s' data. - `ValidateUnsigned` can still be used (for now) if you need to be able to construct transactions which contain none of the extension data, however these will be phased out in stage 2 of the Transactions Horizon, so you should consider moving to an extension-centric design. ## TODO - [x] Introduce `CheckSignature` impl of `TransactionExtension` to ensure it's possible to have crypto be done wholly in a `TransactionExtension`. - [x] Deprecate `SignedExtension` and move all uses in codebase to `TransactionExtension`. - [x] `ChargeTransactionPayment` - [x] `DummyExtension` - [x] `ChargeAssetTxPayment` (asset-tx-payment) - [x] `ChargeAssetTxPayment` (asset-conversion-tx-payment) - [x] `CheckWeight` - [x] `CheckTxVersion` - [x] `CheckSpecVersion` - [x] `CheckNonce` - [x] `CheckNonZeroSender` - [x] `CheckMortality` - [x] `CheckGenesis` - [x] `CheckOnlySudoAccount` - [x] `WatchDummy` - [x] `PrevalidateAttests` - [x] `GenericSignedExtension` - [x] `SignedExtension` (chain-polkadot-bulletin) - [x] `RefundSignedExtensionAdapter` - [x] Implement `fn weight` across the board. - [ ] Go through all pre-existing extensions which assume an account signer and explicitly handle the possibility of another kind of origin. - [x] `CheckNonce` should probably succeed in the case of a non-account origin. - [x] `CheckNonZeroSender` should succeed in the case of a non-account origin. - [x] `ChargeTransactionPayment` and family should fail in the case of a non-account origin. - [ ] - [x] Fix any broken tests. --------- Signed-off-by: georgepisaltu <george.pisaltu@parity.io> Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io> Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> Signed-off-by: Alexandru Gheorghe <alexandru.gheorghe@parity.io> Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> Co-authored-by: Nikhil Gupta <17176722+gupnik@users.noreply.github.com> Co-authored-by: georgepisaltu <52418509+georgepisaltu@users.noreply.github.com> Co-authored-by: Chevdor <chevdor@users.noreply.github.com> Co-authored-by: Bastian Köcher <git@kchr.de> Co-authored-by: Maciej <maciej.zyszkiewicz@parity.io> Co-authored-by: Javier Viola <javier@parity.io> Co-authored-by: Marcin S. <marcin@realemail.net> Co-authored-by: Tsvetomir Dimitrov <tsvetomir@parity.io> Co-authored-by: Javier Bullrich <javier@bullrich.dev> Co-authored-by: Koute <koute@users.noreply.github.com> Co-authored-by: Adrian Catangiu <adrian@parity.io> Co-authored-by: Vladimir Istyufeev <vladimir@parity.io> Co-authored-by: Ross Bulat <ross@parity.io> Co-authored-by: Gonçalo Pestana <g6pestana@gmail.com> Co-authored-by: Liam Aharon <liam.aharon@hotmail.com> Co-authored-by: Svyatoslav Nikolsky <svyatonik@gmail.com> Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com> Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> Co-authored-by: s0me0ne-unkn0wn <48632512+s0me0ne-unkn0wn@users.noreply.github.com> Co-authored-by: ordian <write@reusable.software> Co-authored-by: Sebastian Kunert <skunert49@gmail.com> Co-authored-by: Aaro Altonen <48052676+altonen@users.noreply.github.com> Co-authored-by: Dmitry Markin <dmitry@markin.tech> Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com> Co-authored-by: Alexander Samusev <41779041+alvicsam@users.noreply.github.com> Co-authored-by: Julian Eager <eagr@tutanota.com> Co-authored-by: Michal Kucharczyk <1728078+michalkucharczyk@users.noreply.github.com> Co-authored-by: Davide Galassi <davxy@datawok.net> Co-authored-by: Dónal Murray <donal.murray@parity.io> Co-authored-by: yjh <yjh465402634@gmail.com> Co-authored-by: Tom Mi <tommi@niemi.lol> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Will | Paradox | ParaNodes.io <79228812+paradox-tt@users.noreply.github.com> Co-authored-by: Bastian Köcher <info@kchr.de> Co-authored-by: Joshy Orndorff <JoshOrndorff@users.noreply.github.com> Co-authored-by: Joshy Orndorff <git-user-email.h0ly5@simplelogin.com> Co-authored-by: PG Herveou <pgherveou@gmail.com> Co-authored-by: Alexander Theißen <alex.theissen@me.com> Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> Co-authored-by: Juan Girini <juangirini@gmail.com> Co-authored-by: bader y <ibnbassem@gmail.com> Co-authored-by: James Wilson <james@jsdw.me> Co-authored-by: joe petrowski <25483142+joepetrowski@users.noreply.github.com> Co-authored-by: asynchronous rob <rphmeier@gmail.com> Co-authored-by: Parth <desaiparth08@gmail.com> Co-authored-by: Andrew Jones <ascjones@gmail.com> Co-authored-by: Jonathan Udd <jonathan@dwellir.com> Co-authored-by: Serban Iorga <serban@parity.io> Co-authored-by: Egor_P <egor@parity.io> Co-authored-by: Branislav Kontur <bkontur@gmail.com> Co-authored-by: Evgeny Snitko <evgeny@parity.io> Co-authored-by: Just van Stam <vstam1@users.noreply.github.com> Co-authored-by: Francisco Aguirre <franciscoaguirreperez@gmail.com> Co-authored-by: gupnik <nikhilgupta.iitk@gmail.com> Co-authored-by: dzmitry-lahoda <dzmitry@lahoda.pro> Co-authored-by: zhiqiangxu <652732310@qq.com> Co-authored-by: Nazar Mokrynskyi <nazar@mokrynskyi.com> Co-authored-by: Anwesh <anweshknayak@gmail.com> Co-authored-by: cheme <emericchevalier.pro@gmail.com> Co-authored-by: Sam Johnson <sam@durosoft.com> Co-authored-by: kianenigma <kian@parity.io> Co-authored-by: Jegor Sidorenko <5252494+jsidorenko@users.noreply.github.com> Co-authored-by: Muharem <ismailov.m.h@gmail.com> Co-authored-by: joepetrowski <joe@parity.io> Co-authored-by: Alexandru Gheorghe <49718502+alexggh@users.noreply.github.com> Co-authored-by: Gabriel Facco de Arruda <arrudagates@gmail.com> Co-authored-by: Squirrel <gilescope@gmail.com> Co-authored-by: Andrei Sandu <54316454+sandreim@users.noreply.github.com> Co-authored-by: georgepisaltu <george.pisaltu@parity.io> Co-authored-by: command-bot <>
This commit is contained in:
+61









Gavin Wood
Nikhil Gupta
georgepisaltu
Chevdor
Bastian Köcher
Maciej
Javier Viola
Marcin S.
Tsvetomir Dimitrov
Javier Bullrich
Koute
Adrian Catangiu
Vladimir Istyufeev
Ross Bulat
Gonçalo Pestana
Liam Aharon
Svyatoslav Nikolsky
André Silva
Oliver Tale-Yazdi
s0me0ne-unkn0wn
ordian
Sebastian Kunert
Aaro Altonen
Dmitry Markin
Alexandru Vasile
Alexander Samusev
Julian Eager
Michal Kucharczyk
Davide Galassi
Dónal Murray
yjh
Tom Mi
dependabot[bot]
Will | Paradox | ParaNodes.io
Bastian Köcher
Joshy Orndorff
Joshy Orndorff
PG Herveou
Alexander Theißen
Kian Paimani
Juan Girini
bader y
James Wilson
joe petrowski
asynchronous rob
Parth
Andrew Jones
Jonathan Udd
Serban Iorga
Egor_P
Branislav Kontur
Evgeny Snitko
Just van Stam
Francisco Aguirre
gupnik
dzmitry-lahoda
zhiqiangxu
Nazar Mokrynskyi
Anwesh
cheme
Sam Johnson
kianenigma
Jegor Sidorenko
Muharem
joepetrowski
Alexandru Gheorghe
Gabriel Facco de Arruda
Squirrel
Andrei Sandu
georgepisaltu
command-bot authored and
GitHub committed 2024-03-04 19:12:43 +00:00
1 parent
b0741d4f78
commit
fd5f9292f5
349 files changed
+25580
-17081
No files matched your search
@@ -21,6 +21,7 @@ codec = { package = "parity-scale-codec", version = "3.6.1", default-features =
|
||||
] }
|
||||
scale-info = { version = "2.10.0", default-features = false, features = ["derive"] }
|
||||
serde = { optional = true, workspace = true, default-features = true }
|
||||
frame-benchmarking = { path = "../benchmarking", default-features = false, optional = true }
|
||||
frame-support = { path = "../support", default-features = false }
|
||||
frame-system = { path = "../system", default-features = false }
|
||||
sp-core = { path = "../../primitives/core", default-features = false }
|
||||
@@ -36,6 +37,7 @@ pallet-balances = { path = "../balances" }
|
||||
default = ["std"]
|
||||
std = [
|
||||
"codec/std",
|
||||
"frame-benchmarking?/std",
|
||||
"frame-support/std",
|
||||
"frame-system/std",
|
||||
"pallet-balances/std",
|
||||
@@ -46,6 +48,13 @@ std = [
|
||||
"sp-runtime/std",
|
||||
"sp-std/std",
|
||||
]
|
||||
runtime-benchmarks = [
|
||||
"frame-benchmarking/runtime-benchmarks",
|
||||
"frame-support/runtime-benchmarks",
|
||||
"frame-system/runtime-benchmarks",
|
||||
"pallet-balances/runtime-benchmarks",
|
||||
"sp-runtime/runtime-benchmarks",
|
||||
]
|
||||
try-runtime = [
|
||||
"frame-support/try-runtime",
|
||||
"frame-system/try-runtime",
|
||||
|
||||
@@ -19,6 +19,7 @@ targets = ["x86_64-unknown-linux-gnu"]
|
||||
# Substrate dependencies
|
||||
sp-runtime = { path = "../../../primitives/runtime", default-features = false }
|
||||
sp-std = { path = "../../../primitives/std", default-features = false }
|
||||
frame-benchmarking = { path = "../../benchmarking", default-features = false, optional = true }
|
||||
frame-support = { path = "../../support", default-features = false }
|
||||
frame-system = { path = "../../system", default-features = false }
|
||||
pallet-asset-conversion = { path = "../../asset-conversion", default-features = false }
|
||||
@@ -37,6 +38,7 @@ pallet-balances = { path = "../../balances" }
|
||||
default = ["std"]
|
||||
std = [
|
||||
"codec/std",
|
||||
"frame-benchmarking?/std",
|
||||
"frame-support/std",
|
||||
"frame-system/std",
|
||||
"pallet-asset-conversion/std",
|
||||
@@ -50,6 +52,16 @@ std = [
|
||||
"sp-std/std",
|
||||
"sp-storage/std",
|
||||
]
|
||||
runtime-benchmarks = [
|
||||
"frame-benchmarking/runtime-benchmarks",
|
||||
"frame-support/runtime-benchmarks",
|
||||
"frame-system/runtime-benchmarks",
|
||||
"pallet-asset-conversion/runtime-benchmarks",
|
||||
"pallet-assets/runtime-benchmarks",
|
||||
"pallet-balances/runtime-benchmarks",
|
||||
"pallet-transaction-payment/runtime-benchmarks",
|
||||
"sp-runtime/runtime-benchmarks",
|
||||
]
|
||||
try-runtime = [
|
||||
"frame-support/try-runtime",
|
||||
"frame-system/try-runtime",
|
||||
|
||||
@@ -16,6 +16,6 @@ asset.
|
||||
### Integration
|
||||
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 [`SignedExtension`] ([`ChargeAssetTxPayment`]).
|
||||
pallet's [`TransactionExtension`] ([`ChargeAssetTxPayment`]).
|
||||
|
||||
License: Apache-2.0
|
||||
@@ -0,0 +1,125 @@
|
||||
// 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);
|
||||
}
|
||||
@@ -20,8 +20,8 @@
|
||||
//!
|
||||
//! ## Overview
|
||||
//!
|
||||
//! 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
|
||||
//! 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
|
||||
//! [`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 [`SignedExtension`]
|
||||
//! your `construct_runtime` macro, but only include this pallet's [`TransactionExtension`]
|
||||
//! ([`ChargeAssetTxPayment`]).
|
||||
//!
|
||||
//! ## Terminology
|
||||
@@ -53,23 +53,29 @@ use frame_support::{
|
||||
},
|
||||
DefaultNoBound,
|
||||
};
|
||||
use pallet_transaction_payment::OnChargeTransaction;
|
||||
use pallet_transaction_payment::{ChargeTransactionPayment, OnChargeTransaction};
|
||||
use scale_info::TypeInfo;
|
||||
use sp_runtime::{
|
||||
traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension, Zero},
|
||||
transaction_validity::{
|
||||
InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
|
||||
traits::{
|
||||
AsSystemOriginSigner, DispatchInfoOf, Dispatchable, PostDispatchInfoOf,
|
||||
TransactionExtension, TransactionExtensionBase, ValidateResult, Zero,
|
||||
},
|
||||
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::traits::tokens::AssetId;
|
||||
use frame_support::{pallet_prelude::Weight, traits::tokens::AssetId};
|
||||
pub use payment::*;
|
||||
pub use weights::WeightInfo;
|
||||
|
||||
/// Type aliases used for interaction with `OnChargeTransaction`.
|
||||
pub(crate) type OnChargeTransactionOf<T> =
|
||||
@@ -125,11 +131,30 @@ 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> {
|
||||
@@ -179,9 +204,8 @@ where
|
||||
who: &T::AccountId,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
fee: BalanceOf<T>,
|
||||
) -> 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))
|
||||
@@ -225,9 +249,8 @@ impl<T: Config> sp_std::fmt::Debug for ChargeAssetTxPayment<T> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config> SignedExtension for ChargeAssetTxPayment<T>
|
||||
impl<T: Config> TransactionExtensionBase for ChargeAssetTxPayment<T>
|
||||
where
|
||||
T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
|
||||
AssetBalanceOf<T>: Send + Sync,
|
||||
BalanceOf<T>: Send
|
||||
+ Sync
|
||||
@@ -238,109 +261,145 @@ where
|
||||
ChargeAssetIdOf<T>: Send + Sync,
|
||||
{
|
||||
const IDENTIFIER: &'static str = "ChargeAssetTxPayment";
|
||||
type AccountId = T::AccountId;
|
||||
type Call = T::RuntimeCall;
|
||||
type AdditionalSigned = ();
|
||||
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>
|
||||
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,
|
||||
<T::RuntimeCall as Dispatchable>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId> + Clone,
|
||||
{
|
||||
type Val = (
|
||||
// tip
|
||||
BalanceOf<T>,
|
||||
// who paid the fee
|
||||
T::AccountId,
|
||||
// transaction fee
|
||||
BalanceOf<T>,
|
||||
);
|
||||
type Pre = (
|
||||
// tip
|
||||
BalanceOf<T>,
|
||||
// who paid the fee
|
||||
Self::AccountId,
|
||||
T::AccountId,
|
||||
// imbalance resulting from withdrawing the fee
|
||||
InitialPayment<T>,
|
||||
// asset_id for the transaction payment
|
||||
Option<ChargeAssetIdOf<T>>,
|
||||
);
|
||||
|
||||
fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn validate(
|
||||
&self,
|
||||
who: &Self::AccountId,
|
||||
call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
origin: <T::RuntimeCall as Dispatchable>::RuntimeOrigin,
|
||||
_call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
) -> TransactionValidity {
|
||||
use pallet_transaction_payment::ChargeTransactionPayment;
|
||||
let (fee, _) = self.withdraw_fee(who, call, info, len)?;
|
||||
_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);
|
||||
Ok(ValidTransaction { priority, ..Default::default() })
|
||||
let validity = ValidTransaction { priority, ..Default::default() };
|
||||
let val = (self.tip, who.clone(), fee);
|
||||
Ok((validity, val, origin))
|
||||
}
|
||||
|
||||
fn pre_dispatch(
|
||||
fn prepare(
|
||||
self,
|
||||
who: &Self::AccountId,
|
||||
call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
len: usize,
|
||||
val: Self::Val,
|
||||
_origin: &<T::RuntimeCall as Dispatchable>::RuntimeOrigin,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
_len: usize,
|
||||
_context: &Context,
|
||||
) -> Result<Self::Pre, TransactionValidityError> {
|
||||
let (_fee, initial_payment) = self.withdraw_fee(who, call, info, len)?;
|
||||
Ok((self.tip, who.clone(), initial_payment, self.asset_id))
|
||||
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()))
|
||||
}
|
||||
|
||||
fn post_dispatch(
|
||||
pre: Option<Self::Pre>,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
post_info: &PostDispatchInfoOf<Self::Call>,
|
||||
pre: Self::Pre,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
post_info: &PostDispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
result: &DispatchResult,
|
||||
_context: &Context,
|
||||
) -> Result<(), TransactionValidityError> {
|
||||
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)),
|
||||
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,
|
||||
info,
|
||||
post_info,
|
||||
len,
|
||||
result,
|
||||
actual_fee.into(),
|
||||
tip.into(),
|
||||
used_for_fee.into(),
|
||||
received_exchanged.into(),
|
||||
asset_id.clone(),
|
||||
asset_consumed.into(),
|
||||
)?;
|
||||
},
|
||||
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,
|
||||
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.");
|
||||
},
|
||||
}
|
||||
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(())
|
||||
|
||||
@@ -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,4 +269,72 @@ 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);
|
||||
}
|
||||
}
|
||||
@@ -28,7 +28,10 @@ use frame_support::{
|
||||
use frame_system as system;
|
||||
use mock::{ExtrinsicBaseWeight, *};
|
||||
use pallet_balances::Call as BalancesCall;
|
||||
use sp_runtime::{traits::StaticLookup, BuildStorage};
|
||||
use sp_runtime::{
|
||||
traits::{DispatchTransaction, StaticLookup},
|
||||
BuildStorage,
|
||||
};
|
||||
|
||||
const CALL: &<Runtime as frame_system::Config>::RuntimeCall =
|
||||
&RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
|
||||
@@ -160,33 +163,35 @@ fn transaction_payment_in_native_possible() {
|
||||
.build()
|
||||
.execute_with(|| {
|
||||
let len = 10;
|
||||
let pre = ChargeAssetTxPayment::<Runtime>::from(0, None)
|
||||
.pre_dispatch(&1, CALL, &info_from_weight(WEIGHT_5), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, None)
|
||||
.validate_and_prepare(Some(1).into(), 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(
|
||||
Some(pre),
|
||||
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)
|
||||
.pre_dispatch(&2, CALL, &info_from_weight(WEIGHT_100), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(5 /* tipped */, None)
|
||||
.validate_and_prepare(Some(2).into(), 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(
|
||||
Some(pre),
|
||||
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);
|
||||
});
|
||||
@@ -237,8 +242,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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), CALL, &info_from_weight(WEIGHT_5), len)
|
||||
.unwrap();
|
||||
// assert that native balance is not used
|
||||
assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
|
||||
@@ -247,11 +252,12 @@ fn transaction_payment_in_asset_possible() {
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
|
||||
|
||||
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
|
||||
Some(pre),
|
||||
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);
|
||||
@@ -289,12 +295,8 @@ 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)).pre_dispatch(
|
||||
&caller,
|
||||
CALL,
|
||||
&info_from_weight(WEIGHT_5),
|
||||
len,
|
||||
);
|
||||
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), 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());
|
||||
@@ -344,8 +346,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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), CALL, &info_from_weight(WEIGHT_5), len)
|
||||
.unwrap();
|
||||
|
||||
// assert that native balance is not used
|
||||
@@ -363,11 +365,12 @@ fn transaction_payment_without_fee() {
|
||||
assert_eq!(refund, 199);
|
||||
|
||||
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
|
||||
Some(pre),
|
||||
pre,
|
||||
&info_from_weight(WEIGHT_5),
|
||||
&post_info_from_pays(Pays::No),
|
||||
len,
|
||||
&Ok(())
|
||||
&Ok(()),
|
||||
&()
|
||||
));
|
||||
|
||||
// caller should get refunded
|
||||
@@ -419,8 +422,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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_100), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(tip, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), CALL, &info_from_weight(WEIGHT_100), len)
|
||||
.unwrap();
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
|
||||
|
||||
@@ -435,11 +438,12 @@ fn asset_transaction_payment_with_tip_and_refund() {
|
||||
.unwrap();
|
||||
|
||||
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
|
||||
Some(pre),
|
||||
pre,
|
||||
&info_from_weight(WEIGHT_100),
|
||||
&post_info_from_weight(WEIGHT_50),
|
||||
len,
|
||||
&Ok(())
|
||||
&Ok(()),
|
||||
&()
|
||||
));
|
||||
|
||||
assert_eq!(TipUnbalancedAmount::get(), tip);
|
||||
@@ -500,8 +504,8 @@ fn payment_from_account_with_only_assets() {
|
||||
.unwrap();
|
||||
assert_eq!(fee_in_asset, 301);
|
||||
|
||||
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), CALL, &info_from_weight(WEIGHT_5), len)
|
||||
.unwrap();
|
||||
assert_eq!(Balances::free_balance(caller), ed);
|
||||
// check that fee was charged in the given asset
|
||||
@@ -516,11 +520,12 @@ fn payment_from_account_with_only_assets() {
|
||||
.unwrap();
|
||||
|
||||
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
|
||||
Some(pre),
|
||||
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);
|
||||
@@ -565,18 +570,19 @@ 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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), 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(
|
||||
Some(pre),
|
||||
pre,
|
||||
&info_from_pays(Pays::No),
|
||||
&post_info_from_pays(Pays::No),
|
||||
len,
|
||||
&Ok(())
|
||||
&Ok(()),
|
||||
&()
|
||||
));
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance);
|
||||
}
|
||||
@@ -591,17 +597,23 @@ fn converted_fee_is_never_zero_if_input_fee_is_not() {
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
|
||||
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,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
|
||||
|
||||
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
|
||||
Some(pre),
|
||||
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);
|
||||
});
|
||||
@@ -641,8 +653,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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), CALL, &info_from_pays(Pays::No), len)
|
||||
.unwrap();
|
||||
// `Pays::No` implies no pre-dispatch fees
|
||||
|
||||
@@ -658,62 +670,12 @@ 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(
|
||||
Some(pre),
|
||||
pre,
|
||||
&info_from_pays(Pays::No),
|
||||
&post_info_from_pays(Pays::Yes),
|
||||
len,
|
||||
&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(())
|
||||
&Ok(()),
|
||||
&()
|
||||
));
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance);
|
||||
});
|
||||
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
// 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))
|
||||
}
|
||||
}
|
||||
@@ -66,6 +66,7 @@ runtime-benchmarks = [
|
||||
"frame-system/runtime-benchmarks",
|
||||
"pallet-assets/runtime-benchmarks",
|
||||
"pallet-balances/runtime-benchmarks",
|
||||
"pallet-transaction-payment/runtime-benchmarks",
|
||||
"sp-runtime/runtime-benchmarks",
|
||||
]
|
||||
try-runtime = [
|
||||
|
||||
@@ -16,6 +16,6 @@ asset.
|
||||
### Integration
|
||||
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 [`SignedExtension`] ([`ChargeAssetTxPayment`]).
|
||||
pallet's [`TransactionExtension`] ([`ChargeAssetTxPayment`]).
|
||||
|
||||
License: Apache-2.0
|
||||
@@ -0,0 +1,123 @@
|
||||
// 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);
|
||||
}
|
||||
@@ -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 [`SignedExtension`] ([`ChargeAssetTxPayment`]).
|
||||
//! pallet's [`TransactionExtension`] ([`ChargeAssetTxPayment`]).
|
||||
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
@@ -40,6 +40,7 @@ use sp_std::prelude::*;
|
||||
use codec::{Decode, Encode};
|
||||
use frame_support::{
|
||||
dispatch::{DispatchInfo, DispatchResult, PostDispatchInfo},
|
||||
pallet_prelude::Weight,
|
||||
traits::{
|
||||
tokens::{
|
||||
fungibles::{Balanced, Credit, Inspect},
|
||||
@@ -52,10 +53,11 @@ use frame_support::{
|
||||
use pallet_transaction_payment::OnChargeTransaction;
|
||||
use scale_info::TypeInfo;
|
||||
use sp_runtime::{
|
||||
traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension, Zero},
|
||||
transaction_validity::{
|
||||
InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
|
||||
traits::{
|
||||
AsSystemOriginSigner, DispatchInfoOf, Dispatchable, PostDispatchInfoOf,
|
||||
TransactionExtension, TransactionExtensionBase, Zero,
|
||||
},
|
||||
transaction_validity::{InvalidTransaction, TransactionValidityError, ValidTransaction},
|
||||
};
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -63,8 +65,14 @@ 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> =
|
||||
@@ -120,11 +128,30 @@ 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> {
|
||||
@@ -172,9 +199,8 @@ where
|
||||
who: &T::AccountId,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
fee: BalanceOf<T>,
|
||||
) -> 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))
|
||||
@@ -209,104 +235,139 @@ impl<T: Config> sp_std::fmt::Debug for ChargeAssetTxPayment<T> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config> SignedExtension for ChargeAssetTxPayment<T>
|
||||
impl<T: Config> TransactionExtensionBase 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>>,
|
||||
{
|
||||
const IDENTIFIER: &'static str = "ChargeAssetTxPayment";
|
||||
type AccountId = T::AccountId;
|
||||
type Call = T::RuntimeCall;
|
||||
type AdditionalSigned = ();
|
||||
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>
|
||||
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>,
|
||||
);
|
||||
type Pre = (
|
||||
// tip
|
||||
BalanceOf<T>,
|
||||
// who paid the fee
|
||||
Self::AccountId,
|
||||
T::AccountId,
|
||||
// imbalance resulting from withdrawing the fee
|
||||
InitialPayment<T>,
|
||||
// asset_id for the transaction payment
|
||||
Option<ChargeAssetIdOf<T>>,
|
||||
);
|
||||
|
||||
fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn validate(
|
||||
&self,
|
||||
who: &Self::AccountId,
|
||||
call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
origin: <T::RuntimeCall as Dispatchable>::RuntimeOrigin,
|
||||
_call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
) -> TransactionValidity {
|
||||
_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 (fee, _) = self.withdraw_fee(who, call, info, len)?;
|
||||
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);
|
||||
Ok(ValidTransaction { priority, ..Default::default() })
|
||||
let val = (self.tip, who.clone(), fee);
|
||||
let validity = ValidTransaction { priority, ..Default::default() };
|
||||
Ok((validity, val, origin))
|
||||
}
|
||||
|
||||
fn pre_dispatch(
|
||||
fn prepare(
|
||||
self,
|
||||
who: &Self::AccountId,
|
||||
call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
len: usize,
|
||||
val: Self::Val,
|
||||
_origin: &<T::RuntimeCall as Dispatchable>::RuntimeOrigin,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
_len: usize,
|
||||
_context: &Context,
|
||||
) -> Result<Self::Pre, TransactionValidityError> {
|
||||
let (_fee, initial_payment) = self.withdraw_fee(who, call, info, len)?;
|
||||
Ok((self.tip, who.clone(), initial_payment, self.asset_id))
|
||||
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))
|
||||
}
|
||||
|
||||
fn post_dispatch(
|
||||
pre: Option<Self::Pre>,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
post_info: &PostDispatchInfoOf<Self::Call>,
|
||||
pre: Self::Pre,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
post_info: &PostDispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
result: &DispatchResult,
|
||||
_context: &Context,
|
||||
) -> Result<(), TransactionValidityError> {
|
||||
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)),
|
||||
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,
|
||||
info,
|
||||
post_info,
|
||||
len,
|
||||
result,
|
||||
actual_fee.into(),
|
||||
tip.into(),
|
||||
already_withdrawn.into(),
|
||||
)?;
|
||||
},
|
||||
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.");
|
||||
},
|
||||
}
|
||||
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(())
|
||||
|
||||
@@ -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,4 +205,56 @@ 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);
|
||||
}
|
||||
}
|
||||
@@ -25,7 +25,10 @@ use frame_support::{
|
||||
use frame_system as system;
|
||||
use mock::{ExtrinsicBaseWeight, *};
|
||||
use pallet_balances::Call as BalancesCall;
|
||||
use sp_runtime::{traits::StaticLookup, BuildStorage};
|
||||
use sp_runtime::{
|
||||
traits::{DispatchTransaction, StaticLookup},
|
||||
BuildStorage,
|
||||
};
|
||||
|
||||
const CALL: &<Runtime as frame_system::Config>::RuntimeCall =
|
||||
&RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
|
||||
@@ -116,33 +119,45 @@ fn transaction_payment_in_native_possible() {
|
||||
.build()
|
||||
.execute_with(|| {
|
||||
let len = 10;
|
||||
let pre = ChargeAssetTxPayment::<Runtime>::from(0, None)
|
||||
.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(5, 0)), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, None)
|
||||
.validate_and_prepare(
|
||||
Some(1).into(),
|
||||
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(
|
||||
Some(pre),
|
||||
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)
|
||||
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(5 /* tipped */, None)
|
||||
.validate_and_prepare(
|
||||
Some(2).into(),
|
||||
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(
|
||||
Some(pre),
|
||||
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);
|
||||
});
|
||||
@@ -179,8 +194,13 @@ 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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
|
||||
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,
|
||||
)
|
||||
.unwrap();
|
||||
// assert that native balance is not used
|
||||
assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
|
||||
@@ -189,11 +209,12 @@ fn transaction_payment_in_asset_possible() {
|
||||
assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), 0);
|
||||
|
||||
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
|
||||
Some(pre),
|
||||
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
|
||||
@@ -232,8 +253,13 @@ 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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
|
||||
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,
|
||||
)
|
||||
.unwrap();
|
||||
// assert that native balance is not used
|
||||
assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
|
||||
@@ -242,11 +268,12 @@ fn transaction_payment_without_fee() {
|
||||
assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), 0);
|
||||
|
||||
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
|
||||
Some(pre),
|
||||
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);
|
||||
@@ -287,18 +314,24 @@ 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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
|
||||
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,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance - fee_with_tip);
|
||||
|
||||
let final_weight = 50;
|
||||
assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
|
||||
Some(pre),
|
||||
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();
|
||||
@@ -339,19 +372,25 @@ 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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
|
||||
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,
|
||||
)
|
||||
.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(
|
||||
Some(pre),
|
||||
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);
|
||||
@@ -372,7 +411,12 @@ 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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
|
||||
.validate_and_prepare(
|
||||
Some(caller).into(),
|
||||
CALL,
|
||||
&info_from_weight(Weight::from_parts(weight, 0)),
|
||||
len
|
||||
)
|
||||
.is_err());
|
||||
|
||||
// create the non-sufficient asset
|
||||
@@ -386,7 +430,12 @@ fn payment_only_with_existing_sufficient_asset() {
|
||||
));
|
||||
// pre_dispatch fails for non-sufficient asset
|
||||
assert!(ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
|
||||
.validate_and_prepare(
|
||||
Some(caller).into(),
|
||||
CALL,
|
||||
&info_from_weight(Weight::from_parts(weight, 0)),
|
||||
len
|
||||
)
|
||||
.is_err());
|
||||
});
|
||||
}
|
||||
@@ -424,33 +473,40 @@ 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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), 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(
|
||||
Some(pre),
|
||||
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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
|
||||
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,
|
||||
)
|
||||
.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(
|
||||
Some(pre),
|
||||
pre,
|
||||
&info_from_weight(Weight::from_parts(weight, 0)),
|
||||
&default_post_info(),
|
||||
len,
|
||||
&Ok(())
|
||||
&Ok(()),
|
||||
&()
|
||||
));
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance - 1);
|
||||
});
|
||||
@@ -488,8 +544,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))
|
||||
.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
|
||||
let (pre, _) = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
|
||||
.validate_and_prepare(Some(caller).into(), CALL, &info_from_pays(Pays::No), len)
|
||||
.unwrap();
|
||||
// `Pays::No` implies no pre-dispatch fees
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance);
|
||||
@@ -503,60 +559,12 @@ 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(
|
||||
Some(pre),
|
||||
pre,
|
||||
&info_from_pays(Pays::No),
|
||||
&post_info_from_pays(Pays::Yes),
|
||||
len,
|
||||
&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(())
|
||||
&Ok(()),
|
||||
&()
|
||||
));
|
||||
assert_eq!(Assets::balance(asset_id, caller), balance);
|
||||
});
|
||||
|
||||
@@ -0,0 +1,146 @@
|
||||
// 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))
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,7 @@
|
||||
//!
|
||||
//! ## Overview
|
||||
//!
|
||||
//! It does this by wrapping an existing [`SignedExtension`] implementation (e.g.
|
||||
//! It does this by wrapping an existing [`TransactionExtension`] implementation (e.g.
|
||||
//! [`pallet-transaction-payment`]) and checking if the dispatchable is feeless before applying the
|
||||
//! wrapped extension. If the dispatchable is indeed feeless, the extension is skipped and a custom
|
||||
//! event is emitted instead. Otherwise, the extension is applied as usual.
|
||||
@@ -31,7 +31,8 @@
|
||||
//!
|
||||
//! This pallet wraps an existing transaction payment pallet. This means you should both pallets
|
||||
//! in your `construct_runtime` macro and include this pallet's
|
||||
//! [`SignedExtension`] ([`SkipCheckIfFeeless`]) that would accept the existing one as an argument.
|
||||
//! [`TransactionExtension`] ([`SkipCheckIfFeeless`]) that would accept the existing one as an
|
||||
//! argument.
|
||||
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
@@ -42,7 +43,10 @@ use frame_support::{
|
||||
};
|
||||
use scale_info::{StaticTypeInfo, TypeInfo};
|
||||
use sp_runtime::{
|
||||
traits::{DispatchInfoOf, PostDispatchInfoOf, SignedExtension},
|
||||
traits::{
|
||||
DispatchInfoOf, OriginOf, PostDispatchInfoOf, TransactionExtension,
|
||||
TransactionExtensionBase, ValidateResult,
|
||||
},
|
||||
transaction_validity::TransactionValidityError,
|
||||
};
|
||||
|
||||
@@ -70,11 +74,11 @@ pub mod pallet {
|
||||
#[pallet::generate_deposit(pub(super) fn deposit_event)]
|
||||
pub enum Event<T: Config> {
|
||||
/// A transaction fee was skipped.
|
||||
FeeSkipped { who: T::AccountId },
|
||||
FeeSkipped { origin: <T::RuntimeOrigin as OriginTrait>::PalletsOrigin },
|
||||
}
|
||||
}
|
||||
|
||||
/// A [`SignedExtension`] that skips the wrapped extension if the dispatchable is feeless.
|
||||
/// A [`TransactionExtension`] that skips the wrapped extension if the dispatchable is feeless.
|
||||
#[derive(Encode, Decode, Clone, Eq, PartialEq)]
|
||||
pub struct SkipCheckIfFeeless<T, S>(pub S, sp_std::marker::PhantomData<T>);
|
||||
|
||||
@@ -103,53 +107,96 @@ impl<T, S> From<S> for SkipCheckIfFeeless<T, S> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config + Send + Sync, S: SignedExtension<AccountId = T::AccountId>> SignedExtension
|
||||
pub enum Intermediate<T, O> {
|
||||
/// The wrapped extension should be applied.
|
||||
Apply(T),
|
||||
/// The wrapped extension should be skipped.
|
||||
Skip(O),
|
||||
}
|
||||
use Intermediate::*;
|
||||
|
||||
impl<T: Config + Send + Sync, S: TransactionExtensionBase> TransactionExtensionBase
|
||||
for SkipCheckIfFeeless<T, S>
|
||||
where
|
||||
S::Call: CheckIfFeeless<Origin = frame_system::pallet_prelude::OriginFor<T>>,
|
||||
{
|
||||
type AccountId = T::AccountId;
|
||||
type Call = S::Call;
|
||||
type AdditionalSigned = S::AdditionalSigned;
|
||||
type Pre = (Self::AccountId, Option<<S as SignedExtension>::Pre>);
|
||||
// From the outside this extension should be "invisible", because it just extends the wrapped
|
||||
// extension with an extra check in `pre_dispatch` and `post_dispatch`. Thus, we should forward
|
||||
// the identifier of the wrapped extension to let wallets see this extension as it would only be
|
||||
// the wrapped extension itself.
|
||||
const IDENTIFIER: &'static str = S::IDENTIFIER;
|
||||
type Implicit = S::Implicit;
|
||||
|
||||
fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
|
||||
self.0.additional_signed()
|
||||
fn implicit(&self) -> Result<Self::Implicit, TransactionValidityError> {
|
||||
self.0.implicit()
|
||||
}
|
||||
|
||||
fn pre_dispatch(
|
||||
self,
|
||||
who: &Self::AccountId,
|
||||
call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
fn weight(&self) -> frame_support::weights::Weight {
|
||||
self.0.weight()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config + Send + Sync, Context, S: TransactionExtension<T::RuntimeCall, Context>>
|
||||
TransactionExtension<T::RuntimeCall, Context> for SkipCheckIfFeeless<T, S>
|
||||
where
|
||||
T::RuntimeCall: CheckIfFeeless<Origin = frame_system::pallet_prelude::OriginFor<T>>,
|
||||
{
|
||||
type Val = Intermediate<S::Val, <OriginOf<T::RuntimeCall> as OriginTrait>::PalletsOrigin>;
|
||||
type Pre = Intermediate<S::Pre, <OriginOf<T::RuntimeCall> as OriginTrait>::PalletsOrigin>;
|
||||
|
||||
fn validate(
|
||||
&self,
|
||||
origin: OriginOf<T::RuntimeCall>,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
) -> Result<Self::Pre, TransactionValidityError> {
|
||||
if call.is_feeless(&<T as frame_system::Config>::RuntimeOrigin::signed(who.clone())) {
|
||||
Ok((who.clone(), None))
|
||||
context: &mut Context,
|
||||
self_implicit: S::Implicit,
|
||||
inherited_implication: &impl Encode,
|
||||
) -> ValidateResult<Self::Val, T::RuntimeCall> {
|
||||
if call.is_feeless(&origin) {
|
||||
Ok((Default::default(), Skip(origin.caller().clone()), origin))
|
||||
} else {
|
||||
Ok((who.clone(), Some(self.0.pre_dispatch(who, call, info, len)?)))
|
||||
let (x, y, z) = self.0.validate(
|
||||
origin,
|
||||
call,
|
||||
info,
|
||||
len,
|
||||
context,
|
||||
self_implicit,
|
||||
inherited_implication,
|
||||
)?;
|
||||
Ok((x, Apply(y), z))
|
||||
}
|
||||
}
|
||||
|
||||
fn prepare(
|
||||
self,
|
||||
val: Self::Val,
|
||||
origin: &OriginOf<T::RuntimeCall>,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
context: &Context,
|
||||
) -> Result<Self::Pre, TransactionValidityError> {
|
||||
match val {
|
||||
Apply(val) => self.0.prepare(val, origin, call, info, len, context).map(Apply),
|
||||
Skip(origin) => Ok(Skip(origin)),
|
||||
}
|
||||
}
|
||||
|
||||
fn post_dispatch(
|
||||
pre: Option<Self::Pre>,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
post_info: &PostDispatchInfoOf<Self::Call>,
|
||||
pre: Self::Pre,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
post_info: &PostDispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
result: &DispatchResult,
|
||||
context: &Context,
|
||||
) -> Result<(), TransactionValidityError> {
|
||||
if let Some(pre) = pre {
|
||||
if let Some(pre) = pre.1 {
|
||||
S::post_dispatch(Some(pre), info, post_info, len, result)?;
|
||||
} else {
|
||||
Pallet::<T>::deposit_event(Event::<T>::FeeSkipped { who: pre.0 });
|
||||
}
|
||||
match pre {
|
||||
Apply(pre) => S::post_dispatch(pre, info, post_info, len, result, context),
|
||||
Skip(origin) => {
|
||||
Pallet::<T>::deposit_event(Event::<T>::FeeSkipped { origin });
|
||||
Ok(())
|
||||
},
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -18,9 +18,12 @@ use crate as pallet_skip_feeless_payment;
|
||||
|
||||
use frame_support::{derive_impl, parameter_types};
|
||||
use frame_system as system;
|
||||
use sp_runtime::{
|
||||
impl_tx_ext_default,
|
||||
traits::{OriginOf, TransactionExtension},
|
||||
};
|
||||
|
||||
type Block = frame_system::mocking::MockBlock<Runtime>;
|
||||
type AccountId = u64;
|
||||
|
||||
#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
|
||||
impl frame_system::Config for Runtime {
|
||||
@@ -38,21 +41,22 @@ parameter_types! {
|
||||
#[derive(Clone, Eq, PartialEq, Debug, Encode, Decode, TypeInfo)]
|
||||
pub struct DummyExtension;
|
||||
|
||||
impl SignedExtension for DummyExtension {
|
||||
type AccountId = AccountId;
|
||||
type Call = RuntimeCall;
|
||||
type AdditionalSigned = ();
|
||||
type Pre = ();
|
||||
impl TransactionExtensionBase for DummyExtension {
|
||||
const IDENTIFIER: &'static str = "DummyExtension";
|
||||
fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
|
||||
Ok(())
|
||||
}
|
||||
fn pre_dispatch(
|
||||
type Implicit = ();
|
||||
}
|
||||
impl<C> TransactionExtension<RuntimeCall, C> for DummyExtension {
|
||||
type Val = ();
|
||||
type Pre = ();
|
||||
impl_tx_ext_default!(RuntimeCall; C; validate);
|
||||
fn prepare(
|
||||
self,
|
||||
_who: &Self::AccountId,
|
||||
_call: &Self::Call,
|
||||
_info: &DispatchInfoOf<Self::Call>,
|
||||
_val: Self::Val,
|
||||
_origin: &OriginOf<RuntimeCall>,
|
||||
_call: &RuntimeCall,
|
||||
_info: &DispatchInfoOf<RuntimeCall>,
|
||||
_len: usize,
|
||||
_context: &C,
|
||||
) -> Result<Self::Pre, TransactionValidityError> {
|
||||
PreDispatchCount::mutate(|c| *c += 1);
|
||||
Ok(())
|
||||
|
||||
@@ -16,18 +16,19 @@
|
||||
use super::*;
|
||||
use crate::mock::{pallet_dummy::Call, DummyExtension, PreDispatchCount, Runtime, RuntimeCall};
|
||||
use frame_support::dispatch::DispatchInfo;
|
||||
use sp_runtime::traits::DispatchTransaction;
|
||||
|
||||
#[test]
|
||||
fn skip_feeless_payment_works() {
|
||||
let call = RuntimeCall::DummyPallet(Call::<Runtime>::aux { data: 1 });
|
||||
SkipCheckIfFeeless::<Runtime, DummyExtension>::from(DummyExtension)
|
||||
.pre_dispatch(&0, &call, &DispatchInfo::default(), 0)
|
||||
.validate_and_prepare(Some(0).into(), &call, &DispatchInfo::default(), 0)
|
||||
.unwrap();
|
||||
assert_eq!(PreDispatchCount::get(), 1);
|
||||
|
||||
let call = RuntimeCall::DummyPallet(Call::<Runtime>::aux { data: 0 });
|
||||
SkipCheckIfFeeless::<Runtime, DummyExtension>::from(DummyExtension)
|
||||
.pre_dispatch(&0, &call, &DispatchInfo::default(), 0)
|
||||
.validate_and_prepare(Some(0).into(), &call, &DispatchInfo::default(), 0)
|
||||
.unwrap();
|
||||
assert_eq!(PreDispatchCount::get(), 1);
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
// 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);
|
||||
}
|
||||
@@ -62,23 +62,28 @@ pub use payment::*;
|
||||
use sp_runtime::{
|
||||
traits::{
|
||||
Convert, DispatchInfoOf, Dispatchable, One, PostDispatchInfoOf, SaturatedConversion,
|
||||
Saturating, SignedExtension, Zero,
|
||||
Saturating, TransactionExtension, TransactionExtensionBase, Zero,
|
||||
},
|
||||
transaction_validity::{
|
||||
TransactionPriority, TransactionValidity, TransactionValidityError, ValidTransaction,
|
||||
InvalidTransaction, TransactionPriority, 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;
|
||||
@@ -335,6 +340,7 @@ pub mod pallet {
|
||||
type RuntimeEvent = ();
|
||||
type FeeMultiplierUpdate = ();
|
||||
type OperationalFeeMultiplier = ();
|
||||
type WeightInfo = ();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -387,6 +393,9 @@ pub mod pallet {
|
||||
/// transactions.
|
||||
#[pallet::constant]
|
||||
type OperationalFeeMultiplier: Get<u8>;
|
||||
|
||||
/// The weight information of this pallet.
|
||||
type WeightInfo: WeightInfo;
|
||||
}
|
||||
|
||||
#[pallet::type_value]
|
||||
@@ -507,11 +516,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_signed().unwrap_or(false) {
|
||||
Self::compute_fee(len, &dispatch_info, 0u32.into())
|
||||
} else {
|
||||
// Unsigned extrinsics have no partial fee.
|
||||
let partial_fee = if unchecked_extrinsic.is_bare() {
|
||||
// Bare extrinsics have no partial fee.
|
||||
0u32.into()
|
||||
} else {
|
||||
Self::compute_fee(len, &dispatch_info, 0u32.into())
|
||||
};
|
||||
|
||||
let DispatchInfo { weight, class, .. } = dispatch_info;
|
||||
@@ -531,11 +540,11 @@ impl<T: Config> Pallet<T> {
|
||||
|
||||
let tip = 0u32.into();
|
||||
|
||||
if unchecked_extrinsic.is_signed().unwrap_or(false) {
|
||||
Self::compute_fee_details(len, &dispatch_info, tip)
|
||||
} else {
|
||||
// Unsigned extrinsics have no inclusion fee.
|
||||
if unchecked_extrinsic.is_bare() {
|
||||
// Bare extrinsics have no inclusion fee.
|
||||
FeeDetails { inclusion_fee: None, tip }
|
||||
} else {
|
||||
Self::compute_fee_details(len, &dispatch_info, tip)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -714,7 +723,7 @@ where
|
||||
who: &T::AccountId,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
fee: BalanceOf<T>,
|
||||
) -> Result<
|
||||
(
|
||||
BalanceOf<T>,
|
||||
@@ -723,7 +732,6 @@ 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,
|
||||
@@ -731,6 +739,22 @@ 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.
|
||||
///
|
||||
@@ -817,67 +841,93 @@ impl<T: Config> sp_std::fmt::Debug for ChargeTransactionPayment<T> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config> SignedExtension 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>
|
||||
where
|
||||
BalanceOf<T>: Send + Sync + From<u64>,
|
||||
T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
|
||||
{
|
||||
const IDENTIFIER: &'static str = "ChargeTransactionPayment";
|
||||
type AccountId = T::AccountId;
|
||||
type Call = T::RuntimeCall;
|
||||
type AdditionalSigned = ();
|
||||
type Val = (
|
||||
// tip
|
||||
BalanceOf<T>,
|
||||
// who paid the fee
|
||||
T::AccountId,
|
||||
// computed fee
|
||||
BalanceOf<T>,
|
||||
);
|
||||
type Pre = (
|
||||
// tip
|
||||
BalanceOf<T>,
|
||||
// who paid the fee - this is an option to allow for a Default impl.
|
||||
Self::AccountId,
|
||||
// who paid the fee
|
||||
T::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,
|
||||
who: &Self::AccountId,
|
||||
call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
origin: <T::RuntimeCall as Dispatchable>::RuntimeOrigin,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
) -> TransactionValidity {
|
||||
let (final_fee, _) = self.withdraw_fee(who, call, info, len)?;
|
||||
_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)?;
|
||||
let tip = self.0;
|
||||
Ok(ValidTransaction {
|
||||
priority: Self::get_priority(info, len, tip, final_fee),
|
||||
..Default::default()
|
||||
})
|
||||
Ok((
|
||||
ValidTransaction {
|
||||
priority: Self::get_priority(info, len, tip, final_fee),
|
||||
..Default::default()
|
||||
},
|
||||
(self.0, who, final_fee),
|
||||
origin,
|
||||
))
|
||||
}
|
||||
|
||||
fn pre_dispatch(
|
||||
fn prepare(
|
||||
self,
|
||||
who: &Self::AccountId,
|
||||
call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
len: usize,
|
||||
val: Self::Val,
|
||||
_origin: &<T::RuntimeCall as Dispatchable>::RuntimeOrigin,
|
||||
call: &T::RuntimeCall,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
_len: usize,
|
||||
_context: &Context,
|
||||
) -> Result<Self::Pre, TransactionValidityError> {
|
||||
let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;
|
||||
Ok((self.0, who.clone(), imbalance))
|
||||
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))
|
||||
}
|
||||
|
||||
fn post_dispatch(
|
||||
maybe_pre: Option<Self::Pre>,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
post_info: &PostDispatchInfoOf<Self::Call>,
|
||||
(tip, who, imbalance): Self::Pre,
|
||||
info: &DispatchInfoOf<T::RuntimeCall>,
|
||||
post_info: &PostDispatchInfoOf<T::RuntimeCall>,
|
||||
len: usize,
|
||||
_result: &DispatchResult,
|
||||
_context: &Context,
|
||||
) -> Result<(), TransactionValidityError> {
|
||||
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 });
|
||||
}
|
||||
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(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -157,4 +157,14 @@ 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()
|
||||
}
|
||||
@@ -20,7 +20,7 @@ use crate::Config;
|
||||
|
||||
use core::marker::PhantomData;
|
||||
use sp_runtime::{
|
||||
traits::{DispatchInfoOf, PostDispatchInfoOf, Saturating, Zero},
|
||||
traits::{CheckedSub, DispatchInfoOf, PostDispatchInfoOf, Saturating, Zero},
|
||||
transaction_validity::InvalidTransaction,
|
||||
};
|
||||
|
||||
@@ -51,6 +51,17 @@ 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.
|
||||
@@ -64,6 +75,12 @@ 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`
|
||||
@@ -121,6 +138,33 @@ 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.
|
||||
@@ -153,4 +197,14 @@ 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()
|
||||
}
|
||||
}
|
||||
@@ -21,11 +21,14 @@ use crate as pallet_transaction_payment;
|
||||
use codec::Encode;
|
||||
|
||||
use sp_runtime::{
|
||||
testing::TestXt, traits::One, transaction_validity::InvalidTransaction, BuildStorage,
|
||||
generic::UncheckedExtrinsic,
|
||||
traits::{DispatchTransaction, One},
|
||||
transaction_validity::InvalidTransaction,
|
||||
BuildStorage,
|
||||
};
|
||||
|
||||
use frame_support::{
|
||||
assert_noop, assert_ok,
|
||||
assert_ok,
|
||||
dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, PostDispatchInfo},
|
||||
traits::Currency,
|
||||
weights::Weight,
|
||||
@@ -128,44 +131,37 @@ fn default_post_info() -> PostDispatchInfo {
|
||||
PostDispatchInfo { actual_weight: None, pays_fee: Default::default() }
|
||||
}
|
||||
|
||||
type Ext = ChargeTransactionPayment<Runtime>;
|
||||
|
||||
#[test]
|
||||
fn signed_extension_transaction_payment_work() {
|
||||
fn transaction_extension_transaction_payment_work() {
|
||||
ExtBuilder::default()
|
||||
.balance_factor(10)
|
||||
.base_weight(Weight::from_parts(5, 0))
|
||||
.build()
|
||||
.execute_with(|| {
|
||||
let len = 10;
|
||||
let pre = ChargeTransactionPayment::<Runtime>::from(0)
|
||||
.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(5, 0)), len)
|
||||
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()
|
||||
.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 pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
|
||||
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
|
||||
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()
|
||||
.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);
|
||||
@@ -173,43 +169,37 @@ fn signed_extension_transaction_payment_work() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn signed_extension_transaction_payment_multiplied_refund_works() {
|
||||
fn transaction_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 pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
|
||||
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
|
||||
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()
|
||||
.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 signed_extension_transaction_payment_is_bounded() {
|
||||
fn transaction_extension_transaction_payment_is_bounded() {
|
||||
ExtBuilder::default().balance_factor(1000).byte_fee(0).build().execute_with(|| {
|
||||
// maximum weight possible
|
||||
assert_ok!(ChargeTransactionPayment::<Runtime>::from(0).pre_dispatch(
|
||||
&1,
|
||||
CALL,
|
||||
&info_from_weight(Weight::MAX),
|
||||
10
|
||||
));
|
||||
let info = info_from_weight(Weight::MAX);
|
||||
assert_ok!(Ext::from(0).validate_and_prepare(Some(1).into(), CALL, &info, 10));
|
||||
// fee will be proportional to what is the actual maximum weight in the runtime.
|
||||
assert_eq!(
|
||||
Balances::free_balance(&1),
|
||||
@@ -220,7 +210,7 @@ fn signed_extension_transaction_payment_is_bounded() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn signed_extension_allows_free_transactions() {
|
||||
fn transaction_extension_allows_free_transactions() {
|
||||
ExtBuilder::default()
|
||||
.base_weight(Weight::from_parts(100, 0))
|
||||
.balance_factor(0)
|
||||
@@ -232,38 +222,28 @@ fn signed_extension_allows_free_transactions() {
|
||||
let len = 100;
|
||||
|
||||
// This is a completely free (and thus wholly insecure/DoS-ridden) transaction.
|
||||
let operational_transaction = DispatchInfo {
|
||||
let op_tx = DispatchInfo {
|
||||
weight: Weight::from_parts(0, 0),
|
||||
class: DispatchClass::Operational,
|
||||
pays_fee: Pays::No,
|
||||
};
|
||||
assert_ok!(ChargeTransactionPayment::<Runtime>::from(0).validate(
|
||||
&1,
|
||||
CALL,
|
||||
&operational_transaction,
|
||||
len
|
||||
));
|
||||
assert_ok!(Ext::from(0).validate_only(Some(1).into(), CALL, &op_tx, len));
|
||||
|
||||
// like a InsecureFreeNormal
|
||||
let free_transaction = DispatchInfo {
|
||||
let free_tx = DispatchInfo {
|
||||
weight: Weight::from_parts(0, 0),
|
||||
class: DispatchClass::Normal,
|
||||
pays_fee: Pays::Yes,
|
||||
};
|
||||
assert_noop!(
|
||||
ChargeTransactionPayment::<Runtime>::from(0).validate(
|
||||
&1,
|
||||
CALL,
|
||||
&free_transaction,
|
||||
len
|
||||
),
|
||||
assert_eq!(
|
||||
Ext::from(0).validate_only(Some(1).into(), CALL, &free_tx, len).unwrap_err(),
|
||||
TransactionValidityError::Invalid(InvalidTransaction::Payment),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn signed_ext_length_fee_is_also_updated_per_congestion() {
|
||||
fn transaction_ext_length_fee_is_also_updated_per_congestion() {
|
||||
ExtBuilder::default()
|
||||
.base_weight(Weight::from_parts(5, 0))
|
||||
.balance_factor(10)
|
||||
@@ -272,16 +252,15 @@ fn signed_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;
|
||||
|
||||
assert_ok!(ChargeTransactionPayment::<Runtime>::from(10) // tipped
|
||||
.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(3, 0)), len));
|
||||
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_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
|
||||
);
|
||||
})
|
||||
}
|
||||
@@ -291,62 +270,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 = TestXt::new(call.clone(), Some((origin, extra)));
|
||||
let xt = UncheckedExtrinsic::new_signed(call.clone(), origin, (), extra);
|
||||
let info = xt.get_dispatch_info();
|
||||
let ext = xt.encode();
|
||||
let len = ext.len() as u32;
|
||||
|
||||
let unsigned_xt = TestXt::<_, ()>::new(call, None);
|
||||
let unsigned_xt = UncheckedExtrinsic::<u64, _, (), ()>::new_bare(call);
|
||||
let unsigned_xt_info = unsigned_xt.get_dispatch_info();
|
||||
|
||||
ExtBuilder::default()
|
||||
.base_weight(Weight::from_parts(5, 0))
|
||||
.weight_fee(2)
|
||||
.build()
|
||||
.execute_with(|| {
|
||||
// all fees should be x1.5
|
||||
<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(3, 2));
|
||||
.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]
|
||||
@@ -357,39 +336,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]
|
||||
@@ -526,27 +505,23 @@ fn refund_does_not_recreate_account() {
|
||||
.execute_with(|| {
|
||||
// So events are emitted
|
||||
System::set_block_number(10);
|
||||
let len = 10;
|
||||
let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
|
||||
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
|
||||
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()
|
||||
.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 {
|
||||
@@ -568,20 +543,15 @@ fn actual_weight_higher_than_max_refunds_nothing() {
|
||||
.base_weight(Weight::from_parts(5, 0))
|
||||
.build()
|
||||
.execute_with(|| {
|
||||
let len = 10;
|
||||
let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
|
||||
.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
|
||||
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()
|
||||
.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);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -594,25 +564,20 @@ fn zero_transfer_on_free_transaction() {
|
||||
.execute_with(|| {
|
||||
// So events are emitted
|
||||
System::set_block_number(10);
|
||||
let len = 10;
|
||||
let dispatch_info = DispatchInfo {
|
||||
let info = DispatchInfo {
|
||||
weight: Weight::from_parts(100, 0),
|
||||
pays_fee: Pays::No,
|
||||
class: DispatchClass::Normal,
|
||||
};
|
||||
let user = 69;
|
||||
let pre = ChargeTransactionPayment::<Runtime>::from(0)
|
||||
.pre_dispatch(&user, CALL, &dispatch_info, len)
|
||||
Ext::from(0)
|
||||
.test_run(Some(user).into(), CALL, &info, 10, |_| {
|
||||
assert_eq!(Balances::total_balance(&user), 0);
|
||||
Ok(default_post_info())
|
||||
})
|
||||
.unwrap()
|
||||
.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 {
|
||||
@@ -639,19 +604,11 @@ fn refund_consistent_with_actual_weight() {
|
||||
|
||||
<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(5, 4));
|
||||
|
||||
let pre = ChargeTransactionPayment::<Runtime>::from(tip)
|
||||
.pre_dispatch(&2, CALL, &info, len)
|
||||
Ext::from(tip)
|
||||
.test_run(Some(2).into(), CALL, &info, len, |_| Ok(post_info))
|
||||
.unwrap()
|
||||
.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);
|
||||
@@ -673,18 +630,13 @@ 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 priority = ChargeTransactionPayment::<Runtime>(2 * tip)
|
||||
.validate(&2, CALL, &normal, len)
|
||||
.unwrap()
|
||||
.priority;
|
||||
|
||||
let ext = Ext::from(2 * tip);
|
||||
let priority = ext.validate_only(Some(2).into(), CALL, &normal, len).unwrap().0.priority;
|
||||
assert_eq!(priority, 110);
|
||||
});
|
||||
|
||||
@@ -694,16 +646,13 @@ fn should_alter_operational_priority() {
|
||||
class: DispatchClass::Operational,
|
||||
pays_fee: Pays::Yes,
|
||||
};
|
||||
let priority = ChargeTransactionPayment::<Runtime>(tip)
|
||||
.validate(&2, CALL, &op, len)
|
||||
.unwrap()
|
||||
.priority;
|
||||
|
||||
let ext = Ext::from(tip);
|
||||
let priority = ext.validate_only(Some(2).into(), CALL, &op, len).unwrap().0.priority;
|
||||
assert_eq!(priority, 5810);
|
||||
|
||||
let priority = ChargeTransactionPayment::<Runtime>(2 * tip)
|
||||
.validate(&2, CALL, &op, len)
|
||||
.unwrap()
|
||||
.priority;
|
||||
let ext = Ext::from(2 * tip);
|
||||
let priority = ext.validate_only(Some(2).into(), CALL, &op, len).unwrap().0.priority;
|
||||
assert_eq!(priority, 6110);
|
||||
});
|
||||
}
|
||||
@@ -719,11 +668,8 @@ fn no_tip_has_some_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, 10);
|
||||
});
|
||||
|
||||
@@ -733,10 +679,8 @@ fn no_tip_has_some_priority() {
|
||||
class: DispatchClass::Operational,
|
||||
pays_fee: Pays::Yes,
|
||||
};
|
||||
let priority = ChargeTransactionPayment::<Runtime>(tip)
|
||||
.validate(&2, CALL, &op, len)
|
||||
.unwrap()
|
||||
.priority;
|
||||
let ext = Ext::from(tip);
|
||||
let priority = ext.validate_only(Some(2).into(), CALL, &op, len).unwrap().0.priority;
|
||||
assert_eq!(priority, 5510);
|
||||
});
|
||||
}
|
||||
@@ -744,8 +688,8 @@ fn no_tip_has_some_priority() {
|
||||
#[test]
|
||||
fn higher_tip_have_higher_priority() {
|
||||
let get_priorities = |tip: u64| {
|
||||
let mut priority1 = 0;
|
||||
let mut priority2 = 0;
|
||||
let mut pri1 = 0;
|
||||
let mut pri2 = 0;
|
||||
let len = 10;
|
||||
ExtBuilder::default().balance_factor(100).build().execute_with(|| {
|
||||
let normal = DispatchInfo {
|
||||
@@ -753,10 +697,8 @@ fn higher_tip_have_higher_priority() {
|
||||
class: DispatchClass::Normal,
|
||||
pays_fee: Pays::Yes,
|
||||
};
|
||||
priority1 = ChargeTransactionPayment::<Runtime>(tip)
|
||||
.validate(&2, CALL, &normal, len)
|
||||
.unwrap()
|
||||
.priority;
|
||||
let ext = Ext::from(tip);
|
||||
pri1 = ext.validate_only(Some(2).into(), CALL, &normal, len).unwrap().0.priority;
|
||||
});
|
||||
|
||||
ExtBuilder::default().balance_factor(100).build().execute_with(|| {
|
||||
@@ -765,13 +707,11 @@ fn higher_tip_have_higher_priority() {
|
||||
class: DispatchClass::Operational,
|
||||
pays_fee: Pays::Yes,
|
||||
};
|
||||
priority2 = ChargeTransactionPayment::<Runtime>(tip)
|
||||
.validate(&2, CALL, &op, len)
|
||||
.unwrap()
|
||||
.priority;
|
||||
let ext = Ext::from(tip);
|
||||
pri2 = ext.validate_only(Some(2).into(), CALL, &op, len).unwrap().0.priority;
|
||||
});
|
||||
|
||||
(priority1, priority2)
|
||||
(pri1, pri2)
|
||||
};
|
||||
|
||||
let mut prev_priorities = get_priorities(0);
|
||||
@@ -799,19 +739,11 @@ fn post_info_can_change_pays_fee() {
|
||||
|
||||
<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(5, 4));
|
||||
|
||||
let pre = ChargeTransactionPayment::<Runtime>::from(tip)
|
||||
.pre_dispatch(&2, CALL, &info, len)
|
||||
let post_info = ChargeTransactionPayment::<Runtime>::from(tip)
|
||||
.test_run(Some(2).into(), CALL, &info, len, |_| Ok(post_info))
|
||||
.unwrap()
|
||||
.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);
|
||||
|
||||
@@ -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 `SignedExtension`).
|
||||
/// depends on the signature (i.e. depends on a `TransactionExtension`).
|
||||
#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
|
||||
pub partial_fee: Balance,
|
||||
}
|
||||
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
// 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))
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user