futu_rest/routes/qot/

reference.rs

//! Split from routes/qot.rs: reference.

use axum::extract::{Json, State};
use futu_qot::ipo_calendar::{
    collect_ipo_calendar_events, is_supported_ipo_event_type, is_yyyymmdd,
};
use serde::Deserialize;
use serde_json::Value;

use futu_core::proto_id;

use super::*;

mod company;
mod unusual;
pub use company::{
    get_company_executive_background, get_company_executives, get_company_operational_efficiency,
    get_company_profile, get_financials_earnings_price_history, get_financials_earnings_price_move,
    get_financials_revenue_breakdown, get_financials_statements, get_research_analyst_consensus,
    get_research_morningstar_report, get_research_rating_summary, get_valuation_detail,
    get_valuation_plate_stock_list,
};
pub use unusual::{get_derivative_unusual, get_financial_unusual, get_technical_unusual};

#[cfg(test)]
mod tests;

pub async fn get_plate_set(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_plate_set::Request, qot_get_plate_set::Response>(
        &state,
        proto_id::QOT_GET_PLATE_SET,
        Some(body),
    )
    .await
}

/// POST /api/plate-security — 获取板块内股票
pub async fn get_plate_security(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_plate_security::Request, qot_get_plate_security::Response>(
        &state,
        proto_id::QOT_GET_PLATE_SECURITY,
        Some(body),
    )
    .await
}

/// POST /api/reference — 获取关联数据
pub async fn get_reference(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_reference::Request, qot_get_reference::Response>(
        &state,
        proto_id::QOT_GET_REFERENCE,
        Some(body),
    )
    .await
}

/// POST /api/owner-plate — 获取所属板块
pub async fn get_owner_plate(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_owner_plate::Request, qot_get_owner_plate::Response>(
        &state,
        proto_id::QOT_GET_OWNER_PLATE,
        Some(body),
    )
    .await
}

/// POST /api/option-chain — 获取期权链
pub async fn get_option_chain(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_option_chain::Request, qot_get_option_chain::Response>(
        &state,
        proto_id::QOT_GET_OPTION_CHAIN,
        Some(body),
    )
    .await
}

/// POST /api/option-quote — 获取单腿/组合期权实时行情
pub async fn get_option_quote(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_option_quote::Request, qot_get_option_quote::Response>(
        &state,
        proto_id::QOT_GET_OPTION_QUOTE,
        Some(body),
    )
    .await
}

/// POST /api/option-strategy — 获取组合期权策略列表
pub async fn get_option_strategy(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_option_strategy::Request,
        qot_get_option_strategy::Response,
    >(&state, proto_id::QOT_GET_OPTION_STRATEGY, Some(body))
    .await
}

/// POST /api/option-strategy-analysis — 获取组合期权策略分析
pub async fn get_option_strategy_analysis(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_option_strategy_analysis::Request,
        qot_get_option_strategy_analysis::Response,
    >(
        &state,
        proto_id::QOT_GET_OPTION_STRATEGY_ANALYSIS,
        Some(body),
    )
    .await
}

/// POST /api/option-strategy-spread — 获取组合期权有效价差
pub async fn get_option_strategy_spread(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_option_strategy_spread::Request,
        qot_get_option_strategy_spread::Response,
    >(&state, proto_id::QOT_GET_OPTION_STRATEGY_SPREAD, Some(body))
    .await
}

/// POST /api/warrant — 获取窝轮
pub async fn get_warrant(State(state): State<RestState>, Json(body): Json<Value>) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_warrant::Request, qot_get_warrant::Response>(
        &state,
        proto_id::QOT_GET_WARRANT,
        Some(body),
    )
    .await
}

/// POST /api/capital-flow — 获取资金流向
pub async fn get_capital_flow(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_capital_flow::Request, qot_get_capital_flow::Response>(
        &state,
        proto_id::QOT_GET_CAPITAL_FLOW,
        Some(body),
    )
    .await
}

/// POST /api/capital-distribution — 获取资金分布
pub async fn get_capital_distribution(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_capital_distribution::Request,
        qot_get_capital_distribution::Response,
    >(&state, proto_id::QOT_GET_CAPITAL_DISTRIBUTION, Some(body))
    .await
}

/// POST /api/corporate-actions-buybacks — 获取回购记录
pub async fn get_corporate_actions_buybacks(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_corporate_actions_buybacks::Request,
        qot_get_corporate_actions_buybacks::Response,
    >(
        &state,
        proto_id::QOT_GET_CORPORATE_ACTIONS_BUYBACKS,
        Some(body),
    )
    .await
}

/// POST /api/corporate-actions-dividends — 获取分红派息
pub async fn get_corporate_actions_dividends(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_corporate_actions_dividends::Request,
        qot_get_corporate_actions_dividends::Response,
    >(
        &state,
        proto_id::QOT_GET_CORPORATE_ACTIONS_DIVIDENDS,
        Some(body),
    )
    .await
}

/// POST /api/corporate-actions-stock-splits — 获取拆合股
pub async fn get_corporate_actions_stock_splits(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_corporate_actions_stock_splits::Request,
        qot_get_corporate_actions_stock_splits::Response,
    >(
        &state,
        proto_id::QOT_GET_CORPORATE_ACTIONS_STOCK_SPLITS,
        Some(body),
    )
    .await
}

/// POST /api/daily-short-volume — 获取每日卖空成交
pub async fn get_daily_short_volume(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_daily_short_volume::Request,
        qot_get_daily_short_volume::Response,
    >(&state, proto_id::QOT_GET_DAILY_SHORT_VOLUME, Some(body))
    .await
}

/// POST /api/short-interest — 获取空头持仓
pub async fn get_short_interest(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_short_interest::Request, qot_get_short_interest::Response>(
        &state,
        proto_id::QOT_GET_SHORT_INTEREST,
        Some(body),
    )
    .await
}

/// POST /api/top-ten-buy-sell-brokers — 获取十大买卖经纪商
pub async fn get_top_ten_buy_sell_brokers(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_top_ten_buy_sell_brokers::Request,
        qot_get_top_ten_buy_sell_brokers::Response,
    >(
        &state,
        proto_id::QOT_GET_TOP_TEN_BUY_SELL_BROKERS,
        Some(body),
    )
    .await
}

/// POST /api/shareholders-overview — 获取持股统计
pub async fn get_shareholders_overview(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_shareholders_overview::Request,
        qot_get_shareholders_overview::Response,
    >(&state, proto_id::QOT_GET_SHAREHOLDERS_OVERVIEW, Some(body))
    .await
}

/// POST /api/shareholders-holding-changes — 获取股东持股变动
pub async fn get_shareholders_holding_changes(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_shareholders_holding_changes::Request,
        qot_get_shareholders_holding_changes::Response,
    >(
        &state,
        proto_id::QOT_GET_SHAREHOLDERS_HOLDING_CHANGES,
        Some(body),
    )
    .await
}

/// POST /api/shareholders-holder-detail — 获取股东持股明细
pub async fn get_shareholders_holder_detail(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_shareholders_holder_detail::Request,
        qot_get_shareholders_holder_detail::Response,
    >(
        &state,
        proto_id::QOT_GET_SHAREHOLDERS_HOLDER_DETAIL,
        Some(body),
    )
    .await
}

/// POST /api/shareholders-institutional — 获取机构持股统计
pub async fn get_shareholders_institutional(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_shareholders_institutional::Request,
        qot_get_shareholders_institutional::Response,
    >(
        &state,
        proto_id::QOT_GET_SHAREHOLDERS_INSTITUTIONAL,
        Some(body),
    )
    .await
}

/// POST /api/insider-holder-list — 获取内部人持股列表
pub async fn get_insider_holder_list(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_insider_holder_list::Request,
        qot_get_insider_holder_list::Response,
    >(&state, proto_id::QOT_GET_INSIDER_HOLDER_LIST, Some(body))
    .await
}

/// POST /api/insider-trade-list — 获取内部人交易列表
pub async fn get_insider_trade_list(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_insider_trade_list::Request,
        qot_get_insider_trade_list::Response,
    >(&state, proto_id::QOT_GET_INSIDER_TRADE_LIST, Some(body))
    .await
}

/// POST /api/option-volatility — 获取期权波动率分析
pub async fn get_option_volatility(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_option_volatility::Request,
        qot_get_option_volatility::Response,
    >(&state, proto_id::QOT_GET_OPTION_VOLATILITY, Some(body))
    .await
}

/// POST /api/option-exercise-probability — 获取期权行权概率
pub async fn get_option_exercise_probability(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_option_exercise_probability::Request,
        qot_get_option_exercise_probability::Response,
    >(
        &state,
        proto_id::QOT_GET_OPTION_EXERCISE_PROBABILITY,
        Some(body),
    )
    .await
}

/// POST /api/stock-screen — 获取股票筛选结果
pub async fn stock_screen(State(state): State<RestState>, Json(body): Json<Value>) -> RawApiResult {
    adapter::proto_request_raw::<qot_stock_screen::Request, qot_stock_screen::Response>(
        &state,
        proto_id::QOT_STOCK_SCREEN,
        Some(body),
    )
    .await
}

/// POST /api/option-screen — 获取期权筛选结果
pub async fn option_screen(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_option_screen::Request, qot_option_screen::Response>(
        &state,
        proto_id::QOT_OPTION_SCREEN,
        Some(body),
    )
    .await
}

/// POST /api/warrant-screen — 获取窝轮筛选结果
pub async fn warrant_screen(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_warrant_screen::Request, qot_warrant_screen::Response>(
        &state,
        proto_id::QOT_WARRANT_SCREEN,
        Some(body),
    )
    .await
}

/// POST /api/user-security — 获取自选股
pub async fn get_user_security(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_user_security::Request, qot_get_user_security::Response>(
        &state,
        proto_id::QOT_GET_USER_SECURITY,
        Some(body),
    )
    .await
}

/// POST /api/user-security-groups — 获取自选股分组列表
pub async fn get_user_security_group(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_user_security_group::Request,
        qot_get_user_security_group::Response,
    >(&state, proto_id::QOT_GET_USER_SECURITY_GROUP, Some(body))
    .await
}

/// POST /api/stock-filter — 条件选股
pub async fn stock_filter(State(state): State<RestState>, Json(body): Json<Value>) -> RawApiResult {
    adapter::proto_request_raw::<qot_stock_filter::Request, qot_stock_filter::Response>(
        &state,
        proto_id::QOT_STOCK_FILTER,
        Some(body),
    )
    .await
}

/// POST /api/ipo-list — 获取IPO列表
pub async fn get_ipo_list(State(state): State<RestState>, Json(body): Json<Value>) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_ipo_list::Request, qot_get_ipo_list::Response>(
        &state,
        proto_id::QOT_GET_IPO_LIST,
        Some(body),
    )
    .await
}

#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct IpoCalendarRestReq {
    market: i32,
    #[serde(default, alias = "eventTypes")]
    event_types: Vec<String>,
    #[serde(default, alias = "beginDate")]
    begin_date: Option<String>,
    #[serde(default, alias = "endDate")]
    end_date: Option<String>,
}

fn validate_ipo_calendar_req(req: &IpoCalendarRestReq) -> Result<(), (StatusCode, Json<Value>)> {
    if !matches!(req.market, 1 | 2 | 11 | 21 | 22 | 31 | 41 | 61) {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(serde_json::json!({
                "error": "market must be 1, 2, 11, 21, 22, 31, 41, or 61 (HK/HK_Future/US/SH/SZ/SG/JP/MY)"
            })),
        ));
    }
    for (field, value) in [
        ("begin_date", req.begin_date.as_deref()),
        ("end_date", req.end_date.as_deref()),
    ] {
        if let Some(value) = value
            && !is_yyyymmdd(value)
        {
            return Err((
                StatusCode::BAD_REQUEST,
                Json(serde_json::json!({
                    "error": format!("{field} must be YYYYMMDD")
                })),
            ));
        }
    }
    if let (Some(begin), Some(end)) = (&req.begin_date, &req.end_date)
        && begin > end
    {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(serde_json::json!({
                "error": "begin_date must be earlier than or equal to end_date"
            })),
        ));
    }
    if let Some(event) = req
        .event_types
        .iter()
        .find(|event| !is_supported_ipo_event_type(event))
    {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(serde_json::json!({
                "error": format!("unsupported IPO calendar event_type {event:?}")
            })),
        ));
    }
    Ok(())
}

/// POST /api/ipo-calendar — IPO calendar projection over Qot_GetIpoList
pub async fn get_ipo_calendar(
    State(state): State<RestState>,
    Json(req): Json<IpoCalendarRestReq>,
) -> RawApiResult {
    validate_ipo_calendar_req(&req)?;
    let req_msg = futu_proto::qot_get_ipo_list::Request {
        c2s: futu_proto::qot_get_ipo_list::C2s {
            market: req.market,
            header: None,
        },
    };
    let conn_id = state.next_conn_id();
    let serial_no = state.next_serial();
    let incoming = IncomingRequest::builder(
        conn_id,
        proto_id::QOT_GET_IPO_LIST,
        serial_no,
        ProtoFmtType::Protobuf,
        Bytes::from(req_msg.encode_to_vec()),
    )
    .build();
    let resp_bytes = state
        .router
        .dispatch(incoming.conn_id, &incoming)
        .await
        .ok_or_else(|| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(serde_json::json!({"error": "handler returned no response"})),
            )
        })?;
    let resp =
        futu_proto::qot_get_ipo_list::Response::decode(resp_bytes.as_slice()).map_err(|e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(serde_json::json!({"error": format!("failed to decode response: {e}")})),
            )
        })?;
    if resp.ret_type != 0 {
        let raw = serde_json::to_vec(&serde_json::json!({
            "ret_type": resp.ret_type,
            "ret_msg": resp.ret_msg,
            "err_code": resp.err_code,
            "events": []
        }))
        .map_err(|e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(serde_json::json!({"error": format!("failed to serialize response: {e}")})),
            )
        })?;
        return Ok(adapter::RawJson::new(raw));
    }
    let s2c = resp.s2c.as_ref().ok_or_else(|| {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": "missing s2c"})),
        )
    })?;
    let events = collect_ipo_calendar_events(
        s2c,
        &req.event_types,
        req.begin_date.as_deref(),
        req.end_date.as_deref(),
    );
    let raw = serde_json::to_vec(&serde_json::json!({
        "market": req.market,
        "event_types": req.event_types,
        "begin_date": req.begin_date,
        "end_date": req.end_date,
        "events": events
    }))
    .map_err(|e| {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({"error": format!("failed to serialize response: {e}")})),
        )
    })?;
    Ok(adapter::RawJson::new(raw))
}

/// POST /api/future-info — 获取期货信息
pub async fn get_future_info(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_future_info::Request, qot_get_future_info::Response>(
        &state,
        proto_id::QOT_GET_FUTURE_INFO,
        Some(body),
    )
    .await
}

/// POST /api/market-state — 获取市场状态
pub async fn get_market_state(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_market_state::Request, qot_get_market_state::Response>(
        &state,
        proto_id::QOT_GET_MARKET_STATE,
        Some(body),
    )
    .await
}

/// POST /api/history-kline — 请求历史K线
pub async fn request_history_kl(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_request_history_kl::Request, qot_request_history_kl::Response>(
        &state,
        proto_id::QOT_REQUEST_HISTORY_KL,
        Some(body),
    )
    .await
}

// v1.4.30 新增

/// POST /api/trading-days — 查询交易日（对齐 py-futu-api `request_trading_days`）
pub async fn request_trading_days(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_request_trade_date::Request, qot_request_trade_date::Response>(
        &state,
        proto_id::QOT_REQUEST_TRADE_DATE,
        Some(body),
    )
    .await
}

/// POST /api/rehab — 请求复权因子（对齐 py-futu-api `get_rehab`）
pub async fn request_rehab(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_request_rehab::Request, qot_request_rehab::Response>(
        &state,
        proto_id::QOT_REQUEST_REHAB,
        Some(body),
    )
    .await
}

/// POST /api/suspend — 获取停牌日（对齐 py-futu-api `get_suspend`）
pub async fn get_suspend(State(state): State<RestState>, Json(body): Json<Value>) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_suspend::Request, qot_get_suspend::Response>(
        &state,
        proto_id::QOT_GET_SUSPEND,
        Some(body),
    )
    .await
}

// v1.4.30 P2（100% 覆盖）

/// POST /api/history-kl-quota — 历史 K 线配额
pub async fn request_history_kl_quota(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_request_history_kl_quota::Request,
        qot_request_history_kl_quota::Response,
    >(&state, proto_id::QOT_REQUEST_HISTORY_KL_QUOTA, Some(body))
    .await
}

/// POST /api/used-quota — 当前 daemon 已用订阅额度与历史 K 线额度
pub async fn get_used_quota(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<used_quota::Request, used_quota::Response>(
        &state,
        proto_id::GET_USED_QUOTA,
        Some(body),
    )
    .await
}

/// POST /api/holding-change — 持股变动
pub async fn get_holding_change(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_holding_change_list::Request,
        qot_get_holding_change_list::Response,
    >(&state, proto_id::QOT_GET_HOLDING_CHANGE_LIST, Some(body))
    .await
}

/// POST /api/modify-user-security — 修改自选
pub async fn modify_user_security(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_modify_user_security::Request,
        qot_modify_user_security::Response,
    >(&state, proto_id::QOT_MODIFY_USER_SECURITY, Some(body))
    .await
}

/// POST /api/code-change — 代码变更
pub async fn get_code_change(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_code_change::Request, qot_get_code_change::Response>(
        &state,
        proto_id::QOT_GET_CODE_CHANGE,
        Some(body),
    )
    .await
}

/// POST /api/set-price-reminder — 设置到价提醒
pub async fn set_price_reminder(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_set_price_reminder::Request, qot_set_price_reminder::Response>(
        &state,
        proto_id::QOT_SET_PRICE_REMINDER,
        Some(body),
    )
    .await
}

/// POST /api/price-reminder — 查询到价提醒
pub async fn get_price_reminder(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<qot_get_price_reminder::Request, qot_get_price_reminder::Response>(
        &state,
        proto_id::QOT_GET_PRICE_REMINDER,
        Some(body),
    )
    .await
}

/// POST /api/option-expiration-date — 期权到期日
pub async fn get_option_expiration_date(
    State(state): State<RestState>,
    Json(body): Json<Value>,
) -> RawApiResult {
    adapter::proto_request_raw::<
        qot_get_option_expiration_date::Request,
        qot_get_option_expiration_date::Response,
    >(&state, proto_id::QOT_GET_OPTION_EXPIRATION_DATE, Some(body))
    .await
}