pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-07-20 17:25:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Companion for #11415 (WeightToFee) (#5525)

Browse Source 
* Companion for https://github.com/paritytech/substrate/pull/11415

* Rename `WeightToFee::calc()` to `WeightToFee::wight_to_fee()`

* Fix typo

* Fix compile errors

* update lockfile for {"substrate"}

Co-authored-by: parity-processbot <>
This commit is contained in:
Nazar Mokrynskyi
2022-05-25 11:06:01 +03:00
committed by GitHub
parent 69aa11f680
commit c090fb4c2e
13 changed files with 208 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
polkadot/Cargo.lock
Generated
+172 -173
View File
File diff suppressed because it is too large Load Diff
polkadot/bridges/bin/rialto/runtime/src/millau_messages.rs
+2 -2
View File
@@ -343,7 +343,7 @@ mod tests {
let bridge = MILLAU_CHAIN_ID; let bridge = MILLAU_CHAIN_ID;
let call: Call = SystemCall::set_heap_pages { pages: 64 }.into(); let call: Call = SystemCall::set_heap_pages { pages: 64 }.into();
let dispatch_weight = call.get_dispatch_info().weight; let dispatch_weight = call.get_dispatch_info().weight;
let dispatch_fee = <Runtime as pallet_transaction_payment::Config>::WeightToFee::calc( let dispatch_fee = <Runtime as pallet_transaction_payment::Config>::WeightToFee::weight_to_fee(
&dispatch_weight, &dispatch_weight,
); );
assert!(dispatch_fee > 0); assert!(dispatch_fee > 0);
@@ -508,7 +508,7 @@ mod tests {
} }
let dispatch_weight = 500; let dispatch_weight = 500;
let dispatch_fee = <Runtime as pallet_transaction_payment::Config>::WeightToFee::calc( let dispatch_fee = <Runtime as pallet_transaction_payment::Config>::WeightToFee::weight_to_fee(
&dispatch_weight, &dispatch_weight,
); );
assert!(dispatch_fee > 0); assert!(dispatch_fee > 0);
polkadot/bridges/bin/runtime-common/src/messages.rs
+3 -2
View File
@@ -33,7 +33,7 @@ use bp_runtime::{
use codec::{Decode, DecodeLimit, Encode}; use codec::{Decode, DecodeLimit, Encode};
use frame_support::{ use frame_support::{
traits::{Currency, ExistenceRequirement}, traits::{Currency, ExistenceRequirement},
weights::{Weight, WeightToFeePolynomial}, weights::{Weight, WeightToFee},
RuntimeDebug, RuntimeDebug,
}; };
use hash_db::Hasher; use hash_db::Hasher;
@@ -598,7 +598,8 @@ pub mod target {
message_id, message_id,
message.data.payload.map_err(drop), message.data.payload.map_err(drop),
|dispatch_origin, dispatch_weight| { |dispatch_origin, dispatch_weight| {
let unadjusted_weight_fee = ThisRuntime::WeightToFee::calc(&dispatch_weight); let unadjusted_weight_fee =
ThisRuntime::WeightToFee::weight_to_fee(&dispatch_weight);
let fee_multiplier = let fee_multiplier =
pallet_transaction_payment::Pallet::<ThisRuntime>::next_fee_multiplier(); pallet_transaction_payment::Pallet::<ThisRuntime>::next_fee_multiplier();
let adjusted_weight_fee = let adjusted_weight_fee =
polkadot/bridges/relays/bin-substrate/src/chains/kusama_headers_to_polkadot.rs
+1 -1
View File
@@ -103,7 +103,7 @@ pub(crate) mod tests {
// for simplicity - add extra weight for base tx fee + fee that is paid for the tx size + // for simplicity - add extra weight for base tx fee + fee that is paid for the tx size +
// adjusted fee // adjusted fee
let single_source_header_submit_tx_weight = single_source_header_submit_call_weight * 3 / 2; let single_source_header_submit_tx_weight = single_source_header_submit_call_weight * 3 / 2;
let single_source_header_tx_cost = W::calc(&single_source_header_submit_tx_weight); let single_source_header_tx_cost = W::weight_to_fee(&single_source_header_submit_tx_weight);
single_source_header_tx_cost * B::from(expected_source_headers_per_day) single_source_header_tx_cost * B::from(expected_source_headers_per_day)
} }
polkadot/bridges/relays/lib-substrate-relay/src/messages_target.rs
+5 -5
View File
@@ -493,8 +493,8 @@ fn compute_fee_multiplier<C: Chain>(
) -> FixedU128 { ) -> FixedU128 {
let adjusted_weight_fee_difference = let adjusted_weight_fee_difference =
larger_adjusted_weight_fee.saturating_sub(smaller_adjusted_weight_fee); larger_adjusted_weight_fee.saturating_sub(smaller_adjusted_weight_fee);
let smaller_tx_unadjusted_weight_fee = WeightToFeeOf::<C>::calc(&smaller_tx_weight); let smaller_tx_unadjusted_weight_fee = WeightToFeeOf::<C>::weight_to_fee(&smaller_tx_weight);
let larger_tx_unadjusted_weight_fee = WeightToFeeOf::<C>::calc(&larger_tx_weight); let larger_tx_unadjusted_weight_fee = WeightToFeeOf::<C>::weight_to_fee(&larger_tx_weight);
FixedU128::saturating_from_rational( FixedU128::saturating_from_rational(
adjusted_weight_fee_difference, adjusted_weight_fee_difference,
larger_tx_unadjusted_weight_fee.saturating_sub(smaller_tx_unadjusted_weight_fee), larger_tx_unadjusted_weight_fee.saturating_sub(smaller_tx_unadjusted_weight_fee),
@@ -507,7 +507,7 @@ fn compute_prepaid_messages_refund<C: ChainWithMessages>(
total_prepaid_nonces: MessageNonce, total_prepaid_nonces: MessageNonce,
fee_multiplier: FixedU128, fee_multiplier: FixedU128,
) -> BalanceOf<C> { ) -> BalanceOf<C> {
fee_multiplier.saturating_mul_int(WeightToFeeOf::<C>::calc( fee_multiplier.saturating_mul_int(WeightToFeeOf::<C>::weight_to_fee(
&C::PAY_INBOUND_DISPATCH_FEE_WEIGHT_AT_CHAIN.saturating_mul(total_prepaid_nonces), &C::PAY_INBOUND_DISPATCH_FEE_WEIGHT_AT_CHAIN.saturating_mul(total_prepaid_nonces),
)) ))
} }
@@ -554,11 +554,11 @@ mod tests {
let smaller_weight = 1_000_000; let smaller_weight = 1_000_000;
let smaller_adjusted_weight_fee = let smaller_adjusted_weight_fee =
multiplier.saturating_mul_int(WeightToFeeOf::<Rococo>::calc(&smaller_weight)); multiplier.saturating_mul_int(WeightToFeeOf::<Rococo>::weight_to_fee(&smaller_weight));
let larger_weight = smaller_weight + 200_000; let larger_weight = smaller_weight + 200_000;
let larger_adjusted_weight_fee = let larger_adjusted_weight_fee =
multiplier.saturating_mul_int(WeightToFeeOf::<Rococo>::calc(&larger_weight)); multiplier.saturating_mul_int(WeightToFeeOf::<Rococo>::weight_to_fee(&larger_weight));
assert_eq!( assert_eq!(
compute_fee_multiplier::<Rococo>( compute_fee_multiplier::<Rococo>(
polkadot/runtime/kusama/constants/src/lib.rs
+3 -3
View File
@@ -100,14 +100,14 @@ mod tests {
fee::WeightToFee, fee::WeightToFee,
}; };
use crate::weights::ExtrinsicBaseWeight; use crate::weights::ExtrinsicBaseWeight;
use frame_support::weights::WeightToFeePolynomial; use frame_support::weights::WeightToFee as WeightToFeeT;
use runtime_common::MAXIMUM_BLOCK_WEIGHT; use runtime_common::MAXIMUM_BLOCK_WEIGHT;
#[test] #[test]
// Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds. // Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds.
fn full_block_fee_is_correct() { fn full_block_fee_is_correct() {
// A full block should cost between 1,000 and 10,000 CENTS. // A full block should cost between 1,000 and 10,000 CENTS.
let full_block = WeightToFee::calc(&MAXIMUM_BLOCK_WEIGHT); let full_block = WeightToFee::weight_to_fee(&MAXIMUM_BLOCK_WEIGHT);
assert!(full_block >= 1_000 * CENTS); assert!(full_block >= 1_000 * CENTS);
assert!(full_block <= 10_000 * CENTS); assert!(full_block <= 10_000 * CENTS);
} }
@@ -117,7 +117,7 @@ mod tests {
fn extrinsic_base_fee_is_correct() { fn extrinsic_base_fee_is_correct() {
// `ExtrinsicBaseWeight` should cost 1/10 of a CENT // `ExtrinsicBaseWeight` should cost 1/10 of a CENT
println!("Base: {}", ExtrinsicBaseWeight::get()); println!("Base: {}", ExtrinsicBaseWeight::get());
let x = WeightToFee::calc(&ExtrinsicBaseWeight::get()); let x = WeightToFee::weight_to_fee(&ExtrinsicBaseWeight::get());
let y = CENTS / 10; let y = CENTS / 10;
assert!(x.max(y) - x.min(y) < MILLICENTS); assert!(x.max(y) - x.min(y) < MILLICENTS);
} }
polkadot/runtime/kusama/src/tests.rs
+2 -2
View File
@@ -17,7 +17,7 @@
//! Tests for the Kusama Runtime Configuration //! Tests for the Kusama Runtime Configuration
use crate::*; use crate::*;
use frame_support::weights::{GetDispatchInfo, WeightToFeePolynomial}; use frame_support::weights::{GetDispatchInfo, WeightToFee as WeightToFeeT};
use keyring::Sr25519Keyring::Charlie; use keyring::Sr25519Keyring::Charlie;
use pallet_transaction_payment::Multiplier; use pallet_transaction_payment::Multiplier;
use parity_scale_codec::Encode; use parity_scale_codec::Encode;
@@ -68,7 +68,7 @@ fn payout_weight_portion() {
#[ignore] #[ignore]
fn block_cost() { fn block_cost() {
let max_block_weight = BlockWeights::get().max_block; let max_block_weight = BlockWeights::get().max_block;
let raw_fee = WeightToFee::calc(&max_block_weight); let raw_fee = WeightToFee::weight_to_fee(&max_block_weight);
println!( println!(
"Full Block weight == {} // WeightToFee(full_block) == {} plank", "Full Block weight == {} // WeightToFee(full_block) == {} plank",
polkadot/runtime/polkadot/constants/src/lib.rs
+3 -3
View File
@@ -102,14 +102,14 @@ mod tests {
fee::WeightToFee, fee::WeightToFee,
}; };
use crate::weights::ExtrinsicBaseWeight; use crate::weights::ExtrinsicBaseWeight;
use frame_support::weights::WeightToFeePolynomial; use frame_support::weights::WeightToFee as WeightToFeeT;
use runtime_common::MAXIMUM_BLOCK_WEIGHT; use runtime_common::MAXIMUM_BLOCK_WEIGHT;
#[test] #[test]
// Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds. // Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds.
fn full_block_fee_is_correct() { fn full_block_fee_is_correct() {
// A full block should cost between 10 and 100 DOLLARS. // A full block should cost between 10 and 100 DOLLARS.
let full_block = WeightToFee::calc(&MAXIMUM_BLOCK_WEIGHT); let full_block = WeightToFee::weight_to_fee(&MAXIMUM_BLOCK_WEIGHT);
assert!(full_block >= 10 * DOLLARS); assert!(full_block >= 10 * DOLLARS);
assert!(full_block <= 100 * DOLLARS); assert!(full_block <= 100 * DOLLARS);
} }
@@ -119,7 +119,7 @@ mod tests {
fn extrinsic_base_fee_is_correct() { fn extrinsic_base_fee_is_correct() {
// `ExtrinsicBaseWeight` should cost 1/10 of a CENT // `ExtrinsicBaseWeight` should cost 1/10 of a CENT
println!("Base: {}", ExtrinsicBaseWeight::get()); println!("Base: {}", ExtrinsicBaseWeight::get());
let x = WeightToFee::calc(&ExtrinsicBaseWeight::get()); let x = WeightToFee::weight_to_fee(&ExtrinsicBaseWeight::get());
let y = CENTS / 10; let y = CENTS / 10;
assert!(x.max(y) - x.min(y) < MILLICENTS); assert!(x.max(y) - x.min(y) < MILLICENTS);
} }
polkadot/runtime/polkadot/src/lib.rs
+2 -2
View File
@@ -2009,7 +2009,7 @@ sp_api::impl_runtime_apis! {
#[cfg(test)] #[cfg(test)]
mod test_fees { mod test_fees {
use super::*; use super::*;
use frame_support::weights::{GetDispatchInfo, WeightToFeePolynomial}; use frame_support::weights::{GetDispatchInfo, WeightToFee as WeightToFeeT};
use keyring::Sr25519Keyring::Charlie; use keyring::Sr25519Keyring::Charlie;
use pallet_transaction_payment::Multiplier; use pallet_transaction_payment::Multiplier;
use runtime_common::MinimumMultiplier; use runtime_common::MinimumMultiplier;
@@ -2038,7 +2038,7 @@ mod test_fees {
#[ignore] #[ignore]
fn block_cost() { fn block_cost() {
let max_block_weight = BlockWeights::get().max_block; let max_block_weight = BlockWeights::get().max_block;
let raw_fee = WeightToFee::calc(&max_block_weight); let raw_fee = WeightToFee::weight_to_fee(&max_block_weight);
println!( println!(
"Full Block weight == {} // WeightToFee(full_block) == {} plank", "Full Block weight == {} // WeightToFee(full_block) == {} plank",
polkadot/runtime/rococo/constants/src/lib.rs
+3 -3
View File
@@ -100,14 +100,14 @@ mod tests {
fee::WeightToFee, fee::WeightToFee,
}; };
use crate::weights::ExtrinsicBaseWeight; use crate::weights::ExtrinsicBaseWeight;
use frame_support::weights::WeightToFeePolynomial; use frame_support::weights::WeightToFee as WeightToFeeT;
use runtime_common::MAXIMUM_BLOCK_WEIGHT; use runtime_common::MAXIMUM_BLOCK_WEIGHT;
#[test] #[test]
// Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds. // Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds.
fn full_block_fee_is_correct() { fn full_block_fee_is_correct() {
// A full block should cost between 10 and 100 DOLLARS. // A full block should cost between 10 and 100 DOLLARS.
let full_block = WeightToFee::calc(&MAXIMUM_BLOCK_WEIGHT); let full_block = WeightToFee::weight_to_fee(&MAXIMUM_BLOCK_WEIGHT);
assert!(full_block >= 10 * DOLLARS); assert!(full_block >= 10 * DOLLARS);
assert!(full_block <= 100 * DOLLARS); assert!(full_block <= 100 * DOLLARS);
} }
@@ -117,7 +117,7 @@ mod tests {
fn extrinsic_base_fee_is_correct() { fn extrinsic_base_fee_is_correct() {
// `ExtrinsicBaseWeight` should cost 1/10 of a CENT // `ExtrinsicBaseWeight` should cost 1/10 of a CENT
println!("Base: {}", ExtrinsicBaseWeight::get()); println!("Base: {}", ExtrinsicBaseWeight::get());
let x = WeightToFee::calc(&ExtrinsicBaseWeight::get()); let x = WeightToFee::weight_to_fee(&ExtrinsicBaseWeight::get());
let y = CENTS / 10; let y = CENTS / 10;
assert!(x.max(y) - x.min(y) < MILLICENTS); assert!(x.max(y) - x.min(y) < MILLICENTS);
} }
polkadot/runtime/rococo/src/bridge_messages.rs
+3 -3
View File
@@ -34,7 +34,7 @@ use bridge_runtime_common::messages::{
}; };
use frame_support::{ use frame_support::{
traits::Get, traits::Get,
weights::{Weight, WeightToFeePolynomial}, weights::{Weight, WeightToFee as WeightToFeeT},
RuntimeDebug, RuntimeDebug,
}; };
use rococo_runtime_constants::fee::WeightToFee; use rococo_runtime_constants::fee::WeightToFee;
@@ -141,7 +141,7 @@ impl<B, GI> ThisChainWithMessages for RococoLikeChain<B, GI> {
.base_extrinsic, .base_extrinsic,
crate::TransactionByteFee::get(), crate::TransactionByteFee::get(),
pallet_transaction_payment::Pallet::<Runtime>::next_fee_multiplier(), pallet_transaction_payment::Pallet::<Runtime>::next_fee_multiplier(),
|weight| WeightToFee::calc(&weight), |weight| WeightToFee::weight_to_fee(&weight),
transaction, transaction,
) )
} }
@@ -199,7 +199,7 @@ impl<B, GI> BridgedChainWithMessages for RococoLikeChain<B, GI> {
.base_extrinsic, .base_extrinsic,
crate::TransactionByteFee::get(), crate::TransactionByteFee::get(),
pallet_transaction_payment::Pallet::<Runtime>::next_fee_multiplier(), pallet_transaction_payment::Pallet::<Runtime>::next_fee_multiplier(),
|weight| WeightToFee::calc(&weight), |weight| WeightToFee::weight_to_fee(&weight),
transaction, transaction,
) )
} }
polkadot/runtime/westend/constants/src/lib.rs
+3 -3
View File
@@ -100,14 +100,14 @@ mod tests {
fee::WeightToFee, fee::WeightToFee,
}; };
use crate::weights::ExtrinsicBaseWeight; use crate::weights::ExtrinsicBaseWeight;
use frame_support::weights::WeightToFeePolynomial; use frame_support::weights::WeightToFee as WeightToFeeT;
use runtime_common::MAXIMUM_BLOCK_WEIGHT; use runtime_common::MAXIMUM_BLOCK_WEIGHT;
#[test] #[test]
// Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds. // Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds.
fn full_block_fee_is_correct() { fn full_block_fee_is_correct() {
// A full block should cost between 10 and 100 UNITS. // A full block should cost between 10 and 100 UNITS.
let full_block = WeightToFee::calc(&MAXIMUM_BLOCK_WEIGHT); let full_block = WeightToFee::weight_to_fee(&MAXIMUM_BLOCK_WEIGHT);
assert!(full_block >= 10 * UNITS); assert!(full_block >= 10 * UNITS);
assert!(full_block <= 100 * UNITS); assert!(full_block <= 100 * UNITS);
} }
@@ -117,7 +117,7 @@ mod tests {
fn extrinsic_base_fee_is_correct() { fn extrinsic_base_fee_is_correct() {
// `ExtrinsicBaseWeight` should cost 1/10 of a CENT // `ExtrinsicBaseWeight` should cost 1/10 of a CENT
println!("Base: {}", ExtrinsicBaseWeight::get()); println!("Base: {}", ExtrinsicBaseWeight::get());
let x = WeightToFee::calc(&ExtrinsicBaseWeight::get()); let x = WeightToFee::weight_to_fee(&ExtrinsicBaseWeight::get());
let y = CENTS / 10; let y = CENTS / 10;
assert!(x.max(y) - x.min(y) < MILLICENTS); assert!(x.max(y) - x.min(y) < MILLICENTS);
} }
polkadot/xcm/xcm-builder/src/weight.rs
+6 -6
View File
@@ -16,7 +16,7 @@
use frame_support::{ use frame_support::{
traits::{tokens::currency::Currency as CurrencyT, Get, OnUnbalanced as OnUnbalancedT}, traits::{tokens::currency::Currency as CurrencyT, Get, OnUnbalanced as OnUnbalancedT},
weights::{constants::WEIGHT_PER_SECOND, GetDispatchInfo, Weight, WeightToFeePolynomial}, weights::{constants::WEIGHT_PER_SECOND, GetDispatchInfo, Weight, WeightToFee as WeightToFeeT},
}; };
use parity_scale_codec::Decode; use parity_scale_codec::Decode;
use sp_runtime::traits::{SaturatedConversion, Saturating, Zero}; use sp_runtime::traits::{SaturatedConversion, Saturating, Zero};
@@ -241,7 +241,7 @@ impl<T: Get<(AssetId, u128)>, R: TakeRevenue> Drop for FixedRateOfFungible<T, R>
/// Weight trader which uses the `TransactionPayment` pallet to set the right price for weight and then /// Weight trader which uses the `TransactionPayment` pallet to set the right price for weight and then
/// places any weight bought into the right account. /// places any weight bought into the right account.
pub struct UsingComponents< pub struct UsingComponents<
WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>, WeightToFee: WeightToFeeT<Balance = Currency::Balance>,
AssetId: Get<MultiLocation>, AssetId: Get<MultiLocation>,
AccountId, AccountId,
Currency: CurrencyT<AccountId>, Currency: CurrencyT<AccountId>,
@@ -252,7 +252,7 @@ pub struct UsingComponents<
PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>, PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,
); );
impl< impl<
WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>, WeightToFee: WeightToFeeT<Balance = Currency::Balance>,
AssetId: Get<MultiLocation>, AssetId: Get<MultiLocation>,
AccountId, AccountId,
Currency: CurrencyT<AccountId>, Currency: CurrencyT<AccountId>,
@@ -265,7 +265,7 @@ impl<
fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> { fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {
log::trace!(target: "xcm::weight", "UsingComponents::buy_weight weight: {:?}, payment: {:?}", weight, payment); log::trace!(target: "xcm::weight", "UsingComponents::buy_weight weight: {:?}, payment: {:?}", weight, payment);
let amount = WeightToFee::calc(&weight); let amount = WeightToFee::weight_to_fee(&weight);
let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?; let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;
let required = (Concrete(AssetId::get()), u128_amount).into(); let required = (Concrete(AssetId::get()), u128_amount).into();
let unused = payment.checked_sub(required).map_err(|_| XcmError::TooExpensive)?; let unused = payment.checked_sub(required).map_err(|_| XcmError::TooExpensive)?;
@@ -277,7 +277,7 @@ impl<
fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> { fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {
log::trace!(target: "xcm::weight", "UsingComponents::refund_weight weight: {:?}", weight); log::trace!(target: "xcm::weight", "UsingComponents::refund_weight weight: {:?}", weight);
let weight = weight.min(self.0); let weight = weight.min(self.0);
let amount = WeightToFee::calc(&weight); let amount = WeightToFee::weight_to_fee(&weight);
self.0 -= weight; self.0 -= weight;
self.1 = self.1.saturating_sub(amount); self.1 = self.1.saturating_sub(amount);
let amount: u128 = amount.saturated_into(); let amount: u128 = amount.saturated_into();
@@ -289,7 +289,7 @@ impl<
} }
} }
impl< impl<
WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>, WeightToFee: WeightToFeeT<Balance = Currency::Balance>,
AssetId: Get<MultiLocation>, AssetId: Get<MultiLocation>,
AccountId, AccountId,
Currency: CurrencyT<AccountId>, Currency: CurrencyT<AccountId>,