futu_mcp/handlers/trade/

bond.rs

use std::sync::Arc;

use anyhow::{Result, bail};
use futu_backend::proto_internal::bond_client_view;
use futu_net::client::FutuClient;
use prost::Message as _;
use serde::Serialize;

use super::parse_trd_env_int;

// ============================================================================
// v1.4.95 U2-B Tier M (mobile-driven extension): bond holdings + trade prep
//
// 来源: ftcnnproto/.../bond_client_view.proto + FLCltProtocol.h
// 5 endpoint × 5 cmd_id (9373/9374/9375/10043/10057), 共享
// DaemonBondHeader (acc_id + trd_env + market: "HK"/"US"/"SG").
//
// **市场覆盖**: 仅 HK / US / SG 债券账户; 其他账户 backend 优雅返空.
// ============================================================================

#[derive(Serialize)]
struct BondTotalAssetOut {
    total_asset: String,
    position_incomes: String,
    today_incomes: String,
    accrued_interest: String,
    show_flag: bool,
    ccy: String,
}

#[derive(Serialize)]
struct BondNoticeOut {
    text: String,
    url: String,
    /// 1=派息, 2=到期退出, 3=提前赎回
    notice_type: i32,
    url_id: i32,
    updated_time: u64,
}

#[derive(Serialize)]
struct BondLegacyNotificationOut {
    text: String,
    url: String,
}

#[derive(Serialize)]
struct BondSingleAssetOut {
    market_value: String,
    today_incomes: String,
    position_incomes: String,
    quantity: String,
    cost: String,
    /// epoch 秒 (0=未知)
    expired_time: u64,
    next_dividend_time: u64,
    /// 0=不派息, 1=每年1次, 2=每年2次, 3=每年4次, 4=每月1次, 5=5年1次, 6=2年1次
    dividend_type: u32,
    accrued_interest: String,
    /// 1=固定, 2=不固定
    dividend_option: u32,
    notification: Option<BondLegacyNotificationOut>,
    notice: Option<BondNoticeOut>,
    notice_list: Vec<BondNoticeOut>,
    ccy: String,
    coupon_cash: String,
    position_cost: String,
    /// 中间价 (without accrued interest)
    price: String,
}

#[derive(Serialize)]
struct BondPositionItemOut {
    name: String,
    name_short: String,
    symbol: String,
    make_for_call_flag: bool,
    market_value: String,
    quantity: String,
    price: String,
    cost: String,
    today_incomes: String,
    today_incomes_rate: String,
    position_incomes: String,
    position_incomes_rate: String,
    accrued_interest: String,
    ccy: String,
    notice: Option<BondNoticeOut>,
}

#[derive(Serialize)]
struct BondPositionListOut {
    total: i32,
    bond_list: Vec<BondPositionItemOut>,
}

#[derive(Serialize)]
struct BondNoticeUrlOut {
    title: String,
    content: String,
    confirm_button_title: String,
    confirm_url: String,
    content_url_title: String,
    content_url: String,
    cancel_button_title: String,
}

#[derive(Serialize)]
struct BondAnswerStateOut {
    need_to_answer: bool,
    notice: Option<BondNoticeUrlOut>,
}

#[derive(Serialize)]
struct BondReminderItemOut {
    /// 0/1 标识值 (含义见各字段注释)
    value: i32,
    title: String,
    text: String,
    /// 0=无提醒, 1=弱(底部文案), 2=中(按钮弹窗), 3=强(进详情页弹窗)
    reminder_level: i32,
    url_id: i64,
}

#[derive(Serialize)]
struct BondTradeReminderOut {
    /// 是否可买入 (0=不可, 1=可)
    tradeable: Option<BondReminderItemOut>,
    /// 复杂产品 (0=否, 1=是)
    complex_product: Option<BondReminderItemOut>,
    /// 高风险预警 (0=否, 1=是)
    high_risk: Option<BondReminderItemOut>,
    /// 是否可卖出 (0=不可, 1=可)
    sell_tradeable: Option<BondReminderItemOut>,
    /// 是否需要非 AI 资格预审 (0=否, 1=是)
    pre_qualification: Option<BondReminderItemOut>,
}

/// 共用 helper: env str → trd_env_int + market str validation
///
/// v1.4.102 codex 41 F3 (P2): typo (e.g. "prod") 现 reject, 不 silent → sim.
fn parse_bond_inputs(env: &str, market: &str) -> Result<(i32, String)> {
    let trd_env_int: i32 = parse_trd_env_int(env)?;
    let market_clean = market.trim().to_string();
    if market_clean.is_empty() {
        bail!("market 必填: HK / US / SG");
    }
    let market_upper = market_clean.to_ascii_uppercase();
    if !matches!(
        market_upper.as_str(),
        "HK" | "US" | "USA" | "SG" | "SG_UNIVERSAL"
    ) {
        bail!(
            "unsupported market {market_clean:?} (supported: HK / US / SG; \
             仅 HK/US/SG 债券账户有数据)"
        );
    }
    Ok((trd_env_int, market_upper))
}

fn convert_notice(n: bond_client_view::Notice) -> BondNoticeOut {
    BondNoticeOut {
        text: n.text.unwrap_or_default(),
        url: n.url.unwrap_or_default(),
        notice_type: n.notice_type.unwrap_or(0),
        url_id: n.url_id.unwrap_or(0),
        updated_time: n.updated_time.unwrap_or(0),
    }
}

fn convert_bond_notification(
    n: bond_client_view::income_with_bond_rsp::Notification,
) -> BondLegacyNotificationOut {
    BondLegacyNotificationOut {
        text: n.text.unwrap_or_default(),
        url: n.url.unwrap_or_default(),
    }
}

fn convert_reminder(r: bond_client_view::ReminderItem) -> BondReminderItemOut {
    BondReminderItemOut {
        value: r.value.unwrap_or(0),
        title: r.title.unwrap_or_default(),
        text: r.text.unwrap_or_default(),
        reminder_level: r.reminder_level.unwrap_or(0),
        url_id: r.url_id.unwrap_or(0),
    }
}

fn bond_single_asset_out_from_proto(
    inner: bond_client_view::IncomeWithBondRsp,
) -> BondSingleAssetOut {
    BondSingleAssetOut {
        market_value: inner.market_value.unwrap_or_default(),
        today_incomes: inner.today_incomes.unwrap_or_default(),
        position_incomes: inner.position_incomes.unwrap_or_default(),
        quantity: inner.quantity.unwrap_or_default(),
        cost: inner.cost.unwrap_or_default(),
        expired_time: inner.expired_time.unwrap_or(0),
        next_dividend_time: inner.next_dividend_time.unwrap_or(0),
        dividend_type: inner.dividend_type.unwrap_or(0),
        accrued_interest: inner.accrued_interest.unwrap_or_default(),
        dividend_option: inner.dividend_option.unwrap_or(0),
        notification: inner.notification.map(convert_bond_notification),
        notice: inner.notice.map(convert_notice),
        notice_list: inner.notice_list.into_iter().map(convert_notice).collect(),
        ccy: inner.ccy.unwrap_or_default(),
        coupon_cash: inner.coupon_cash.unwrap_or_default(),
        position_cost: inner.position_cost.unwrap_or_default(),
        price: inner.price.unwrap_or_default(),
    }
}

/// v1.4.95 U2-B: MCP tool `futu_get_bond_total_asset`
pub async fn get_bond_total_asset(
    client: &Arc<FutuClient>,
    env: &str,
    acc_id: u64,
    market: &str,
) -> Result<String> {
    if acc_id == 0 {
        bail!("acc_id 必填 (call futu_list_accounts to discover)");
    }
    let (trd_env_int, market_upper) = parse_bond_inputs(env, market)?;

    let req = bond_client_view::DaemonGetBondTotalAssetReq {
        c2s: bond_client_view::daemon_get_bond_total_asset_req::C2s {
            header: bond_client_view::DaemonBondHeader {
                acc_id,
                trd_env: Some(trd_env_int),
                market: market_upper,
            },
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::TRD_GET_BOND_TOTAL_ASSET, body)
        .await?;
    let resp = <bond_client_view::DaemonGetBondTotalAssetRsp as prost::Message>::decode(
        frame.body.as_ref(),
    )
    .map_err(|e| anyhow::anyhow!("decode DaemonGetBondTotalAssetRsp: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "GetBondTotalAsset ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let inner = resp
        .s2c
        .and_then(|s| s.inner)
        .ok_or_else(|| anyhow::anyhow!("empty s2c.inner in GetBondTotalAssetRsp"))?;

    let out = BondTotalAssetOut {
        total_asset: inner.total_asset.unwrap_or_default(),
        position_incomes: inner.position_incomes.unwrap_or_default(),
        today_incomes: inner.today_incomes.unwrap_or_default(),
        accrued_interest: inner.accrued_interest.unwrap_or_default(),
        show_flag: inner.show_flag.unwrap_or(false),
        ccy: inner.ccy.unwrap_or_default(),
    };
    Ok(serde_json::to_string_pretty(&out)?)
}

/// v1.4.95 U2-B: MCP tool `futu_get_bond_single_asset`
pub async fn get_bond_single_asset(
    client: &Arc<FutuClient>,
    env: &str,
    acc_id: u64,
    market: &str,
    symbol: &str,
) -> Result<String> {
    if acc_id == 0 {
        bail!("acc_id 必填 (call futu_list_accounts to discover)");
    }
    if symbol.trim().is_empty() {
        bail!("symbol 必填 (债券代码)");
    }
    let (trd_env_int, market_upper) = parse_bond_inputs(env, market)?;

    let req = bond_client_view::DaemonGetBondSingleAssetReq {
        c2s: bond_client_view::daemon_get_bond_single_asset_req::C2s {
            header: bond_client_view::DaemonBondHeader {
                acc_id,
                trd_env: Some(trd_env_int),
                market: market_upper,
            },
            symbol: symbol.to_string(),
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::TRD_GET_BOND_SINGLE_ASSET, body)
        .await?;
    let resp = <bond_client_view::DaemonGetBondSingleAssetRsp as prost::Message>::decode(
        frame.body.as_ref(),
    )
    .map_err(|e| anyhow::anyhow!("decode DaemonGetBondSingleAssetRsp: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "GetBondSingleAsset ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let inner = resp
        .s2c
        .and_then(|s| s.inner)
        .ok_or_else(|| anyhow::anyhow!("empty s2c.inner in GetBondSingleAssetRsp"))?;

    let out = bond_single_asset_out_from_proto(inner);
    Ok(serde_json::to_string_pretty(&out)?)
}

/// v1.4.95 U2-B: MCP tool `futu_get_bond_position_list`
pub async fn get_bond_position_list(
    client: &Arc<FutuClient>,
    env: &str,
    acc_id: u64,
    market: &str,
) -> Result<String> {
    if acc_id == 0 {
        bail!("acc_id 必填 (call futu_list_accounts to discover)");
    }
    let (trd_env_int, market_upper) = parse_bond_inputs(env, market)?;

    let req = bond_client_view::DaemonGetBondPositionListReq {
        c2s: bond_client_view::daemon_get_bond_position_list_req::C2s {
            header: bond_client_view::DaemonBondHeader {
                acc_id,
                trd_env: Some(trd_env_int),
                market: market_upper,
            },
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::TRD_GET_BOND_POSITION_LIST, body)
        .await?;
    let resp = <bond_client_view::DaemonGetBondPositionListRsp as prost::Message>::decode(
        frame.body.as_ref(),
    )
    .map_err(|e| anyhow::anyhow!("decode DaemonGetBondPositionListRsp: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "GetBondPositionList ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let inner = resp
        .s2c
        .and_then(|s| s.inner)
        .ok_or_else(|| anyhow::anyhow!("empty s2c.inner in GetBondPositionListRsp"))?;

    let bond_list: Vec<BondPositionItemOut> = inner
        .bond_list
        .into_iter()
        .map(|b| BondPositionItemOut {
            name: b.name.unwrap_or_default(),
            name_short: b.name_short.unwrap_or_default(),
            symbol: b.symbol.unwrap_or_default(),
            make_for_call_flag: b.make_for_call_flag.unwrap_or(false),
            market_value: b.market_value.unwrap_or_default(),
            quantity: b.quantity.unwrap_or_default(),
            price: b.price.unwrap_or_default(),
            cost: b.cost.unwrap_or_default(),
            today_incomes: b.today_incomes.unwrap_or_default(),
            today_incomes_rate: b.today_incomes_rate.unwrap_or_default(),
            position_incomes: b.position_incomes.unwrap_or_default(),
            position_incomes_rate: b.position_incomes_rate.unwrap_or_default(),
            accrued_interest: b.accrued_interest.unwrap_or_default(),
            ccy: b.ccy.unwrap_or_default(),
            notice: b.notice.map(convert_notice),
        })
        .collect();

    let out = BondPositionListOut {
        total: inner.total.unwrap_or(0),
        bond_list,
    };
    Ok(serde_json::to_string_pretty(&out)?)
}

/// v1.4.95 U2-B: MCP tool `futu_get_bond_answer_state`
pub async fn get_bond_answer_state(
    client: &Arc<FutuClient>,
    env: &str,
    acc_id: u64,
    market: &str,
    symbol: &str,
) -> Result<String> {
    if acc_id == 0 {
        bail!("acc_id 必填");
    }
    if symbol.trim().is_empty() {
        bail!("symbol 必填 (债券 symbol, 类似 11000018)");
    }
    let (trd_env_int, market_upper) = parse_bond_inputs(env, market)?;

    let req = bond_client_view::DaemonGetBondAnswerStateReq {
        c2s: bond_client_view::daemon_get_bond_answer_state_req::C2s {
            header: bond_client_view::DaemonBondHeader {
                acc_id,
                trd_env: Some(trd_env_int),
                market: market_upper,
            },
            symbol: symbol.to_string(),
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::TRD_GET_BOND_ANSWER_STATE, body)
        .await?;
    let resp = <bond_client_view::DaemonGetBondAnswerStateRsp as prost::Message>::decode(
        frame.body.as_ref(),
    )
    .map_err(|e| anyhow::anyhow!("decode DaemonGetBondAnswerStateRsp: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "GetBondAnswerState ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let inner = resp
        .s2c
        .and_then(|s| s.inner)
        .ok_or_else(|| anyhow::anyhow!("empty s2c.inner in GetBondAnswerStateRsp"))?;

    let out = BondAnswerStateOut {
        need_to_answer: inner.need_to_answer.unwrap_or(false),
        notice: inner.notice.map(|n| BondNoticeUrlOut {
            title: n.title.unwrap_or_default(),
            content: n.content.unwrap_or_default(),
            confirm_button_title: n.confirm_button_title.unwrap_or_default(),
            confirm_url: n.confirm_url.unwrap_or_default(),
            content_url_title: n.content_url_title.unwrap_or_default(),
            content_url: n.content_url.unwrap_or_default(),
            cancel_button_title: n.cancel_button_title.unwrap_or_default(),
        }),
    };
    Ok(serde_json::to_string_pretty(&out)?)
}

/// v1.4.95 U2-B: MCP tool `futu_get_bond_trade_reminder`
pub async fn get_bond_trade_reminder(
    client: &Arc<FutuClient>,
    env: &str,
    acc_id: u64,
    market: &str,
    symbol: &str,
) -> Result<String> {
    if acc_id == 0 {
        bail!("acc_id 必填");
    }
    if symbol.trim().is_empty() {
        bail!("symbol 必填 (债券 symbol)");
    }
    let (trd_env_int, market_upper) = parse_bond_inputs(env, market)?;

    let req = bond_client_view::DaemonGetBondTradeReminderReq {
        c2s: bond_client_view::daemon_get_bond_trade_reminder_req::C2s {
            header: bond_client_view::DaemonBondHeader {
                acc_id,
                trd_env: Some(trd_env_int),
                market: market_upper,
            },
            symbol: symbol.to_string(),
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::TRD_GET_BOND_TRADE_REMINDER, body)
        .await?;
    let resp = <bond_client_view::DaemonGetBondTradeReminderRsp as prost::Message>::decode(
        frame.body.as_ref(),
    )
    .map_err(|e| anyhow::anyhow!("decode DaemonGetBondTradeReminderRsp: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "GetBondTradeReminder ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let inner = resp
        .s2c
        .and_then(|s| s.inner)
        .ok_or_else(|| anyhow::anyhow!("empty s2c.inner in GetBondTradeReminderRsp"))?;

    let out = BondTradeReminderOut {
        tradeable: inner.tradeable.map(convert_reminder),
        complex_product: inner.complex_product.map(convert_reminder),
        high_risk: inner.high_risk.map(convert_reminder),
        sell_tradeable: inner.sell_tradeable.map(convert_reminder),
        pre_qualification: inner.pre_qualification.map(convert_reminder),
    };
    Ok(serde_json::to_string_pretty(&out)?)
}

#[cfg(test)]
mod tests;