Struct phoenix_sdk_core::packet_decoder::LimitPacket

pub struct LimitPacket {
    pub side: Side,
    pub price_in_ticks: u64,
    pub num_base_lots: u64,
    pub self_trade_behavior: SelfTradeBehavior,
    pub match_limit: Option<u64>,
    pub client_order_id: u128,
    pub use_only_deposited_funds: bool,
    pub last_valid_slot: Option<u64>,
    pub last_valid_unix_timestamp_in_seconds: Option<u64>,
}

Fields

side: Side

price_in_ticks: u64

The price of the order, in ticks

num_base_lots: u64

Total number of base lots to place on the book or fill at a better price

self_trade_behavior: SelfTradeBehavior

How the matching engine should handle a self trade

match_limit: Option<u64>

Number of orders to match against. If this is None there is no limit

client_order_id: u128

Client order id used to identify the order in the response to the client

use_only_deposited_funds: bool

Flag for whether or not the order should only use funds that are already in the account. Using only deposited funds will allow the trader to pass in less accounts per instruction and save transaction space as well as compute. This is only for traders who have a seat

last_valid_slot: Option<u64>

If this is set, the order will be invalid after the specified slot

last_valid_unix_timestamp_in_seconds: Option<u64>

If this is set, the order will be invalid after the specified unix timestamp

Trait Implementations

impl BorshDeserialize for LimitPacketwhere Side: BorshDeserialize, u64: BorshDeserialize, SelfTradeBehavior: BorshDeserialize, Option<u64>: BorshDeserialize, u128: BorshDeserialize, bool: 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 LimitPacketwhere Side: BorshSerialize, u64: BorshSerialize, SelfTradeBehavior: BorshSerialize, Option<u64>: BorshSerialize, u128: BorshSerialize, bool: 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.