rusty_oms/exchanges/

bybit.rs

//! Bybit exchange implementation
//!
//! This module provides order management functionality for the Bybit exchange.
//! Note: This implementation is deprecated in favor of rusty_ems::exchanges::BybitRestClient.

use std::time::{SystemTime, UNIX_EPOCH};

use async_trait::async_trait;
use hmac::{Hmac, Mac};
use log::{debug, error};
use reqwest::Client;
use rusty_model::{
    enums::{OrderSide, OrderStatus, OrderType, TimeInForce},
    trading_order::Order,
};
use serde::{Deserialize, Serialize};
use sha2::Sha256;
use simd_json::json;
use smallvec::SmallVec;

use crate::execution_engine::Exchange;

type HmacSha256 = Hmac<Sha256>;

// Bybit API URLs
const API_URL: &str = "https://api.bybit.com";
const TESTNET_API_URL: &str = "https://api-testnet.bybit.com";

/// Generic response wrapper for Bybit API
#[derive(Debug, Serialize, Deserialize)]
struct BybitResponse<T> {
    /// Return code (0 for success)
    ret_code: i32,
    /// Return message
    ret_msg: std::string::String,
    /// Response result data
    result: Option<T>,
    /// Extended information
    ret_ext_info: Option<simd_json::OwnedValue>,
    /// Response timestamp
    time: u64,
}

/// Order result structure from Bybit API
#[derive(Debug, Serialize, Deserialize)]
struct BybitOrderResult {
    /// Exchange-assigned order ID
    order_id: std::string::String,
    /// Client-assigned order ID
    order_link_id: std::string::String,
    /// Trading symbol
    symbol: std::string::String,
    /// Order side
    side: std::string::String,
    /// Order type
    order_type: std::string::String,
    /// Order price
    price: std::string::String,
    /// Order quantity
    qty: std::string::String,
    /// Time in force
    time_in_force: std::string::String,
    /// Order status
    order_status: std::string::String,
    /// Creation timestamp
    create_time: std::string::String,
    /// Update timestamp
    update_time: std::string::String,
}

/// Bybit exchange implementation
#[deprecated(
    note = "Use rusty_ems::exchanges::BybitRestClient instead for better performance and features"
)]
pub struct BybitExchange {
    /// API key for authentication
    pub api_key: std::string::String,
    /// Secret key for signing requests
    pub secret_key: std::string::String,
    /// HTTP client for REST API calls
    client: Client,
    /// Whether to use testnet
    testnet: bool,
}

#[allow(deprecated)]
impl BybitExchange {
    /// Create a new Bybit exchange instance
    #[must_use]
    pub fn new(api_key: std::string::String, secret_key: std::string::String) -> Self {
        Self {
            api_key,
            secret_key,
            client: Client::new(),
            testnet: false,
        }
    }

    /// Create a new Bybit exchange instance with testnet flag
    #[must_use]
    pub fn with_testnet(
        api_key: std::string::String,
        secret_key: std::string::String,
        testnet: bool,
    ) -> Self {
        Self {
            api_key,
            secret_key,
            client: Client::new(),
            testnet,
        }
    }

    /// Get the base URL based on testnet flag
    const fn get_base_url(&self) -> &'static str {
        if self.testnet {
            TESTNET_API_URL
        } else {
            API_URL
        }
    }

    /// Map Bybit order status to internal `OrderStatus`
    fn map_order_status(status: &str) -> OrderStatus {
        match status {
            "Created" | "New" => OrderStatus::New,
            "PartiallyFilled" => OrderStatus::PartiallyFilled,
            "Filled" => OrderStatus::Filled,
            "Cancelled" | "Rejected" => OrderStatus::Cancelled, // Use the correct variant spelling
            "PendingCancel" => OrderStatus::PendingCancel,
            _ => OrderStatus::New,
        }
    }

    /// Map internal `OrderType` to Bybit order type
    const fn map_order_type(order_type: OrderType) -> &'static str {
        match order_type {
            OrderType::Limit => "Limit",
            OrderType::Market => "Market",
            _ => "Limit", // Default to limit for unsupported types
        }
    }

    /// Map internal `OrderSide` to Bybit order side
    const fn map_order_side(side: OrderSide) -> &'static str {
        match side {
            OrderSide::Buy => "Buy",
            OrderSide::Sell => "Sell",
        }
    }

    /// Map internal `TimeInForce` to Bybit time in force
    const fn map_time_in_force(tif: TimeInForce) -> &'static str {
        match tif {
            TimeInForce::GTC => "GoodTillCancel",
            TimeInForce::IOC => "ImmediateOrCancel",
            TimeInForce::FOK => "FillOrKill",
            _ => "GoodTillCancel", // Default to GTC for unsupported types
        }
    }

    /// Generate signature for Bybit API requests
    fn generate_signature(&self, timestamp: u64, params: &str) -> std::string::String {
        let string_to_sign = format!("{}{}{}", timestamp, self.api_key, params);
        let mut mac = HmacSha256::new_from_slice(self.secret_key.as_bytes())
            .expect("HMAC can take key of any size");
        mac.update(string_to_sign.as_bytes());
        let result = mac.finalize();
        hex::encode(result.into_bytes())
    }

    /// Get current timestamp in milliseconds
    fn get_timestamp() -> u64 {
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("Time went backwards")
            .as_millis() as u64
    }

    /// Function to extract `time_in_force` from `order_type`
    const fn get_time_in_force(&self, order_type: OrderType) -> TimeInForce {
        match order_type {
            OrderType::Market => TimeInForce::IOC,
            OrderType::Limit => TimeInForce::GTC,
            _ => TimeInForce::GTC,
        }
    }
}

#[async_trait]
#[allow(deprecated)]
impl Exchange for BybitExchange {
    async fn send_order(&self, order: Order) -> crate::Result<()> {
        let timestamp = Self::get_timestamp();
        let base_url = self.get_base_url();

        // Determine the category based on the instrument type
        // For simplicity, we'll assume spot trading here
        let category = "spot";

        // Construct the request body
        let body = json!({
            "category": category,
            "symbol": order.symbol.clone(),
            "side": Self::map_order_side(order.side),
            "orderType": Self::map_order_type(order.order_type),
            "qty": order.quantity.to_string(),
            "price": order.price.map_or_else(|| "0".to_string(), |p| p.to_string()),
            "timeInForce": Self::map_time_in_force(self.get_time_in_force(order.order_type)),
            "orderLinkId": order.id.clone(), // Using order ID as order link ID
        });

        let body_str = simd_json::to_string(&body)
            .map_err(|e| crate::OmsError::Exchange(format!("Failed to serialize: {e}").into()))?;

        // Generate signature
        let signature = self.generate_signature(timestamp, &body_str);

        // Construct the URL
        let url = format!("{base_url}/v5/order/create");

        // Send the request
        let response = match self
            .client
            .post(&url)
            .header("X-BAPI-API-KEY", self.api_key.as_str())
            .header("X-BAPI-TIMESTAMP", timestamp.to_string().as_str())
            .header("X-BAPI-SIGN", signature.as_str())
            .header("Content-Type", "application/json")
            .body(body_str)
            .send()
            .await
        {
            Ok(resp) => resp,
            Err(e) => {
                return Err(crate::OmsError::Exchange(
                    format!("Request error: {e}").into(),
                ));
            }
        };

        let response_text = match response.text().await {
            Ok(text) => text,
            Err(e) => {
                return Err(crate::OmsError::Exchange(
                    format!("Failed to read response: {e}").into(),
                ));
            }
        };

        // Keep original response text for error messages before converting to bytes
        let original_response_text = response_text.clone();
        let mut response_bytes = response_text.into_bytes();
        let response_json: BybitResponse<BybitOrderResult> =
            match simd_json::from_slice(&mut response_bytes) {
                Ok(json) => json,
                Err(e) => {
                    // Use original response text to avoid corrupted buffer in error message
                    return Err(crate::OmsError::Exchange(
                        format!("Failed to parse response: {e}: {original_response_text}").into(),
                    ));
                }
            };

        if response_json.ret_code != 0 {
            let error_message = format!(
                "Bybit order placement failed: {} (code: {})",
                response_json.ret_msg, response_json.ret_code
            );
            error!("{error_message}");
            return Err(crate::OmsError::Exchange(error_message.into()));
        }

        debug!("Order placed successfully: {}", order.id);
        Ok(())
    }

    async fn cancel_order(&self, order_id: std::string::String) -> crate::Result<()> {
        let timestamp = Self::get_timestamp();
        let base_url = self.get_base_url();

        // In a real implementation, we would need to know the symbol and category
        // For simplicity, we'll assume the order_id contains the necessary information
        // Format: CATEGORY:SYMBOL:ORDER_LINK_ID
        let parts: SmallVec<[&str; 3]> = order_id.split(':').collect();
        if parts.len() < 3 {
            return Err(crate::OmsError::Exchange(
                "Invalid order_id format. Expected CATEGORY:SYMBOL:ORDER_LINK_ID".into(),
            ));
        }

        let category = parts[0];
        let symbol = parts[1];
        let order_link_id = parts[2];

        // Construct the request body
        let body = json!({
            "category": category,
            "symbol": symbol,
            "orderLinkId": order_link_id,
        });

        let body_str = simd_json::to_string(&body)
            .map_err(|e| crate::OmsError::Exchange(format!("Failed to serialize: {e}").into()))?;

        // Generate signature
        let signature = self.generate_signature(timestamp, &body_str);

        // Construct the URL
        let url = format!("{base_url}/v5/order/cancel");

        // Send the request
        let response = match self
            .client
            .post(&url)
            .header("X-BAPI-API-KEY", self.api_key.as_str())
            .header("X-BAPI-TIMESTAMP", timestamp.to_string().as_str())
            .header("X-BAPI-SIGN", signature.as_str())
            .header("Content-Type", "application/json")
            .body(body_str)
            .send()
            .await
        {
            Ok(resp) => resp,
            Err(e) => {
                return Err(crate::OmsError::Exchange(
                    format!("Request error: {e}").into(),
                ));
            }
        };

        let response_text = match response.text().await {
            Ok(text) => text,
            Err(e) => {
                return Err(crate::OmsError::Exchange(
                    format!("Failed to read response: {e}").into(),
                ));
            }
        };

        // Keep original response text for error messages before converting to bytes
        let original_response_text = response_text.clone();
        let mut response_bytes = response_text.into_bytes();
        let response_json: BybitResponse<BybitOrderResult> =
            match simd_json::from_slice(&mut response_bytes) {
                Ok(json) => json,
                Err(e) => {
                    // Use original response text to avoid corrupted buffer in error message
                    return Err(crate::OmsError::Exchange(
                        format!("Failed to parse response: {e}: {original_response_text}").into(),
                    ));
                }
            };

        if response_json.ret_code != 0 {
            let error_message = format!(
                "Bybit order cancellation failed: {} (code: {})",
                response_json.ret_msg, response_json.ret_code
            );
            error!("{error_message}");
            return Err(crate::OmsError::Exchange(error_message.into()));
        }

        debug!("Order cancelled successfully: {}", order_id);
        Ok(())
    }

    async fn get_order_status(
        &self,
        order_id: std::string::String,
    ) -> crate::Result<std::string::String> {
        let timestamp = Self::get_timestamp();
        let base_url = self.get_base_url();

        // In a real implementation, we would need to know the symbol and category
        // For simplicity, we'll assume the order_id contains the necessary information
        // Format: CATEGORY:SYMBOL:ORDER_LINK_ID
        let parts: SmallVec<[&str; 3]> = order_id.split(':').collect();
        if parts.len() < 3 {
            return Err(crate::OmsError::Exchange(
                "Invalid order_id format. Expected CATEGORY:SYMBOL:ORDER_LINK_ID".into(),
            ));
        }

        let category = parts[0];
        let symbol = parts[1];
        let order_link_id = parts[2];

        // Construct the query parameters
        let params = format!("category={category}&symbol={symbol}&orderLinkId={order_link_id}");

        // Generate signature
        let signature = self.generate_signature(timestamp, &params);

        // Construct the URL
        let url = format!("{base_url}/v5/order/realtime?{params}");

        // Send the request
        let response = match self
            .client
            .get(&url)
            .header("X-BAPI-API-KEY", self.api_key.as_str())
            .header("X-BAPI-TIMESTAMP", timestamp.to_string().as_str())
            .header("X-BAPI-SIGN", signature.as_str())
            .send()
            .await
        {
            Ok(resp) => resp,
            Err(e) => {
                return Err(crate::OmsError::Exchange(
                    format!("Request error: {e}").into(),
                ));
            }
        };

        let response_text = match response.text().await {
            Ok(text) => text,
            Err(e) => {
                return Err(crate::OmsError::Exchange(
                    format!("Failed to read response: {e}").into(),
                ));
            }
        };

        #[derive(Debug, Serialize, Deserialize)]
        struct OrderList {
            list: Vec<BybitOrderResult>,
        }

        // Keep original response text for error messages before converting to bytes
        let original_response_text = response_text.clone();
        let mut response_bytes = response_text.into_bytes();
        let response_json: BybitResponse<OrderList> =
            match simd_json::from_slice(&mut response_bytes) {
                Ok(json) => json,
                Err(e) => {
                    // Use original response text to avoid corrupted buffer in error message
                    return Err(crate::OmsError::Exchange(
                        format!("Failed to parse response: {e}: {original_response_text}").into(),
                    ));
                }
            };

        if response_json.ret_code != 0 {
            let error_message = format!(
                "Bybit get order status failed: {} (code: {})",
                response_json.ret_msg, response_json.ret_code
            );
            error!("{error_message}");
            return Err(crate::OmsError::Exchange(error_message.into()));
        }

        if let Some(result) = response_json.result
            && let Some(order) = result.list.first()
        {
            return Ok(order.order_status.clone());
        }

        Err(crate::OmsError::OrderNotFound("Order not found".into()))
    }
}