Struct kintsugi_runtime_parachain::contracts::NativeCurrencyWithEd

pub struct NativeCurrencyWithEd;

Trait Implementations

impl Currency<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for NativeCurrencyWithEd

type Balance = <CurrencyAdapter<Runtime, GetNativeCurrencyId> as Currency<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>::Balance

The balance of an account.

type NegativeImbalance = <CurrencyAdapter<Runtime, GetNativeCurrencyId> as Currency<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>::NegativeImbalance

The opaque token type for an imbalance. This is returned by unbalanced operations and must be dealt with. It may be dropped but cannot be cloned.

type PositiveImbalance = <CurrencyAdapter<Runtime, GetNativeCurrencyId> as Currency<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>::PositiveImbalance

The opaque token type for an imbalance. This is returned by unbalanced operations and must be dealt with. It may be dropped but cannot be cloned.

fn total_balance(who: &AccountId) -> Self::Balance

The combined balance of who.

fn can_slash(who: &AccountId, value: Self::Balance) -> bool

Same result as slash(who, value) (but without the side-effects) assuming there are no balance changes in the meantime and only the reserved balance is not taken into account.

fn total_issuance() -> Self::Balance

The total amount of issuance in the system.

fn active_issuance() -> Self::Balance

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

fn deactivate(x: Self::Balance)

Reduce the active issuance by some amount.

fn reactivate(x: Self::Balance)

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

fn minimum_balance() -> Self::Balance

The minimum balance any single account may have. This is equivalent to the Balances module’s ExistentialDeposit.

fn burn(amount: Self::Balance) -> Self::PositiveImbalance

Reduce the total issuance by amount and return the according imbalance. The imbalance will typically be used to reduce an account by the same amount with e.g. settle.

fn issue(amount: Self::Balance) -> Self::NegativeImbalance

Increase the total issuance by amount and return the according imbalance. The imbalance will typically be used to increase an account by the same amount with e.g. resolve_into_existing or resolve_creating.

fn pair( amount: Self::Balance ) -> (Self::PositiveImbalance, Self::NegativeImbalance)

Produce a pair of imbalances that cancel each other out exactly.

fn free_balance(who: &AccountId) -> Self::Balance

The ‘free’ balance of a given account.

fn ensure_can_withdraw( who: &AccountId, _amount: Self::Balance, reasons: WithdrawReasons, new_balance: Self::Balance ) -> DispatchResult

Returns Ok iff the account is able to make a withdrawal of the given amount for the given reason. Basically, it’s just a dry-run of withdraw.

fn transfer( source: &AccountId, dest: &AccountId, value: Self::Balance, existence_requirement: ExistenceRequirement ) -> DispatchResult

Transfer some liquid free balance to another staker.

fn slash( who: &AccountId, value: Self::Balance ) -> (Self::NegativeImbalance, Self::Balance)

Deducts up to value from the combined balance of who, preferring to deduct from the free balance. This function cannot fail.

fn deposit_into_existing( who: &AccountId, value: Self::Balance ) -> Result<Self::PositiveImbalance, DispatchError>

Mints value to the free balance of who.

fn resolve_into_existing( who: &AccountId, value: Self::NegativeImbalance ) -> Result<(), Self::NegativeImbalance>

Similar to deposit_creating, only accepts a NegativeImbalance and returns nothing on success.

fn deposit_creating( who: &AccountId, value: Self::Balance ) -> Self::PositiveImbalance

Adds up to value to the free balance of who. If who doesn’t exist, it is created.

fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)

Similar to deposit_creating, only accepts a NegativeImbalance and returns nothing on success.

fn withdraw( who: &AccountId, value: Self::Balance, reasons: WithdrawReasons, liveness: ExistenceRequirement ) -> Result<Self::NegativeImbalance, DispatchError>

Removes some free balance from who account for reason if possible. If liveness is KeepAlive, then no less than ExistentialDeposit must be left remaining.

fn settle( who: &AccountId, value: Self::PositiveImbalance, reasons: WithdrawReasons, liveness: ExistenceRequirement ) -> Result<(), Self::PositiveImbalance>

Similar to withdraw, only accepts a PositiveImbalance and returns nothing on success.

fn make_free_balance_be( who: &AccountId, balance: Self::Balance ) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>

Ensure an account’s free balance equals some value; this will create the account if needed.

impl Inspect<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for NativeCurrencyWithEd

type Balance = u128

Scalar type for representing balance of an account.

fn total_issuance() -> Self::Balance

The total amount of issuance in the system.

fn active_issuance() -> Self::Balance

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

fn minimum_balance() -> Self::Balance

The minimum balance any single account may have.

fn total_balance(who: &AccountId) -> Self::Balance

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

fn balance(who: &AccountId) -> Self::Balance

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

fn reducible_balance( who: &AccountId, preservation: Preservation, force: Fortitude ) -> Self::Balance

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( who: &AccountId, amount: Self::Balance, provenance: Provenance ) -> DepositConsequence

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

fn can_withdraw( who: &AccountId, amount: Self::Balance ) -> WithdrawConsequence<Self::Balance>

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

impl ReservableCurrency<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for NativeCurrencyWithEd

fn can_reserve(who: &AccountId, value: Self::Balance) -> bool

Same result as reserve(who, value) (but without the side-effects) assuming there are no balance changes in the meantime.

fn slash_reserved( who: &AccountId, value: Self::Balance ) -> (Self::NegativeImbalance, Self::Balance)

Deducts up to value from reserved balance of who. This function cannot fail.

fn reserved_balance(who: &AccountId) -> Self::Balance

The amount of the balance of a given account that is externally reserved; this can still get slashed, but gets slashed last of all.

fn reserve(who: &AccountId, value: Self::Balance) -> DispatchResult

Moves value from balance to reserved balance.

fn unreserve(who: &AccountId, value: Self::Balance) -> Self::Balance

Moves up to value from reserved balance to free balance. This function cannot fail.

fn repatriate_reserved( slashed: &AccountId, beneficiary: &AccountId, value: Self::Balance, status: BalanceStatus ) -> Result<Self::Balance, DispatchError>

Moves up to value from reserved balance of account slashed to balance of account beneficiary. beneficiary must exist for this to succeed. If it does not, Err will be returned. Funds will be placed in either the free balance or the reserved balance, depending on the status.