crypto-pair 2.3.20

Parse exchange-specific symbols to unified format
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

mod utils;

use crypto_market_type::MarketType;
use crypto_pair::{get_market_type, normalize_currency, normalize_pair};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;
use utils::http_get;

const EXCHANGE_NAME: &str = "bitget";

// See https://bitgetlimited.github.io/apidoc/en/spot/#get-all-instruments
#[derive(Clone, Serialize, Deserialize)]
#[allow(non_snake_case)]
struct SpotMarket {
    symbol: String,     // symbol Id
    symbolName: String, // symbol name
    baseCoin: String,   // Base coin
    quoteCoin: String,  // Denomination coin
    status: String,     // Status
    #[serde(flatten)]
    extra: HashMap<String, Value>,
}

// See https://bitgetlimited.github.io/apidoc/en/mix/#get-all-symbols
#[derive(Clone, Serialize, Deserialize)]
#[allow(non_snake_case)]
struct SwapMarket {
    symbol: String,    // symbol Id
    baseCoin: String,  // Base coin
    quoteCoin: String, // Denomination coin
    #[serde(flatten)]
    extra: HashMap<String, Value>,
}

// See https://bitgetlimited.github.io/apidoc/en/spot/#get-all-instruments
fn fetch_spot_markets_raw() -> Vec<SpotMarket> {
    #[derive(Serialize, Deserialize)]
    #[allow(non_snake_case)]
    struct Response {
        code: String,
        msg: String,
        data: Vec<SpotMarket>,
        requestTime: Value,
        #[serde(flatten)]
        extra: HashMap<String, Value>,
    }

    let txt = http_get("https://api.bitget.com/api/spot/v1/public/products").unwrap();
    let resp = serde_json::from_str::<Response>(&txt).unwrap();
    if resp.msg != "success" {
        Vec::new()
    } else {
        resp.data
            .into_iter()
            // Ignored ETH_SPBL and BTC_SPBL for now because they're not tradable
            .filter(|x| x.status == "online" && x.symbol.ends_with("USDT_SPBL"))
            .collect::<Vec<SpotMarket>>()
    }
}

// See https://bitgetlimited.github.io/apidoc/en/mix/#get-all-symbols
// product_type: umcbl, LinearSwap; dmcbl, InverseSwap;
fn fetch_swap_markets_raw(product_type: &str) -> Vec<SwapMarket> {
    #[derive(Serialize, Deserialize)]
    #[allow(non_snake_case)]
    struct Response {
        code: String,
        msg: String,
        data: Vec<SwapMarket>,
        requestTime: Value,
        #[serde(flatten)]
        extra: HashMap<String, Value>,
    }

    let txt = http_get(
        format!("https://api.bitget.com/api/mix/v1/market/contracts?productType={product_type}")
            .as_str(),
    )
    .unwrap();
    let resp = serde_json::from_str::<Response>(&txt).unwrap();
    if resp.msg != "success" { Vec::new() } else { resp.data }
}

#[test]
fn verify_spot_symbols() {
    let markets = fetch_spot_markets_raw();
    for market in markets.iter() {
        let pair = normalize_pair(&market.symbol, EXCHANGE_NAME).unwrap();
        let pair_expected = format!(
            "{}/{}",
            normalize_currency(&market.baseCoin, EXCHANGE_NAME),
            normalize_currency(&market.quoteCoin, EXCHANGE_NAME)
        );

        assert_eq!(pair.as_str(), pair_expected);
        assert_eq!(MarketType::Spot, get_market_type(&market.symbol, EXCHANGE_NAME, None));
    }
}

#[test]
fn verify_swap_symbols() {
    let usdt_linear_markets = fetch_swap_markets_raw("umcbl");
    let usdc_linear_markets = fetch_swap_markets_raw("cmcbl");
    let inverse_markets = fetch_swap_markets_raw("dmcbl");
    let markets = usdt_linear_markets
        .into_iter()
        .chain(usdc_linear_markets)
        .chain(inverse_markets)
        .collect::<Vec<SwapMarket>>();
    for market in markets.iter() {
        let pair = normalize_pair(&market.symbol, EXCHANGE_NAME).unwrap();
        let pair_expected = format!(
            "{}/{}",
            normalize_currency(&market.baseCoin, EXCHANGE_NAME),
            normalize_currency(
                if market.symbol.ends_with("PERP_CMCBL") { "USDC" } else { &market.quoteCoin },
                EXCHANGE_NAME
            )
        );
        assert_eq!(pair.as_str(), pair_expected);

        let market_type = get_market_type(&market.symbol, EXCHANGE_NAME, None);
        assert!(
            market_type == MarketType::LinearSwap
                || market_type == MarketType::InverseSwap
                || market_type == MarketType::InverseFuture
        );
    }
}