Struct NamespacePricingConfig

pub struct NamespacePricingConfig<T: Config> {
    pub deposit_per_byte: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    pub base_fee: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    pub count_midpoint: u32,
    pub fee_steepness: Percent,
    pub max_fee_multiplier: u32,
}

Fields

deposit_per_byte: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance

Tokens held per byte inserted.

base_fee: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance

Used as the base fee for the logistic function that calculates the fees based on the amount of namespace entries for a given agent.

count_midpoint: u32

The logistic function’s midpoint. The function is performed over the number of namespace entries the agent has registered. The midpoint determines at how many entries for that agent the price reaches it’s mid-point.

fee_steepness: Percent

How steep the pricing increase is.

max_fee_multiplier: u32

The maximum multiplier for the base fee.

Implementations

impl<T: Config> NamespacePricingConfig<T>

pub fn namespace_fee( &self, account_namespace_count: u32, ) -> Result<<<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, DispatchError>

Calculate namespace cost using sigmoid pricing model.

pub fn namespace_deposit( &self, path: &NamespacePath, ) -> <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance

Calculates the deposit needed to register a namespace. If a path with the agent prefix is provided and contains more segments, the prefix (agent literal and agent name) will be dropped.

pub fn fee_midpoint( &self, ) -> <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance

The fee midpoint.

pub fn fee_ceiling( &self, ) -> <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance

The fee theoretical ceiling.

Trait Implementations

impl<T: Clone + Config> Clone for NamespacePricingConfig<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Config> Debug for NamespacePricingConfig<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for NamespacePricingConfig<T>

where <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T: Config> Encode for NamespacePricingConfig<T>

where <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> MaxEncodedLen for NamespacePricingConfig<T>

where <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: PartialEq + Config> PartialEq for NamespacePricingConfig<T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> TypeInfo for NamespacePricingConfig<T>

where <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: TypeInfo + 'static, T: Config + 'static,

type Identity = NamespacePricingConfig<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> EncodeLike for NamespacePricingConfig<T>

where <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Encode,

impl<T: Eq + Config> Eq for NamespacePricingConfig<T>

impl<T: Config> StructuralPartialEq for NamespacePricingConfig<T>