Struct pallet_transaction_payment::Module

pub struct Module<T: Trait>(_);

Implementations

impl<T: Trait + 'static> Module<T>

pub fn next_fee_multiplier() -> Multiplier

impl<T: Trait> Module<T> where
    <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance: FixedPointOperand, 

pub fn query_info<Extrinsic: GetDispatchInfo>(
    unchecked_extrinsic: Extrinsic,
    len: u32
) -> RuntimeDispatchInfo<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> where
    T: Send + Sync,
    <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Send + Sync,
    T::Call: Dispatchable<Info = DispatchInfo>, 

Query the data that we know about the fee of a given call.

This module is not and cannot be aware of the internals of a signed extension, for example a tip. It only interprets the extrinsic as some encoded value and accounts for its weight and length, the runtime’s extrinsic base weight, and the current fee multiplier.

All dispatchables must be annotated with weight and will have some fee info. This function always returns.

pub fn compute_fee(
    len: u32,
    info: &DispatchInfoOf<T::Call>,
    tip: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance
) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance where
    T::Call: Dispatchable<Info = DispatchInfo>, 

Compute the final fee value for a particular transaction.

The final fee is composed of:

• base_fee: This is the minimum amount a user pays for a transaction. It is declared as a base weight in the runtime and converted to a fee using WeightToFee.
• len_fee: The length fee, the amount paid for the encoded length (in bytes) of the transaction.
• weight_fee: This amount is computed based on the weight of the transaction. Weight accounts for the execution time of a transaction.
• targeted_fee_adjustment: This is a multiplier that can tune the final fee based on the congestion of the network.
• (Optional) tip: If included in the transaction, the tip will be added on top. Only signed transactions can have a tip.

The base fee and adjusted weight and length fees constitute the inclusion fee, which is the minimum fee for a transaction to be included in a block.

inclusion_fee = base_fee + len_fee + [targeted_fee_adjustment * weight_fee];
final_fee = inclusion_fee + tip;

pub fn compute_actual_fee(
    len: u32,
    info: &DispatchInfoOf<T::Call>,
    post_info: &PostDispatchInfoOf<T::Call>,
    tip: <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance
) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance where
    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>, 

Compute the actual post dispatch fee for a particular transaction.

Identical to compute_fee with the only difference that the post dispatch corrected weight is used for the weight fee calculation.

Trait Implementations

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

fn clone(&self) -> Module<T>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Convert<u64, <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T> where
    T: Trait,
    <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance: FixedPointOperand, 

fn convert(
    weight: Weight
) -> <<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance

Compute the fee for the specified weight.

This fee is already adjusted by the per block fee adjustment factor and is therefore the share that the weight contributes to the overall fee of a transaction. It is mainly for informational purposes and not used in the actual fee calculation.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> IntegrityTest for Module<T>

fn integrity_test()

Run integrity test.

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait + Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

pub fn offchain_worker(_n: BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Trait + Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

fn on_finalize(_block_number_not_used: <T as Trait>::BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait + Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

pub fn on_initialize(_n: BlockNumber) -> u64

The block is being initialized. Implement to have something happen.

impl<T: Trait> OnRuntimeUpgrade for Module<T>

pub fn on_runtime_upgrade() -> u64

Perform a module upgrade.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

fn eq(&self, other: &Module<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>