Struct orml_tokens::MultiTokenCurrencyAdapter

pub struct MultiTokenCurrencyAdapter<T>(_);

Trait Implementations

impl<T> MultiTokenCurrency<<T as Config>::AccountId> for MultiTokenCurrencyAdapter<T>where T: Config,

type Balance = <T as Config>::Balance

The balance of an account. Mangata-node expected Balance to be u128, and uses U256 as higher precision type for arithemthics we should refactor to some HigherPrecisionType trait in those pallets eventually and remove the Into<_>

type CurrencyId = <T as Config>::CurrencyId

type PositiveImbalance = PositiveImbalance<T>

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 NegativeImbalance = NegativeImbalance<T>

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( currency_id: T::CurrencyId, who: &T::AccountId ) -> Self::Balance

The combined balance of who.

fn can_slash( currency_id: T::CurrencyId, who: &T::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(currency_id: T::CurrencyId) -> Self::Balance

The total amount of issuance in the system.

fn minimum_balance(currency_id: T::CurrencyId) -> Self::Balance

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

fn burn( currency_id: T::CurrencyId, 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( currency_id: T::CurrencyId, 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 free_balance(currency_id: T::CurrencyId, who: &T::AccountId) -> Self::Balance

The ‘free’ balance of a given account.

fn ensure_can_withdraw( currency_id: T::CurrencyId, who: &T::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( currency_id: T::CurrencyId, source: &T::AccountId, dest: &T::AccountId, value: Self::Balance, existence_requirement: ExistenceRequirement ) -> DispatchResult

Transfer some liquid free balance to another staker.

fn slash( currency_id: T::CurrencyId, who: &T::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( currency_id: T::CurrencyId, who: &T::AccountId, value: Self::Balance ) -> Result<Self::PositiveImbalance, DispatchError>

Mints value to the free balance of who.

fn deposit_creating( currency_id: T::CurrencyId, who: &T::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 withdraw( currency_id: T::CurrencyId, who: &T::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 make_free_balance_be( currency_id: T::CurrencyId, who: &T::AccountId, value: Self::Balance ) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>

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

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

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

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

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

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

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

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

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

impl<T> MultiTokenCurrencyExtended<<T as Config>::AccountId> for MultiTokenCurrencyAdapter<T>where T: Config,

fn burn_and_settle( currency_id: T::CurrencyId, who: &T::AccountId, amount: T::Balance ) -> DispatchResult

either succeeds or leaves state unchanged

fn create( who: &T::AccountId, amount: T::Balance ) -> Result<T::CurrencyId, DispatchError>

fn mint( currency_id: T::CurrencyId, who: &T::AccountId, amount: T::Balance ) -> DispatchResult

fn get_next_currency_id() -> Self::CurrencyId

fn exists(currency_id: Self::CurrencyId) -> bool

fn locked_balance(currency_id: T::CurrencyId, who: &T::AccountId) -> T::Balance

fn available_balance( currency_id: T::CurrencyId, who: &T::AccountId ) -> T::Balance

impl<T> MultiTokenLockableCurrency<<T as Config>::AccountId> for MultiTokenCurrencyAdapter<T>where T: Config,

type Moment = <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number

The quantity used to denote time; usually just a BlockNumber.

type MaxLocks = ()

The maximum number of locks a user should have on their account.

fn set_lock( currency_id: T::CurrencyId, id: LockIdentifier, who: &T::AccountId, amount: Self::Balance, _reasons: WithdrawReasons )

Create a new balance lock on account who.

fn extend_lock( currency_id: T::CurrencyId, id: LockIdentifier, who: &T::AccountId, amount: Self::Balance, _reasons: WithdrawReasons )

Changes a balance lock (selected by id) so that it becomes less liquid in all parameters or creates a new one if it does not exist.

fn remove_lock( currency_id: T::CurrencyId, id: LockIdentifier, who: &T::AccountId )

Remove an existing lock.

impl<T> MultiTokenReservableCurrency<<T as Config>::AccountId> for MultiTokenCurrencyAdapter<T>where T: Config,

fn can_reserve( currency_id: T::CurrencyId, who: &T::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( currency_id: T::CurrencyId, who: &T::AccountId, value: Self::Balance ) -> (Self::NegativeImbalance, Self::Balance)

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

fn reserved_balance( currency_id: T::CurrencyId, who: &T::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( currency_id: T::CurrencyId, who: &T::AccountId, value: Self::Balance ) -> DispatchResult

Moves value from balance to reserved balance.

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

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

fn repatriate_reserved( currency_id: T::CurrencyId, slashed: &T::AccountId, beneficiary: &T::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.