Struct vault_registry::Vault

pub struct Vault<AccountId, BlockNumber, Balance, CurrencyId: Copy, UnsignedFixedPoint> {
    pub id: VaultId<AccountId, CurrencyId>,
    pub status: VaultStatus,
    pub banned_until: Option<BlockNumber>,
    pub secure_collateral_threshold: Option<UnsignedFixedPoint>,
    pub to_be_issued_tokens: Balance,
    pub issued_tokens: Balance,
    pub to_be_redeemed_tokens: Balance,
    pub to_be_replaced_tokens: Balance,
    pub replace_collateral: Balance,
    pub active_replace_collateral: Balance,
    pub liquidated_collateral: Balance,
}

Fields

id: VaultId<AccountId, CurrencyId>

Account identifier of the Vault

status: VaultStatus

Current status of the vault

banned_until: Option<BlockNumber>

Block height until which this Vault is banned from being used for Issue, Redeem (except during automatic liquidation) and Replace.

secure_collateral_threshold: Option<UnsignedFixedPoint>

Custom secure collateral threshold

to_be_issued_tokens: Balance

Number of tokens pending issue

issued_tokens: Balance

Number of issued tokens

to_be_redeemed_tokens: Balance

Number of tokens pending redeem

to_be_replaced_tokens: Balance

Number of tokens that have been requested for a replace through request_replace, but that have not been accepted yet by a new_vault.

replace_collateral: Balance

Amount of collateral that is available as griefing collateral to vaults accepting a replace request. It is to be payed out if the old_vault fails to call execute_replace.

active_replace_collateral: Balance

Amount of collateral locked for accepted replace requests.

liquidated_collateral: Balance

Amount of collateral that is locked for remaining to_be_redeemed tokens upon liquidation.

Implementations

impl<AccountId: Ord, BlockNumber: Default, Balance: HasCompact + Default, CurrencyId: Copy, UnsignedFixedPoint: Default> Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

pub fn new( id: VaultId<AccountId, CurrencyId> ) -> Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

pub fn is_liquidated(&self) -> bool

pub fn accepts_new_issues(&self) -> bool

Trait Implementations

impl<AccountId: Clone, BlockNumber: Clone, Balance: Clone, CurrencyId: Clone + Copy, UnsignedFixedPoint: Clone> Clone for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

fn clone( &self ) -> Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<AccountId: Debug, BlockNumber: Debug, Balance: Debug, CurrencyId: Debug + Copy, UnsignedFixedPoint: Debug> Debug for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

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

Formats the value using the given formatter.

impl<AccountId, BlockNumber, Balance, CurrencyId: Copy, UnsignedFixedPoint> Decode for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>where VaultId<AccountId, CurrencyId>: Decode, Option<BlockNumber>: Decode, Option<UnsignedFixedPoint>: Decode, Balance: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<AccountId, BlockNumber, Balance, CurrencyId: Copy, UnsignedFixedPoint> Encode for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>where VaultId<AccountId, CurrencyId>: Encode, Option<BlockNumber>: Encode, Option<UnsignedFixedPoint>: Encode, Balance: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> From<Vault<<T as Config>::AccountId, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, <T as Config>::Balance, <T as Config>::CurrencyId, <T as Config>::UnsignedFixedPoint>> for RichVault<T>

fn from(vault: DefaultVault<T>) -> RichVault<T>

Converts to this type from the input type.

impl<AccountId, BlockNumber, Balance, CurrencyId: Copy, UnsignedFixedPoint> MaxEncodedLen for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>where VaultId<AccountId, CurrencyId>: MaxEncodedLen, Option<BlockNumber>: MaxEncodedLen, Option<UnsignedFixedPoint>: MaxEncodedLen, Balance: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<AccountId: PartialEq, BlockNumber: PartialEq, Balance: PartialEq, CurrencyId: PartialEq + Copy, UnsignedFixedPoint: PartialEq> PartialEq<Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>> for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

fn eq( &self, other: &Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint> ) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint> TypeInfo for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>where VaultId<AccountId, CurrencyId>: TypeInfo + 'static, Option<BlockNumber>: TypeInfo + 'static, Option<UnsignedFixedPoint>: TypeInfo + 'static, Balance: TypeInfo + 'static, AccountId: TypeInfo + 'static, BlockNumber: TypeInfo + 'static, CurrencyId: Copy + TypeInfo + 'static, UnsignedFixedPoint: TypeInfo + 'static,

type Identity = Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<AccountId, BlockNumber, Balance, CurrencyId: Copy, UnsignedFixedPoint> EncodeLike<Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>> for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>where VaultId<AccountId, CurrencyId>: Encode, Option<BlockNumber>: Encode, Option<UnsignedFixedPoint>: Encode, Balance: Encode,

impl<AccountId: Eq, BlockNumber: Eq, Balance: Eq, CurrencyId: Eq + Copy, UnsignedFixedPoint: Eq> Eq for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

impl<AccountId, BlockNumber, Balance, CurrencyId: Copy, UnsignedFixedPoint> StructuralEq for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>

impl<AccountId, BlockNumber, Balance, CurrencyId: Copy, UnsignedFixedPoint> StructuralPartialEq for Vault<AccountId, BlockNumber, Balance, CurrencyId, UnsignedFixedPoint>