crypto_trading 0.2.2

Easy Binance API Wrapping Crate
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

use std::env;
use anyhow::Ok;

use crate::port::binance_port::TradePort;
use crate::model::binance_model::{BaseUrl, BinanceRequest, TradeEndpoint};

use super::adapter_utils;

pub struct BinanceTrade {
    secret_key: String,
    api_key: String,
}

impl BinanceTrade {
    pub fn new() -> Self {
        let api_key = env::var("BINANCE_API_KEY").expect("fail to get api_key");
        let secret_key = env::var("BINANCE_SECRET_KEY").expect("fail to get secret_key");

        BinanceTrade {
            secret_key, 
            api_key, 
        }
    }
}

impl TradePort for BinanceTrade {
    async fn order_position(&self) -> anyhow::Result<()> {
        Ok(())
    }
    
    async fn change_leverage(&self, symbol: &str, leverage: i32) -> anyhow::Result<String> {
        let binance_request = BinanceRequest::new(BaseUrl::future, TradeEndpoint::Leverage { symbol: symbol.to_string(), leverage });
        
        let text = adapter_utils::request_with_signature(
            "post", 
            &self.secret_key, 
            &self.api_key, 
            binance_request
            )
            .await?;

        Ok(text)
    }
    
    async fn all_open_orders(&self, symbol: &str) -> anyhow::Result<String> {
        let binance_request = BinanceRequest::new(BaseUrl::future, TradeEndpoint::AllOpenOrder { symbol: symbol.to_string() });

        let text = adapter_utils::request_with_signature(
            "Delete", 
            &self.secret_key, 
            &self.api_key, 
            binance_request
        )
        .await?;

        Ok(text)
    }
    
    async fn new_order(
           &self,
           symbol: Option<String>,
           side: Option<String>,   // buy or sell
           r#type: Option<String>, // order type ... additional parameter need...
           time_in_force: Option<String>,
           quantity: Option<String>,
           price: Option<String>,
           stop_price: Option<f64>,
           callback_rate: Option<f64>,
       ) -> anyhow::Result<String> {
        let binance_request = BinanceRequest::new(BaseUrl::future, TradeEndpoint::NewOrder { 
            symbol: symbol.unwrap_or_default(), 
            side: side.unwrap_or_default(), 
            r#type: r#type.unwrap_or_default(), 
            time_in_force: time_in_force.unwrap_or_default(), 
            quantity: quantity.unwrap_or_default(), 
            price: price.unwrap_or_default(), 
            stop_price: stop_price.unwrap_or_default(), 
            callback_rate: callback_rate.unwrap_or_default(), 
        });

        let res = adapter_utils::request_with_signature(
            "Post", 
            &self.secret_key, 
            &self.api_key, 
            binance_request
        )
        .await?;

        Ok(res)
    }
}