Struct jet_margin::MarginAccount

#[repr(C)]
#[repr(align(8))]
pub struct MarginAccount {
    pub version: u8,
    pub bump_seed: [u8; 1],
    pub user_seed: [u8; 2],
    pub invocation: Invocation,
    pub reserved0: [u8; 3],
    pub owner: Pubkey,
    pub liquidation: Pubkey,
    pub liquidator: Pubkey,
    pub positions: [u8; 7432],
}

Fields

version: u8

bump_seed: [u8; 1]

user_seed: [u8; 2]

invocation: Invocation

Data an adapter can use to check what the margin program thinks about the current invocation Must normally be zeroed, except during an invocation.

reserved0: [u8; 3]

owner: Pubkey

The owner of this account, which generally has to sign for any changes to it

liquidation: Pubkey

The state of an active liquidation for this account

liquidator: Pubkey

The active liquidator for this account

positions: [u8; 7432]

The storage for tracking account balances

Implementations

impl MarginAccount

pub fn start_liquidation(&mut self, liquidation: Pubkey, liquidator: Pubkey)

pub fn end_liquidation(&mut self)

pub fn verify_not_liquidating(&self) -> AnchorResult<()>

pub fn is_liquidating(&self) -> bool

pub fn initialize(&mut self, owner: Pubkey, seed: u16, bump_seed: u8)

pub fn positions(&self) -> impl Iterator<Item = &AccountPosition>

Get the list of positions on this account

pub fn register_position(
    &mut self,
    token: Pubkey,
    decimals: u8,
    address: Pubkey,
    adapter: Pubkey,
    kind: TokenKind,
    value_modifier: u16,
    max_staleness: u64,
    approvals: &[Approver]
) -> AnchorResult<AccountPositionKey>

Register the space for a new position into this account

pub fn unregister_position(
    &mut self,
    mint: &Pubkey,
    account: &Pubkey,
    approvals: &[Approver]
) -> AnchorResult<()>

Free the space from a previously registered position no longer needed

pub fn refresh_position_metadata(
    &mut self,
    mint: &Pubkey,
    kind: TokenKind,
    value_modifier: u16,
    max_staleness: u64
) -> Result<AccountPosition, ErrorCode>

pub fn get_position_key(&self, mint: &Pubkey) -> Option<AccountPositionKey>

pub fn get_position(&mut self, mint: &Pubkey) -> Option<&AccountPosition>

pub fn get_position_mut(&mut self, mint: &Pubkey) -> Option<&mut AccountPosition>

pub fn get_position_by_key(
    &self,
    key: &AccountPositionKey
) -> Option<&AccountPosition>

faster than searching by mint only if you have the correct key slightly slower if you have the wrong key

pub fn get_position_by_key_mut(
    &mut self,
    key: &AccountPositionKey
) -> Option<&mut AccountPosition>

faster than searching by mint only if you have the correct key slightly slower if you have the wrong key

pub fn set_position_balance(
    &mut self,
    mint: &Pubkey,
    account: &Pubkey,
    balance: u64
) -> Result<AccountPosition, ErrorCode>

Change the balance for a position

pub fn set_position_price(
    &mut self,
    mint: &Pubkey,
    price: &PriceInfo
) -> Result<(), ErrorCode>

Change the current price value of a position

pub fn verify_healthy_positions(&self) -> AnchorResult<()>

Check that the overall health of the account is acceptable, by comparing the total value of the claims versus the available collateral. If the collateralization ratio is above the minimum, then the account is considered healthy.

pub fn verify_unhealthy_positions(&self) -> AnchorResult<()>

Check that the overall health of the account is not acceptable.

pub fn verify_authority(&self, authority: Pubkey) -> Result<(), ErrorCode>

Check if the given address is the current authority for this margin account

pub fn valuation(&self) -> AnchorResult<Valuation>

Trait Implementations

impl AccountDeserialize for MarginAccount

fn try_deserialize(buf: &mut &[u8]) -> Result<Self>

Deserializes previously initialized account data. Should fail for all uninitialized accounts, where the bytes are zeroed. Implementations should be unique to a particular account type so that one can never successfully deserialize the data of one account type into another. For example, if the SPL token program were to implement this trait, it should be impossible to deserialize a Mint account into a token Account.

fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self>

Deserializes account data without checking the account discriminator. This should only be used on account initialization, when the bytes of the account are zeroed.

impl AnchorVerify for MarginAccount

fn anchor_verify(info: &AccountInfo<'_>) -> AnchorResult<()>

impl Clone for MarginAccount

fn clone(&self) -> MarginAccount

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MarginAccount

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

Formats the value using the given formatter.

impl Discriminator for MarginAccount

fn discriminator() -> [u8; 8]

impl Owner for MarginAccount

fn owner() -> Pubkey

impl SignerSeeds<3> for MarginAccount

fn signer_seeds(&self) -> [&[u8]; 3]

fn signer_seeds_owned(&self) -> Box<dyn SignerSeeds<3>>

impl Zeroable for MarginAccount

fn zeroed() -> Self

Calls zeroed.

impl Copy for MarginAccount

impl Pod for MarginAccount

impl ZeroCopy for MarginAccount