Struct NoCounterpart

pub struct NoCounterpart<T>(/* private fields */);

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: Eq> 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, preservation: Preservation, precision: Precision, force: Fortitude, ) -> Result<Self::Balance, DispatchError>

Attempt to decrease the balance of who, burning the tokens. The actual amount burned is derived from the amount, preservation, precision and force, and might end up being more, less or equal to the amount specified.

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 [Unbalanced::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 [Inspect::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.