Struct Order 

pub struct Order {
    pub symbol: Symbol,
    pub side: Side,
    pub kind: OrderKind,
    pub size: Volume,
    pub limit_price: Option<Price>,
    pub reduce_only: bool,
    pub client_id: Option<String>,
    pub stop: Option<StopAttachment>,
}

A request to enter, exit, or reduce a position.

This is the framework-level abstraction; concrete exchange adapters translate it into exchange-specific payloads. The client_id is optional but strongly recommended — it lets the framework reconcile fills back to this order.

Example

use rustrade_core::{Order, Price, Side, StopAttachment, Volume};

// Market order — the everyday case.
let mkt = Order::market("BTCUSDT", Side::Buy, Volume(2.0));
assert_eq!(mkt.symbol.as_str(), "BTCUSDT");

// Limit order with a stop-market attachment.
let limit = Order::limit("ETHUSDT", Side::Sell, Volume(1.0), Price(3_500.0))
    .with_stop(StopAttachment::stop_market(Price(3_400.0)));
assert!(limit.stop.is_some());

Fields

symbol: Symbol

Symbol the order is for.

side: Side

Side of the trade (buy or sell).

kind: OrderKind

Market / limit / time-in-force variant.

size: Volume

Quantity in base-asset units or contracts.

limit_price: Option<Price>

Limit price for non-market orders.

reduce_only: bool

Set to true for exit orders that must never increase the position.

client_id: Option<String>

Optional client-supplied id. Exchanges that support it will echo it back on fills, making reconciliation trivial.

stop: Option<StopAttachment>

Optional stop-order attachment. Adapters that don’t advertise Capability::StopOrders must reject orders carrying this field.

Implementations

impl Order

pub fn market(symbol: impl Into<Symbol>, side: Side, size: Volume) -> Order

Construct a market order.

pub fn limit( symbol: impl Into<Symbol>, side: Side, size: Volume, price: Price, ) -> Order

Construct a standard limit order resting at price.

pub fn with_reduce_only(self, reduce_only: bool) -> Order

Set or clear the reduce_only flag.

pub fn with_client_id(self, id: impl Into<String>) -> Order

Set the optional client id used to reconcile fills back to this order.

pub fn with_stop(self, stop: StopAttachment) -> Order

Attach a stop. Adapter must advertise Capability::StopOrders.

Trait Implementations

impl Clone for Order

fn clone(&self) -> Order

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Order

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Order

fn deserialize<__D>( __deserializer: __D, ) -> Result<Order, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Order

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

where __S: Serializer,

Serialize this value into the given Serde serializer.