ibapi 5.0.0

An unofficial Rust client for the Interactive Brokers TWS API. Async (Tokio) and blocking clients for TWS and IB Gateway.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::messages::ResponseMessage;
use crate::orders::{CommissionReport, ExecutionData, OrderBound, OrderData, OrderStatus};
use crate::proto::decoders::{required, DecodeProto};
use crate::Error;

// All originating outgoing-request gates for OpenOrder, CompletedOrder,
// OrderStatus, ExecutionData, and CommissionReport are <= the connection floor.
// The server always emits proto framing for these messages; text-framed arrival
// is rejected via `ResponseMessage::require_proto`, which raises
// `Error::UnexpectedWireFormat` (docs/rules/wire/proto-only-decoding.md).

pub(crate) fn decode_open_order(message: &ResponseMessage) -> Result<OrderData, Error> {
    decode_open_order_proto(message.require_proto()?)
}

pub(crate) fn decode_order_status(message: &ResponseMessage) -> Result<OrderStatus, Error> {
    decode_order_status_proto(message.require_proto()?)
}

pub(crate) fn decode_order_bound(message: &ResponseMessage) -> Result<OrderBound, Error> {
    let p = crate::proto::OrderBound::decode_proto(message.require_proto()?)?;
    Ok(OrderBound {
        perm_id: required(p.perm_id, "perm_id", "OrderBound")?,
        client_id: required(p.client_id, "client_id", "OrderBound")?,
        order_id: required(p.order_id, "order_id", "OrderBound")?,
    })
}

pub(crate) fn decode_execution_data(message: &ResponseMessage) -> Result<ExecutionData, Error> {
    decode_execution_data_proto(message.require_proto()?)
}

pub(crate) fn decode_commission_report(message: &ResponseMessage) -> Result<CommissionReport, Error> {
    decode_commission_report_proto(message.require_proto()?)
}

pub(crate) fn decode_completed_order(message: &ResponseMessage) -> Result<OrderData, Error> {
    decode_completed_order_proto(message.require_proto()?)
}

// === Protobuf decoders ===

pub(crate) fn decode_open_order_proto(bytes: &[u8]) -> Result<OrderData, Error> {
    let p = crate::proto::OpenOrder::decode_proto(bytes)?;

    Ok(OrderData {
        order_id: p.order_id.unwrap_or_default(),
        contract: crate::proto::decoders::decode_contract(required(p.contract.as_ref(), "contract", "OpenOrder")?)?,
        order: crate::proto::decoders::decode_order(required(p.order.as_ref(), "order", "OpenOrder")?)?,
        order_state: crate::proto::decoders::decode_order_state(required(p.order_state.as_ref(), "order_state", "OpenOrder")?)?,
    })
}

pub(crate) fn decode_order_status_proto(bytes: &[u8]) -> Result<OrderStatus, Error> {
    let p = crate::proto::OrderStatus::decode_proto(bytes)?;

    Ok(OrderStatus {
        order_id: p.order_id.unwrap_or_default(),
        status: crate::proto::decoders::parse_required(p.status.as_deref(), "OrderStatus")?,
        filled: crate::proto::decoders::parse_decimal_or_zero(p.filled.as_deref())?,
        remaining: crate::proto::decoders::parse_decimal_or_zero(p.remaining.as_deref())?,
        average_fill_price: p.avg_fill_price,
        perm_id: p.perm_id.unwrap_or_default(),
        parent_id: p.parent_id.unwrap_or_default(),
        last_fill_price: p.last_fill_price,
        client_id: p.client_id.unwrap_or_default(),
        why_held: p.why_held.unwrap_or_default(),
        market_cap_price: p.mkt_cap_price,
    })
}

pub(crate) fn decode_execution_data_proto(bytes: &[u8]) -> Result<ExecutionData, Error> {
    let p = crate::proto::ExecutionDetails::decode_proto(bytes)?;

    Ok(ExecutionData {
        request_id: p.req_id.unwrap_or_default(),
        contract: crate::proto::decoders::decode_contract(required(p.contract.as_ref(), "contract", "ExecutionDetails")?)?,
        execution: crate::proto::decoders::decode_execution(required(p.execution.as_ref(), "execution", "ExecutionDetails")?)?,
    })
}

pub(crate) fn decode_completed_order_proto(bytes: &[u8]) -> Result<OrderData, Error> {
    let p = crate::proto::CompletedOrder::decode_proto(bytes)?;
    let contract = crate::proto::decoders::decode_contract(required(p.contract.as_ref(), "contract", "CompletedOrder")?)?;
    let order = crate::proto::decoders::decode_order(required(p.order.as_ref(), "order", "CompletedOrder")?)?;
    let order_state = crate::proto::decoders::decode_order_state(required(p.order_state.as_ref(), "order_state", "CompletedOrder")?)?;

    Ok(OrderData {
        // Completed orders carry no live order_id; preserve the legacy text-decoder
        // sentinel so v2 → v3 consumers see the same value.
        order_id: -1,
        contract,
        order,
        order_state,
    })
}

pub(crate) fn decode_commission_report_proto(bytes: &[u8]) -> Result<CommissionReport, Error> {
    let p = crate::proto::CommissionAndFeesReport::decode_proto(bytes)?;

    Ok(CommissionReport {
        execution_id: p.exec_id.unwrap_or_default(),
        commission: p.commission_and_fees.unwrap_or_default(),
        currency: p.currency.unwrap_or_default(),
        realized_pnl: crate::proto::decoders::optional_f64(p.realized_pnl),
        yields: crate::proto::decoders::optional_f64(p.bond_yield),
        yield_redemption_date: p.yield_redemption_date.unwrap_or_default(),
    })
}

pub(crate) fn decode_next_valid_id_proto(p: crate::proto::NextValidId) -> Result<i32, Error> {
    Ok(p.order_id.unwrap_or_default())
}

#[cfg(test)]
mod tests;