architect-api 11.6.3

Architect.xyz Trading Platform 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
137
138

use crate::{
    folio::{AccountBalances, AccountPositions, AccountStatistics},
    orderflow::{Cancel, Order},
    symbology::{ExecutionInfo, ExecutionVenue, TradableProduct},
    AccountId, AccountIdOrName, UserId,
};
use derive::grpc;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use uuid::Uuid;

pub mod cpty_id;

pub use cpty_id::CptyId;

#[grpc(package = "json.architect")]
#[grpc(service = "Cpty", name = "cpty", response = "CptyResponse", server_streaming)]
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[serde(tag = "t", rename_all = "snake_case")]
/// <!-- py: tag=t -->
pub enum CptyRequest {
    #[schemars(title = "Login|CptyLoginRequest")]
    Login(CptyLoginRequest),
    #[schemars(title = "Logout|CptyLogoutRequest")]
    Logout(CptyLogoutRequest),
    #[schemars(title = "PlaceOrder|Order")]
    PlaceOrder(Order),
    #[schemars(title = "PlaceBatchOrder|BatchOrder")]
    PlaceBatchOrder { orders: Vec<Order> },
    #[schemars(title = "CancelOrder")]
    CancelOrder { cancel: Cancel, original_order: Option<Order> },
    #[schemars(title = "CancelAllOrders")]
    CancelAllOrders {
        cancel_id: Uuid,
        trader: Option<UserId>,
        account: Option<AccountId>,
    },
    #[schemars(title = "BatchCancelOrders")]
    BatchCancelOrders { cancels: Vec<Cancel>, original_orders: Vec<Option<Order>> },
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct CptyLoginRequest {
    pub trader: UserId,
    pub account: AccountId,
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct CptyLogoutRequest {}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[serde(tag = "t", rename_all = "snake_case")]
/// <!-- py: tag=t -->
pub enum CptyResponse {
    #[serde(rename = "xs")]
    #[schemars(title = "Symbology")]
    Symbology {
        execution_info:
            BTreeMap<TradableProduct, BTreeMap<ExecutionVenue, ExecutionInfo>>,
    },
    #[serde(rename = "ro")]
    #[schemars(title = "ReconcileOrder|Order")]
    ReconcileOrder(Order),
    #[serde(rename = "oo")]
    #[schemars(title = "ReconcileOpenOrders")]
    ReconcileOpenOrders {
        orders: Vec<Order>,
        snapshot_for_account: Option<AccountIdOrName>,
    },
    #[serde(rename = "as")]
    #[schemars(title = "UpdateAccountSummary")]
    UpdateAccountSummary {
        account: AccountIdOrName,
        timestamp: i64,
        timestamp_ns: u32,
        #[serde(default)]
        balances: Option<AccountBalances>,
        #[serde(default)]
        positions: Option<AccountPositions>,
        #[serde(default)]
        statistics: Option<AccountStatistics>,
        is_snapshot: bool,
    },
}

#[grpc(package = "json.architect")]
#[grpc(service = "Cpty", name = "cpty_status", response = "CptyStatus")]
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct CptyStatusRequest {
    pub kind: String,
    pub instance: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct CptyStatus {
    pub kind: String,
    pub instance: Option<String>,
    pub connected: bool,
    /// Not applicable to cpty if None
    pub logged_in: Option<bool>,
    pub stale: bool,
    pub connections: BTreeMap<String, ConnectionStatus>,
}

impl CptyStatus {
    pub fn new(id: CptyId) -> Self {
        Self {
            kind: id.kind.to_string(),
            instance: id.instance.map(|s| s.to_string()),
            connected: true,
            logged_in: None,
            stale: false,
            connections: BTreeMap::new(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct ConnectionStatus {
    pub connected: bool,
    /// Not applicable to connection if None
    pub logged_in: Option<bool>,
    /// UNIX epoch time or -1 for never
    pub last_heartbeat: i64,
    /// Stale threshold in seconds, or -1 for never stale
    pub last_heartbeat_stale_threshold: i64,
}

#[grpc(package = "json.architect")]
#[grpc(service = "Cpty", name = "cptys", response = "CptysResponse")]
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct CptysRequest {}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct CptysResponse {
    pub cptys: Vec<CptyStatus>,
}