Enum Side 

pub enum Side {
    Buy,
    Sell,
    Unspecified,
}

Order direction specifying whether to buy or sell the base asset.

This enum defines the fundamental direction of an order, determining whether the trader wants to purchase (buy) or dispose of (sell) the base asset in a trading pair. Side is one of the most basic but critical order parameters.

Market Pair Interpretation

In a trading pair like “BTCUSD”:

• Base Asset: BTC (the asset being traded)
• Quote Asset: USD (the asset used for pricing/payment)

Buy Orders

• Action: Purchase base asset (BTC)
• Payment: Using quote asset (USD)
• Result: Increase BTC position, decrease USD balance

Sell Orders

• Action: Dispose of base asset (BTC)
• Receipt: Receive quote asset (USD)
• Result: Decrease BTC position, increase USD balance

Position Impact

Current Position	Buy Order	Sell Order
Flat (0)	Long	Short
Long (+)	Larger	Smaller/Short
Short (-)	Smaller/Long	Larger

Usage Examples

Basic buy and sell orders

use types::common::Side;

// Buy 1 BTC with USD
let buy_order = Side::Buy;

// Sell 1 BTC for USD
let sell_order = Side::Sell;

// Sides can be flipped for opposite orders
assert_eq!(buy_order.flip(), Side::Sell);
assert_eq!(sell_order.flip(), Side::Buy);

Order matching logic

use types::common::Side;

// Buy orders match against sell orders at same/better price
let incoming_buy = Side::Buy;   // Matches existing sells
let incoming_sell = Side::Sell; // Matches existing buys

// Order book has two sides
// Bid side: Buy orders (buyers willing to purchase)
// Ask side: Sell orders (sellers willing to sell)

Risk and Position Management

Reduce-Only Orders

• Long position + Sell order: Reduces position (allowed)
• Long position + Buy order: Increases position (blocked if reduce-only)
• Short position + Buy order: Reduces position (allowed)
• Short position + Sell order: Increases position (blocked if reduce-only)

Stop-Loss Applications

• Long position stop-loss: Sell order triggered on price drop
• Short position stop-loss: Buy order triggered on price rise

Trading Strategy Context

Directional Strategies

• Bullish: More buy orders, building long positions
• Bearish: More sell orders, building short positions
• Neutral: Balanced buy/sell for market making or arbitrage

Market Making

• Bid orders: Buy orders below current market price
• Ask orders: Sell orders above current market price
• Spread capture: Profit from bid-ask spread

JSON Representation

"Buy"   // Purchase base asset
"Sell"  // Dispose of base asset

Validation

• Must not be Unspecified in valid orders
• Should align with intended strategy and position management
• Consider current position when using reduce-only flag

Variants

Buy

Buy order - purchase the base asset using the quote asset.

Buy orders express demand for the base asset and willingness to pay the quote asset. They increase long positions or reduce short positions when executed.

Market Mechanics

• Order book side: Bid side (buyers)
• Liquidity role: Can be maker (bid below market) or taker (bid at/above market)
• Matching: Executes against existing sell orders
• Price improvement: Executes at ask price or better (lower)

Position Effects

• From flat: Creates long position
• From long: Increases position size (adds to long)
• From short: Reduces position size (covers short)

Execution Examples

Limit Buy Order

• Order: Buy 1 BTC at $50,000 (limit)
• Execution: If market trades at $50,000 or lower
• Result: Acquire 1 BTC, pay ≤ $50,000

Market Buy Order

• Order: Buy 1 BTC at market price
• Execution: Immediately at best available ask price
• Result: Acquire 1 BTC, pay current ask price

Risk Considerations

• Price risk: May pay higher than expected (market orders)
• Liquidity risk: Large orders may impact price unfavorably
• Margin requirements: May require additional collateral

Common Use Cases

• Opening long positions
• Covering short positions
• Dollar-cost averaging (regular buy orders)
• Breakout trading (buy on resistance breaks)
• Stop-loss for short positions

Sell

Sell order - dispose of the base asset to receive the quote asset.

Sell orders express supply of the base asset and willingness to accept the quote asset. They increase short positions or reduce long positions when executed.

Market Mechanics

• Order book side: Ask side (sellers)
• Liquidity role: Can be maker (ask above market) or taker (ask at/below market)
• Matching: Executes against existing buy orders
• Price improvement: Executes at bid price or better (higher)

Position Effects

• From flat: Creates short position
• From long: Reduces position size (sells long)
• From short: Increases position size (adds to short)

Execution Examples

Limit Sell Order

• Order: Sell 1 ETH at $3,500 (limit)
• Execution: If market trades at $3,500 or higher
• Result: Dispose 1 ETH, receive ≥ $3,500

Market Sell Order

• Order: Sell 1 ETH at market price
• Execution: Immediately at best available bid price
• Result: Dispose 1 ETH, receive current bid price

Risk Considerations

• Price risk: May receive less than expected (market orders)
• Liquidity risk: Large orders may depress prices
• Short selling risks: Unlimited loss potential for naked shorts

Common Use Cases

• Closing long positions (profit taking or loss cutting)
• Opening short positions (bearish speculation)
• Stop-loss for long positions
• Rebalancing portfolios
• Arbitrage opportunities

Unspecified

Unspecified order side - invalid for actual orders.

This is what serde substitutes when a submitted request omits side; validation then rejects the order. It is not Side::default() — #[default] sits on Buy, so building a request with Side::default() silently submits a buy — and it is not what SubmitOrderRequestBuilder starts from either: the builder holds Option<Side> and build() reports a missing field.

Behavior

• Always causes order validation to fail
• Never valid for order submission
• Should be replaced with Buy or Sell before submission
• Will cause flip() method to panic if used

Implementations

impl Side

pub fn flip(&self) -> Side

Trait Implementations

impl Clone for Side

fn clone(&self) -> Side

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Side

impl Debug for Side

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

Formats the value using the given formatter.

impl Default for Side

fn default() -> Side

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Side

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Side

impl PartialEq for Side

fn eq(&self, other: &Side) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Side

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.

impl StructuralPartialEq for Side