Struct eq_balances::Module

pub struct Module<T: Trait>(_);

Implementations

impl<T: Trait> Module<T>

Can also be called using Call.

pub fn transfer(
    origin: T::Origin,
    currency: Currency,
    to: <T as Trait>::AccountId,
    value: T::Balance
) -> DispatchResult

Transfers value amount of currency from trx sender to account id to

NOTE: Calling this function will bypass origin filters.

pub fn deposit(
    origin: T::Origin,
    currency: Currency,
    to: <T as Trait>::AccountId,
    value: T::Balance
) -> DispatchResult

Adds currency to account balance (sudo only). Used to deposit currency into system

NOTE: Calling this function will bypass origin filters.

pub fn burn(
    origin: T::Origin,
    currency: Currency,
    from: <T as Trait>::AccountId,
    value: T::Balance
) -> DispatchResult

Burns currency (sudo only). Used to withdraw currency from the system

NOTE: Calling this function will bypass origin filters.

impl<T: Trait> Module<T>

pub fn set_balance_with_agg_unsafe(
    who: &T::AccountId,
    currency: &Currency,
    value: SignedBalance<T::Balance>
)

Trait Implementations

impl<T: Trait> BalanceGetter<<T as Trait>::AccountId, <T as Trait>::Balance> for Module<T>

type PriceGetter = T::PriceGetter

fn get_balance(
    who: &T::AccountId,
    currency: &Currency
) -> SignedBalance<T::Balance>

fn get_total_collateral_value() -> FixedI64

Gets total USD value of positive currency balances

fn iterate_balances(
) -> BTreeMap<T::AccountId, Vec<(Currency, SignedBalance<T::Balance>)>>

Used for iteration over whole balances storage. DO NOT USE IN RUNTIME, only for offchain workers

fn iterate_account_balances(
    account: &T::AccountId
) -> Vec<(Currency, SignedBalance<T::Balance>)>

Used to iterate over each currency balance of account

fn get_total_debt_value() -> FixedI64

Gets total USD value of of negative currency balances

fn get_debt_and_colaterall(who: &AccountId) -> (FixedI128, FixedI128)

Gets total value of account's debt and collateral in USD

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> EqCurrency<<T as Trait>::AccountId, <T as Trait>::Balance> for Module<T>

fn total_balance(currency: Currency, who: &T::AccountId) -> T::Balance

Returns balance value if balance is positive or zero if negative

fn debt(currency: Currency, who: &T::AccountId) -> T::Balance

Returns balance value if balance is negative or zero if negative

fn can_slash(
    _currency: Currency,
    _who: &T::AccountId,
    _value: T::Balance
) -> bool

fn currency_total_issuance(currency: Currency) -> T::Balance

Gets total issuance of given currency

fn currency_minimum_balance(_currency: Currency) -> T::Balance

Returns ExistentialDeposit for given currency

fn burn(
    _currency: Currency,
    _amount: T::Balance
) -> PositiveImbalance<T::Balance>

Unimplemented

fn issue(
    _currency: Currency,
    _amount: T::Balance
) -> NegativeImbalance<T::Balance>

Unimplemented. Use deposit instead

fn free_balance(currency: Currency, who: &T::AccountId) -> T::Balance

Same as total_balance

fn ensure_can_withdraw(
    currency: Currency,
    who: &T::AccountId,
    amount: T::Balance,
    reasons: WithdrawReasons,
    _new_balance: T::Balance
) -> DispatchResult

Used to ensure that user's balance in specified currency can be decreased for amount

fn currency_transfer(
    currency: Currency,
    transactor: &T::AccountId,
    dest: &T::AccountId,
    value: T::Balance,
    _existence_requirement: ExistenceRequirement,
    transfer_reason: TransferReason,
    ensure_can_change: bool
) -> DispatchResult

Operates transfers inside pallet functions - transactor - account sending currency - dest - account receiving currency - value - amount transferred - existence_requirement - currently unused - ensure_can_change - flag for ensuring transfer can be performed with can_change_balance

fn slash(
    _currency: Currency,
    _who: &T::AccountId,
    _value: T::Balance
) -> (NegativeImbalance<T::Balance>, T::Balance)

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

Adds given amount of currency to account's balance

fn deposit_creating(
    currency: Currency,
    who: &T::AccountId,
    value: T::Balance,
    ensure_can_change: bool
) -> PositiveImbalance<T::Balance>

Performs a deposit creating balance storage for account if it does not exist

fn withdraw(
    currency: Currency,
    who: &T::AccountId,
    value: T::Balance,
    reasons: WithdrawReasons,
    _liveness: ExistenceRequirement,
    ensure_can_change: bool
) -> Result<NegativeImbalance<T::Balance>, DispatchError>

Decreases who account balance for specified amount of currency - ensure_can_change - flag for ensuring transfer can be performed with can_change_balance

fn make_free_balance_be(
    currency: Currency,
    who: &T::AccountId,
    value: T::Balance
) -> SignedImbalance<T::Balance, PositiveImbalance<T::Balance>>

Force the new free balance of a target account to some new value

fn resolve_creating(
    currency: Currency,
    who: &AccountId,
    value: NegativeImbalance<Balance>
)

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

impl<T: Trait> IntegrityTest for Module<T>

fn integrity_test()

Run integrity test.

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

fn offchain_worker(_n: BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(_n: BlockNumber) -> u64

The block is being initialized. Implement to have something happen.

impl<T: Trait> OnKilledAccount<<T as Trait>::AccountId> for Module<T>

fn on_killed_account(who: &T::AccountId)

The account with the given id was reaped.

impl<T: Trait> OnRuntimeUpgrade for Module<T>

fn on_runtime_upgrade() -> u64

Perform a module upgrade.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>