bybit-rust-api 0.3.0

Complete Rust SDK for Bybit API V5 with all endpoints, comprehensive type safety and full test coverage
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

use serde::Deserialize;
use std::collections::HashMap;
use std::fs::File;
use std::io::{BufReader, Read};

#[derive(Debug, Clone, Deserialize)]
pub struct ApiKeyPair {
    profile_name: String,
    key: String,
    secret: String,
}

#[derive(Debug, Deserialize)]
pub struct ApiKeyPairs {
    #[serde(rename = "profiles")]
    pairs: HashMap<String, ApiKeyPair>,
}

impl ApiKeyPair {
    pub fn new(profile_name: String, key: String, secret: String) -> ApiKeyPair {
        ApiKeyPair {
            profile_name: profile_name.to_string(),
            key: key.to_string(),
            secret: secret.to_string(),
        }
    }

    pub fn profile_name(&self) -> &str {
        self.profile_name.as_str()
    }

    pub fn key(&self) -> &str {
        self.key.as_str()
    }

    pub fn secret(&self) -> &str {
        self.secret.as_str()
    }
}

impl ApiKeyPairs {
    pub fn new() -> ApiKeyPairs {
        ApiKeyPairs {
            pairs: HashMap::new(),
        }
    }

    pub fn add(&mut self, profile_name: String, key: String, secret: String) {
        self.pairs.insert(
            profile_name.to_string(),
            ApiKeyPair::new(profile_name, key, secret),
        );
    }

    pub fn get(&self, profile_name: &str) -> Option<&ApiKeyPair> {
        self.pairs.get(profile_name)
    }

    /*
    [
        {
            "profile_name": "profile1",
            "key": "key1",
            "secret": "secret1"
        },
        {
            "profile_name": "profile2",
            "key": "key2",
            "secret": "secret2"
        }
    ]
     */
    pub fn load_from_json_file(file_path: &str) -> Result<ApiKeyPairs, Box<dyn std::error::Error>> {
        let mut api_key_pairs = ApiKeyPairs::new();
        let pairs: Vec<ApiKeyPair> =
            serde_json::from_reader(BufReader::new(File::open(file_path)?))?;
        for pair in pairs {
            api_key_pairs.add(pair.profile_name, pair.key, pair.secret);
        }
        Ok(api_key_pairs)
    }

    /*
    profiles:
        profile1:
            key: "key1"
            secret: "secret1"
        profile2:
            key: "key2"
            secret: "secret2"
    */

    pub fn load_from_yaml_file(file_path: &str) -> Result<ApiKeyPairs, Box<dyn std::error::Error>> {
        let mut file = File::open(file_path)?;
        let mut contents = String::new();
        file.read_to_string(&mut contents)?;
        let pairs: ApiKeyPairs = serde_yaml::from_str(&contents)?;

        Ok(pairs)
    }
}