Struct Trade 

pub struct Trade {
    pub id: TradeId,
    pub price: Price,
    pub quantity: Quantity,
    pub aggressor_order_id: OrderId,
    pub passive_order_id: OrderId,
    pub aggressor_side: Side,
    pub timestamp: Timestamp,
}

A completed trade between two orders.

Trades are created when an incoming (aggressor) order matches against a resting (passive) order on the book.

Fields

id: TradeId

Unique identifier assigned by exchange

price: Price

Execution price (always the resting order’s price)

quantity: Quantity

Quantity executed

aggressor_order_id: OrderId

Order that initiated the trade (taker)

passive_order_id: OrderId

Order that was resting on the book (maker)

aggressor_side: Side

Side of the aggressor order

timestamp: Timestamp

When the trade occurred

Implementations

impl Trade

pub fn new( id: TradeId, price: Price, quantity: Quantity, aggressor_order_id: OrderId, passive_order_id: OrderId, aggressor_side: Side, timestamp: Timestamp, ) -> Self

Create a new trade.

pub fn passive_side(&self) -> Side

Returns the side of the passive (maker) order.

pub fn notional(&self) -> i64

Returns the notional value (price × quantity).

Note: This returns the raw product of price units × quantity. Interpretation depends on your price unit convention.

pub fn vwap(trades: &[Trade]) -> Option<Price>

Compute the volume-weighted average price (VWAP) of a trade series.

Returns None if the slice is empty or total quantity is zero.

use nanobook::{Trade, Price, TradeId, OrderId, Side};

let trades = vec![
    Trade::new(TradeId(1), Price(100_00), 50, OrderId(1), OrderId(2), Side::Buy, 1),
    Trade::new(TradeId(2), Price(102_00), 150, OrderId(3), OrderId(4), Side::Buy, 2),
];
let vwap = Trade::vwap(&trades).unwrap();
// (100_00 * 50 + 102_00 * 150) / 200 = 101_50
assert_eq!(vwap, Price(101_50));

Trait Implementations

impl Clone for Trade

fn clone(&self) -> Trade

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Trade

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

Formats the value using the given formatter.

impl Display for Trade

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

Formats the value using the given formatter.

impl PartialEq for Trade

fn eq(&self, other: &Trade) -> 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 Eq for Trade

impl StructuralPartialEq for Trade