Struct TradeData

#[repr(C)]
pub struct TradeData {

    pub trade_id: u64,
    pub authority: Pubkey,
    pub store: Pubkey,
    pub market_token: Pubkey,
    pub user: Pubkey,
    pub position: Pubkey,
    pub order: Pubkey,
    pub final_output_token: Pubkey,
    pub ts: i64,
    pub slot: u64,
    pub before: PositionState,
    pub after: PositionState,
    pub transfer_out: TransferOut,
    pub prices: TradePrices,
    pub execution_price: u128,
    pub price_impact_value: i128,
    pub price_impact_diff: u128,
    pub pnl: TradePnl,
    pub fees: TradeFees,
    pub output_amounts: TradeOutputAmounts,
    /* private fields */
}

Trade event data.

Fields

trade_id: u64

Trade id.

authority: Pubkey

Authority.

store: Pubkey

Store address.

market_token: Pubkey

Market token.

user: Pubkey

User.

position: Pubkey

Position address.

order: Pubkey

Order address.

final_output_token: Pubkey

Final output token.

ts: i64

Trade ts.

slot: u64

Trade slot.

before: PositionState

Before state.

after: PositionState

After state.

transfer_out: TransferOut

Transfer out.

prices: TradePrices

Prices.

execution_price: u128

Execution price.

price_impact_value: i128

Price impact value.

price_impact_diff: u128

Price impact diff.

pnl: TradePnl

Processed pnl.

fees: TradeFees

Fees.

output_amounts: TradeOutputAmounts

Output amounts.

Implementations

impl TradeData

pub fn is_long(&self) -> bool

Return whether the position side is long.

pub fn is_collateral_long(&self) -> bool

Return whether the collateral side is long.

pub fn is_increase(&self) -> bool

Return whether the trade is caused by an increase order.

Trait Implementations

impl AccountDeserialize for TradeData

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 BorshDeserialize for TradeData

where u8: BorshDeserialize, [u8; 7]: BorshDeserialize, u64: BorshDeserialize, Pubkey: BorshDeserialize, i64: BorshDeserialize, PositionState: BorshDeserialize, TransferOut: BorshDeserialize, [u8; 8]: BorshDeserialize, TradePrices: BorshDeserialize, u128: BorshDeserialize, i128: BorshDeserialize, TradePnl: BorshDeserialize, TradeFees: BorshDeserialize, TradeOutputAmounts: 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 TradeData

where u8: BorshSerialize, [u8; 7]: BorshSerialize, u64: BorshSerialize, Pubkey: BorshSerialize, i64: BorshSerialize, PositionState: BorshSerialize, TransferOut: BorshSerialize, [u8; 8]: BorshSerialize, TradePrices: BorshSerialize, u128: BorshSerialize, i128: BorshSerialize, TradePnl: BorshSerialize, TradeFees: BorshSerialize, TradeOutputAmounts: 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 TradeData

fn clone(&self) -> TradeData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TradeData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TradeData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Discriminator for TradeData

const DISCRIMINATOR: [u8; 8]

fn discriminator() -> [u8; 8]

impl InitSpace for TradeData

const INIT_SPACE: usize = 1_232usize

Init Space.

impl Owner for TradeData

fn owner() -> Pubkey

impl Seed for TradeData

const SEED: &'static [u8] = b"trade_event_data"

Prefix seed for program derived addresses.

impl Serialize for TradeData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Space for TradeData

const INIT_SPACE: usize = 1_232usize

impl Zeroable for TradeData

fn zeroed() -> Self

Calls zeroed.

impl Copy for TradeData

impl Pod for TradeData

impl ZeroCopy for TradeData