Fix bug in get_wallets and add support for funding

Cargo.toml

@@ -28,3 +28,4 @@ reqwest = "0.9"
 url = "2.1"
 log = "0.3"
 tungstenite = "0.9"
+serde-aux = "3.1.0"

src/account.rs

@@ -3,33 +3,46 @@ use errors::*;
 use serde_json::from_str;
 
 #[derive(Serialize, Deserialize)]
-pub struct Wallet { 
-    pub wallet_type: String,   
-    pub currency: String,                   
+pub struct Wallet {
+    pub wallet_type: String,
+    pub currency: String,
     pub balance: f64,
     pub unsettled_interest: f64,
-    pub balance_available: Option<f64>             
+    pub balance_available: Option<f64>,
+    pub last_change: Option<String>,
+    pub trade_details: Option<TradeDetail>,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct MarginBase { 
+pub struct TradeDetail {
+    pub reason: String,
+    pub order_id: i64,
+    pub order_id_oppo: i64,
+    pub trade_price: String,
+    pub trade_amount: String,
+    pub order_cid: i64,
+    pub order_gid: Option<i64>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct MarginBase {
     key: String,
-    pub margin: Base
+    pub margin: Base,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct Base {
     pub user_profit_loss: f64,
-    pub user_swaps: f64,      
+    pub user_swaps: f64,
     pub margin_balance: f64,
-    pub margin_net: f64        
+    pub margin_net: f64,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct MarginSymbol { 
+pub struct MarginSymbol {
     key: String,
-    symbol: String,    
-    pub margin: Symbol
+    symbol: String,
+    pub margin: Symbol,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -46,22 +59,22 @@ pub struct Symbol {
     #[serde(skip_serializing)]
     _placeholder_3: Option<String>,
     #[serde(skip_serializing)]
-    _placeholder_4: Option<String>
+    _placeholder_4: Option<String>,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct FundingInfo { 
+pub struct FundingInfo {
     key: String,
-    symbol: String,    
-    pub funding: Funding
+    symbol: String,
+    pub funding: FundingYield,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct Funding {
+pub struct FundingYield {
     pub yield_loan: f64,
     pub yield_lend: f64,
     pub duration_loan: f64,
-    pub duration_lend: f64
+    pub duration_lend: f64,
 }
 
 #[derive(Clone)]
@@ -78,47 +91,49 @@ impl Account {
 
     pub fn get_wallets(&self) -> Result<Vec<Wallet>> {
         let payload: String = format!("{}", "{}");
-        let data = self.client.post_signed("wallets".into(), payload)?;
-
+        let data = self.client.post_signed("r/wallets".into(), payload)?;
         let wallets: Vec<Wallet> = from_str(data.as_str())?;
 
         Ok(wallets)
     }
 
-    pub fn margin_base(&self) -> Result<MarginBase>
-    { 
+    pub fn margin_base(&self) -> Result<MarginBase> {
         let payload: String = format!("{}", "{}");
 
-        let data = self.client.post_signed("info/margin/base".into(), payload)?;
+        let data = self
+            .client
+            .post_signed("r/info/margin/base".into(), payload)?;
 
         let margin: MarginBase = from_str(data.as_str())?;
 
         Ok(margin)
     }
 
-    pub fn margin_symbol<S>(&self, key: S) -> Result<MarginSymbol> 
-        where S: Into<String>
-    { 
+    pub fn margin_symbol<S>(&self, key: S) -> Result<MarginSymbol>
+    where
+        S: Into<String>,
+    {
         let payload: String = format!("{}", "{}");
-        let request: String = format!("info/margin/t{}", key.into());
+        let request: String = format!("r/info/margin/t{}", key.into());
 
         let data = self.client.post_signed(request, payload)?;
 
         let margin: MarginSymbol = from_str(data.as_str())?;
 
         Ok(margin)
-    }    
+    }
 
-    pub fn funding_info<S>(&self, key: S) -> Result<FundingInfo> 
-        where S: Into<String>
-    { 
+    pub fn funding_info<S>(&self, key: S) -> Result<FundingInfo>
+    where
+        S: Into<String>,
+    {
         let payload: String = format!("{}", "{}");
-        let request: String = format!("info/funding/f{}", key.into());
+        let request: String = format!("r/info/funding/f{}", key.into());
 
         let data = self.client.post_signed(request, payload)?;
 
         let info: FundingInfo = from_str(data.as_str())?;
 
         Ok(info)
-    }    
-}
+    }
+}

src/api.rs

@@ -1,10 +1,11 @@
+use account::*;
 use book::*;
-use ticker::*;
-use trades::*;
 use candles::*;
-use orders::*;
-use account::*;
+use funding::*;
 use ledger::*;
+use orders::*;
+use ticker::*;
+use trades::*;
 
 #[derive(Clone)]
 pub struct Bitfinex {
@@ -14,7 +15,8 @@ pub struct Bitfinex {
     pub candles: Candles,
     pub orders: Orders,
     pub account: Account,
-    pub ledger: Ledger
+    pub ledger: Ledger,
+    pub funding: Funding,
 }
 
 impl Bitfinex {
@@ -27,6 +29,7 @@ impl Bitfinex {
             orders: Orders::new(api_key.clone(), secret_key.clone()),
             account: Account::new(api_key.clone(), secret_key.clone()),
             ledger: Ledger::new(api_key.clone(), secret_key.clone()),
+            funding: Funding::new(api_key.clone(), secret_key.clone()),
         }
     }
 }

src/candles.rs

@@ -15,6 +15,9 @@ pub struct CandleHistoryParams {
 
     /// Sorts the results from old > new
     pub sort: Option<bool>,
+
+    /// Funding period. Mandatory for funding candles
+    pub period: Option<i32>,
 }
 
 impl CandleHistoryParams {
@@ -24,35 +27,35 @@ impl CandleHistoryParams {
             sort: Some(false),
             start: None,
             end: None,
+            period: None,
         }
     }
 
     pub fn to_query(&self) -> String {
-        format!("{}={}&{}={}&{}={}&{}={}",
-            "limit", self.limit
-                         .map(|a| a.to_string())
-                         .unwrap_or("".into()),
-            "start", self.start
-                         .map(|a| a.to_string())
-                         .unwrap_or("".into()),
-            "end", self.end
-                       .map(|a| a.to_string())
-                       .unwrap_or("".into()),
-            "sort", self.sort
-                        .map(|a| if a { "1" } else { "0" })
-                        .unwrap_or("".into()),
+        format!(
+            "{}={}&{}={}&{}={}&{}={}",
+            "limit",
+            self.limit.map(|a| a.to_string()).unwrap_or("".into()),
+            "start",
+            self.start.map(|a| a.to_string()).unwrap_or("".into()),
+            "end",
+            self.end.map(|a| a.to_string()).unwrap_or("".into()),
+            "sort",
+            self.sort
+                .map(|a| if a { "1" } else { "0" })
+                .unwrap_or("".into()),
         )
     }
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct Candle { 
-    pub timestamp: i64,   
-    pub open: f64,                   
+pub struct Candle {
+    pub timestamp: i64,
+    pub open: f64,
     pub close: f64,
     pub high: f64,
     pub low: f64,
-    pub volume: f64                        
+    pub volume: f64,
 }
 
 #[derive(Clone)]
@@ -68,29 +71,39 @@ impl Candles {
     }
 
     pub fn last<S>(&self, symbol: S, timeframe: S) -> Result<Candle>
-        where S: Into<String>
-    {    
-        let endpoint: String = format!("candles/trade:{}:t{}/last", timeframe.into(), symbol.into());
+    where
+        S: Into<String>,
+    {
+        let endpoint: String = format!("candles/trade:{}:{}/last", timeframe.into(), symbol.into());
         let data = self.client.get(endpoint, String::new())?;
 
         let history: Candle = from_str(data.as_str())?;
 
         Ok(history)
-    }    
+    }
 
     pub fn history<S>(
         &self,
         symbol: S,
         timeframe: S,
         params: &CandleHistoryParams,
     ) -> Result<Vec<Candle>>
-        where S: Into<String>
-    {    
-        let endpoint: String = format!("candles/trade:{}:t{}/hist", timeframe.into(), symbol.into());
+    where
+        S: Into<String>,
+    {
+        let endpoint: String = format!(
+            "candles/trade:{}:{}{}/hist",
+            timeframe.into(),
+            symbol.into(),
+            params
+                .period
+                .map(|a| format!(":p{}", a.to_string()))
+                .unwrap_or("".into())
+        );
         let data = self.client.get(endpoint, params.to_query())?;
 
         let history: Vec<Candle> = from_str(data.as_str())?;
 
         Ok(history)
     }
-}
+}