Struct TunaPosition

pub struct TunaPosition {

    pub discriminator: [u8; 8],
    pub version: u16,
    pub bump: [u8; 1],
    pub authority: Pubkey,
    pub pool: Pubkey,
    pub mint_a: Pubkey,
    pub mint_b: Pubkey,
    pub position_mint: Pubkey,
    pub liquidity: u128,
    pub tick_lower_index: i32,
    pub tick_upper_index: i32,
    pub loan_shares_a: u64,
    pub loan_shares_b: u64,
    pub loan_funds_a: u64,
    pub loan_funds_b: u64,
    pub leftovers_a: u64,
    pub leftovers_b: u64,
    pub tick_entry_index: i32,
    pub tick_stop_loss_index: i32,
    pub tick_take_profit_index: i32,
    pub state: TunaPositionState,
    pub swap_to_token_on_limit_order: u8,
    pub compounded_yield_a: u64,
    pub compounded_yield_b: u64,
    pub flags: u32,
    pub market_maker: MarketMaker,
    pub reserved: [u8; 61],
}

Fields

discriminator: [u8; 8]

version: u16

Struct version

bump: [u8; 1]

Bump seed for the tuna position account

authority: Pubkey

The authority address used for managing the position

pool: Pubkey

Liquidity pool address this position belongs to

mint_a: Pubkey

The mint address for token A

mint_b: Pubkey

The mint address for token B

position_mint: Pubkey

The mint address for the position token (minted and used in Orca/Fusion)

liquidity: u128

Total minted liquidity

tick_lower_index: i32

Position lower tick

tick_upper_index: i32

Position upper tick

loan_shares_a: u64

The amount of shares borrowed by user from vault A.

loan_shares_b: u64

The amount of shares borrowed by user from vault B.

loan_funds_a: u64

The amount of funds borrowed by user from vault A. Doesn’t include accrued interest.

loan_funds_b: u64

The amount of funds borrowed by user from vault B. Doesn’t include accrued interest.

leftovers_a: u64

The leftovers are funds that couldn’t be added to a pool as liquidity. They remain in the position token account.

leftovers_b: u64

The leftovers are funds that couldn’t be added to a pool as liquidity. They remain in the position token account.

tick_entry_index: i32

Position entry tick index.

tick_stop_loss_index: i32

Position stop loss tick index.

tick_take_profit_index: i32

Position stop loss tick index.

state: TunaPositionState

Position state: normal, liquidated, closed by limit order

swap_to_token_on_limit_order: u8

OBSOLETE: Which token to swap collateral to when a limit order is executed. Used for position ver 4 or older. bits 0..1: Stop loss swap. 0 - no swap, 1 - swap to token A, 2 - swap to token B bits 2..3: Take profit swap. 0 - no swap, 1 - swap to token A, 2 - swap to token B

compounded_yield_a: u64

Yield amount in token A that has already been collected and compounded into the position.

compounded_yield_b: u64

Yield amount in token B that has already been collected and compounded into the position.

flags: u32

Position options. Bits 0..1: Stop loss swap. 0 - no swap, 1 - swap to token A, 2 - swap to token B Bits 2..3: Take profit swap. 0 - no swap, 1 - swap to token A, 2 - swap to token B Bits 4..5: Yield auto compounding. 0 - don’t compound, 1 - compound yield, 2 - compound yield with leverage

market_maker: MarketMaker

Market maker (Orca, Fusion)

reserved: [u8; 61]

Reserved

Implementations

impl TunaPosition

pub fn get_total_balance( &self, sqrt_price: u128, ) -> Result<(u64, u64), ErrorCode>

Returns the total position balance.

pub fn compute_total_and_debt( &self, sqrt_price: u128, vault_a: &Vault, vault_b: &Vault, ) -> Result<(u64, u64), ErrorCode>

Returns the current position total and debt size.

pub fn is_healthy( &self, sqrt_price: u128, market: &Market, vault_a: &Vault, vault_b: &Vault, ) -> Result<(bool, u32), ErrorCode>

Returns if the position is healthy or not. Vaults must be passed with accrued interest.

pub fn is_liquidated(&self) -> bool

pub fn is_limit_order_reached(&self, sqrt_price: u128) -> bool

pub fn compute_leverage( &self, sqrt_price: u128, vault_a: &Vault, vault_b: &Vault, ) -> Result<Fixed128, ErrorCode>

Returns the current leverage of a position. Vaults must be passed with accrued interest.

pub fn get_pool_key(&self) -> String

impl TunaPosition

pub const LEN: usize = 339usize

pub fn from_bytes(data: &[u8]) -> Result<Self, Error>

Trait Implementations

impl BorshDeserialize for TunaPosition

where [u8; 8]: BorshDeserialize, u16: BorshDeserialize, [u8; 1]: BorshDeserialize, Pubkey: BorshDeserialize, u128: BorshDeserialize, i32: BorshDeserialize, u64: BorshDeserialize, TunaPositionState: BorshDeserialize, u8: BorshDeserialize, u32: BorshDeserialize, MarketMaker: BorshDeserialize, [u8; 61]: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for TunaPosition

where [u8; 8]: BorshSerialize, u16: BorshSerialize, [u8; 1]: BorshSerialize, Pubkey: BorshSerialize, u128: BorshSerialize, i32: BorshSerialize, u64: BorshSerialize, TunaPositionState: BorshSerialize, u8: BorshSerialize, u32: BorshSerialize, MarketMaker: BorshSerialize, [u8; 61]: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for TunaPosition

fn clone(&self) -> TunaPosition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TunaPosition

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

Formats the value using the given formatter.

impl Display for TunaPosition

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

Formats the value using the given formatter.

impl PartialEq for TunaPosition

fn eq(&self, other: &TunaPosition) -> 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<'a> TryFrom<&AccountInfo<'a>> for TunaPosition

type Error = Error

The type returned in the event of a conversion error.

fn try_from(account_info: &AccountInfo<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for TunaPosition

impl StructuralPartialEq for TunaPosition