1use crate::{
2 OrderId,
3 domain::{
4 book::{
5 MarketId,
6 OrderBooksBalances,
7 Price,
8 Quantity,
9 },
10 depth::{
11 DepthBookChanges,
12 DepthView,
13 },
14 event::{
15 Identity,
16 OnChainTimeStamp,
17 SeenTimeStamp,
18 },
19 trade::{
20 TradeId,
21 TradeSide,
22 },
23 },
24 fuel_types::{
25 AssetId,
26 Bytes32,
27 ContractId,
28 TxId,
29 },
30 parse::HexDisplayFromStr,
31 primitives::{
32 OrderType,
33 Side,
34 },
35};
36use serde::{
37 Deserialize,
38 Serialize,
39};
40use serde_with::{
41 DisplayFromStr,
42 serde_as,
43};
44use std::{
45 collections::BTreeMap,
46 sync::Arc,
47};
48
49#[serde_as]
50#[derive(Serialize, Deserialize, Debug, Clone)]
51pub struct SubscribeDepthResponse {
52 pub action: String,
53 pub view: Arc<DepthView>,
54 #[serde_as(as = "HexDisplayFromStr")]
55 pub market_id: Bytes32,
56}
57
58#[serde_as]
59#[derive(Serialize, Deserialize, Debug, Clone, Default)]
60pub struct SubscribeDepthResponseUpdate {
61 pub action: String,
62 pub changes: Arc<DepthBookChanges>,
63 #[serde_as(as = "HexDisplayFromStr")]
64 pub market_id: Bytes32,
65 #[serde_as(as = "Option<DisplayFromStr>")]
66 pub onchain_timestamp: Option<OnChainTimeStamp>,
67 #[serde_as(as = "DisplayFromStr")]
68 pub seen_timestamp: SeenTimeStamp,
69}
70
71#[serde_as]
72#[derive(Serialize, Deserialize, Debug, Clone)]
73pub struct OrderHistoryResponse {
74 #[serde(rename = "type")]
75 pub kind: String,
76 pub status: String,
77 #[serde_as(as = "HexDisplayFromStr")]
78 pub tx_id: TxId,
79}
80
81#[serde_as]
82#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
83pub struct Fill {
84 #[serde_as(as = "HexDisplayFromStr")]
85 pub order_id: OrderId,
86 #[serde_as(as = "DisplayFromStr")]
87 pub quantity: Quantity,
88 #[serde_as(as = "DisplayFromStr")]
89 pub price: Price,
90 #[serde_as(as = "DisplayFromStr")]
91 pub timestamp: u128,
92 #[serde_as(as = "DisplayFromStr")]
93 pub fee: u64,
94}
95
96#[serde_as]
97#[derive(Debug, Serialize, Deserialize, Clone)]
98pub struct SubscribeOrder {
99 #[serde_as(as = "HexDisplayFromStr")]
100 pub order_id: OrderId,
101 pub owner: Identity,
102 #[serde_as(as = "DisplayFromStr")]
103 pub side: Side,
104 pub order_type: OrderType,
105 #[serde_as(as = "HexDisplayFromStr")]
106 pub market_id: MarketId,
107 #[serde_as(as = "DisplayFromStr")]
108 pub quantity: u64,
109 #[serde_as(as = "DisplayFromStr")]
110 pub quantity_fill: u64,
111 #[serde_as(as = "DisplayFromStr")]
112 pub price: u64,
113 #[serde_as(as = "DisplayFromStr")]
114 pub price_fill: u64,
115 #[serde_as(as = "DisplayFromStr")]
116 pub timestamp: u128,
117 pub close: bool,
118 pub partially_filled: bool,
119 pub cancel: bool,
120 pub history: Vec<OrderHistoryResponse>,
121 pub fills: Vec<Fill>,
122}
123
124#[serde_as]
125#[derive(Debug, Serialize, Deserialize, Clone)]
126pub struct SubscribeOrdersResponse {
127 pub action: String,
128 pub orders: Vec<SubscribeOrder>,
129 #[serde_as(as = "Option<DisplayFromStr>")]
130 pub onchain_timestamp: Option<OnChainTimeStamp>,
131 #[serde_as(as = "DisplayFromStr")]
132 pub seen_timestamp: SeenTimeStamp,
133}
134
135#[serde_as]
136#[derive(Serialize, Deserialize, Debug)]
137pub struct SubscribeCoinsResponse {
138 pub action: String,
139 pub trades: Vec<TradeResponse>,
140 pub market_id: String,
141 #[serde_as(as = "Option<DisplayFromStr>")]
142 pub onchain_timestamp: Option<OnChainTimeStamp>,
143 #[serde_as(as = "DisplayFromStr")]
144 pub seen_timestamp: SeenTimeStamp,
145}
146
147#[serde_as]
148#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
149pub struct TradeResponse {
150 #[serde_as(as = "DisplayFromStr")]
151 pub trade_id: TradeId,
152 #[serde_as(as = "DisplayFromStr")]
153 pub side: Side,
154 #[serde_as(as = "DisplayFromStr")]
155 pub total: u128,
156 #[serde_as(as = "DisplayFromStr")]
157 pub quantity: u64,
158 #[serde_as(as = "DisplayFromStr")]
159 pub price: u64,
160 #[serde_as(as = "DisplayFromStr")]
161 pub timestamp: u128,
162}
163
164#[serde_as]
165#[derive(Serialize, Deserialize, Debug)]
166pub struct TradeByAccountResponse {
167 #[serde_as(as = "DisplayFromStr")]
168 pub trade_id: TradeId,
169 #[serde_as(as = "DisplayFromStr")]
170 pub side: Side,
171 #[serde_as(as = "DisplayFromStr")]
172 pub total: u128,
173 #[serde_as(as = "DisplayFromStr")]
174 pub quantity: u64,
175 #[serde_as(as = "DisplayFromStr")]
176 pub price: u64,
177 #[serde_as(as = "DisplayFromStr")]
178 pub timestamp: u128,
179 #[serde_as(as = "DisplayFromStr")]
180 pub trader_side: TradeSide,
181 #[serde_as(as = "DisplayFromStr")]
182 pub maker_fee: u64,
183 #[serde_as(as = "DisplayFromStr")]
184 pub taker_fee: u64,
185}
186
187#[serde_as]
188#[derive(Serialize, Deserialize, Debug, Clone)]
189pub struct SubscribeTradeResponse {
190 pub action: String,
191 pub trades: Vec<TradeResponse>,
192 #[serde_as(as = "HexDisplayFromStr")]
193 pub market_id: Bytes32,
194 #[serde_as(as = "Option<DisplayFromStr>")]
195 pub onchain_timestamp: Option<OnChainTimeStamp>,
196 #[serde_as(as = "DisplayFromStr")]
197 pub seen_timestamp: SeenTimeStamp,
198}
199
200#[serde_as]
201#[derive(Serialize, Deserialize, Debug)]
202pub struct GetTradesResponse {
203 pub action: String,
204 pub trades: Vec<TradeResponse>,
205 #[serde_as(as = "HexDisplayFromStr")]
206 pub market_id: Bytes32,
207}
208
209#[serde_as]
210#[derive(Serialize, Deserialize, Debug)]
211pub struct GetTradesByAccountResponse {
212 pub action: String,
213 pub trades: Vec<TradeByAccountResponse>,
214 #[serde_as(as = "HexDisplayFromStr")]
215 pub market_id: Bytes32,
216}
217
218#[serde_as]
219#[derive(Serialize, Deserialize, Debug)]
220pub struct GetTradeByAccountResponse {
221 pub trade: TradeByAccountResponse,
222 #[serde_as(as = "HexDisplayFromStr")]
223 pub market_id: Bytes32,
224}
225
226#[serde_as]
227#[derive(Serialize, Deserialize, Debug)]
228pub struct CreateLimitOrderResponse {
229 pub action: String,
230 #[serde_as(as = "HexDisplayFromStr")]
231 pub transaction_id: Bytes32,
232}
233
234#[serde_as]
235#[derive(Serialize, Deserialize, Debug)]
236pub struct CreateStopLimitOrderResponse {
237 pub action: String,
238 #[serde_as(as = "HexDisplayFromStr")]
239 pub transaction_id: Bytes32,
240}
241
242#[derive(Serialize, Deserialize, Debug)]
243pub struct GetUtxosResponse {
244 pub action: String,
245 pub utxos: Vec<String>,
246}
247
248#[serde_as]
249#[derive(Serialize, Deserialize, Debug)]
250pub struct GetTradeDataResponse {
251 pub action: String,
252 pub trend: String,
253 #[serde_as(as = "DisplayFromStr")]
254 pub low_price: u64,
255 #[serde_as(as = "DisplayFromStr")]
256 pub high_price: u64,
257 #[serde_as(as = "DisplayFromStr")]
258 pub current_price: u64,
259 #[serde_as(as = "DisplayFromStr")]
260 pub ratio: u64,
261 #[serde_as(as = "DisplayFromStr")]
262 pub buys: u64,
263 #[serde_as(as = "DisplayFromStr")]
264 pub sells: u64,
265 #[serde_as(as = "DisplayFromStr")]
266 pub buy_volume: u64,
267 #[serde_as(as = "DisplayFromStr")]
268 pub sell_volume: u64,
269}
270
271#[serde_as]
272#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
273pub struct BalanceUpdate {
274 pub identity: Identity,
275 #[serde_as(as = "HexDisplayFromStr")]
276 pub asset_id: AssetId,
277 #[serde_as(as = "DisplayFromStr")]
278 pub total_locked: u128,
279 #[serde_as(as = "DisplayFromStr")]
280 pub total_unlocked: u128,
281 #[serde_as(as = "DisplayFromStr")]
282 pub trading_account_balance: u128,
283 #[serde_as(as = "BTreeMap<HexDisplayFromStr, _>")]
284 pub order_books: OrderBooksBalances,
285}
286
287#[serde_as]
288#[derive(Serialize, Deserialize, Debug, Clone)]
289pub struct SubscribeBalancesResponse {
290 pub action: String,
291 pub balance: Arc<[BalanceUpdate]>,
292 #[serde_as(as = "Option<DisplayFromStr>")]
293 pub onchain_timestamp: Option<OnChainTimeStamp>,
294 #[serde_as(as = "DisplayFromStr")]
295 pub seen_timestamp: SeenTimeStamp,
296}
297
298#[serde_as]
299#[derive(Serialize, Deserialize, Debug, Clone)]
300pub struct SubscribeNonceResponse {
301 pub action: String,
302 #[serde_as(as = "DisplayFromStr")]
303 pub contract_id: ContractId,
304 #[serde_as(as = "DisplayFromStr")]
305 pub nonce: u64,
306 #[serde_as(as = "Option<DisplayFromStr>")]
307 pub onchain_timestamp: Option<OnChainTimeStamp>,
308 #[serde_as(as = "DisplayFromStr")]
309 pub seen_timestamp: SeenTimeStamp,
310}
311
312#[serde_as]
313#[derive(Serialize, Deserialize, Debug, Clone)]
314pub struct GetFeeForTradeResponse {
315 #[serde_as(as = "DisplayFromStr")]
316 pub maker_fee: u64,
317 #[serde_as(as = "DisplayFromStr")]
318 pub taker_fee: u64,
319}