Standardize OKX execution flows and enum conversions

Author: cjdsellers

crates/adapters/okx/src/common/enums.rs

@@ -15,6 +15,7 @@
 
 use nautilus_model::enums::{
     AggressorSide, LiquiditySide, OptionKind, OrderSide, OrderStatus, OrderType, PositionSide,
+    TriggerType,
 };
 use serde::{Deserialize, Serialize};
 use strum::{AsRefStr, Display, EnumIter, EnumString};
@@ -554,6 +555,17 @@ pub enum OKXTriggerType {
     Mark,
 }
 
+impl From<TriggerType> for OKXTriggerType {
+    fn from(value: TriggerType) -> Self {
+        match value {
+            TriggerType::LastPrice => Self::Last,
+            TriggerType::MarkPrice => Self::Mark,
+            TriggerType::IndexPrice => Self::Index,
+            _ => Self::Last,
+        }
+    }
+}
+
 /// Represents OKX VIP level tiers for trading fee structure and API limits.
 ///
 /// VIP levels determine:

crates/adapters/okx/src/common/parse.rs

@@ -414,26 +414,9 @@ pub fn parse_order_status_report(
         .map(|v| Quantity::new(v, size_precision))
         .unwrap_or_default();
     let order_side: OrderSide = order.side.into();
-    let okx_status: OKXOrderStatus = match order.state.as_str() {
-        "live" => OKXOrderStatus::Live,
-        "partially_filled" => OKXOrderStatus::PartiallyFilled,
-        "filled" => OKXOrderStatus::Filled,
-        "canceled" => OKXOrderStatus::Canceled,
-        "mmp_canceled" => OKXOrderStatus::MmpCanceled,
-        _ => OKXOrderStatus::Live, // Default fallback
-    };
+    let okx_status: OKXOrderStatus = order.state;
     let order_status: OrderStatus = okx_status.into();
-    let okx_ord_type: OKXOrderType = match order.ord_type.as_str() {
-        "market" => OKXOrderType::Market,
-        "limit" => OKXOrderType::Limit,
-        "post_only" => OKXOrderType::PostOnly,
-        "fok" => OKXOrderType::Fok,
-        "ioc" => OKXOrderType::Ioc,
-        "optimal_limit_ioc" => OKXOrderType::OptimalLimitIoc,
-        "mmp" => OKXOrderType::Mmp,
-        "mmp_and_post_only" => OKXOrderType::MmpAndPostOnly,
-        _ => OKXOrderType::Limit, // Default fallback
-    };
+    let okx_ord_type: OKXOrderType = order.ord_type;
     let order_type: OrderType = okx_ord_type.into();
     // Note: OKX uses ordType for type and liquidity instructions; time-in-force not explicitly represented here
     let time_in_force = TimeInForce::Gtc;
@@ -476,7 +459,7 @@ pub fn parse_order_status_report(
     {
         report = report.with_avg_px(avg);
     }
-    if order.ord_type == "post_only" {
+    if order.ord_type == OKXOrderType::PostOnly {
         report = report.with_post_only(true);
     }
     if order.reduce_only == "true" {

crates/adapters/okx/src/http/client.rs

@@ -85,7 +85,10 @@ use crate::{
     common::{
         consts::{OKX_HTTP_URL, OKX_NAUTILUS_BROKER_ID, should_retry_error_code},
         credential::Credential,
-        enums::{OKXInstrumentType, OKXPositionMode, OKXTradeMode},
+        enums::{
+            OKXAlgoOrderType, OKXInstrumentType, OKXPositionMode, OKXSide, OKXTradeMode,
+            OKXTriggerType,
+        },
         models::OKXInstrument,
         parse::{
             okx_instrument_type, parse_account_state, parse_candlestick, parse_fill_report,
@@ -2063,28 +2066,15 @@ impl OKXHttpClient {
         limit_price: Option<Price>,
         reduce_only: Option<bool>,
     ) -> Result<OKXPlaceAlgoOrderResponse, OKXHttpError> {
-        // Map order side to OKX format
-        let side_str = match order_side {
-            OrderSide::Buy => "buy",
-            OrderSide::Sell => "sell",
-            _ => {
-                return Err(OKXHttpError::ValidationError(
-                    "Invalid order side".to_string(),
-                ));
-            }
-        };
+        if !matches!(order_side, OrderSide::Buy | OrderSide::Sell) {
+            return Err(OKXHttpError::ValidationError(
+                "Invalid order side".to_string(),
+            ));
+        }
+        let okx_side: OKXSide = order_side.into();
 
         // Map trigger type to OKX format
-        let trigger_px_type_str = if let Some(trigger) = trigger_type {
-            match trigger {
-                TriggerType::LastPrice => "last",
-                TriggerType::MarkPrice => "mark",
-                TriggerType::IndexPrice => "index",
-                _ => "last", // Default to last for unsupported types
-            }
-        } else {
-            "last" // Default
-        };
+        let trigger_px_type_enum = trigger_type.map(Into::into).unwrap_or(OKXTriggerType::Last);
 
         // Determine order price based on order type
         let order_px = if matches!(order_type, OrderType::StopLimit | OrderType::LimitIfTouched) {
@@ -2096,14 +2086,14 @@ impl OKXHttpClient {
 
         let request = OKXPlaceAlgoOrderRequest {
             inst_id: instrument_id.symbol.as_str().to_string(),
-            td_mode: td_mode.to_string().to_lowercase(),
-            side: side_str.to_string(),
-            ord_type: "trigger".to_string(), // All conditional orders use 'trigger' type
+            td_mode,
+            side: okx_side,
+            ord_type: OKXAlgoOrderType::Trigger, // All conditional orders use 'trigger' type
             sz: quantity.to_string(),
             algo_cl_ord_id: Some(client_order_id.as_str().to_string()),
             trigger_px: Some(trigger_price.to_string()),
             order_px,
-            trigger_px_type: Some(trigger_px_type_str.to_string()),
+            trigger_px_type: Some(trigger_px_type_enum),
             tgt_ccy: None,  // Let OKX determine based on instrument
             pos_side: None, // Use default position side
             close_position: None,

crates/adapters/okx/src/http/models.rs

@@ -62,7 +62,10 @@ pub struct OKXCandlestick(
 );
 
 use crate::common::{
-    enums::{OKXExecType, OKXInstrumentType, OKXMarginMode, OKXPositionSide, OKXSide},
+    enums::{
+        OKXAlgoOrderType, OKXExecType, OKXInstrumentType, OKXMarginMode, OKXOrderStatus,
+        OKXOrderType, OKXPositionSide, OKXSide, OKXTradeMode, OKXTriggerType,
+    },
     parse::deserialize_string_to_u64,
 };
 
@@ -372,13 +375,12 @@ pub struct OKXPlaceOrderResponse {
     pub side: Option<OKXSide>,
     /// Order type (optional).
     #[serde(default)]
-    pub ord_type: Option<String>,
+    pub ord_type: Option<OKXOrderType>,
     /// Order size (optional).
     #[serde(default)]
     pub sz: Option<String>,
     /// Order state (optional).
-    #[serde(default)]
-    pub state: Option<String>,
+    pub state: Option<OKXOrderStatus>,
     /// Price (optional).
     #[serde(default)]
     pub px: Option<String>,
@@ -446,7 +448,7 @@ pub struct OKXOrderHistory {
     /// Instrument ID.
     pub inst_id: Ustr,
     /// Order type.
-    pub ord_type: String,
+    pub ord_type: OKXOrderType,
     /// Order size.
     pub sz: String,
     /// Price (optional).
@@ -456,13 +458,13 @@ pub struct OKXOrderHistory {
     /// Position side.
     pub pos_side: OKXPositionSide,
     /// Trade mode.
-    pub td_mode: String,
+    pub td_mode: OKXTradeMode,
     /// Reduce-only flag.
     pub reduce_only: String,
     /// Target currency (optional).
     pub tgt_ccy: String,
     /// Order state.
-    pub state: String,
+    pub state: OKXOrderStatus,
     /// Average price (optional).
     pub avg_px: String,
     /// Execution fee.
@@ -617,12 +619,12 @@ pub struct OKXPlaceAlgoOrderRequest {
     pub inst_id: String,
     /// Trade mode (isolated, cross, cash).
     #[serde(rename = "tdMode")]
-    pub td_mode: String,
+    pub td_mode: OKXTradeMode,
     /// Order side (buy, sell).
-    pub side: String,
+    pub side: OKXSide,
     /// Algo order type (trigger).
     #[serde(rename = "ordType")]
-    pub ord_type: String,
+    pub ord_type: OKXAlgoOrderType,
     /// Order size.
     pub sz: String,
     /// Client-supplied algo order ID.
@@ -636,13 +638,13 @@ pub struct OKXPlaceAlgoOrderRequest {
     pub order_px: Option<String>,
     /// Trigger type (last, mark, index).
     #[serde(rename = "triggerPxType", skip_serializing_if = "Option::is_none")]
-    pub trigger_px_type: Option<String>,
+    pub trigger_px_type: Option<OKXTriggerType>,
     /// Target currency (base_ccy or quote_ccy).
     #[serde(rename = "tgtCcy", skip_serializing_if = "Option::is_none")]
     pub tgt_ccy: Option<String>,
     /// Position side (net, long, short).
     #[serde(rename = "posSide", skip_serializing_if = "Option::is_none")]
-    pub pos_side: Option<String>,
+    pub pos_side: Option<OKXPositionSide>,
     /// Whether to close position.
     #[serde(rename = "closePosition", skip_serializing_if = "Option::is_none")]
     pub close_position: Option<bool>,
@@ -717,14 +719,14 @@ mod tests {
     fn test_algo_order_request_serialization() {
         let request = OKXPlaceAlgoOrderRequest {
             inst_id: "ETH-USDT-SWAP".to_string(),
-            td_mode: "isolated".to_string(),
-            side: "buy".to_string(),
-            ord_type: "trigger".to_string(),
+            td_mode: OKXTradeMode::Isolated,
+            side: OKXSide::Buy,
+            ord_type: OKXAlgoOrderType::Trigger,
             sz: "0.01".to_string(),
             algo_cl_ord_id: Some("test123".to_string()),
             trigger_px: Some("3000".to_string()),
             order_px: Some("-1".to_string()),
-            trigger_px_type: Some("last".to_string()),
+            trigger_px_type: Some(OKXTriggerType::Last),
             tgt_ccy: None,
             pos_side: None,
             close_position: None,
@@ -753,16 +755,16 @@ mod tests {
     fn test_algo_order_request_array_serialization() {
         let request = OKXPlaceAlgoOrderRequest {
             inst_id: "BTC-USDT".to_string(),
-            td_mode: "cross".to_string(),
-            side: "sell".to_string(),
-            ord_type: "trigger".to_string(),
+            td_mode: OKXTradeMode::Cross,
+            side: OKXSide::Sell,
+            ord_type: OKXAlgoOrderType::Trigger,
             sz: "0.1".to_string(),
             algo_cl_ord_id: None,
             trigger_px: Some("50000".to_string()),
             order_px: Some("49900".to_string()),
-            trigger_px_type: Some("mark".to_string()),
+            trigger_px_type: Some(OKXTriggerType::Mark),
             tgt_ccy: Some("base_ccy".to_string()),
-            pos_side: Some("net".to_string()),
+            pos_side: Some(OKXPositionSide::Net),
             close_position: None,
             tag: None,
             reduce_only: Some(true),

crates/adapters/okx/src/http/parse.rs

@@ -20,7 +20,10 @@ mod tests {
 
     use crate::{
         common::{
-            enums::{OKXExecType, OKXInstrumentType, OKXMarginMode, OKXPositionSide, OKXSide},
+            enums::{
+                OKXExecType, OKXInstrumentType, OKXMarginMode, OKXOrderStatus, OKXPositionSide,
+                OKXSide,
+            },
             testing::load_test_json,
         },
         http::{
@@ -227,7 +230,7 @@ mod tests {
         assert_eq!(order.ord_id, "2497956918703120384");
         assert_eq!(order.fill_sz, "0.03");
         assert_eq!(order.acc_fill_sz, "0.03");
-        assert_eq!(order.state, "filled");
+        assert_eq!(order.state, OKXOrderStatus::Filled);
         // fill_fee was omitted in response
         assert!(order.fill_fee.is_none());
     }

crates/adapters/okx/src/http/query.rs

@@ -43,7 +43,8 @@ use serde::{self, Deserialize, Serialize};
 
 use crate::{
     common::enums::{
-        OKXInstrumentType, OKXOrderStatus, OKXPositionMode, OKXPositionSide, OKXTradeMode,
+        OKXInstrumentType, OKXOrderStatus, OKXOrderType, OKXPositionMode, OKXPositionSide,
+        OKXTradeMode,
     },
     http::error::BuildError,
 };
@@ -315,7 +316,7 @@ pub struct GetOrderHistoryParams {
     pub inst_id: Option<String>,
     /// Order type: limit, market, post_only, fok, ioc (optional).
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub ord_type: Option<String>,
+    pub ord_type: Option<OKXOrderType>,
     /// Order state: live, filled, canceled (optional).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub state: Option<String>,

crates/adapters/okx/src/python/websocket.rs

@@ -265,7 +265,7 @@ impl OKXWebSocketClient {
                             call_python(py, &callback, py_obj);
                         }),
                         NautilusWsMessage::AccountUpdate(msg) => {
-                            call_python_with_data(&callback, |py| msg.py_to_dict(py));
+                            call_python_with_data(&callback, |py| msg.into_py_any(py));
                         }
                         NautilusWsMessage::Reconnected => {} // Nothing to handle
                         NautilusWsMessage::Error(msg) => {

crates/adapters/okx/src/websocket/client.rs

@@ -82,8 +82,8 @@ use crate::{
         },
         credential::Credential,
         enums::{
-            OKXInstrumentType, OKXOrderStatus, OKXOrderType, OKXPositionSide, OKXSide,
-            OKXTradeMode, OKXTriggerType, conditional_order_to_algo_type, is_conditional_order,
+            OKXInstrumentType, OKXOrderStatus, OKXOrderType, OKXPositionSide, OKXTradeMode,
+            OKXTriggerType, conditional_order_to_algo_type, is_conditional_order,
         },
         parse::{
             bar_spec_as_okx_channel, okx_instrument_type, parse_account_state,
@@ -1927,7 +1927,7 @@ impl OKXWebSocketClient {
         }
         // If is_quote_quantity is false, we don't set tgtCcy (defaults to base currency)
 
-        builder.side(OKXSide::from(order_side));
+        builder.side(order_side);
 
         if let Some(pos_side) = position_side {
             builder.pos_side(pos_side);
@@ -2206,7 +2206,7 @@ impl OKXWebSocketClient {
             builder.inst_id(inst_id.symbol.inner());
             builder.td_mode(td_mode);
             builder.cl_ord_id(cl_ord_id.as_str());
-            builder.side(OKXSide::from(ord_side));
+            builder.side(ord_side);
 
             if let Some(ps) = pos_side {
                 builder.pos_side(OKXPositionSide::from(ps));
@@ -2389,10 +2389,16 @@ impl OKXWebSocketClient {
         }
 
         let mut builder = WsPostAlgoOrderParamsBuilder::default();
+        if !matches!(order_side, OrderSide::Buy | OrderSide::Sell) {
+            return Err(OKXWsError::ClientError(
+                "Invalid order side for OKX".to_string(),
+            ));
+        }
+
         builder.inst_id(instrument_id.symbol.inner());
         builder.td_mode(td_mode);
         builder.cl_ord_id(client_order_id.as_str());
-        builder.side(OKXSide::from(order_side));
+        builder.side(order_side);
         builder.ord_type(
             conditional_order_to_algo_type(order_type)
                 .map_err(|e| OKXWsError::ClientError(e.to_string()))?,
@@ -2401,16 +2407,7 @@ impl OKXWebSocketClient {
         builder.trigger_px(trigger_price.to_string());
 
         // Map Nautilus TriggerType to OKX trigger type
-        let okx_trigger_type = if let Some(trigger) = trigger_type {
-            match trigger {
-                TriggerType::LastPrice => OKXTriggerType::Last,
-                TriggerType::MarkPrice => OKXTriggerType::Mark,
-                TriggerType::IndexPrice => OKXTriggerType::Index,
-                _ => OKXTriggerType::Last, // Default to Last for unsupported types
-            }
-        } else {
-            OKXTriggerType::Last // Default
-        };
+        let okx_trigger_type = trigger_type.map(Into::into).unwrap_or(OKXTriggerType::Last);
         builder.trigger_px_type(okx_trigger_type);
 
         // For stop-limit orders, set the limit price
@@ -3389,7 +3386,7 @@ mod tests {
     use rstest::rstest;
 
     use super::*;
-    use crate::common::enums::OKXExecType;
+    use crate::common::enums::{OKXExecType, OKXSide};
 
     #[rstest]
     fn test_timestamp_format_for_websocket_auth() {

crates/adapters/okx/src/websocket/parse.rs

@@ -611,14 +611,7 @@ pub fn parse_algo_order_status_report(
         OrderType::StopLimit
     };
 
-    let status = match msg.state {
-        OKXOrderStatus::Live => OrderStatus::Accepted,
-        OKXOrderStatus::Canceled => OrderStatus::Canceled,
-        OKXOrderStatus::MmpCanceled => OrderStatus::Canceled,
-        OKXOrderStatus::Filled => OrderStatus::Filled,
-        OKXOrderStatus::PartiallyFilled => OrderStatus::PartiallyFilled,
-        OKXOrderStatus::OrderPlaced => OrderStatus::Triggered,
-    };
+    let status: OrderStatus = msg.state.into();
 
     let quantity = parse_quantity(msg.sz.as_str(), instrument.size_precision())?;