Struct pallet_nis::NoCounterpart

pub struct NoCounterpart<T>(_);

Trait Implementations

impl<T> Convert<Perquintill, u32> for NoCounterpart<T>

fn convert(_: Perquintill) -> u32

Make conversion.

impl<T> Inspect<T> for NoCounterpart<T>

type Balance = u32

Scalar type for representing balance of an account.

fn total_issuance() -> u32

The total amount of issuance in the system.

fn minimum_balance() -> u32

The minimum balance any single account may have.

fn balance(_: &T) -> u32

Get the balance of who which does not include funds which are exclusively allocated to subsystems of the chain (“on hold” or “reserved”).

fn total_balance(_: &T) -> u32

Get the total amount of funds whose ultimate beneficial ownership can be determined as who.

fn reducible_balance(_: &T, _: Preservation, _: Fortitude) -> u32

Get the maximum amount that who can withdraw/transfer successfully based on whether the account should be kept alive (preservation) or whether we are willing to force the reduction and potentially go below user-level restrictions on the minimum amount of the account.

fn can_deposit(_: &T, _: u32, _: Provenance) -> DepositConsequence

Returns true if the balance of who may be increased by amount.

fn can_withdraw(_: &T, _: u32) -> WithdrawConsequence<u32>

Returns Success if the balance of who may be decreased by amount, otherwise the consequence.

fn active_issuance() -> Self::Balance

The total amount of issuance in the system excluding those which are controlled by the system.

impl<T> Mutate<T> for NoCounterpart<T>

fn mint_into( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>

Increase the balance of who by exactly amount, minting new tokens. If that isn’t possible then an Err is returned and nothing is changed.

fn burn_from( who: &AccountId, amount: Self::Balance, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>

Decrease the balance of who by at least amount, possibly slightly more in the case of minimum-balance requirements, burning the tokens. If that isn’t possible then an Err is returned and nothing is changed. If successful, the amount of tokens reduced is returned.

fn shelve( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>

Attempt to decrease the asset balance of who by amount.

fn restore( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>

Attempt to increase the asset balance of who by amount.

fn transfer( source: &AccountId, dest: &AccountId, amount: Self::Balance, preservation: Preservation ) -> Result<Self::Balance, DispatchError>

Transfer funds from one account into another.

fn set_balance(who: &AccountId, amount: Self::Balance) -> Self::Balance

Simple infallible function to force an account to have a particular balance, good for use in tests and benchmarks but not recommended for production code owing to the lack of error reporting.

fn done_mint_into(_who: &AccountId, _amount: Self::Balance)

fn done_burn_from(_who: &AccountId, _amount: Self::Balance)

fn done_shelve(_who: &AccountId, _amount: Self::Balance)

fn done_restore(_who: &AccountId, _amount: Self::Balance)

fn done_transfer(_source: &AccountId, _dest: &AccountId, _amount: Self::Balance)

impl<T> Unbalanced<T> for NoCounterpart<T>

fn handle_dust(_: Dust<T, Self>)

Do something with the dust which has been destroyed from the system. Dust can be converted into a Credit with the Balanced trait impl.

fn write_balance( _: &T, _: Self::Balance ) -> Result<Option<Self::Balance>, DispatchError>

Forcefully set the balance of who to amount.

fn set_total_issuance(_: Self::Balance)

Set the total issuance to amount.

fn handle_raw_dust(amount: Self::Balance)

Create some dust and handle it with Self::handle_dust. This is an unbalanced operation and it must only be used when an account is modified in a raw fashion, outside of the entire fungibles API. The amount is capped at Self::minimum_balance() - 1.

fn decrease_balance( who: &AccountId, amount: Self::Balance, precision: Precision, preservation: Preservation, force: Fortitude ) -> Result<Self::Balance, DispatchError>

Reduce the balance of who by amount.

fn increase_balance( who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>

Increase the balance of who by amount.

fn deactivate(_: Self::Balance)

Reduce the active issuance by some amount.

fn reactivate(_: Self::Balance)

Increase the active issuance by some amount, up to the outstanding amount reduced.