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

//! Crypto-bank exchanges API primitives.

#[macro_use]
extern crate serde_derive;
extern crate async_trait;
extern crate serde;

extern crate cxmr_currency;
extern crate cxmr_exchanges;

use std::sync::Arc;

use async_trait::async_trait;

use cxmr_currency::CurrencyPair;
use cxmr_exchanges::{
    AccountInfo, Exchange, ExchangeInfo, ExchangeOrder, MarketOrder, OrderExecution,
};

/// Exchange account configuration.
#[derive(Deserialize, Serialize, Clone)]
pub struct Account {
    /// Human readable unique name of account.
    pub name: String,
    /// When false automatic trading is disabled.
    pub enabled: bool,
    /// Exchange identifier of account.
    pub exchange: Exchange,
    /// Exchange API credentials.
    pub credentials: Credentials,
}

impl Account {
    pub fn new(key: String, secret: String, exchange: Exchange) -> Self {
        let mut name = key.clone();
        name.truncate(3);
        Account {
            name: name,
            enabled: false,
            exchange: exchange,
            credentials: Credentials::new(key, secret),
        }
    }
}

/// Exchange account credentials.
#[derive(Deserialize, Serialize, Clone, Default)]
pub struct Credentials {
    pub key: String,
    pub secret: String,
}

impl Credentials {
    pub fn new(key: String, secret: String) -> Self {
        Credentials {
            key: key,
            secret: secret,
        }
    }
}

/// Exchange API private client struct.
#[async_trait]
pub trait PrivateClient: Send + Sync {
    type Error;

    fn account(&self) -> &Account;

    /// Returns static exchange identifier.
    fn exchange(&self) -> &'static Exchange;

    /// Requests account information.
    async fn account_info(&self) -> Result<AccountInfo, Self::Error>;

    /// Requests all open orders.
    async fn open_orders(&self, pair: CurrencyPair) -> Result<Vec<MarketOrder>, Self::Error>;

    /// Creates an order.
    async fn create_order(&self, order: &ExchangeOrder) -> Result<OrderExecution, Self::Error>;

    /// Renews key for user event data stream.
    async fn user_data_stream(&self, key: Option<String>) -> Result<String, Self::Error>;
}

/// Exchange API public client struct.
#[async_trait]
pub trait PublicClient: Send + Sync {
    type Error;

    /// Returns static exchange identifier.
    fn exchange(&self) -> &'static Exchange;

    /// Requests exchange information.
    async fn exchange_info(&self) -> Result<ExchangeInfo, Self::Error>;
}

/// Shared public client type alias.
pub type SharedPublicClient<E> = Arc<dyn PublicClient<Error = E>>;

/// Shared private client type alias.
pub type SharedPrivateClient<E> = Arc<dyn PrivateClient<Error = E>>;