Enum agnostic_orderbook::state::Event

pub enum Event {
    Fill {
        taker_side: Side,
        maker_order_id: u128,
        quote_size: u64,
        base_size: u64,
        maker_callback_info: Vec<u8>,
        taker_callback_info: Vec<u8>,
    },
    Out {
        side: Side,
        order_id: u128,
        base_size: u64,
        delete: bool,
        callback_info: Vec<u8>,
    },
}

Events are the primary output of the asset agnostic orderbook

Variants

Fill

A fill event describes a match between a taker order and a provider order

Fields of Fill

taker_side: Sidemaker_order_id: u128

The order id of the maker order

quote_size: u64

The total quote size of the transaction

base_size: u64

The total base size of the transaction

maker_callback_info: Vec<u8>

The callback information for the maker

taker_callback_info: Vec<u8>

The callback information for the taker

Out

An out event describes an order which has been taken out of the orderbook

Fields of Out

side: Sideorder_id: u128base_size: u64delete: boolcallback_info: Vec<u8>

Implementations

impl Event

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

Used to serialize an event object into a generic byte writer.

pub fn deserialize(buf: &mut &[u8], callback_info_len: usize) -> Self

Used to deserialize an event object from bytes.

pub fn compute_slot_size(callback_info_len: usize) -> usize

An event queue is divided into slots. The size of these slots depend on the particular market’s callback_info_len constant.

Trait Implementations

impl BorshDeserialize for Event where
    Side: BorshDeserialize,
    u128: BorshDeserialize,
    u64: BorshDeserialize,
    u64: BorshDeserialize,
    Vec<u8>: BorshDeserialize,
    Vec<u8>: BorshDeserialize,
    Side: BorshDeserialize,
    u128: BorshDeserialize,
    u64: BorshDeserialize,
    bool: BorshDeserialize,
    Vec<u8>: 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 Event where
    Side: BorshSerialize,
    u128: BorshSerialize,
    u64: BorshSerialize,
    u64: BorshSerialize,
    Vec<u8>: BorshSerialize,
    Vec<u8>: BorshSerialize,
    Side: BorshSerialize,
    u128: BorshSerialize,
    u64: BorshSerialize,
    bool: BorshSerialize,
    Vec<u8>: 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 Debug for Event

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

Formats the value using the given formatter.