Struct Obligation 

pub struct Obligation {
    pub version: u8,
    pub last_update: LastUpdate,
    pub lending_market: Pubkey,
    pub owner: Pubkey,
    pub deposits: Vec<ObligationCollateral>,
    pub borrows: Vec<ObligationLiquidity>,
    pub deposited_value: Decimal,
    pub borrowed_value: Decimal,
    pub allowed_borrow_value: Decimal,
    pub unhealthy_borrow_value: Decimal,
}

Lending market obligation state

Fields

version: u8

Version of the struct

last_update: LastUpdate

Last update to collateral, liquidity, or their market values

lending_market: Pubkey

Lending market address

owner: Pubkey

Owner authority which can borrow liquidity

deposits: Vec<ObligationCollateral>

Deposited collateral for the obligation, unique by deposit reserve address

borrows: Vec<ObligationLiquidity>

Borrowed liquidity for the obligation, unique by borrow reserve address

deposited_value: Decimal

Market value of deposits

borrowed_value: Decimal

Market value of borrows

allowed_borrow_value: Decimal

The maximum borrow value at the weighted average loan to value ratio

unhealthy_borrow_value: Decimal

The dangerous borrow value at the weighted average liquidation threshold

Implementations

impl Obligation

pub fn new(params: InitObligationParams) -> Self

Create a new obligation

pub fn init(&mut self, params: InitObligationParams)

Initialize an obligation

pub fn loan_to_value(&self) -> Result<Decimal, ProgramError>

Calculate the current ratio of borrowed value to deposited value

pub fn repay( &mut self, settle_amount: Decimal, liquidity_index: usize, ) -> ProgramResult

Repay liquidity and remove it from borrows if zeroed out

pub fn withdraw( &mut self, withdraw_amount: u64, collateral_index: usize, ) -> ProgramResult

Withdraw collateral and remove it from deposits if zeroed out

pub fn max_withdraw_value( &self, withdraw_collateral_ltv: Rate, ) -> Result<Decimal, ProgramError>

Calculate the maximum collateral value that can be withdrawn

pub fn remaining_borrow_value(&self) -> Result<Decimal, ProgramError>

Calculate the maximum liquidity value that can be borrowed

pub fn max_liquidation_amount( &self, liquidity: &ObligationLiquidity, ) -> Result<Decimal, ProgramError>

Calculate the maximum liquidation amount for a given liquidity

pub fn find_collateral_in_deposits( &self, deposit_reserve: Pubkey, ) -> Result<(&ObligationCollateral, usize), ProgramError>

Find collateral by deposit reserve

pub fn find_or_add_collateral_to_deposits( &mut self, deposit_reserve: Pubkey, ) -> Result<&mut ObligationCollateral, ProgramError>

Find or add collateral by deposit reserve

pub fn find_liquidity_in_borrows( &self, borrow_reserve: Pubkey, ) -> Result<(&ObligationLiquidity, usize), ProgramError>

Find liquidity by borrow reserve

pub fn find_liquidity_in_borrows_mut( &mut self, borrow_reserve: Pubkey, ) -> Result<(&mut ObligationLiquidity, usize), ProgramError>

Find liquidity by borrow reserve mut

pub fn find_or_add_liquidity_to_borrows( &mut self, borrow_reserve: Pubkey, cumulative_borrow_rate_wads: Decimal, ) -> Result<&mut ObligationLiquidity, ProgramError>

Find or add liquidity by borrow reserve

Trait Implementations

impl Clone for Obligation

fn clone(&self) -> Obligation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Obligation

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

Formats the value using the given formatter.

impl Default for Obligation

fn default() -> Obligation

Returns the “default value” for a type.

impl IsInitialized for Obligation

fn is_initialized(&self) -> bool

Is initialized

impl Pack for Obligation

const LEN: usize = 1_300usize

The length, in bytes, of the packed representation

fn get_packed_len() -> usize

Get the packed length

fn unpack(input: &[u8]) -> Result<Self, ProgramError>

where Self: IsInitialized,

Unpack from slice and check if initialized

fn unpack_unchecked(input: &[u8]) -> Result<Self, ProgramError>

Unpack from slice without checking if initialized

fn pack(src: Self, dst: &mut [u8]) -> Result<(), ProgramError>

Pack into slice

impl PartialEq for Obligation

fn eq(&self, other: &Obligation) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Sealed for Obligation

impl StructuralPartialEq for Obligation