From 6bfd0c24520c08c34d05f046d9802df5137b3361 Mon Sep 17 00:00:00 2001
From: Xavier59 <xavier@opcodes.fr>
Date: Thu, 7 Jul 2022 04:41:09 -0700
Subject: [PATCH 1/4] add support for funding candles

---
 src/account.rs | 61 +++++++++++++++++++++++++-----------------------
 src/candles.rs | 63 ++++++++++++++++++++++++++++++--------------------
 2 files changed, 70 insertions(+), 54 deletions(-)

diff --git a/src/account.rs b/src/account.rs
index 3f8d8fb..a75ec58 100644
--- a/src/account.rs
+++ b/src/account.rs
@@ -3,33 +3,33 @@ 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>,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct MarginBase { 
+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,14 +46,14 @@ 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: Funding,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -61,7 +61,7 @@ pub struct Funding {
     pub yield_loan: f64,
     pub yield_lend: f64,
     pub duration_loan: f64,
-    pub duration_lend: f64
+    pub duration_lend: f64,
 }
 
 #[derive(Clone)]
@@ -79,26 +79,28 @@ impl Account {
     pub fn get_wallets(&self) -> Result<Vec<Wallet>> {
         let payload: String = format!("{}", "{}");
         let data = self.client.post_signed("wallets".into(), payload)?;
-
+        println!("{}", data.as_str());
         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("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());
 
@@ -107,11 +109,12 @@ impl Account {
         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());
 
@@ -120,5 +123,5 @@ impl Account {
         let info: FundingInfo = from_str(data.as_str())?;
 
         Ok(info)
-    }    
-}
\ No newline at end of file
+    }
+}
diff --git a/src/candles.rs b/src/candles.rs
index f2c7ba6..51f3c6e 100644
--- a/src/candles.rs
+++ b/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,15 +71,16 @@ 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,
@@ -84,13 +88,22 @@ impl Candles {
         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)
     }
-}
\ No newline at end of file
+}

From cddb8df10359774aac7e98180bee7e919cc62e39 Mon Sep 17 00:00:00 2001
From: Xavier59 <xavier@opcodes.fr>
Date: Thu, 7 Jul 2022 06:31:16 -0700
Subject: [PATCH 2/4] fix wallet deserialization

---
 src/account.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/account.rs b/src/account.rs
index a75ec58..92c38e7 100644
--- a/src/account.rs
+++ b/src/account.rs
@@ -9,6 +9,19 @@ pub struct Wallet {
     pub balance: f64,
     pub unsettled_interest: f64,
     pub balance_available: Option<f64>,
+    pub last_change: Option<String>,
+    pub trade_details: Option<TradeDetail>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct TradeDetail {
+    pub reason: String,
+    pub order_id: i64,
+    pub order_id_oppo: i64,
+    pub trade_price: String,
+    pub trade_amount: f64,
+    pub order_cid: i64,
+    pub order_gid: i64,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -79,7 +92,7 @@ impl Account {
     pub fn get_wallets(&self) -> Result<Vec<Wallet>> {
         let payload: String = format!("{}", "{}");
         let data = self.client.post_signed("wallets".into(), payload)?;
-        println!("{}", data.as_str());
+
         let wallets: Vec<Wallet> = from_str(data.as_str())?;
 
         Ok(wallets)

From 348af16d09f97f236be5bdffb1e250f75bdab462 Mon Sep 17 00:00:00 2001
From: Xavier59 <xavier@opcodes.fr>
Date: Fri, 8 Jul 2022 16:18:41 -0700
Subject: [PATCH 3/4] add funding methods

---
 Cargo.toml     |   1 +
 src/account.rs |  12 +++---
 src/api.rs     |  13 +++---
 src/client.rs  |  47 ++++++++++++--------
 src/funding.rs | 114 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/ledger.rs  |   4 +-
 src/lib.rs     |  27 ++++++------
 src/orders.rs  |  36 ++++++++--------
 src/trades.rs  |  33 ++++++++------
 9 files changed, 214 insertions(+), 73 deletions(-)
 create mode 100644 src/funding.rs

diff --git a/Cargo.toml b/Cargo.toml
index 0a59d31..d8774b0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,3 +28,4 @@ reqwest = "0.9"
 url = "2.1"
 log = "0.3"
 tungstenite = "0.9"
+serde-aux = "3.1.0"
diff --git a/src/account.rs b/src/account.rs
index 92c38e7..274835a 100644
--- a/src/account.rs
+++ b/src/account.rs
@@ -66,11 +66,11 @@ pub struct Symbol {
 pub struct FundingInfo {
     key: String,
     symbol: String,
-    pub funding: Funding,
+    pub funding: FundingYield,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct Funding {
+pub struct FundingYield {
     pub yield_loan: f64,
     pub yield_lend: f64,
     pub duration_loan: f64,
@@ -91,7 +91,7 @@ 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())?;
 
@@ -103,7 +103,7 @@ impl Account {
 
         let data = self
             .client
-            .post_signed("info/margin/base".into(), payload)?;
+            .post_signed("r/info/margin/base".into(), payload)?;
 
         let margin: MarginBase = from_str(data.as_str())?;
 
@@ -115,7 +115,7 @@ impl Account {
         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)?;
 
@@ -129,7 +129,7 @@ impl Account {
         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)?;
 
diff --git a/src/api.rs b/src/api.rs
index ad20f9b..22220ec 100644
--- a/src/api.rs
+++ b/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()),
         }
     }
 }
diff --git a/src/client.rs b/src/client.rs
index ad154ee..1ffa2d7 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,26 +1,26 @@
-use errors::*;
 use auth;
+use errors::*;
 use reqwest;
-use reqwest::{StatusCode, Response};
-use reqwest::header::{HeaderMap, HeaderName, HeaderValue, USER_AGENT, CONTENT_TYPE};
-use std::io::Read;
+use reqwest::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE, USER_AGENT};
+use reqwest::{Response, StatusCode};
 use serde::Serialize;
+use std::io::Read;
 
-static API1_HOST : &'static str = "https://api.bitfinex.com/v2/";
-static API_SIGNATURE_PATH : &'static str = "/api/v2/auth/r/";
+static API1_HOST: &'static str = "https://api.bitfinex.com/v2/";
+static API_SIGNATURE_PATH: &'static str = "/api/v2/auth/";
 static NO_PARAMS: &'static [(); 0] = &[];
 
 #[derive(Clone)]
 pub struct Client {
     api_key: String,
-    secret_key: String
+    secret_key: String,
 }
 
 impl Client {
     pub fn new(api_key: Option<String>, secret_key: Option<String>) -> Self {
         Client {
-            api_key : api_key.unwrap_or("".into()),
-            secret_key : secret_key.unwrap_or("".into())
+            api_key: api_key.unwrap_or("".into()),
+            secret_key: secret_key.unwrap_or("".into()),
         }
     }
 
@@ -45,10 +45,11 @@ impl Client {
         payload: String,
         params: &P,
     ) -> Result<String> {
-        let url: String = format!("{}auth/r/{}", API1_HOST, request);
+        let url: String = format!("{}auth/{}", API1_HOST, request);
 
         let client = reqwest::Client::new();
-        let response = client.post(url.as_str())
+        let response = client
+            .post(url.as_str())
             .headers(self.build_headers(request, payload.clone())?)
             .body(payload)
             .query(params)
@@ -59,15 +60,25 @@ impl Client {
 
     fn build_headers(&self, request: String, payload: String) -> Result<HeaderMap> {
         let nonce: String = auth::generate_nonce()?;
-        let signature_path: String = format!("{}{}{}{}", API_SIGNATURE_PATH, request, nonce, payload);
+        let signature_path: String =
+            format!("{}{}{}{}", API_SIGNATURE_PATH, request, nonce, payload);
 
         let signature = auth::sign_payload(self.secret_key.as_bytes(), signature_path.as_bytes())?;
 
         let mut headers = HeaderMap::new();
         headers.insert(USER_AGENT, HeaderValue::from_static("bitfinex-rs"));
-        headers.insert(HeaderName::from_static("bfx-nonce"), HeaderValue::from_str(nonce.as_str())?);
-        headers.insert(HeaderName::from_static("bfx-apikey"), HeaderValue::from_str(self.api_key.as_str())?);
-        headers.insert(HeaderName::from_static("bfx-signature"), HeaderValue::from_str(signature.as_str())?);
+        headers.insert(
+            HeaderName::from_static("bfx-nonce"),
+            HeaderValue::from_str(nonce.as_str())?,
+        );
+        headers.insert(
+            HeaderName::from_static("bfx-apikey"),
+            HeaderValue::from_str(self.api_key.as_str())?,
+        );
+        headers.insert(
+            HeaderName::from_static("bfx-signature"),
+            HeaderValue::from_str(signature.as_str())?,
+        );
         headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
 
         Ok(headers)
@@ -79,8 +90,11 @@ impl Client {
                 let mut body = String::new();
                 response.read_to_string(&mut body)?;
                 return Ok(body);
-            },
+            }
             StatusCode::INTERNAL_SERVER_ERROR => {
+                let mut body = String::new();
+                response.read_to_string(&mut body)?;
+                println!("{}", body);
                 bail!("Internal Server Error");
             }
             StatusCode::SERVICE_UNAVAILABLE => {
@@ -97,5 +111,4 @@ impl Client {
             }
         };
     }
-
 }
diff --git a/src/funding.rs b/src/funding.rs
new file mode 100644
index 0000000..f6355e1
--- /dev/null
+++ b/src/funding.rs
@@ -0,0 +1,114 @@
+use client::*;
+use errors::*;
+use serde_aux::prelude::*;
+use serde_json::from_str;
+
+#[derive(Serialize, Deserialize)]
+pub struct ActiveOffer {
+    pub id: i64,
+    pub symbol: String,
+    pub mts_created: i64,
+    pub mts_updated: i64,
+    pub amount: f64,
+    pub amount_orig: f64,
+    pub order_type: String,
+    _placeholder_1: Option<String>,
+    _placeholder_2: Option<String>,
+    pub flags: Option<i8>,
+    pub status: String,
+    _placeholder_3: Option<String>,
+    _placeholder_4: Option<String>,
+    _placeholder_5: Option<String>,
+    pub rate: f64,
+    pub period: i64,
+    #[serde(deserialize_with = "deserialize_bool_from_anything")]
+    pub notify: bool,
+    pub hidden: i32,
+    _placeholder_6: Option<String>,
+    #[serde(deserialize_with = "deserialize_bool_from_anything")]
+    pub renew: bool,
+    _placeholder_7: Option<String>,
+}
+
+#[derive(Serialize)]
+pub struct FundingOfferParams {
+    #[serde(rename = "type")]
+    pub t: String,
+    pub symbol: String,
+    pub amount: String,
+    pub rate: String,
+    pub period: i32,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct FundingOffer {
+    pub mts: i64,
+    pub notification_type: String,
+    pub message_id: Option<String>,
+    null: Option<String>,
+    pub offer: ActiveOffer,
+    pub code: Option<String>,
+    pub status: String,
+    pub text: String,
+}
+
+#[derive(Serialize)]
+pub struct Currency {
+    pub currency: String,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct CancellAllFundingResponse {
+    pub mts: i64,
+    pub t: String,
+    _placeholder_1: Option<String>,
+    _placeholder_2: Option<String>,
+    _placeholder_3: Option<String>,
+    _placeholder_4: Option<String>,
+    pub status: String,
+    pub text: String,
+}
+
+#[derive(Clone)]
+pub struct Funding {
+    client: Client,
+}
+
+impl Funding {
+    pub fn new(api_key: Option<String>, secret_key: Option<String>) -> Self {
+        Funding {
+            client: Client::new(api_key, secret_key),
+        }
+    }
+
+    pub fn get_active_offers(&self, symbol: String) -> Result<Vec<ActiveOffer>> {
+        let payload: String = format!("{}", "");
+
+        let data = self
+            .client
+            .post_signed(format!("r/funding/offers/{}", symbol).into(), payload)?;
+        let funding_offers: Vec<ActiveOffer> = from_str(data.as_str())?;
+        Ok(funding_offers)
+    }
+
+    pub fn submit_funding_offer(&self, params: FundingOfferParams) -> Result<FundingOffer> {
+        let payload = serde_json::to_string(&params).unwrap();
+        let data = self
+            .client
+            .post_signed("w/funding/offer/submit".to_string(), payload)?;
+        let offer: FundingOffer = from_str(data.as_str())?;
+
+        Ok(offer)
+    }
+
+    pub fn cancel_all_funding_offers(&self, symbol: String) -> Result<CancellAllFundingResponse> {
+        let params = Currency { currency: symbol };
+        let payload = serde_json::to_string(&params).unwrap();
+        let data = self
+            .client
+            .post_signed("w/funding/offer/cancel/all".to_string(), payload)?;
+        let res: CancellAllFundingResponse = from_str(data.as_str())?;
+
+        Ok(res)
+    }
+}
diff --git a/src/ledger.rs b/src/ledger.rs
index 15bb04c..297ec29 100644
--- a/src/ledger.rs
+++ b/src/ledger.rs
@@ -45,8 +45,8 @@ impl Ledger {
         S: Into<String>,
     {
         let payload: String = format!("{}", "{}");
-        let request: String = format!("ledgers/{}/hist", symbol.into());
-        let params = HistoryParams{
+        let request: String = format!("r/ledgers/{}/hist", symbol.into());
+        let params = HistoryParams {
             start: format!("{}", start),
             end: format!("{}", end),
             limit: limit,
diff --git a/src/lib.rs b/src/lib.rs
index 9b7cac5..dbb7e81 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,37 +3,40 @@
     unused_must_use,
     unused_mut,
     unused_imports,
-    unused_import_braces)]
+    unused_import_braces
+)]
 
-#[macro_use] 
+#[macro_use]
 extern crate error_chain;
 
 extern crate hex;
-extern crate ring;
 extern crate reqwest;
+extern crate ring;
 extern crate serde;
+extern crate serde_aux;
 #[macro_use]
 extern crate serde_json;
 extern crate tungstenite;
 extern crate url;
 
-#[macro_use] 
+#[macro_use]
 extern crate serde_derive;
 
+mod account;
+mod auth;
 mod book;
 mod client;
+mod ledger;
+mod orders;
 mod ticker;
 mod trades;
-mod orders;
-mod account;
-mod ledger;
-mod auth;
 
-pub mod candles;
 pub mod api;
-pub mod pairs;
+pub mod candles;
 pub mod currency;
+pub mod errors;
+pub mod events;
+pub mod funding;
+pub mod pairs;
 pub mod precision;
 pub mod websockets;
-pub mod events;
-pub mod errors;
diff --git a/src/orders.rs b/src/orders.rs
index c6001ac..c3b77d0 100644
--- a/src/orders.rs
+++ b/src/orders.rs
@@ -3,9 +3,9 @@ use errors::*;
 use serde_json::from_str;
 
 #[derive(Serialize, Deserialize)]
-pub struct Order { 
-    pub id: i64,   
-    pub group_id: Option<i32>,                   
+pub struct Order {
+    pub id: i64,
+    pub group_id: Option<i32>,
     pub client_id: i64,
     pub symbol: String,
     pub creation_timestamp: i64,
@@ -19,8 +19,8 @@ pub struct Order {
     _placeholder_1: Option<String>,
     #[serde(skip_serializing)]
     _placeholder_2: Option<String>,
-    
-    pub flags: Option<i32>,                   
+
+    pub flags: Option<i32>,
     pub order_status: Option<String>,
 
     #[serde(skip_serializing)]
@@ -32,17 +32,17 @@ pub struct Order {
     pub price_avg: f64,
     pub price_trailing: Option<f64>,
     pub price_aux_limit: Option<f64>,
-    
+
     #[serde(skip_serializing)]
     __placeholder_5: Option<String>,
     #[serde(skip_serializing)]
     _placeholder_6: Option<String>,
     #[serde(skip_serializing)]
-    _placeholder_7: Option<String>,    
-    
+    _placeholder_7: Option<String>,
+
     pub notify: i32,
     pub hidden: i32,
-    pub placed_id: Option<i32>                      
+    pub placed_id: Option<i32>,
 }
 
 #[derive(Clone)]
@@ -60,30 +60,32 @@ impl Orders {
     pub fn active_orders(&self) -> Result<Vec<Order>> {
         let payload: String = format!("{}", "{}");
 
-        self.orders("orders".to_owned(), payload)
+        self.orders("r/orders".to_owned(), payload)
     }
 
     pub fn history<T>(&self, symbol: T) -> Result<Vec<Order>>
-        where T: Into<Option<String>>
-    {    
+    where
+        T: Into<Option<String>>,
+    {
         let value = symbol.into().unwrap_or("".into());
         let payload: String = format!("{}", "{}");
 
         if value.is_empty() {
-            return self.orders("orders/hist".into(), payload);
+            return self.orders("r/orders/hist".into(), payload);
         } else {
-            let request: String = format!("orders/t{}/hist", value);
+            let request: String = format!("r/orders/t{}/hist", value);
             return self.orders(request, payload);
         }
     }
 
     pub fn orders<S>(&self, request: S, payload: S) -> Result<Vec<Order>>
-        where S: Into<String>
-    {    
+    where
+        S: Into<String>,
+    {
         let data = self.client.post_signed(request.into(), payload.into())?;
 
         let orders: Vec<Order> = from_str(data.as_str())?;
 
         Ok(orders)
     }
-}
\ No newline at end of file
+}
diff --git a/src/trades.rs b/src/trades.rs
index 106bd1a..5c7c6e8 100644
--- a/src/trades.rs
+++ b/src/trades.rs
@@ -14,7 +14,7 @@ pub struct Trade {
     pub order_price: f64,
     pub maker: i32,
     pub fee: f64,
-    pub fee_currency: String
+    pub fee_currency: String,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -22,7 +22,7 @@ pub struct TradingPair {
     pub id: i64,
     pub mts: i64,
     pub amount: f64,
-    pub price: f64
+    pub price: f64,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -31,7 +31,7 @@ pub struct FundingCurrency {
     pub amount: f64,
     pub price: f64,
     pub rate: f64,
-    pub period: i64
+    pub period: i64,
 }
 
 #[derive(Clone)]
@@ -47,8 +47,9 @@ impl Trades {
     }
 
     pub fn funding_currency<S>(&self, symbol: S) -> Result<Vec<FundingCurrency>>
-        where S: Into<String>
-    {     
+    where
+        S: Into<String>,
+    {
         let endpoint: String = format!("trades/f{}/hist", symbol.into());
         let data = self.client.get(endpoint, String::new())?;
 
@@ -58,7 +59,8 @@ impl Trades {
     }
 
     pub fn trading_pair<S>(&self, symbol: S) -> Result<Vec<TradingPair>>
-        where S: Into<String>
+    where
+        S: Into<String>,
     {
         let endpoint: String = format!("trades/t{}/hist", symbol.into());
         let data = self.client.get(endpoint, String::new())?;
@@ -69,31 +71,34 @@ impl Trades {
     }
 
     pub fn history<S>(&self, symbol: S) -> Result<Vec<Trade>>
-        where S: Into<String>
+    where
+        S: Into<String>,
     {
         let payload: String = format!("{}", "{}");
 
-        let request: String = format!("trades/t{}/hist", symbol.into());
+        let request: String = format!("r/trades/t{}/hist", symbol.into());
         println!("HISTORY {}", request);
         return self.trades(request, payload);
     }
 
     pub fn generated_by_order<S>(&self, symbol: S, order_id: S) -> Result<Vec<Trade>>
-        where S: Into<String>
+    where
+        S: Into<String>,
     {
         let payload: String = format!("{}", "{}");
 
-        let request: String = format!("order/t{}:{}/trades", symbol.into(), order_id.into());
+        let request: String = format!("r/order/t{}:{}/trades", symbol.into(), order_id.into());
         return self.trades(request, payload);
-    }   
+    }
 
     pub fn trades<S>(&self, request: S, payload: S) -> Result<Vec<Trade>>
-        where S: Into<String>
+    where
+        S: Into<String>,
     {
         let data = self.client.post_signed(request.into(), payload.into())?;
 
         let orders: Vec<Trade> = from_str(data.as_str())?;
 
         Ok(orders)
-    }    
-}
\ No newline at end of file
+    }
+}

From 107a1b493a2e63c509586e07a7fdd4e8cb11f2d7 Mon Sep 17 00:00:00 2001
From: Xavier Bruni <b.xavier@protonmail.com>
Date: Fri, 18 Nov 2022 18:36:47 +0100
Subject: [PATCH 4/4] fix: fix trade detail deser (bitfinex doc is incorrect )

---
 src/account.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/account.rs b/src/account.rs
index 274835a..dcebf01 100644
--- a/src/account.rs
+++ b/src/account.rs
@@ -19,9 +19,9 @@ pub struct TradeDetail {
     pub order_id: i64,
     pub order_id_oppo: i64,
     pub trade_price: String,
-    pub trade_amount: f64,
+    pub trade_amount: String,
     pub order_cid: i64,
-    pub order_gid: i64,
+    pub order_gid: Option<i64>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -92,7 +92,6 @@ impl Account {
     pub fn get_wallets(&self) -> Result<Vec<Wallet>> {
         let payload: String = format!("{}", "{}");
         let data = self.client.post_signed("r/wallets".into(), payload)?;
-
         let wallets: Vec<Wallet> = from_str(data.as_str())?;
 
         Ok(wallets)