futu_backend/trade_query/crypto_orders/

queries_misc.rs

//! trade_query/crypto_orders/queries_misc — query_crypto_order_fees / cash_logs / trade_configs / max_buy_sell_qty
//! (v1.4.110 CC Batch K: 拆自 crypto_orders.rs L539-793)

use futu_cache::static_data::CryptoTradeConfig;
use futu_core::error::{FutuError, Result};
use futu_domain_trade_history::projection::crypto::{
    CryptoCashLogPageDecision, CryptoCashLogResponseStatusDecision,
    CryptoCashLogResponseStatusFacts, crypto_cash_log_pagination_exceeded_like_cpp,
    decide_crypto_cash_log_page_like_cpp, decide_crypto_cash_log_response_status_like_cpp,
    plan_crypto_cash_log_request_like_cpp, plan_crypto_order_fee_batch_ranges_like_cpp,
};
use futu_domain_trade_write::{
    CryptoMaxQtyBackendRequestPlan, CryptoTradeConfigRequestPlan,
    plan_crypto_trade_config_full_request_like_cpp, project_crypto_max_qty_backend_values_like_cpp,
};

use super::super::*;

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

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

pub async fn query_crypto_order_fees(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
    order_ids: &[String],
) -> Result<Vec<CryptoOrderFeeInfo>> {
    use prost::Message;

    let _ctx = lookup_crypto_account_context(trd_cache, acc_id)?;
    let spec = crypto_trade_command(CryptoTradeOperation::BatchOrderFee);
    let mut fees = Vec::new();

    for batch in plan_crypto_order_fee_batch_ranges_like_cpp(order_ids.len()) {
        let req = inbound_oe::BatchQueryOrderFeeReq {
            order_id_list: order_ids[batch].to_vec(),
            long_account_id: Some(acc_id),
        };
        let resp = crate::command_runtime::execute_crypto_trade_command(
            backend,
            CryptoTradeOperation::BatchOrderFee,
            None,
            bytes::Bytes::from(req.encode_to_vec()),
        )
        .await
        .map_err(|e| {
            tracing::warn!(
                cmd_id = spec.cmd,
                error = %e,
                "crypto order fee query failed"
            );
            e
        })?;

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

        fees.extend(
            parsed
                .fee_group_list
                .iter()
                .filter_map(project_crypto_order_fee),
        );
    }

    Ok(fees)
}

/// Query crypto cash logs through CMD20632 for FTAPI Trd_FlowSummary.
///
/// C++ 10.5.6508 `NNProto_Trd_FlowSummaryCrypto.cpp:191-219` sends
/// `cash_change_detail_cmn::GetCashLogReq` with `MARKET_CRYPTO`, public long
/// account id, backend intra account id, and broker id.
pub async fn query_crypto_cash_logs(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
    begin_time: u64,
    end_time: u64,
) -> Result<Vec<CryptoCashLogInfo>> {
    use prost::Message;

    let ctx = lookup_crypto_account_context(trd_cache, acc_id)?;
    let spec = crypto_trade_command(CryptoTradeOperation::CashLog);
    let mut all_logs = Vec::new();
    let mut log_id: Option<String> = None;

    for _ in 0..MAX_PAGES {
        let plan = plan_crypto_cash_log_request_like_cpp(
            ctx.require_intra_acc_id("crypto_cash_log")?,
            ctx.require_broker_id("crypto_cash_log")?,
            acc_id,
            begin_time,
            end_time,
            log_id.as_deref(),
        );
        let req = cash_change_detail_cmn::GetCashLogReq {
            market: Some(plan.market),
            account_id: Some(plan.account_id),
            broker_id: Some(plan.broker_id),
            long_account_id: Some(plan.long_account_id),
            begin_time: Some(plan.begin_time),
            end_time: Some(plan.end_time),
            log_id: plan.log_id,
            // C++ `NNProto_Trd_FlowSummaryCrypto.cpp:200-211` only sets the
            // seven fields above. biz_group/in_out/max_cnt/keyword/
            // biz_sub_group/currency/stock_id/time_location intentionally stay
            // absent; this prost default is construction shorthand, not a
            // fallback for unknown protocol semantics.
            ..Default::default()
        };
        let resp = crate::command_runtime::execute_crypto_trade_command(
            backend,
            CryptoTradeOperation::CashLog,
            None,
            bytes::Bytes::from(req.encode_to_vec()),
        )
        .await
        .map_err(|e| {
            tracing::warn!(
                cmd_id = spec.cmd,
                error = %e,
                "crypto cash log query failed"
            );
            e
        })?;

        let parsed: cash_change_detail_cmn::GetCashLogRsp = Message::decode(resp.body.as_ref())
            .map_err(|e| {
                tracing::warn!(
                    cmd_id = spec.cmd,
                    body_len = resp.body.len(),
                    error = %e,
                    "crypto cash log decode failed"
                );
                FutuError::Proto(e)
            })?;

        match decide_crypto_cash_log_response_status_like_cpp(CryptoCashLogResponseStatusFacts {
            result: parsed.result,
            err_msg: parsed.err_msg.as_deref(),
        }) {
            CryptoCashLogResponseStatusDecision::Accepted => {}
            CryptoCashLogResponseStatusDecision::BusinessError { ret_type, message } => {
                return Err(FutuError::ServerError {
                    ret_type,
                    msg: message,
                });
            }
        }

        all_logs.extend(
            parsed
                .monthly_log_list
                .iter()
                .flat_map(|month| month.cash_log_list.iter())
                .filter_map(project_crypto_cash_log),
        );

        match decide_crypto_cash_log_page_like_cpp(parsed.has_more, parsed.next_log_id.as_deref()) {
            CryptoCashLogPageDecision::Continue { next_log_id } => {
                log_id = Some(next_log_id);
                continue;
            }
            CryptoCashLogPageDecision::Complete => {}
        }

        tracing::debug!(count = all_logs.len(), "crypto cash logs queried");
        return Ok(all_logs);
    }

    Err(FutuError::Codec(
        crypto_cash_log_pagination_exceeded_like_cpp("query_crypto_cash_logs", MAX_PAGES),
    ))
}

/// Query crypto trade configs through CMD20102.
///
/// C++ `NNProto_Trd_CryptoTradeConfig.cpp:14-23,63-89` pulls the full trade
/// config list per broker and stores it in `INNData_Trd_CryptoTradeConfig`.
/// MaxBuySellQty needs the same config for min quantity and quantity increment.
pub async fn query_crypto_trade_configs(
    backend: &BackendConn,
    broker_id: u32,
) -> Result<Vec<CryptoTradeConfig>> {
    use prost::Message;

    let spec = crypto_trade_command(CryptoTradeOperation::FetchTradeConfig);
    let req =
        fetch_trade_config_request_from_plan(plan_crypto_trade_config_full_request_like_cpp());
    let resp = crate::command_runtime::execute_crypto_trade_command(
        backend,
        CryptoTradeOperation::FetchTradeConfig,
        None,
        bytes::Bytes::from(req.encode_to_vec()),
    )
        .await
        .map_err(|e| {
            tracing::warn!(broker_id, cmd_id = spec.cmd, error = %e, "crypto trade config query failed");
            e
        })?;

    let parsed: inbound_oe::FetchTradeConfigResponse = Message::decode(resp.body.as_ref())
        .map_err(|e| {
            tracing::warn!(
                broker_id,
                cmd_id = spec.cmd,
                body_len = resp.body.len(),
                error = %e,
                "crypto trade config decode failed"
            );
            FutuError::Proto(e)
        })?;
    crypto_trade_config_response_status(&parsed)?;

    Ok(parsed
        .full_trade_config_list
        .iter()
        .filter_map(project_crypto_trade_config)
        .collect())
}

fn fetch_trade_config_request_from_plan(
    plan: CryptoTradeConfigRequestPlan,
) -> inbound_oe::FetchTradeConfigRequest {
    inbound_oe::FetchTradeConfigRequest {
        currency_pair_list: plan
            .currency_pairs
            .into_iter()
            .map(|pair| config_base::CurrencyPair {
                base_currency: Some(pair.base_currency),
                quote_currency: Some(pair.quote_currency),
            })
            .collect(),
        data_from: plan.data_from,
        data_max_count: plan.data_max_count,
        symbol_list: plan.symbols,
        status: plan.status,
    }
}

/// Query crypto max buy/sell quantity through CMD20622.
///
/// C++ `NNProto_Trd_MaxQtyCrypto.cpp:14-38,49-78` builds
/// `crypto_risk::GetMaxBuySellReq` from account context, `cc_origin`, and
/// `cc_destination`.
pub async fn query_crypto_max_buy_sell_qty(
    backend: &BackendConn,
    ctx: &CryptoAccountContext,
    input: CryptoMaxQtyBackendRequestPlan,
) -> Result<CryptoMaxBuySellQtyInfo> {
    use prost::Message;

    let spec = crypto_trade_command(CryptoTradeOperation::MaxBuySellQty);
    let req = crypto_risk::GetMaxBuySellReq {
        account: Some(crypto_risk_comm::Account {
            cid: Some(ctx.require_customer_id("max_buy_sell_qty")?),
            acct_id: Some(ctx.require_intra_acc_id("max_buy_sell_qty")?),
            market: Some(input.account_market),
            broker_id: Some(ctx.require_broker_id("max_buy_sell_qty")?),
            long_acct_id: Some(ctx.acc_id),
        }),
        order_type: Some(input.order_type),
        currency: Some(input.currency),
        coin: Some(input.coin),
        price: input.price,
        order_id: input.order_id,
    };
    let resp = crate::command_runtime::execute_crypto_trade_command(
        backend,
        CryptoTradeOperation::MaxBuySellQty,
        None,
        bytes::Bytes::from(req.encode_to_vec()),
    )
    .await
    .map_err(|e| {
        tracing::warn!(
            cmd_id = spec.cmd,
            error = %e,
            "crypto max buy/sell qty query failed"
        );
        e
    })?;
    let parsed: crypto_risk::GetMaxBuySellRsp =
        Message::decode(resp.body.as_ref()).map_err(|e| {
            tracing::warn!(
                cmd_id = spec.cmd,
                body_len = resp.body.len(),
                error = %e,
                "crypto max buy/sell qty decode failed"
            );
            FutuError::Proto(e)
        })?;

    let values = project_crypto_max_qty_backend_values_like_cpp(
        parsed.max_cash_buy_qty.as_deref(),
        parsed.max_sell_qty.as_deref(),
    );

    Ok(CryptoMaxBuySellQtyInfo {
        max_cash_buy_qty: values.max_cash_buy_qty,
        max_sell_qty: values.max_sell_qty,
    })
}