hypercall_api/handlers/

orders.rs

use std::str::FromStr;
use std::time::Instant;

use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
use rust_decimal::Decimal;
use rust_decimal_macros::dec;

use crate::rfq::rfq_manager::{RfqLeg, SubmitRpiAuction};
use crate::rpi_monitor::{self, RpiMonitorRecord};
use crate::sonic_json::SonicJson;
use crate::{error::ApiError, middleware::SignerContext, models::ApiResponse};
use axum::extract::State;
use hypercall_runtime_api::increment_pending_requests;
use hypercall_runtime_api::BookSnapshotState;
use hypercall_runtime_api::RfqExecuteResult;
use hypercall_types::utils::get_timestamp_millis;
use hypercall_types::{
    to_contract_units_decimal, validate_price_precision, CancelOrderByCloidRequest,
    CancelOrderRequest, ParsedOptionSymbol, PlaceOrderRequest, MAX_PRICE_SIGNIFICANT_FIGURES,
};
use hypercall_types::{
    OrderAction, OrderActionMessage, OrderInfo, OrderUpdateMessage, OrderUpdateStatus, TimeInForce,
};
use hypercall_types::{Side, TradingModes};
use tokio::sync::mpsc;
use tokio::time::timeout;
use tracing::Instrument;
use uuid::Uuid;

#[cfg(feature = "otel-tracing")]
use tracing_opentelemetry::OpenTelemetrySpanExt;

use super::{ensure_order_creation_allowed, AppState, ENGINE_RESPONSE_TIMEOUT};

/// Place an options order
#[utoipa::path(
    post,
    path = "/order",
    request_body = PlaceOrderRequest,
    responses(
        (status = 200, description = "Order placed", body = OrderUpdateMessage),
        (status = 400, description = "Invalid order parameters"),
        (status = 401, description = "Unauthorized"),
        (status = 500, description = "Internal server error")
    ),
    security(("eip712_signature" = [])),
    tag = "Trading"
)]
pub async fn place_order(
    State(state): State<AppState>,
    signer_ctx: SignerContext,
    SonicJson(request): SonicJson<PlaceOrderRequest>,
) -> Result<SonicJson<OrderUpdateMessage>, ApiError> {
    let span = tracing::info_span!(
        "api.place_order",
        wallet = %signer_ctx.wallet_address,
        symbol = %request.symbol,
        side = ?request.side,
        size = %request.size,
        price = %request.price,
        client_id = ?request.client_id,
        action = "CreateOrder",
        is_perp = false,
    );

    async move {
        // Parse price and size from strings as Decimal for precision
        let price: Decimal = Decimal::from_str(&request.price).map_err(|_| {
            tracing::warn!("Invalid price format: {}", request.price);
            ApiError::bad_request(format!("Invalid price format: {}", request.price))
        })?;
        let size: Decimal = Decimal::from_str(&request.size).map_err(|_| {
            tracing::warn!("Invalid size format: {}", request.size);
            ApiError::bad_request(format!("Invalid size format: {}", request.size))
        })?;

        // Validate the order by parsing the symbol
        let _parsed_symbol = ParsedOptionSymbol::from_symbol(&request.symbol).map_err(|e| {
            tracing::warn!("Order validation failed: {}", e);
            ApiError::bad_request(format!("Invalid symbol: {}", e))
        })?;

        ensure_order_creation_allowed(&state, &request.symbol).await?;

        // Validate order parameters
        if price <= dec!(0) {
            return Err(ApiError::bad_request("Price must be positive"));
        }
        if size <= dec!(0) {
            return Err(ApiError::bad_request("Size must be positive"));
        }

        // Validate price precision (max 5 significant figures)
        let price_f64 = price.to_f64().ok_or_else(|| {
            ApiError::bad_request(format!("Price {} cannot be represented as f64", price))
        })?;
        if let Err(e) = validate_price_precision(price_f64, MAX_PRICE_SIGNIFICANT_FIGURES) {
            tracing::warn!("Price validation failed: {}", e);
            return Err(ApiError::bad_request(format!(
                "Invalid price precision: {}",
                e
            )));
        }

        tracing::info!(
            "Placing order for wallet: {} (signed by: {}), symbol: {}",
            signer_ctx.wallet_address,
            signer_ctx.signer_address,
            request.symbol
        );

        // Create OrderInfo
        let order_info = OrderInfo {
            symbol: request.symbol.clone(),
            price,
            size: to_contract_units_decimal(&request.symbol, size),
            side: request.side,
            tif: request.tif,
            client_id: request.client_id.clone(),
            order_id: None,
            is_perp: false,
            underlying: None,
            reduce_only: None,
            nonce: Some(request.nonce),
            signature: None,
            mmp_enabled: request.mmp_enabled,
            builder_code_address: request.builder_code_address,
        };

        // Create OrderActionMessage
        let order_action_msg = OrderActionMessage {
            timestamp: get_timestamp_millis(),
            info: order_info.clone(),
            action: OrderAction::CreateOrder,
            wallet: request.wallet,
            api_wallet_address: Some(signer_ctx.signer_address),
            mmp_triggered: false,
            request_id: Some(Uuid::now_v7().to_string()),
        };

        if let Some(response) = maybe_execute_rpi_place_order(
            &state,
            &request,
            &order_action_msg,
            &order_info,
            price,
            size,
        )
        .await?
        {
            return Ok(SonicJson(response));
        }

        let response = dispatch_order_to_engine(&state.order_sender, order_action_msg).await?;

        // Store order in database if it was accepted
        if response.status == OrderUpdateStatus::Open {
            // TODO: Store order in database
            tracing::info!("Order placed successfully: {:?}", response.order_id);
        }

        Ok(SonicJson(response))
    }
    .instrument(span)
    .await
}

async fn dispatch_order_to_engine(
    order_sender: &mpsc::Sender<hypercall_runtime_api::UnifiedEngineRequest>,
    order_action_msg: OrderActionMessage,
) -> Result<OrderUpdateMessage, ApiError> {
    let (response_tx, mut response_rx) = mpsc::channel(1);
    let engine_request = hypercall_runtime_api::UnifiedEngineRequest {
        message: order_action_msg,
        response_tx,
        enqueued_at: Instant::now(),
        #[cfg(feature = "otel-tracing")]
        trace_context: Some(tracing::Span::current().context()),
    };

    increment_pending_requests();
    order_sender.send(engine_request).await.map_err(|_| {
        tracing::error!("Failed to send order to engine");
        ApiError::internal_error("Failed to send order to engine")
    })?;

    match timeout(ENGINE_RESPONSE_TIMEOUT, response_rx.recv()).await {
        Ok(Some(resp)) => Ok(resp),
        Ok(None) => {
            tracing::error!("No response from engine");
            Err(ApiError::internal_error("No response from engine"))
        }
        Err(_) => {
            tracing::error!("Timeout waiting for engine response");
            Err(ApiError::gateway_timeout(
                "Timeout waiting for engine response",
            ))
        }
    }
}

// RPI auction discovery is intentionally outside the deterministic engine loop:
// it depends on live QP WebSocket sessions, timers, and network responses. Any
// winning quote is still executed through the engine as RfqExecute; no fill is
// applied from the API handler.
async fn maybe_execute_rpi_place_order(
    state: &AppState,
    request: &PlaceOrderRequest,
    order_action_msg: &OrderActionMessage,
    order_info: &OrderInfo,
    limit_price: Decimal,
    human_size: Decimal,
) -> Result<Option<OrderUpdateMessage>, ApiError> {
    let Some(rfq_manager) = state.rfq_manager.as_ref() else {
        record_rpi_event(
            "unavailable_manager",
            "not_applicable",
            Some("RFQ manager unavailable".to_string()),
            request,
            order_action_msg,
            human_size,
            limit_price,
            None,
            None,
            None,
        );
        return Ok(None);
    };

    let Some(instrument) = state.instruments_cache.get_by_symbol(&request.symbol).await else {
        record_rpi_event(
            "unknown_instrument",
            "not_applicable",
            Some("Instrument not found".to_string()),
            request,
            order_action_msg,
            human_size,
            limit_price,
            None,
            None,
            None,
        );
        return Ok(None);
    };
    if !allows_rpi_orderbook_routing(instrument.trading_mode) {
        record_rpi_event(
            "unsupported_trading_mode",
            "not_applicable",
            Some(format!(
                "Trading mode {:?} does not allow combined RFQ/orderbook routing",
                instrument.trading_mode
            )),
            request,
            order_action_msg,
            human_size,
            limit_price,
            None,
            None,
            None,
        );
        return Ok(None);
    }

    let book_reference =
        match best_within_limit_book_price(state, &request.symbol, request.side, limit_price)? {
            BookReferencePrice::Ready(reference) => reference,
            BookReferencePrice::SnapshotMissing => {
                tracing::warn!(
                    symbol = %request.symbol,
                    "Skipping RPI auction because orderbook snapshot is missing"
                );
                record_rpi_event(
                    "snapshot_not_ready",
                    "snapshot_not_ready",
                    Some("Orderbook snapshot is not ready".to_string()),
                    request,
                    order_action_msg,
                    human_size,
                    limit_price,
                    None,
                    None,
                    None,
                );
                return Ok(None);
            }
        };
    let min_tick = rfq_manager.min_improvement_tick();
    let reference_price = book_reference.reference_price;
    let reference_state = book_reference.reference_state();

    let rfq_id = Uuid::now_v7();
    let rfq_leg_request = hypercall_types::RfqLegRequest {
        instrument: request.symbol.clone(),
        side: request.side,
        size: human_size.to_string(),
    };
    let legs_hash = super::rfq::compute_legs_hash_from_legs(std::slice::from_ref(&rfq_leg_request))
        .map_err(ApiError::bad_request)?;

    let record = rfq_manager
        .submit_rpi_auction(SubmitRpiAuction {
            rfq_id,
            taker_wallet: request.wallet,
            taker_signer: order_action_msg
                .api_wallet_address
                .unwrap_or(request.wallet),
            builder_code_address: request.builder_code_address,
            legs: vec![RfqLeg {
                instrument: request.symbol.clone(),
                side: request.side,
                size: human_size,
            }],
            legs_hash,
            taker_signature: request.signature.clone(),
            taker_nonce: request.nonce,
            limit_price,
            reference_price,
            min_tick,
        })
        .await
        .map_err(ApiError::bad_request)?;

    record_rpi_event(
        "auction_started",
        reference_state,
        None,
        request,
        order_action_msg,
        human_size,
        limit_price,
        Some(record.rfq_id),
        reference_price,
        Some(book_reference.l2_seq),
    );

    let closed = rfq_manager
        .wait_for_rpi_auction_close(record.rfq_id)
        .await
        .map_err(ApiError::internal_error)?;

    let candidate_quote_ids = rfq_manager
        .rpi_candidate_quote_ids(&closed.rfq_id)
        .map_err(ApiError::internal_error)?;

    for quote_id in candidate_quote_ids {
        let execution_result = rfq_manager
            .execute_rpi_quote(closed.rfq_id, quote_id, request.signature.clone())
            .await;

        match execution_result {
            Ok(RfqExecuteResult::Success { fill_id }) => {
                let rpi = closed.rpi_auction.as_ref().ok_or_else(|| {
                    ApiError::internal_error("RPI context missing after auction close")
                })?;
                let filled_record = rfq_manager
                    .get_rfq(&closed.rfq_id)
                    .ok_or_else(|| ApiError::internal_error("RPI RFQ missing after execution"))?;
                let accepted_quote = filled_record
                    .quotes
                    .iter()
                    .find(|quote| quote.quote_id == quote_id)
                    .ok_or_else(|| ApiError::internal_error("RPI winning quote missing"))?;
                let fill_price = accepted_quote
                    .legs
                    .first()
                    .map(|leg| leg.price)
                    .ok_or_else(|| ApiError::internal_error("RPI winning quote missing leg"))?;
                if let Some(reference_price) = rpi.reference_price {
                    let improvement = match request.side {
                        Side::Buy => reference_price - fill_price,
                        Side::Sell => fill_price - reference_price,
                    };
                    if improvement > Decimal::ZERO {
                        let improvement_bps = ((improvement / reference_price) * dec!(10000))
                            .to_f64()
                            .ok_or_else(|| {
                                ApiError::internal_error(format!(
                                    "RPI improvement {} cannot be represented as f64",
                                    improvement
                                ))
                            })?;
                        metrics::histogram!(
                            "ht_rpi_price_improvement_bps",
                            "reference" => "book"
                        )
                        .record(improvement_bps);
                    }
                }

                let mut filled_info = order_info.clone();
                filled_info.price = fill_price;
                tracing::info!(
                    rfq_id = %closed.rfq_id,
                    quote_id = %quote_id,
                    fill_id = %fill_id,
                    symbol = %request.symbol,
                    limit_price = %limit_price,
                    fill_price = %fill_price,
                    "RPI auction filled PlaceOrder"
                );
                record_rpi_fill_event(
                    "filled",
                    reference_state,
                    None,
                    request,
                    order_action_msg,
                    human_size,
                    limit_price,
                    closed.rfq_id,
                    quote_id,
                    Some(fill_id.clone()),
                    reference_price,
                    Some(fill_price),
                    Some(book_reference.l2_seq),
                );
                return Ok(Some(OrderUpdateMessage {
                    timestamp: get_timestamp_millis(),
                    info: filled_info,
                    status: OrderUpdateStatus::Filled,
                    reason: Some("Filled through RPI auction".to_string()),
                    filled_size: order_info.size,
                    order_id: None,
                    wallet_address: request.wallet,
                    mmp_triggered: false,
                    request_id: order_action_msg.request_id.clone(),
                }));
            }
            Ok(RfqExecuteResult::Failed { reason }) => {
                tracing::warn!(
                    rfq_id = %closed.rfq_id,
                    quote_id = %quote_id,
                    reason = %reason,
                    "RPI quote execution failed, trying next candidate"
                );
                record_rpi_fill_event(
                    "quote_failed",
                    reference_state,
                    Some(reason),
                    request,
                    order_action_msg,
                    human_size,
                    limit_price,
                    closed.rfq_id,
                    quote_id,
                    None,
                    reference_price,
                    None,
                    Some(book_reference.l2_seq),
                );
            }
            Err(reason) => {
                tracing::warn!(
                    rfq_id = %closed.rfq_id,
                    quote_id = %quote_id,
                    reason = %reason,
                    "RPI quote execution errored, trying next candidate"
                );
                record_rpi_fill_event(
                    "quote_error",
                    reference_state,
                    Some(reason),
                    request,
                    order_action_msg,
                    human_size,
                    limit_price,
                    closed.rfq_id,
                    quote_id,
                    None,
                    reference_price,
                    None,
                    Some(book_reference.l2_seq),
                );
            }
        }
    }

    rfq_manager.mark_rpi_fallback_to_book(&closed.rfq_id);
    let response = dispatch_order_to_engine(&state.order_sender, order_action_msg.clone()).await?;
    record_rpi_event_with_order(
        "fallback_to_book",
        reference_state,
        response.reason.clone(),
        request,
        order_action_msg,
        human_size,
        limit_price,
        Some(closed.rfq_id),
        reference_price,
        Some(book_reference.l2_seq),
        response.order_id,
    );
    Ok(Some(response))
}

fn allows_rpi_orderbook_routing(trading_mode: TradingModes) -> bool {
    trading_mode.allows_rfq() && trading_mode.allows_orderbook()
}

#[derive(Debug, Clone, PartialEq, Eq)]
enum BookReferencePrice {
    SnapshotMissing,
    Ready(BookReference),
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct BookReference {
    reference_price: Option<Decimal>,
    empty_book: bool,
    l2_seq: i64,
}

impl BookReference {
    fn reference_state(&self) -> &'static str {
        match (self.reference_price.is_some(), self.empty_book) {
            (true, _) => "book",
            (false, true) => "none_empty_book",
            (false, false) => "none_no_executable_liquidity",
        }
    }
}

fn best_within_limit_book_price(
    state: &AppState,
    symbol: &str,
    side: Side,
    limit_price: Decimal,
) -> Result<BookReferencePrice, ApiError> {
    book_reference_from_snapshot_state(
        state.quote_provider.book_snapshot_state(symbol),
        side,
        limit_price,
    )
}

fn book_reference_from_snapshot_state(
    snapshot_state: BookSnapshotState,
    side: Side,
    limit_price: Decimal,
) -> Result<BookReferencePrice, ApiError> {
    let (quote, l2_seq) = match snapshot_state {
        BookSnapshotState::NotReady { .. } => return Ok(BookReferencePrice::SnapshotMissing),
        BookSnapshotState::Ready { quote, l2_seq } => (quote, l2_seq),
    };

    let levels = match side {
        Side::Buy => &quote.asks,
        Side::Sell => &quote.bids,
    };

    best_within_limit_level_price(levels, side, limit_price).map(|reference_price| {
        BookReferencePrice::Ready(BookReference {
            reference_price,
            empty_book: quote.is_empty_book(),
            l2_seq,
        })
    })
}

fn record_rpi_event(
    outcome: &'static str,
    reference_state: &'static str,
    reason: Option<String>,
    request: &PlaceOrderRequest,
    order_action_msg: &OrderActionMessage,
    human_size: Decimal,
    limit_price: Decimal,
    rfq_id: Option<Uuid>,
    reference_price: Option<Decimal>,
    l2_seq: Option<i64>,
) {
    record_rpi_event_with_order(
        outcome,
        reference_state,
        reason,
        request,
        order_action_msg,
        human_size,
        limit_price,
        rfq_id,
        reference_price,
        l2_seq,
        None,
    );
}

fn record_rpi_event_with_order(
    outcome: &'static str,
    reference_state: &'static str,
    reason: Option<String>,
    request: &PlaceOrderRequest,
    order_action_msg: &OrderActionMessage,
    human_size: Decimal,
    limit_price: Decimal,
    rfq_id: Option<Uuid>,
    reference_price: Option<Decimal>,
    l2_seq: Option<i64>,
    order_id: Option<u64>,
) {
    rpi_monitor::record(RpiMonitorRecord {
        outcome,
        reference_state,
        reason,
        wallet: request.wallet.to_string(),
        symbol: request.symbol.clone(),
        side: format!("{:?}", request.side),
        size: human_size.to_string(),
        limit_price: limit_price.to_string(),
        reference_price: reference_price.map(|price| price.to_string()),
        fill_price: None,
        rfq_id: rfq_id.map(|id| id.to_string()),
        quote_id: None,
        fill_id: None,
        order_id,
        request_id: order_action_msg.request_id.clone(),
        l2_seq,
    });
}

fn record_rpi_fill_event(
    outcome: &'static str,
    reference_state: &'static str,
    reason: Option<String>,
    request: &PlaceOrderRequest,
    order_action_msg: &OrderActionMessage,
    human_size: Decimal,
    limit_price: Decimal,
    rfq_id: Uuid,
    quote_id: Uuid,
    fill_id: Option<String>,
    reference_price: Option<Decimal>,
    fill_price: Option<Decimal>,
    l2_seq: Option<i64>,
) {
    rpi_monitor::record(RpiMonitorRecord {
        outcome,
        reference_state,
        reason,
        wallet: request.wallet.to_string(),
        symbol: request.symbol.clone(),
        side: format!("{:?}", request.side),
        size: human_size.to_string(),
        limit_price: limit_price.to_string(),
        reference_price: reference_price.map(|price| price.to_string()),
        fill_price: fill_price.map(|price| price.to_string()),
        rfq_id: Some(rfq_id.to_string()),
        quote_id: Some(quote_id.to_string()),
        fill_id,
        order_id: None,
        request_id: order_action_msg.request_id.clone(),
        l2_seq,
    });
}

fn best_within_limit_level_price(
    levels: &[(f64, f64)],
    side: Side,
    limit_price: Decimal,
) -> Result<Option<Decimal>, ApiError> {
    for (price, size) in levels {
        if !price.is_finite() || *price <= 0.0 || !size.is_finite() || *size <= 0.0 {
            continue;
        }

        let decimal_price = Decimal::from_f64(*price).ok_or_else(|| {
            ApiError::internal_error(format!(
                "Book price {} cannot be represented as Decimal",
                price
            ))
        })?;
        let crosses_limit = match side {
            Side::Buy => decimal_price <= limit_price,
            Side::Sell => decimal_price >= limit_price,
        };
        if !crosses_limit {
            break;
        }

        return Ok(Some(decimal_price));
    }

    Ok(None)
}

#[cfg(test)]
mod tests {
    use super::*;
    use hypercall_runtime_api::SnapshotBookQuote;
    use rust_decimal_macros::dec;

    #[test]
    fn rpi_orderbook_routing_requires_combined_trading_mode() {
        assert!(allows_rpi_orderbook_routing(
            TradingModes::ORDERBOOK | TradingModes::RFQ
        ));
        assert!(!allows_rpi_orderbook_routing(TradingModes::ORDERBOOK));
        assert!(!allows_rpi_orderbook_routing(TradingModes::RFQ));
        assert!(!allows_rpi_orderbook_routing(TradingModes::empty()));
    }

    #[test]
    fn rpi_buy_reference_uses_partial_resting_ask() {
        let levels = vec![(99.0, 0.01)];

        let reference = best_within_limit_level_price(&levels, Side::Buy, dec!(100)).unwrap();

        assert_eq!(reference, Some(dec!(99)));
    }

    #[test]
    fn rpi_buy_reference_absent_when_best_ask_misses_limit() {
        let levels = vec![(101.0, 100.0)];

        let reference = best_within_limit_level_price(&levels, Side::Buy, dec!(100)).unwrap();

        assert_eq!(reference, None);
    }

    #[test]
    fn rpi_sell_reference_uses_partial_resting_bid() {
        let levels = vec![(101.0, 0.01)];

        let reference = best_within_limit_level_price(&levels, Side::Sell, dec!(100)).unwrap();

        assert_eq!(reference, Some(dec!(101)));
    }

    #[test]
    fn rpi_reference_distinguishes_missing_snapshot_from_empty_book() {
        let missing = book_reference_from_snapshot_state(
            BookSnapshotState::NotReady { l2_seq: 0 },
            Side::Buy,
            dec!(100),
        )
        .unwrap();
        assert_eq!(missing, BookReferencePrice::SnapshotMissing);

        let ready_empty = book_reference_from_snapshot_state(
            BookSnapshotState::Ready {
                quote: SnapshotBookQuote::empty(),
                l2_seq: 1,
            },
            Side::Buy,
            dec!(100),
        )
        .unwrap();

        assert_eq!(
            ready_empty,
            BookReferencePrice::Ready(BookReference {
                reference_price: None,
                empty_book: true,
                l2_seq: 1,
            })
        );
    }
}

/// Cancel an order by order ID
#[utoipa::path(
    delete,
    path = "/order",
    request_body = CancelOrderRequest,
    responses(
        (status = 200, description = "Order cancelled", body = OrderUpdateMessage),
        (status = 400, description = "Invalid request"),
        (status = 401, description = "Unauthorized"),
        (status = 500, description = "Internal server error")
    ),
    security(("eip712_signature" = [])),
    tag = "Trading"
)]
pub async fn cancel_order(
    State(state): State<AppState>,
    signer_ctx: SignerContext,
    SonicJson(request): SonicJson<CancelOrderRequest>,
) -> Result<SonicJson<ApiResponse<OrderUpdateMessage>>, ApiError> {
    let span = tracing::info_span!(
        "api.cancel_order",
        wallet = %signer_ctx.wallet_address,
        order_id = %request.order_id,
        action = "CancelOrder",
    );

    async move {
        tracing::info!(
            "Canceling order {} for wallet: {} (signed by: {})",
            request.order_id,
            signer_ctx.wallet_address,
            signer_ctx.signer_address
        );

        // Create minimal OrderInfo for cancellation
        let order_info = OrderInfo {
            symbol: String::new(), // Will be looked up by order_id in the engine
            price: dec!(0),
            size: dec!(0),
            side: Side::Buy, // Dummy value
            tif: TimeInForce::GTC,
            client_id: None,
            order_id: Some(request.order_id),
            is_perp: false,
            underlying: None,
            reduce_only: None,
            nonce: Some(request.nonce),
            signature: None,
            mmp_enabled: false,
            builder_code_address: None,
        };

        // Create OrderActionMessage with CancelOrder action
        let order_action_msg = OrderActionMessage {
            timestamp: get_timestamp_millis(),
            info: order_info,
            action: OrderAction::CancelOrder,
            wallet: signer_ctx.wallet_address,
            api_wallet_address: Some(signer_ctx.signer_address),
            mmp_triggered: false,
            request_id: Some(Uuid::now_v7().to_string()),
        };

        // Create a channel for the response
        let (response_tx, mut response_rx) = mpsc::channel(1);

        // Create engine request
        let engine_request = hypercall_runtime_api::UnifiedEngineRequest {
            message: order_action_msg,
            response_tx,
            enqueued_at: Instant::now(),
            #[cfg(feature = "otel-tracing")]
            trace_context: Some(tracing::Span::current().context()),
        };

        // Send cancel request to RSM engine
        increment_pending_requests();
        state.order_sender.send(engine_request).await.map_err(|_| {
            tracing::error!("Failed to send cancel request to engine");
            ApiError::internal_error("Failed to send cancel request to engine")
        })?;

        // Wait for response from engine with timeout
        let response = match timeout(ENGINE_RESPONSE_TIMEOUT, response_rx.recv()).await {
            Ok(Some(resp)) => resp,
            Ok(None) => {
                tracing::error!("No response from engine");
                return Err(ApiError::internal_error("No response from engine"));
            }
            Err(_) => {
                tracing::error!("Timeout waiting for engine response");
                return Err(ApiError::gateway_timeout(
                    "Timeout waiting for engine response",
                ));
            }
        };

        // Check if cancellation was successful based on the status
        let success = response.status == OrderUpdateStatus::Canceled;

        Ok(SonicJson(ApiResponse {
            success,
            data: Some(response),
            error: None,
        }))
    }
    .instrument(span)
    .await
}

/// Cancel an order by client order ID
#[utoipa::path(
    delete,
    path = "/order_cloid",
    request_body = CancelOrderByCloidRequest,
    responses(
        (status = 200, description = "Order cancelled", body = OrderUpdateMessage),
        (status = 400, description = "Invalid request"),
        (status = 401, description = "Unauthorized"),
        (status = 500, description = "Internal server error")
    ),
    security(("eip712_signature" = [])),
    tag = "Trading"
)]
pub async fn cancel_order_by_cloid(
    State(state): State<AppState>,
    signer_ctx: SignerContext,
    SonicJson(request): SonicJson<CancelOrderByCloidRequest>,
) -> Result<SonicJson<ApiResponse<OrderUpdateMessage>>, ApiError> {
    tracing::info!(
        "Canceling order by client_id {} for wallet: {} (signed by: {})",
        request.client_id,
        signer_ctx.wallet_address,
        signer_ctx.signer_address
    );

    // Create minimal OrderInfo for cancellation
    let order_info = OrderInfo {
        symbol: String::new(), // Will be looked up by client_id in the engine
        price: dec!(0),
        size: dec!(0),
        side: Side::Buy, // Dummy value
        tif: TimeInForce::GTC,
        client_id: Some(request.client_id.clone()),
        order_id: None,
        is_perp: false,
        underlying: None,
        reduce_only: None,
        nonce: Some(request.nonce),
        signature: None,
        mmp_enabled: false,
        builder_code_address: None,
    };

    // Create OrderActionMessage with CancelOrder action
    let order_action_msg = OrderActionMessage {
        timestamp: get_timestamp_millis(),
        info: order_info,
        action: OrderAction::CancelOrder,
        wallet: signer_ctx.wallet_address,
        api_wallet_address: Some(signer_ctx.signer_address),
        mmp_triggered: false,
        request_id: Some(Uuid::now_v7().to_string()),
    };

    // Create a channel for the response
    let (response_tx, mut response_rx) = mpsc::channel(1);

    // Create engine request
    let engine_request = hypercall_runtime_api::UnifiedEngineRequest {
        message: order_action_msg,
        response_tx,
        enqueued_at: Instant::now(),
        #[cfg(feature = "otel-tracing")]
        trace_context: Some(tracing::Span::current().context()),
    };

    // Send cancel request to RSM engine
    increment_pending_requests();
    state.order_sender.send(engine_request).await.map_err(|_| {
        tracing::error!("Failed to send cancel request to engine");
        ApiError::internal_error("Failed to send cancel request to engine")
    })?;

    // Wait for response from engine with timeout
    let response = match timeout(ENGINE_RESPONSE_TIMEOUT, response_rx.recv()).await {
        Ok(Some(resp)) => resp,
        Ok(None) => {
            tracing::error!("No response from engine");
            return Err(ApiError::internal_error("No response from engine"));
        }
        Err(_) => {
            tracing::error!("Timeout waiting for engine response");
            return Err(ApiError::gateway_timeout(
                "Timeout waiting for engine response",
            ));
        }
    };

    // Check if cancellation was successful based on the status
    let success = response.status == OrderUpdateStatus::Canceled;

    Ok(SonicJson(ApiResponse {
        success,
        data: Some(response),
        error: None,
    }))
}