ib_tws_core 0.2.0

Core utilities for interacting with Interactive Broker's TWS API
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::io;
use std::{f64, i32};

use bytes::BytesMut;

use super::constants::*;
use super::context::{Context, DispatchId};
use super::error::EncodeError;
use super::request::*;
use super::response::*;
use super::wire::{TwsWireDecoder, TwsWireEncoder};

pub fn encode_req_pnl(
    ctx: &mut Context,
    buf: &mut BytesMut,
    req: &ReqPnl,
) -> Result<DispatchId, EncodeError> {
    if ctx.server_version() < MIN_SERVER_VER_PNL {
        return Err(EncodeError::VersionLessError(MIN_SERVER_VER_PNL));
    }

    buf.push_int(REQ_PNL);
    buf.push_int(req.req_id);
    buf.push_string(&req.account);
    buf.push_string(&req.model_code);

    Ok(DispatchId::Oneshot(req.req_id))
}

pub fn encode_cancel_pnl(
    ctx: &mut Context,
    buf: &mut BytesMut,
    req: &CancelPnl,
) -> Result<DispatchId, EncodeError> {
    if ctx.server_version() < MIN_SERVER_VER_PNL {
        return Err(EncodeError::VersionLessError(MIN_SERVER_VER_PNL));
    }

    buf.push_int(CANCEL_PNL);
    buf.push_int(req.req_id);

    Ok(DispatchId::Oneshot(req.req_id))
}

pub fn decode_pnl_msg(ctx: &mut Context, buf: &mut BytesMut) -> Result<(Response, i32), io::Error> {
    let req_id = buf.read_int()?;
    let daily_pnl = buf.read_double()?;
    let mut unrealized_pnl = f64::MAX;
    let mut realized_pnl = f64::MAX;

    if ctx.server_version() >= MIN_SERVER_VER_UNREALIZED_PNL {
        unrealized_pnl = buf.read_double()?;
    }

    if ctx.server_version() >= MIN_SERVER_VER_REALIZED_PNL {
        realized_pnl = buf.read_double()?;
    }

    Ok((
        Response::PnlMsg(PnlMsg {
            req_id,
            daily_pnl,
            unrealized_pnl,
            realized_pnl,
        }),
        req_id,
    ))
}

////////////////////////////////////////////////////////////////////////////////////////////////////

pub fn encode_req_pnl_single(
    ctx: &mut Context,
    buf: &mut BytesMut,
    req: &ReqPnlSingle,
) -> Result<DispatchId, EncodeError> {
    if ctx.server_version() < MIN_SERVER_VER_PNL {
        return Err(EncodeError::VersionLessError(MIN_SERVER_VER_PNL));
    }

    buf.push_int(REQ_PNL_SINGLE);
    buf.push_int(req.req_id);
    buf.push_string(&req.account);
    buf.push_string(&req.model_code);
    buf.push_int(req.con_id);

    Ok(DispatchId::Oneshot(req.req_id))
}

pub fn encode_cancel_pnl_single(
    ctx: &mut Context,
    buf: &mut BytesMut,
    req: &CancelPnlSingle,
) -> Result<DispatchId, EncodeError> {
    if ctx.server_version() < MIN_SERVER_VER_PNL {
        return Err(EncodeError::VersionLessError(MIN_SERVER_VER_PNL));
    }

    buf.push_int(CANCEL_PNL_SINGLE);
    buf.push_int(req.req_id);

    Ok(DispatchId::Oneshot(req.req_id))
}

pub fn decode_pnl_single_msg(
    ctx: &mut Context,
    buf: &mut BytesMut,
) -> Result<(Response, i32), io::Error> {
    let req_id = buf.read_int()?;
    let pos = buf.read_int()?;
    let daily_pnl = buf.read_double()?;
    let mut unrealized_pnl = f64::MAX;
    let mut realized_pnl = f64::MAX;

    if ctx.server_version() >= MIN_SERVER_VER_UNREALIZED_PNL {
        unrealized_pnl = buf.read_double()?;
    }

    if ctx.server_version() >= MIN_SERVER_VER_REALIZED_PNL {
        realized_pnl = buf.read_double()?;
    }

    let value = buf.read_double()?;

    Ok((
        Response::PnlSingleMsg(PnlSingleMsg {
            req_id,
            pos,
            daily_pnl,
            unrealized_pnl,
            realized_pnl,
            value,
        }),
        req_id,
    ))
}