futu_backend/trade_query/

account_info.rs

use super::common::{
    backend_currency_to_api, backend_market_to_trd_market, backend_stock_market_to_sec_market,
    build_market_info_list, currency_to_fund_bond_ccy, pf, pfo,
    sum_diff_market_fund_assets_in_response_currency, trd_market_to_currency,
};
use super::*;

#[derive(Debug, Clone, Default)]
struct AccountInfoSidecarPlan {
    account_market: Option<i32>,
    security_firm: Option<i32>,
    uni_card_num: Option<String>,
    unique_id: u64,
}

impl AccountInfoSidecarPlan {
    fn from_cache(trd_cache: &TrdCache, acc_id: u64) -> Self {
        trd_cache
            .accounts
            .get(&acc_id)
            .map(|acc| {
                let acc = acc.value();
                Self {
                    account_market: acc.trd_market,
                    security_firm: acc.security_firm,
                    uni_card_num: acc.uni_card_num.clone(),
                    // C++ `INNData_Trd_AllAccList::GetAccUniqueID`:
                    // `(BrokerID << 48) | (NN_TrdMarket_ConvC2S(enTrdMkt) << 32)
                    // | IntraAccID`. `CachedTrdAcc.sort_key` stores the same
                    // tuple from the backend account list.
                    unique_id: if acc.sort_key != 0 {
                        acc.sort_key
                    } else {
                        acc_id
                    },
                }
            })
            .unwrap_or(Self {
                unique_id: acc_id,
                ..Self::default()
            })
    }

    fn is_hk_us_fund_account(&self) -> bool {
        matches!(self.account_market, Some(13 | 22 | 23 | 113 | 123))
    }

    fn is_universal(&self) -> bool {
        if matches!(self.account_market, Some(6)) {
            return true;
        }
        // Rust cache may carry backend raw Account.market values (for example
        // AU/JP/MY/CA) even though C++ m_enTrdMkt is the normalized Universal
        // enum. Mirror the gateway currency classifier's cache-drift defense:
        // a non-empty universal card number plus known broker is enough to
        // keep Universal-only sidecars enabled.
        self.uni_card_num
            .as_deref()
            .is_some_and(|s| !s.trim().is_empty())
            && self.security_firm.is_some()
    }

    fn universal_supports_fund_sidecar(&self) -> bool {
        // C++ `IsUniAccSupportFund`: Futu HK / SG / MY / JP.
        self.is_universal() && matches!(self.security_firm, Some(1 | 3 | 6 | 7))
    }
}

/// 查询真实账户资金+持仓 (CMD 3020: AccountInfoReq)
///
/// **v1.4.106 codex 1556 F1+F2 (P1) 修法**:
///
/// - F1: 接 `currency: Option<i32>` — caller (handler) 把 user 请求的
///   currency 透传进来; None 时由 daemon 补账户默认币种再发 CMD3020。
///   对齐 C++ `QueryFundNoLimit` 最终要求 backend `AccountInfoReq`
///   携带有效 `union_currency`; backend 对缺省值会报
///   `unsupported currency:NONE`.
///
/// - F2: transport / decode error → `Err` (loud propagate). 之前 `Ok(())`
///   silent 让 caller 看到 cache miss + `ret_type=0 + s2c.funds=None`
///   (silent-success 反模式 D / pitfall #45). C++ 失败不会伪装成功.
///
/// - v1.4.107: when caller has no user-requested `assetCategory`, match C++
///   `GetCategoriesByKouzaType`: FutuJP margin sends Foreign(2), FutuJP
///   derivative fans out Domestic(1) + Foreign(2), other accounts send no
///   asset_category field.
pub async fn query_account_info(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
    requested_currency: Option<i32>,
    requested_asset_category: Option<i32>,
) -> Result<()> {
    let category_plan =
        account_info_asset_category_plan(trd_cache, acc_id, requested_asset_category);
    for category in category_plan {
        query_account_info_one(
            backend,
            acc_id,
            trd_cache,
            requested_currency,
            category,
            false,
        )
        .await?;
    }
    Ok(())
}

#[cfg(test)]
mod tests;

/// Query real-account positions through CMD3020 using the C++ PositionList
/// request shape.
///
/// C++ `QueryPositionListNoLimit` calls `QueryAssetInner(...,
/// bWithoutFund=true, ...)`, so this wrapper keeps the same asset-category
/// fanout as [`query_account_info`] but asks backend to omit fund/bond asset
/// data from the response.
pub async fn query_position_account_info(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
    requested_asset_category: Option<i32>,
    requested_currency: Option<i32>,
) -> Result<()> {
    let category_plan =
        account_info_asset_category_plan(trd_cache, acc_id, requested_asset_category);
    for category in category_plan {
        query_account_info_one(
            backend,
            acc_id,
            trd_cache,
            requested_currency,
            category,
            true,
        )
        .await?;
    }
    Ok(())
}

fn account_info_asset_category_plan(
    trd_cache: &TrdCache,
    acc_id: u64,
    requested_asset_category: Option<i32>,
) -> Vec<Option<i32>> {
    if let Some(category) = requested_asset_category.filter(|category| *category > 0) {
        return vec![Some(category)];
    }

    if let Some(acc) = trd_cache.accounts.get(&acc_id) {
        let acc = acc.value();
        let is_jp_broker = acc.security_firm == Some(7);
        if is_jp_broker {
            match acc.kouza_type {
                Some(2) => return vec![Some(2)],
                Some(3) => return vec![Some(1), Some(2)],
                _ => {}
            }
        }
    }

    vec![None]
}

fn cmd3020_union_currency(
    trd_cache: &TrdCache,
    acc_id: u64,
    requested_currency: Option<u32>,
) -> u32 {
    requested_currency
        .or_else(|| cmd3020_default_currency_from_cache(trd_cache, acc_id))
        .unwrap_or(1)
}

fn cmd3020_default_currency_from_cache(trd_cache: &TrdCache, acc_id: u64) -> Option<u32> {
    let acc = trd_cache.lookup_account(acc_id)?;

    // C++ `NNProto_Trd_AccBase::GetQueryCurrencySet`: omitted currency first
    // uses common-currency cache; if that set is empty, it falls back to
    // `INNData_Trd_CommonCurrency::GetAccountFirstValidCurrency(accItem)`.
    // Rust does not yet persist C++'s common-currency deque, so the safe
    // backend refresh default is the same first-valid rule. User-facing
    // GetFunds defaults stay in `futu_trd::read_plan`.
    futu_trd::currency::first_valid_currency_for_account(
        acc.security_firm,
        acc.trd_market,
        acc.uni_card_num.as_deref(),
        &acc.trd_market_auth_list,
    )
    .map(|currency| currency as u32)
    .or_else(|| acc.trd_market.map(trd_market_to_currency))
}

async fn query_account_info_one(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
    requested_currency: Option<i32>,
    effective_asset_category: Option<i32>,
    without_fund_and_bond_data: bool,
) -> Result<()> {
    use prost::Message;

    // CMD3020 backend requires an explicit `union_currency`. C++ fills a
    // default when the FTAPI request omits `currency`; sending None reaches
    // backend as `unsupported currency:NONE`.
    //
    // FTAPI proto.Trd_GetFunds.currency is i32, backend asset_query is u32.
    // Handler 层已对 Futures/Universal currency 和 JP derivative assetCategory
    // 做 loud validation；这里仍避免把负数 cast 成巨大 u32.
    let requested_currency_u32: Option<u32> =
        requested_currency.and_then(|c| u32::try_from(c).ok());
    let union_currency_u32 = cmd3020_union_currency(trd_cache, acc_id, requested_currency_u32);
    let mut sidecar_currency_u32 = union_currency_u32;

    let asset_category_u32: Option<u32> =
        effective_asset_category.and_then(|a| u32::try_from(a).ok());
    let cache_asset_category = effective_asset_category.filter(|a| *a > 0).unwrap_or(0);
    let sidecar_plan = AccountInfoSidecarPlan::from_cache(trd_cache, acc_id);
    let should_query_fund_bond_sidecar = !without_fund_and_bond_data
        && (sidecar_plan.is_hk_us_fund_account() || sidecar_plan.universal_supports_fund_sidecar());
    let skip_account_info_for_fund_account =
        !without_fund_and_bond_data && sidecar_plan.is_hk_us_fund_account();
    let account_info_without_fund =
        without_fund_and_bond_data || sidecar_plan.universal_supports_fund_sidecar();

    if !skip_account_info_for_fund_account {
        let req = asset_query::AccountInfoReq {
            // v1.4.110 P0-1: cipher: Some(vec![]) — C++ always sets cipher
            // (empty if not unlocked). 走 msg_header::build_real 收口.
            msg_header: Some(crate::msg_header::build_real(
                acc_id,
                Some(vec![]),
                None,
                None,
            )),
            union_currency: Some(union_currency_u32),
            select_field_list: vec![], // 返回全部
            quote_level: Some(1),      // US_BASIC
            quote_type: Some(1),       // BOTH
            with_position_im: None,
            notice_type: None,
            with_matched_quantity: None,
            // C++ `QueryFundNoLimit` sends SG/Universal AccountInfoReq with
            // `without_fund_and_bond_data=true` and merges CMD20086
            // FundBondDetailAsset separately.
            without_fund_and_bond_data: Some(account_info_without_fund),
            use_overnight_price: Some(true),
            without_combo: None,
            without_delisted_symbol: None,
            without_zero_quantity_pstn: None,
            aas_fallback: None,
            version: None,
            expand_portfolio: None,
            asset_category: asset_category_u32, // v1.4.106 F3: JP 衍生品账户必传; 其他类型 None
            op_nn_uid: None,
            high_prec_cur_price: None,
            use_high_prec: None,
        };

        // v1.4.106 codex 1556 F2 (P1): transport/decode error 必须 loud propagate
        // (Err), 不允许 silent Ok(()). caller (handler) 已经 loud-propagate Err,
        // user 可以看到清晰 backend 失败原因 (cipher 过期 / acc 状态 / 反刷).
        let resp = backend
            .request(CMD_ACCOUNT_INFO, req.encode_to_vec())
            .await
            .map_err(|e| {
                tracing::warn!(acc_id, error = %e, "CMD3020 account info query failed (loud propagate per codex 1556 F2)");
                e
            })?;

        let parsed: asset_query::AccountInfoRsp =
            Message::decode(resp.body.as_ref()).map_err(|e| {
                tracing::warn!(acc_id, error = %e, body_len = resp.body.len(),
                               "CMD3020 decode failed (loud propagate per codex 1556 F2)");
                futu_core::error::FutuError::Proto(e)
            })?;
        account_info_response_status_like_cpp(&parsed, acc_id)?;

        tracing::info!(
            acc_id,
            has_fund = parsed.union_fund_info.is_some(),
            has_cash = parsed.union_cash_info.is_some(),
            positions = parsed.pstn_info_list.len(),
            "CMD3020 response parsed"
        );

        // === 资金 ===
        if let Some(ref fund_info) = parsed.union_fund_info {
            let backend_top_currency = fund_info
                .currency
                .or_else(|| parsed.union_cash_info.as_ref().and_then(|c| c.currency));
            if requested_currency_u32.is_none()
                && let Some(currency) = backend_top_currency
            {
                sidecar_currency_u32 = currency;
            }
            let currency = backend_top_currency.map(backend_currency_to_api);
            let cash_currency = parsed
                .union_cash_info
                .as_ref()
                .and_then(|c| c.currency)
                .map(backend_currency_to_api);
            let cash = parsed
                .union_cash_info
                .as_ref()
                .map(|c| pf(&c.balance))
                .unwrap_or(0.0);
            let avl_withdrawal = parsed
                .union_cash_info
                .as_ref()
                .map(|c| pf(&c.cash_drawable))
                .unwrap_or(0.0);

            // C++ dt_status mapping: 2→Unlimited, 3→EMCall, 4/5→DTCall, else→Unknown
            let _dt_status_raw = fund_info.dt_status.unwrap_or(0);

            let market_info_list = build_market_info_list(&parsed.fund_info_list);

            let securities_assets = sum_diff_market_fund_assets_in_response_currency(
                &parsed.diff_market_fund_info_list,
            )
            .or_else(|| {
                // Legacy backend fallback before `diff_market_fund_info_list`:
                // keep the old native marketInfo projection rather than
                // fabricating a cross-currency total.
                let req_currency = currency.unwrap_or(0);
                let markets_currencies: [(i32, i32); 8] = [
                    (1, 1),
                    (2, 2),
                    (4, 3),
                    (15, 4),
                    (6, 5),
                    (8, 6),
                    (112, 7),
                    (111, 8),
                ];
                let sum: f64 = market_info_list
                    .iter()
                    .filter_map(|mi| {
                        markets_currencies
                            .iter()
                            .find(|&&(m, native_currency)| {
                                m == mi.trd_market && native_currency == req_currency
                            })
                            .map(|_| mi.assets)
                    })
                    .sum();
                (!market_info_list.is_empty()).then_some(sum)
            });

            trd_cache.update_funds_scoped_with_returned_currency(
                acc_id,
                cache_asset_category,
                requested_currency,
                CachedFunds {
                    power: pf(&fund_info.max_power_long),
                    total_assets: pf(&fund_info.total_asset),
                    cash,
                    market_val: pf(&fund_info.mv),
                    frozen_cash: pf(&fund_info.hold),
                    debt_cash: pf(&fund_info.debit_recover),
                    avl_withdrawal_cash: avl_withdrawal,
                    currency,
                    available_funds: pfo(&fund_info.available),
                    unrealized_pl: pfo(&fund_info.unrealized_profit),
                    realized_pl: pfo(&fund_info.realized_profit),
                    risk_level: fund_info.risk_level.map(|r| r as i32),
                    initial_margin: pfo(&fund_info.initial_margin),
                    maintenance_margin: pfo(&fund_info.maintenance_margin),
                    max_power_short: pfo(&fund_info.max_power_short),
                    net_cash_power: pfo(&fund_info.net_cash_power),
                    long_mv: pfo(&fund_info.long_mv),
                    short_mv: pfo(&fund_info.short_mv),
                    pending_asset: pfo(&fund_info.pending_asset),
                    max_withdrawal: pfo(&fund_info.drawable),
                    risk_status: fund_info.risk_status_client,
                    margin_call_margin: pfo(&fund_info.margin_call),
                    securities_assets,
                    fund_assets: None,
                    bond_assets: None,
                    crypto_mv: None,
                    exposure_level: None,
                    exposure_limit: None,
                    used_limit: None,
                    remaining_limit: None,
                    // v1.4.98 T1-4 (mobile-source-audit): US PDT 6 字段透传
                    // (asset_query.proto:80-102 backend already returns 这些)
                    is_pdt: fund_info.is_pdt,
                    // pdt_seq: backend repeated int32, daemon join 成 string
                    // ("1,3,5") 对齐 proto/Trd_Common.proto:378 string 类型
                    // (mobile UI 直接显示数字 list)
                    pdt_seq: if fund_info.pdt_seq.is_empty() {
                        None
                    } else {
                        Some(
                            fund_info
                                .pdt_seq
                                .iter()
                                .map(|n| n.to_string())
                                .collect::<Vec<_>>()
                                .join(","),
                        )
                    },
                    beginning_dtbp: pfo(&fund_info.beginning_dtbp),
                    remaining_dtbp: pfo(&fund_info.remaining_dtbp),
                    dt_call_amount: pfo(&fund_info.dt_call_amount),
                    dt_status: fund_info.dt_status,
                    cash_info_list: parsed
                        .cash_info_list
                        .iter()
                        .map(|c| CachedCashInfo {
                            currency: c.currency.map(backend_currency_to_api).unwrap_or(0),
                            cash: pf(&c.balance),
                            available_balance: pf(&c.cash_drawable),
                            net_cash_power: pf(&c.cash_buypower),
                        })
                        .collect(),
                    market_info_list,
                },
            );

            tracing::info!(
                acc_id,
                power = pf(&fund_info.max_power_long),
                total = pf(&fund_info.total_asset),
                top_currency = ?currency,
                cash_currency = ?cash_currency,
                "fund cached via CMD3020"
            );
        }

        // === 持仓 ===
        let positions: Vec<CachedPosition> = parsed
            .pstn_info_list
            .iter()
            .map(|p| {
                let sec_market = p.stock_market.map(backend_stock_market_to_sec_market);
                let pstn_id_str = p.pstn_id.as_deref().unwrap_or("");
                let position_id = hash_str_to_u64(pstn_id_str);
                tracing::debug!(pstn_id_str, position_id, code = ?p.symbol, "position hash");
                CachedPosition {
                    position_id,
                    position_side: p.pstn_type.unwrap_or(0),
                    code: p.symbol.clone().unwrap_or_default(),
                    name: p.stock_name.clone().unwrap_or_default(),
                    qty: pf(&p.qty),
                    can_sell_qty: pf(&p.qty_avbl),
                    price: pf(&p.cur_price),
                    cost_price: pf(&p.diluted_cost),
                    val: pf(&p.mv),
                    pl_val: pf(&p.diluted_profit),
                    pl_ratio: pfo(&p.diluted_profit_ratio),
                    sec_market,
                    td_pl_val: pfo(&p.today_profit),
                    td_trd_val: pfo(&p.today_turnover),
                    td_buy_val: pfo(&p.today_buy_turnover),
                    td_buy_qty: pfo(&p.today_buy_qty),
                    td_sell_val: pfo(&p.today_sell_turnover),
                    td_sell_qty: pfo(&p.today_sell_qty),
                    unrealized_pl: pfo(&p.unrealized_profit),
                    realized_pl: pfo(&p.realized_profit),
                    currency: p.currency.map(backend_currency_to_api),
                    trd_market: p.stock_market.map(backend_market_to_trd_market),
                    diluted_cost_price: pfo(&p.diluted_cost),
                    average_cost_price: pfo(&p.average_cost),
                    average_pl_ratio: pfo(&p.average_profit_ratio),
                    // v1.4.42: DTE 在 handler 层按 code 实时算（每天变，cache 不存）
                    expiry_date_distance: None,
                }
            })
            .collect();

        tracing::info!(
            acc_id,
            count = positions.len(),
            "positions cached via CMD3020"
        );
        // C++ `FillPositionList` reads the current `Ndt_Trd_AccPosition` array
        // returned for the asset key. A successful empty backend reply means the
        // authoritative position list is empty, so we must replace the cache with
        // `[]`; keeping the previous vector would resurrect sold-out positions.
        trd_cache.update_positions_scoped(acc_id, cache_asset_category, positions);
    }

    if should_query_fund_bond_sidecar {
        query_fund_bond_detail_asset(
            backend,
            acc_id,
            trd_cache,
            requested_currency,
            cache_asset_category,
            sidecar_currency_u32,
            sidecar_plan,
        )
        .await?;
    }

    tracing::info!(
        acc_id,
        asset_category = ?cache_asset_category,
        without_fund_and_bond_data,
        "CMD3020 warmup complete"
    );

    Ok(())
}

fn account_info_response_status_like_cpp(
    parsed: &asset_query::AccountInfoRsp,
    acc_id: u64,
) -> Result<()> {
    // Ref: FutuOpenD/Src/NNProtoCenter/Trade/_NNProto_Trd_Comm.h:20-30
    // and Trade/Asset/NNProto_Trd_AccReal.cpp:512-568.
    // C++ requires `result`, `msg_header`, and matching `msg_header.account_id`
    // before writing CMD3020 funds / positions into account cache.
    let Some(result_code) = parsed.result else {
        return Err(futu_core::error::FutuError::Codec(
            "CMD3020 account info missing result".to_string(),
        ));
    };
    if result_code != 0 {
        let err = parsed.err_msg.as_deref().unwrap_or("unknown");
        tracing::warn!(acc_id, result_code, err, "CMD3020 returned error");
        // v1.4.53 A2 log bug 修：之前 return Ok(()) 让上层 bridge.rs 误判
        // "succeeded"。现在正确返 Err 让 dispatch_trade_data_queries 触发 warn
        // fallback 分支。
        return Err(futu_core::error::FutuError::ServerError {
            ret_type: result_code,
            msg: format!("CMD3020 business error: {err}"),
        });
    }
    let header = parsed.msg_header.as_ref().ok_or_else(|| {
        futu_core::error::FutuError::Codec("CMD3020 account info missing msg_header".to_string())
    })?;
    let backend_acc_id = header.account_id.unwrap_or(0);
    if backend_acc_id != acc_id {
        return Err(futu_core::error::FutuError::Codec(format!(
            "CMD3020 account info account mismatch: server={backend_acc_id} local={acc_id}"
        )));
    }
    Ok(())
}

async fn query_fund_bond_detail_asset(
    backend: &BackendConn,
    acc_id: u64,
    trd_cache: &TrdCache,
    requested_currency: Option<i32>,
    cache_asset_category: i32,
    currency_u32: u32,
    sidecar_plan: AccountInfoSidecarPlan,
) -> Result<()> {
    use prost::Message;

    let ccy = currency_to_fund_bond_ccy(currency_u32).to_string();
    let req = mobile_fund_asset::FundBondDetailAssetReq {
        unique_id: Some(sidecar_plan.unique_id),
        ccy: Some(ccy.clone()),
        asset_type: Some(mobile_fund_asset::AssetType::AllAsset as i32),
    };

    let resp = backend
        .request(CMD_FUND_BOND_DETAIL_ASSET, req.encode_to_vec())
        .await
        .map_err(|e| {
            tracing::warn!(
                acc_id,
                unique_id = sidecar_plan.unique_id,
                ccy,
                error = %e,
                "CMD20086 fund/bond detail asset query failed"
            );
            e
        })?;

    let parsed: mobile_fund_asset::FundBondDetailAssetRsp = Message::decode(resp.body.as_ref())
        .map_err(|e| {
            tracing::warn!(
                acc_id,
                body_len = resp.body.len(),
                error = %e,
                "CMD20086 decode failed"
            );
            futu_core::error::FutuError::Proto(e)
        })?;

    if parsed.error_code.unwrap_or(-1) != 0 {
        let result_code = parsed.error_code.unwrap_or(-1);
        let err = parsed.error_msg.as_deref().unwrap_or("unknown");
        tracing::warn!(acc_id, result_code, err, "CMD20086 returned error");
        return Err(futu_core::error::FutuError::ServerError {
            ret_type: result_code,
            msg: format!("CMD20086 fund/bond detail asset business error: {err}"),
        });
    }

    let fund_asset = parsed
        .fund_asset
        .as_ref()
        .map(|asset| pf(&asset.fund_asset))
        .ok_or_else(|| futu_core::error::FutuError::ServerError {
            ret_type: -1,
            msg: "CMD20086 missing fund_asset".to_string(),
        })?;
    let bond_asset = parsed
        .bond_asset
        .as_ref()
        .map(|asset| pf(&asset.bond_asset))
        .ok_or_else(|| futu_core::error::FutuError::ServerError {
            ret_type: -1,
            msg: "CMD20086 missing bond_asset".to_string(),
        })?;

    let (existing, _) =
        trd_cache.get_funds_scoped(acc_id, cache_asset_category, requested_currency);
    let mut funds = existing.unwrap_or_default();
    funds.fund_assets = Some(fund_asset);
    funds.bond_assets = Some(bond_asset);

    if sidecar_plan.is_hk_us_fund_account() {
        // C++ fund-account branch displays fund + bond as the total account
        // assets. `total_asset.pending_asset` is copied into
        // `Ndt_Trd_AccFund::fPendingAsset` by `UnPackFundFunds`.
        //
        // C++ `UnPackFundFunds` treats `total_asset` as required for HK/US
        // fund accounts; a missing field turns the whole QueryFund reply into
        // a data error instead of a success with partial fund/bond totals.
        let total = parsed.total_asset.as_ref().ok_or_else(|| {
            futu_core::error::FutuError::ServerError {
                ret_type: -1,
                msg: "CMD20086 missing total_asset for fund account".to_string(),
            }
        })?;
        funds.total_assets = fund_asset + bond_asset;
        funds.pending_asset = pfo(&total.pending_asset);
    } else if sidecar_plan.universal_supports_fund_sidecar() {
        // C++ SG/Universal branch sends AccountInfoReq with
        // `without_fund_and_bond_data=true`, then adds the two sidecar totals
        // to the securities net asset before filling `totalAssets`.
        funds.total_assets += fund_asset + bond_asset;
    }

    trd_cache.update_funds_scoped_with_returned_currency(
        acc_id,
        cache_asset_category,
        requested_currency,
        funds,
    );

    tracing::info!(
        acc_id,
        unique_id = sidecar_plan.unique_id,
        ccy,
        fund_asset,
        bond_asset,
        "fund/bond totals cached via CMD20086"
    );

    Ok(())
}