_

Author: valeratrades

Cargo.lock

@@ -2,7 +2,7 @@
 ![Minimum Supported Rust Version](https://img.shields.io/badge/nightly-1.85+-ab6000.svg)
 [<img alt="crates.io" src="https://img.shields.io/crates/v/v_exchanges.svg?color=fc8d62&logo=rust" height="20" style=flat-square>](https://crates.io/crates/v_exchanges)
 [<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs&style=flat-square" height="20">](https://docs.rs/v_exchanges)
-![Lines Of Code](https://img.shields.io/badge/LoC-3894-lightblue)
+![Lines Of Code](https://img.shields.io/badge/LoC-3919-lightblue)
 <br>
 [<img alt="ci errors" src="https://img.shields.io/github/actions/workflow/status/valeratrades/v_exchanges/errors.yml?branch=master&style=for-the-badge&style=flat-square&label=errors&labelColor=420d09" height="20">](https://github.com/valeratrades/v_exchanges/actions?query=branch%3Amaster) <!--NB: Won't find it if repo is private-->
 [<img alt="ci warnings" src="https://img.shields.io/github/actions/workflow/status/valeratrades/v_exchanges/warnings.yml?branch=master&style=for-the-badge&style=flat-square&label=warnings&labelColor=d16002" height="20">](https://github.com/valeratrades/v_exchanges/actions?query=branch%3Amaster) <!--NB: Won't find it if repo is private-->

README.md

@@ -27,3 +27,11 @@ async fn main() {
 		eprintln!("BINANCE_TIGER_READ_KEY or BINANCE_TIGER_READ_SECRET is missing, skipping private API methods.");
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn test_main() {
+		super::main();
+	}
+}

examples/binance/market_futures.rs

@@ -14,3 +14,11 @@ async fn main() {
 	let spot_prices = c.prices(None, m).await.unwrap();
 	dbg!(&spot_prices[..5]);
 }
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn test_main() {
+		super::main();
+	}
+}

examples/binance/market_spot.rs

@@ -31,3 +31,11 @@ async fn private(c: &mut Box<dyn Exchange>, m: AbsMarket) {
 	let balances = c.balances(m).await.unwrap();
 	dbg!(&balances);
 }
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn test_main() {
+		super::main();
+	}
+}

examples/bybit/market.rs

@@ -14,82 +14,82 @@ use crate::core::{AbsMarket, AssetBalance, Exchange, ExchangeInfo, Klines, Reque
 
 #[derive(Clone, Debug, Default, Deref, DerefMut)]
 pub struct Bybit {
-    #[deref_mut]
-    #[deref]
-    client: Client,
-    source_market: AbsMarket,
+	#[deref_mut]
+	#[deref]
+	client: Client,
+	source_market: AbsMarket,
 }
 
 //? currently client ends up importing this from crate::binance, but could it be possible to lift the [Client] reexport up, and still have the ability to call all exchange methods right on it?
 #[async_trait::async_trait]
 impl Exchange for Bybit {
-    fn source_market(&self) -> AbsMarket {
-        todo!()
-    }
-    fn exchange_name(&self) -> &'static str {
-        self.source_market().exchange_name()
-    }
+	fn source_market(&self) -> AbsMarket {
+		todo!()
+	}
 
-    fn auth(&mut self, key: String, secret: String) {
-        self.update_default_option(BybitOption::Key(key));
-        self.update_default_option(BybitOption::Secret(secret));
-    }
+	fn exchange_name(&self) -> &'static str {
+		self.source_market().exchange_name()
+	}
 
-    async fn exchange_info(&self, am: AbsMarket) -> Result<ExchangeInfo> {
-        match am {
-            AbsMarket::Bybit(_) => todo!(),
-            _ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
-        }
-    }
+	fn auth(&mut self, key: String, secret: String) {
+		self.update_default_option(BybitOption::Key(key));
+		self.update_default_option(BybitOption::Secret(secret));
+	}
 
-    async fn klines(&self, pair: Pair, tf: Timeframe, range: RequestRange, am: AbsMarket) -> Result<Klines> {
-        match am {
-            AbsMarket::Bybit(m) => match m {
-                Market::Linear => market::klines(&self.client, pair, tf, range).await,
-                _ => unimplemented!(),
-            },
-            _ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
-        }
-    }
+	async fn exchange_info(&self, am: AbsMarket) -> Result<ExchangeInfo> {
+		match am {
+			AbsMarket::Bybit(_) => todo!(),
+			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
+		}
+	}
 
-    async fn price(&self, pair: Pair, am: AbsMarket) -> Result<f64> {
-        match am {
-            AbsMarket::Bybit(m) => match m {
-                Market::Linear => market::price(&self.client, pair).await,
-                _ => unimplemented!(),
-            },
-            _ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
-        }
-    }
+	async fn klines(&self, pair: Pair, tf: Timeframe, range: RequestRange, am: AbsMarket) -> Result<Klines> {
+		match am {
+			AbsMarket::Bybit(m) => match m {
+				Market::Linear => market::klines(&self.client, pair, tf, range).await,
+				_ => unimplemented!(),
+			},
+			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
+		}
+	}
 
-    async fn prices(&self, pairs: Option<Vec<Pair>>, am: AbsMarket) -> Result<Vec<(Pair, f64)>> {
-        match am {
-            AbsMarket::Bybit(_) => todo!(),
-            _ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
-        }
-    }
+	async fn price(&self, pair: Pair, am: AbsMarket) -> Result<f64> {
+		match am {
+			AbsMarket::Bybit(m) => match m {
+				Market::Linear => market::price(&self.client, pair).await,
+				_ => unimplemented!(),
+			},
+			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
+		}
+	}
 
-    async fn asset_balance(&self, asset: Asset, am: AbsMarket) -> Result<AssetBalance> {
-        match am {
-            AbsMarket::Bybit(m) => match m {
-                Market::Linear => account::asset_balance(&self.client, asset).await,
-                _ => unimplemented!(),
-            },
-            _ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
-        }
-    }
+	async fn prices(&self, pairs: Option<Vec<Pair>>, am: AbsMarket) -> Result<Vec<(Pair, f64)>> {
+		match am {
+			AbsMarket::Bybit(_) => todo!(),
+			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
+		}
+	}
 
-    async fn balances(&self, am: AbsMarket) -> Result<Vec<AssetBalance>> {
-        match am {
-            AbsMarket::Bybit(m) => match m {
-                Market::Linear => account::balances(&self.client).await,
-                _ => unimplemented!()
-            },
-            _ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
-        }
-    }
-}
+	async fn asset_balance(&self, asset: Asset, am: AbsMarket) -> Result<AssetBalance> {
+		match am {
+			AbsMarket::Bybit(m) => match m {
+				Market::Linear => account::asset_balance(&self.client, asset).await,
+				_ => unimplemented!(),
+			},
+			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
+		}
+	}
 
+	async fn balances(&self, am: AbsMarket) -> Result<Vec<AssetBalance>> {
+		match am {
+			AbsMarket::Bybit(m) => match m {
+				Market::Linear => account::balances(&self.client).await,
+				_ => unimplemented!(),
+			},
+			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
+		}
+	}
+}
 
 #[derive(Debug, Clone, Default, Copy, Display, FromStr)]
 pub enum Market {

v_exchanges/src/bybit/mod.rs

@@ -39,7 +39,6 @@ pub trait Exchange: std::fmt::Debug {
 	//? could implement many things that are _explicitly_ combinatorial. I can imagine several cases, where knowing that say the specified limit for the klines is wayyy over the max and that you may be opting into a long wait by calling it, could be useful.
 }
 
-
 // AbsMarket {{{
 #[derive(derive_more::Debug, derive_new::new, thiserror::Error)]
 pub struct WrongExchangeError {
@@ -48,7 +47,11 @@ pub struct WrongExchangeError {
 }
 impl std::fmt::Display for WrongExchangeError {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(f, "Wrong exchange provided. Accessible object: {:?}, provided \"abs market path\": {}", self.correct, self.provided)
+		write!(
+			f,
+			"Wrong exchange provided. Accessible object: {:?}, provided \"abs market path\": {}",
+			self.correct, self.provided
+		)
 	}
 }
 
@@ -71,6 +74,7 @@ impl AbsMarket {
 			Self::Bybit(m) => m.client(),
 		}
 	}
+
 	pub fn exchange_name(&self) -> &'static str {
 		match self {
 			Self::Binance(_) => "Binance",
@@ -110,7 +114,7 @@ impl std::str::FromStr for AbsMarket {
 					Err(e) => match sub_market.to_lowercase() == "futures" {
 						true => crate::bybit::Market::Linear,
 						false => bail!(e),
-					}
+					},
 				}
 			})),
 			_ => bail!("Invalid market string: {}", s),