Enum OrderType 

pub enum OrderType {
    Limit,
    Market,
    Unspecified,
}

Order execution type determining how orders interact with the market.

This enum defines the fundamental execution behavior of orders, controlling how they interact with existing liquidity and what prices they can execute at. Order type is one of the most important parameters affecting execution outcomes.

Execution Behavior

Price Discovery vs Price Taking

• Limit orders: Specify maximum/minimum acceptable prices
• Market orders: Accept current market prices for immediate execution

Liquidity Interaction

• Limit orders: Can add liquidity (maker) or take liquidity (taker)
• Market orders: Always take liquidity (taker behavior only)

Order Type Characteristics

Type	Price Control	Execution Speed	Liquidity Role	Price Risk
Limit	High	Variable	Maker/Taker	Low
Market	Low	Immediate	Taker Only	High

Usage Examples

Limit orders for price control

use types::common::OrderType;

let limit_order = OrderType::Limit;
assert!(limit_order.is_persistant()); // Can rest on book

// Requires limit_price in SubmitOrderRequest
// Executes at specified price or better

Market orders for immediate execution

use types::common::OrderType;

let market_order = OrderType::Market;
assert!(!market_order.is_persistant()); // Never rests on book

// No limit_price allowed
// Executes immediately at best available prices

Validation Requirements

Limit Orders

• Must specify limit_price
• Price must be positive and within market bounds
• Compatible with all time-in-force options
• Can use post_only flag

Market Orders

• Must NOT specify limit_price
• Cannot use post_only flag (always takes liquidity)
• Must use IOC or FOK time-in-force; a GTC or GTT market order is rejected

Risk Considerations

Limit Order Risks

• Execution risk: May not fill if price doesn’t reach limit
• Opportunity cost: Missing moves while waiting for target price
• Stale orders: Prices may move away from limit over time

Market Order Risks

• Price risk: Execution price unknown until filled
• Slippage: Large orders may execute at multiple price levels
• Market impact: Can move prices unfavorably, especially in thin markets

JSON Representation

"Limit"   // Limit order execution
"Market"  // Market order execution

Variants

Limit

Limit order - executes only at specified price or better.

Limit orders provide precise price control by specifying the exact price at which the order should execute. They will only execute at the limit price or at a more favorable price.

Price Behavior

• Buy limits: Execute at limit price or lower (better)
• Sell limits: Execute at limit price or higher (better)
• No worse prices: Never execute at worse than limit price

Execution Characteristics

• Conditional execution: May or may not execute
• Queue position: Earlier orders have priority at same price
• Partial fills: Common as liquidity becomes available
• Book resting: Can remain on book until filled or canceled

Liquidity Role

• Maker: When limit price doesn’t cross existing orders
• Taker: When limit price matches or crosses existing orders
• Mixed: Can be maker initially, then taker as market moves

Use Cases

• Target entry prices: “Buy only if price drops to $45,000”
• Profit targets: “Sell when price reaches $55,000”
• Budget constraints: “Don’t pay more than $3,000 per ETH”
• Fee optimization: Maker orders often have lower fees

Requirements

• Must specify limit_price field
• Price must be positive and valid for the market
• Compatible with post-only flag for guaranteed maker behavior

Market

Market order - executes immediately at best available prices.

Market orders prioritize execution speed over price control, accepting whatever prices are currently available in the market. They provide guaranteed execution attempt but uncertain execution prices.

Price Behavior

• Best available: Executes at current best bid/offer prices
• Price taking: Accepts existing prices, doesn’t set new ones
• Multiple levels: Large orders may execute across price levels
• No price limits: Will execute at any available price

Execution Characteristics

• Immediate execution: Attempts to execute immediately
• Guaranteed attempt: Will always try to execute (subject to liquidity)
• No book resting: Never remains on order book
• Taker only: Always consumes existing liquidity

Slippage Considerations

Large market orders may experience slippage:

• Expected: Execute at best bid/offer
• Reality: May execute across multiple price levels
• Impact: Larger orders have higher slippage risk

Use Cases

• Urgent execution: When speed matters more than price
• Liquidity testing: Discovering available market depth
• Stop-loss execution: Exiting positions quickly
• Market opens: Getting filled at market reopening

Restrictions

• Cannot specify limit_price field
• Cannot use post_only flag (incompatible with taker-only behavior)
• Must use IOC or FOK time-in-force; GTC and GTT are rejected

Risk Management

• Consider market depth before large market orders
• Monitor for low liquidity periods
• Use limit orders when price control is important
• Consider IOC limits as alternative to pure market orders

Unspecified

Unspecified order type - invalid for actual orders.

This is what serde substitutes when a submitted request omits order_type; validation then rejects the order. It is not OrderType::default() — #[default] sits on Limit — and it is not what SubmitOrderRequestBuilder starts from either: the builder holds Option<OrderType> and build() reports a missing field.

Behavior

• Always causes order validation to fail
• Never valid for order submission
• Should be replaced with Limit or Market before submission

Implementations

impl OrderType

pub fn is_persistant(&self) -> bool

Trait Implementations

impl Clone for OrderType

fn clone(&self) -> OrderType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for OrderType

impl Debug for OrderType

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

Formats the value using the given formatter.

impl Default for OrderType

fn default() -> OrderType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OrderType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for OrderType

impl PartialEq for OrderType

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for OrderType

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 OrderType