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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use chrono::{DateTime, Utc};
use kucoin_api::model::websocket::SymbolTicker;
use lazy_static::lazy_static;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

pub type Map = HashMap<String, TickerInfo>;
lazy_static! {
    pub static ref MIRROR: Arc<Mutex<Map>> = Arc::new(Mutex::new(HashMap::new()));
}

pub fn insert(ticker_name: String, ticker_info: TickerInfo) {
    let mut mir = MIRROR.lock().unwrap();
    (*mir).insert(ticker_name, ticker_info);
}

pub fn has(ticker_name: String) -> bool {
    let mut mir = MIRROR.lock().unwrap();
    (*mir).get_mut(&ticker_name).is_some()
}

#[derive(Debug, Clone)]
pub struct TickerInfo {
    pub symbol: SymbolTicker,
    pub last_update: DateTime<Utc>,
}

impl Default for TickerInfo {
    fn default() -> TickerInfo {
        let symbol = SymbolTicker {
            sequence: String::default(),
            best_ask: String::default(),
            size: String::default(),
            best_bid_size: String::default(),
            price: String::default(),
            best_ask_size: String::default(),
            best_bid: String::default(),
        };
        TickerInfo::new(symbol)
    }
}

impl TickerInfo {
    pub fn new(symbol: SymbolTicker) -> Self {
        TickerInfo {
            symbol,
            last_update: chrono::offset::Utc::now(),
        }
    }

    // return price and size
    pub fn get_bid(&self) -> (f64, f64) {
        let float_err = "float deparse error";
        let p = self.symbol.best_bid.parse::<f64>().expect(float_err);
        let v = self.symbol.best_bid_size.parse::<f64>().expect(float_err);
        return (p, v);
    }

    // return price and size
    pub fn get_ask(&self) -> (f64, f64) {
        let float_err = "float deparse error";
        let p = self.symbol.best_ask.parse::<f64>().expect(float_err);
        let v = self.symbol.best_ask_size.parse::<f64>().expect(float_err);
        return (p, v);
    }

    // merged so no copy twice
    pub fn get_askbid(&self) -> ((f64, f64), (f64, f64)) {
        let ask = self.get_ask();
        let bid = self.get_bid();
        return (ask, bid);
    }
}

#[cfg(test)]
mod tests {
    use crate::mirror;
    use core::panic;

    #[test]
    fn test_insert_and_read() {
        let ticker_name = "BTC-USDT".to_string();
        let def_ticker = mirror::TickerInfo::default();
        mirror::insert(ticker_name.clone(), def_ticker.clone());
        if !mirror::has(ticker_name) {
            panic!("not inserted");
        }
    }
}