kucoin_arbitrage 0.0.6

Event-Driven Kucoin Arbitrage Framework in Async Rust
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

/*
    Translates from kucoin_api crates model to out internal model
*/

use crate::model as internal_model;
use crate::translator::translator;
use kucoin_api::model as kucoin_api_model;
use ordered_float::OrderedFloat;

impl translator::OrderBookTranslator for kucoin_api_model::market::OrderBook {
    fn to_internal(&self) -> internal_model::orderbook::Orderbook {
        let parse_err_msg = "Failed to parse input";
        let sequence = self.sequence.parse::<u64>().unwrap();
        let mut ask = internal_model::orderbook::PVMap::new();
        let mut bid = internal_model::orderbook::PVMap::new();

        for ask_pv in self.asks.clone() {
            let price: OrderedFloat<f64> = ask_pv[0].parse().expect(parse_err_msg);
            let volume: OrderedFloat<f64> = ask_pv[1].parse().expect(parse_err_msg);
            ask.insert(price, volume);
        }
        for bid_pv in self.bids.clone() {
            let price: OrderedFloat<f64> = bid_pv[0].parse().expect(parse_err_msg);
            let volume: OrderedFloat<f64> = bid_pv[1].parse().expect(parse_err_msg);
            bid.insert(price, volume);
        }
        internal_model::orderbook::Orderbook { ask, bid, sequence }
    }
}

impl translator::OrderBookChangeTranslator for kucoin_api_model::websocket::Level2 {
    fn to_internal(&self, last_serial: u64) -> (String, internal_model::orderbook::Orderbook) {
        // return Orderbook::new();
        let mut ask = internal_model::orderbook::PVMap::new();
        let mut bid = internal_model::orderbook::PVMap::new();
        let parse_err_msg = "Failed to parse input";

        for ask_change in self.changes.asks.clone() {
            // ignore if sequence <=serial
            if ask_change[2].parse::<u64>().unwrap() > last_serial {
                let price: OrderedFloat<f64> = ask_change[0].parse().expect(parse_err_msg);
                let volume: OrderedFloat<f64> = ask_change[1].parse().expect(parse_err_msg);
                ask.insert(price, volume);
            }
        }
        for bid_change in self.changes.bids.clone() {
            // ignore if sequence <=serial
            if bid_change[2].parse::<u64>().unwrap() > last_serial {
                let price: OrderedFloat<f64> = bid_change[0].parse().expect(parse_err_msg);
                let volume: OrderedFloat<f64> = bid_change[1].parse().expect(parse_err_msg);
                bid.insert(price, volume);
            }
        }
        let sequence = self.sequence_end.clone() as u64;
        (
            self.symbol.clone(),
            internal_model::orderbook::Orderbook { ask, bid, sequence },
        )
    }
}

impl translator::SymbolInfoTranslator for kucoin_api_model::market::SymbolList {
    fn to_internal(&self) -> internal_model::symbol::SymbolInfo {
        internal_model::symbol::SymbolInfo {
            symbol: self.symbol.clone(),
            base: self.base_currency.clone(),
            quote: self.quote_currency.clone(),
            base_increment: self.base_increment.parse().unwrap(),
            base_min: self.base_min_size.parse().unwrap(),
        }
    }
}