o2-api-types 0.1.23

Shared domain and API types for the Fuel O2 exchange
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

use crate::{
    OrderId,
    domain::{
        book::{
            Price,
            Quantity,
        },
        event::*,
        trade::TradeId,
    },
    fuel_types::{
        BlockHeight,
        Bytes32,
        ContractId,
        TxId,
        TxPointer,
    },
    parse::HexDisplayFromStr,
    primitives::{
        OrderType,
        Side,
    },
};
use serde::Serialize;
use serde_with::{
    DisplayFromStr,
    serde_as,
};

#[derive(Debug, serde::Serialize, serde::Deserialize)]
pub struct EventPrimaryKey {
    pub tx_pointer: TxPointer,
    pub receipt_index: u16,
}

#[serde_as]
#[derive(Debug, serde::Serialize)]
pub struct BlockChainEventResponse<Event> {
    pub primary_key: EventPrimaryKey,
    #[serde_as(as = "HexDisplayFromStr")]
    pub contract_id: ContractId,
    pub event: Event,
}

#[derive(Debug, serde::Serialize)]
pub struct OrderCreatedEventResponse {
    pub order_id: OrderId,
    pub trader_id: Identity,
    pub order_side: Side,
    pub order_type: OrderType,
    pub quantity: Quantity,
    pub price: Price,
}

#[derive(Debug, serde::Serialize)]
pub struct OrderMatchedEventResponse {
    pub trade_id: TradeId,
    pub quantity: Quantity,
    pub price: Price,
}

#[derive(Debug, serde::Serialize)]
pub struct OrderCancelledEventResponse {
    pub order_id: Bytes32,
    pub reason: CancellationReason,
}

#[derive(Debug, serde::Serialize)]
pub struct EndOfMarketOrderEventResponse {
    pub order_id: Bytes32,
}

#[derive(Debug, serde::Serialize, strum_macros::AsRefStr)]
#[strum(serialize_all = "snake_case")]
pub enum EventV1Response {
    BalanceIncrease(BlockChainEventResponse<BalanceIncrease>),
    BalanceDecrease(BlockChainEventResponse<BalanceDecrease>),
    OrderCreated(BlockChainEventResponse<OrderCreatedEventResponse>),
    OrderCanceled(BlockChainEventResponse<OrderCancelledEventResponse>),
    EndOfMarketOrder(BlockChainEventResponse<EndOfMarketOrderEventResponse>),
    TradePerformed(BlockChainEventResponse<OrderMatchedEventResponse>),
    Withdrawal(BlockChainEventResponse<WithdrawSettledTradeEvent>),
    Configuration(BlockChainEventResponse<OrderBookConfigEvent>),
    ConfigurationSymbols(BlockChainEventResponse<OrderBookSymbolsEvent>),
    ConfigurationWhitelist(BlockChainEventResponse<OrderBookWhitelistEvent>),
    ConfigurationBlacklist(BlockChainEventResponse<OrderBookBlacklistEvent>),
    NonceChange(BlockChainEventResponse<NonceChangeEvent>),
    TradeAccountRegistration(BlockChainEventResponse<TradeAccountRegistered>),
    TradeAccountReferer(BlockChainEventResponse<TradeAccountReferer>),
    OrderBookRegistration(BlockChainEventResponse<OrderBookRegistered>),
    PauseEvent(BlockChainEventResponse<PauseEvent>),
    UnpauseEvent(BlockChainEventResponse<UnpauseEvent>),
    FeesClaimedEvent(BlockChainEventResponse<FeesClaimedEvent>),
    SessionCreated(BlockChainEventResponse<SessionCreated>),
    SessionRevoked(BlockChainEventResponse<SessionRevoked>),
}

#[derive(serde::Serialize, Debug)]
pub enum EventResponse {
    EventV1(EventV1Response),
}

#[serde_as]
#[derive(Serialize, Debug)]
pub struct TransactionEventsResponse {
    #[serde_as(as = "HexDisplayFromStr")]
    pub tx_id: TxId,
    pub events: Vec<EventResponse>,
}

#[serde_as]
#[derive(Serialize, Debug)]
pub struct HeaderResponse {
    pub block_height: BlockHeight,
    #[serde_as(as = "DisplayFromStr")]
    pub timestamp: u128,
}

#[derive(Serialize, Debug)]
pub struct GetEventsResponse {
    pub header: HeaderResponse,
    pub events: Vec<TransactionEventsResponse>,
}