futu_backend/trade_query/crypto_orders/

queries_fills.rs

//! trade_query/crypto_orders/queries_fills — query_crypto_order_fills / history_order_fills / related_fills
//! (v1.4.110 CC Batch K: 拆自 crypto_orders.rs L293-538)

use futu_core::error::{FutuError, Result};
use futu_domain_trade_history::pagination::{
    CryptoOeFillPageDecision, CryptoReadCursorPageDecision,
    crypto_oe_fill_pagination_exceeded_like_cpp, crypto_read_cursor_pagination_exceeded_like_cpp,
    decide_crypto_oe_fill_page_like_cpp, decide_crypto_read_cursor_page_like_cpp,
};
use futu_domain_trade_history::{
    plan_crypto_current_fill_list_request_like_cpp, plan_crypto_history_fill_list_request_like_cpp,
    plan_crypto_order_related_fill_request_like_cpp,
};

use super::super::*;

use crate::crypto_trade::{
    CryptoAccountContext, lookup_crypto_account_context, lookup_crypto_read_account_context,
};
use crate::trade_cmd::{CryptoTradeOperation, crypto_trade_command};

use super::projections::*;
use super::types::*;

pub async fn query_crypto_order_fills(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
) -> Result<Vec<OrderFillInfo>> {
    // C++ QueryDealList is a Login read and CMD21237 carries no cipher field.
    // Keep strict context requirements on detail/write operations only.
    let ctx = lookup_crypto_read_account_context(trd_cache, acc_id)?;
    query_crypto_order_fills_with_context(backend, acc_id, &ctx).await
}

/// Startup-only current-fill read. CMD21237 carries the long account id but no
/// cipher field; C++ permits this Login read before trade unlock.
pub async fn query_crypto_order_fills_for_startup(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
) -> Result<Vec<OrderFillInfo>> {
    let ctx = lookup_crypto_read_account_context(trd_cache, acc_id)?;
    query_crypto_order_fills_with_context(backend, acc_id, &ctx).await
}

async fn query_crypto_order_fills_with_context(
    backend: &BackendConn,
    acc_id: u64,
    _ctx: &CryptoAccountContext,
) -> Result<Vec<OrderFillInfo>> {
    use prost::Message;

    let spec = crypto_trade_command(CryptoTradeOperation::Deals);
    let mut all_fills = Vec::new();
    let mut page_token: Option<String> = None;

    for _ in 0..MAX_PAGES {
        let plan = plan_crypto_current_fill_list_request_like_cpp(page_token.as_deref());
        let req = inbound_oe::FillListReq {
            page_size: Some(plan.page_size),
            page_token: plan.page_token,
            long_account_id: Some(acc_id),
            symbol: plan.symbol,
            list_type: Some(plan.list_type),
        };
        let resp = crate::command_runtime::execute_crypto_trade_command(
            backend,
            CryptoTradeOperation::Deals,
            None,
            bytes::Bytes::from(req.encode_to_vec()),
        )
        .await
        .map_err(|e| {
            tracing::warn!(
                cmd_id = spec.cmd,
                error = %e,
                "crypto order fill query failed"
            );
            e
        })?;

        let parsed: inbound_oe::FillListRsp = Message::decode(resp.body.as_ref()).map_err(|e| {
            tracing::warn!(
                cmd_id = spec.cmd,
                body_len = resp.body.len(),
                error = %e,
                "crypto order fill query decode failed"
            );
            FutuError::Proto(e)
        })?;

        all_fills.extend(
            parsed
                .base_fill_list
                .iter()
                .filter_map(project_crypto_base_fill),
        );
        match decide_crypto_oe_fill_page_like_cpp(parsed.page_token.as_deref()) {
            CryptoOeFillPageDecision::Complete => {
                tracing::debug!(count = all_fills.len(), "crypto order fills queried");
                return Ok(all_fills);
            }
            CryptoOeFillPageDecision::Continue { next_page_token } => {
                page_token = Some(next_page_token);
            }
        }
    }

    Err(FutuError::Codec(
        crypto_oe_fill_pagination_exceeded_like_cpp("query_crypto_order_fills", MAX_PAGES),
    ))
}

/// Query crypto history fills through CMD21234.
///
/// C++ 10.5.6508 `NNProto_Trd_DealCrypto.cpp:402-418` sends
/// `inbound_oe::GetFillListByAccountAndTimeRangeRequest`, with begin/end in
/// microseconds and page size 2000.
pub async fn query_crypto_history_order_fills(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
    start_micros: u64,
    end_micros: u64,
) -> Result<Vec<OrderFillInfo>> {
    use prost::Message;

    let _ctx = lookup_crypto_account_context(trd_cache, acc_id)?;
    let spec = crypto_trade_command(CryptoTradeOperation::HistoryDeals);
    let mut all_fills = Vec::new();
    let mut page_token: Option<String> = None;

    for _ in 0..MAX_PAGES {
        let plan = plan_crypto_history_fill_list_request_like_cpp(
            start_micros,
            end_micros,
            page_token.as_deref(),
        );
        let req = inbound_oe::GetFillListByAccountAndTimeRangeRequest {
            page_size: Some(plan.page_size),
            page_token: plan.page_token,
            long_account_id: Some(acc_id),
            start_time: Some(plan.start_time_micros),
            end_time: Some(plan.end_time_micros),
            symbol: plan.symbol,
        };
        let resp = crate::command_runtime::execute_crypto_trade_command(
            backend,
            CryptoTradeOperation::HistoryDeals,
            None,
            bytes::Bytes::from(req.encode_to_vec()),
        )
        .await
        .map_err(|e| {
            tracing::warn!(
                cmd_id = spec.cmd,
                error = %e,
                "crypto history fill query failed"
            );
            e
        })?;

        let parsed: inbound_oe::GetFillListByAccountAndTimeRangeResponse =
            Message::decode(resp.body.as_ref()).map_err(|e| {
                tracing::warn!(
                    cmd_id = spec.cmd,
                    body_len = resp.body.len(),
                    error = %e,
                    "crypto history fill query decode failed"
                );
                FutuError::Proto(e)
            })?;

        all_fills.extend(
            parsed
                .base_fill_list
                .iter()
                .filter_map(project_crypto_base_fill),
        );
        match decide_crypto_oe_fill_page_like_cpp(parsed.page_token.as_deref()) {
            CryptoOeFillPageDecision::Complete => {
                tracing::debug!(count = all_fills.len(), "crypto history fills queried");
                return Ok(all_fills);
            }
            CryptoOeFillPageDecision::Continue { next_page_token } => {
                page_token = Some(next_page_token);
            }
        }
    }

    Err(FutuError::Codec(
        crypto_oe_fill_pagination_exceeded_like_cpp("query_crypto_history_order_fills", MAX_PAGES),
    ))
}

/// Query fills for one crypto order through CMD20624.
///
/// C++ 10.5.6508 `NNProto_Trd_DealCrypto.cpp:500-529` sends
/// `inbound_read::OrderFillDetailReq` with crypto msg header, order id, page
/// size 500, and follows `page_flag` until `completed=true`.
pub async fn query_crypto_order_related_fills(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
    order_id_ex: &str,
) -> Result<Vec<OrderFillInfo>> {
    use prost::Message;

    let initial_plan = plan_crypto_order_related_fill_request_like_cpp(order_id_ex, None)
        .map_err(FutuError::Codec)?;
    let order_id_ex = initial_plan.order_id;

    let ctx = lookup_crypto_account_context(trd_cache, acc_id)?;
    let spec = crypto_trade_command(CryptoTradeOperation::OrderFillDetail);
    let mut all_fills = Vec::new();
    let mut page_flag: Option<String> = None;

    for _ in 0..MAX_PAGES {
        let plan =
            plan_crypto_order_related_fill_request_like_cpp(&order_id_ex, page_flag.as_deref())
                .map_err(FutuError::Codec)?;
        let req = inbound_read::OrderFillDetailReq {
            msg_header: Some(ctx.build_crypto_msg_header("order_fill_detail")),
            page_size: Some(plan.page_size),
            page_flag: plan.page_flag,
            order_id: Some(plan.order_id),
        };
        let resp = crate::command_runtime::execute_crypto_trade_command(
            backend,
            CryptoTradeOperation::OrderFillDetail,
            None,
            bytes::Bytes::from(req.encode_to_vec()),
        )
        .await
        .map_err(|e| {
            tracing::warn!(
                cmd_id = spec.cmd,
                order_id = %order_id_ex,
                error = %e,
                "crypto order related fill query failed"
            );
            e
        })?;

        let parsed: inbound_read::OrderFillDetailRsp = Message::decode(resp.body.as_ref())
            .map_err(|e| {
                tracing::warn!(
                    cmd_id = spec.cmd,
                    order_id = %order_id_ex,
                    body_len = resp.body.len(),
                    error = %e,
                    "crypto order related fill query decode failed"
                );
                FutuError::Proto(e)
            })?;

        all_fills.extend(
            parsed
                .order_fills
                .iter()
                .filter_map(project_crypto_read_fill),
        );
        match decide_crypto_read_cursor_page_like_cpp(
            "query_crypto_order_related_fills",
            parsed.completed,
            parsed.page_flag.as_deref(),
            all_fills.len(),
        ) {
            CryptoReadCursorPageDecision::Complete => {
                tracing::debug!(
                    order_id = %order_id_ex,
                    count = all_fills.len(),
                    "crypto order related fills queried"
                );
                return Ok(all_fills);
            }
            CryptoReadCursorPageDecision::Continue { next_page_flag } => {
                page_flag = Some(next_page_flag);
            }
            CryptoReadCursorPageDecision::PartialMissingPageFlag { error_message, .. } => {
                return Err(FutuError::Codec(error_message));
            }
        }
    }

    Err(FutuError::Codec(
        crypto_read_cursor_pagination_exceeded_like_cpp(
            "query_crypto_order_related_fills",
            MAX_PAGES,
        ),
    ))
}