Struct dex_v3::state::UserAccountHeader

pub struct UserAccountHeader {
    pub tag: AccountTag,
    pub market: Pubkey,
    pub owner: Pubkey,
    pub base_token_free: u64,
    pub base_token_locked: u64,
    pub quote_token_free: u64,
    pub quote_token_locked: u64,
    pub accumulated_rebates: u64,
    pub number_of_orders: u32,
}

This header describes a user account’s state

Fields

tag: AccountTag

This byte is used to verify and version the dex state

market: Pubkey

The user account’s assocatied DEX market

owner: Pubkey

The user account owner’s wallet

base_token_free: u64

The amount of base token available for settlement

base_token_locked: u64

The amount of base token currently locked in the orderbook

quote_token_free: u64

The amount of quote token available for settlement

quote_token_locked: u64

The amount of quote token currently locked in the orderbook

accumulated_rebates: u64

The all time quantity of rebates accumulated by this user account.

The actual rebates will always be transfer to the user account’s main balance. This field is just a metric.

number_of_orders: u32

The user account’s number of active orders.

Trait Implementations

impl BorshDeserialize for UserAccountHeader where
    AccountTag: BorshDeserialize,
    Pubkey: BorshDeserialize,
    Pubkey: BorshDeserialize,
    u64: BorshDeserialize,
    u64: BorshDeserialize,
    u64: BorshDeserialize,
    u64: BorshDeserialize,
    u64: BorshDeserialize,
    u32: BorshDeserialize, 

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.

impl BorshSerialize for UserAccountHeader where
    AccountTag: BorshSerialize,
    Pubkey: BorshSerialize,
    Pubkey: BorshSerialize,
    u64: BorshSerialize,
    u64: BorshSerialize,
    u64: BorshSerialize,
    u64: BorshSerialize,
    u64: BorshSerialize,
    u32: BorshSerialize, 

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

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

Serialize this instance into a vector of bytes.

impl IsInitialized for UserAccountHeader

fn is_initialized(&self) -> bool

Is initialized

impl Pack for UserAccountHeader

const LEN: usize

The length, in bytes, of the packed representation

fn pack_into_slice(&self, dst: &mut [u8])

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

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 Sealed for UserAccountHeader