feat: \Exchange\ generic over Market

valeratrades · valeratrades · commit ff01d8e73451 · 2025-01-11T14:35:12.000Z
diff --git a/examples/binance/market_futures.rs b/examples/binance/market_futures.rs
@@ -1,21 +1,25 @@
 use std::env;
 
-use v_exchanges::{binance::Binance, core::Exchange};
+use v_exchanges::{
+	binance::{self},
+	core::{Exchange, MarketTrait as _},
+};
 
 #[tokio::main]
 async fn main() {
 	color_eyre::install().unwrap();
 	v_utils::utils::init_subscriber(v_utils::utils::LogDestination::xdg("v_exchanges"));
 
-	let mut bn = Binance::default();
+	let m = binance::Market::Futures;
+	let mut bn = m.client();
 
-	let klines = bn.futures_klines(("BTC", "USDT").into(), "1m".into(), 2.into()).await.unwrap();
-	let price = bn.futures_price(("BTC", "USDT").into()).await.unwrap();
+	let klines = bn.klines(("BTC", "USDT").into(), "1m".into(), 2.into(), m).await.unwrap();
+	let price = bn.price(("BTC", "USDT").into(), m).await.unwrap();
 	dbg!(&klines, price);
 
 	if let (Ok(key), Ok(secret)) = (env::var("BINANCE_TIGER_READ_KEY"), env::var("BINANCE_TIGER_READ_SECRET")) {
 		bn.auth(key, secret);
-		let balance = bn.futures_asset_balance("USDT".into()).await.unwrap();
+		let balance = bn.asset_balance("USDT".into(), m).await.unwrap();
 		dbg!(&balance);
 	} else {
 		eprintln!("BINANCE_TIGER_READ_KEY or BINANCE_TIGER_READ_SECRET is missing, skipping private API methods.");
diff --git a/examples/binance/market_spot.rs b/examples/binance/market_spot.rs
@@ -1,14 +1,19 @@
-use v_exchanges::{binance::Binance, core::Exchange};
+use v_exchanges::{
+	binance::{self},
+	core::{Exchange, MarketTrait as _},
+};
 
 #[tokio::main]
 async fn main() {
 	color_eyre::install().unwrap();
 	v_utils::utils::init_subscriber(v_utils::utils::LogDestination::xdg("v_exchanges"));
-	let bn = Binance::default();
 
-	let spot_klines = bn.spot_klines(("BTC", "USDT").into(), "1m".into(), 2.into()).await.unwrap();
+	let m = binance::Market::Spot;
+	let bn = m.client();
+
+	let spot_klines = bn.klines(("BTC", "USDT").into(), "1m".into(), 2.into(), m).await.unwrap();
 	dbg!(&spot_klines);
 
-	let spot_prices = bn.spot_prices(None).await.unwrap();
+	let spot_prices = bn.prices(None, m).await.unwrap();
 	dbg!(&spot_prices[..5]);
 }
diff --git a/examples/bybit/market.rs b/examples/bybit/market.rs
@@ -1,15 +1,15 @@
 use std::env;
 
-use v_exchanges::{bybit::Bybit, core::Exchange, Market};
+use v_exchanges::{bybit::{self, Bybit}, core::{Exchange, MarketTrait as _}};
 
 #[tokio::main]
 async fn main() {
 	color_eyre::install().unwrap();
 	v_utils::utils::init_subscriber(v_utils::utils::LogDestination::xdg("v_exchanges"));
 
-	let m: Market = "Bybit/Linear".into();
+	//let m: Market = "Bybit/Linear".into(); // would be nice to be able to do it like this
+	let m =  bybit::Market::Linear;
 	let mut bb = m.client();	
-	let mut bb = Bybit::default();
 
 	//let ticker: serde_json::Value =
 	//bb.get("/v5/market/tickers", &[("category", "spot"), ("symbol", "BTCUSDT")], [BybitOption::Default])
@@ -24,17 +24,17 @@ async fn main() {
 
 	if let (Ok(key), Ok(secret)) = (env::var("BYBIT_TIGER_READ_KEY"), env::var("BYBIT_TIGER_READ_SECRET")) {
 		bb.auth(key, secret);
-		private(&mut bb).await;
+		private(&mut bb, m).await;
 	} else {
 		eprintln!("BYBIT_TIGER_READ_KEY or BYBIT_TIGER_READ_SECRET is missing, skipping private API methods.");
 	}
 }
 
-async fn private(bb: &mut Bybit) {
+async fn private(bb: &mut Bybit, m: bybit::Market) {
 	//let key_permissions: serde_json::Value = bb.get_no_query("/v5/user/query-api", [BybitOption::HttpAuth(BybitHttpAuth::V3AndAbove)])
 	//	.await
 	//	.unwrap();
 
-	let balances = bb.futures_balances().await.unwrap();
+	let balances = bb.balances(m).await.unwrap();
 	dbg!(&balances);
 }
diff --git a/v_exchanges/src/binance/mod.rs b/v_exchanges/src/binance/mod.rs
@@ -8,50 +8,49 @@ use eyre::Result;
 use v_exchanges_adapters::Client;
 use v_utils::trades::{Asset, Pair, Timeframe};
 
-use crate::core::{AssetBalance, Exchange, Klines, KlinesRequestRange, Market as M};
+use crate::core::{AssetBalance, Exchange, Klines, KlinesRequestRange};
 
 #[derive(Clone, Debug, Default, Deref, DerefMut)]
 pub struct Binance(pub Client);
 
 //? 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?
 impl Exchange for Binance {
+	type M = Market;
+
 	fn auth<S: Into<String>>(&mut self, key: S, secret: S) {
 		self.update_default_option(BinanceOption::Key(key.into()));
 		self.update_default_option(BinanceOption::Secret(secret.into()));
 	}
 
-	async fn klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange, m: M) -> Result<Klines> {
-		match m {
-			M::Binance(m) => market::klines(&self.0, pair, tf, range, m).await,
-			_ => unimplemented!(),
-		}
+	async fn klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange, m: Self::M) -> Result<Klines> {
+		market::klines(&self.0, pair, tf, range, m).await
 	}
 
-	async fn prices(&self, pairs: Option<Vec<Pair>>, m: M) -> Result<Vec<(Pair, f64)>> {
+	async fn prices(&self, pairs: Option<Vec<Pair>>, m: Self::M) -> Result<Vec<(Pair, f64)>> {
 		match m {
-			M::Binance(Market::Spot) => spot::market::prices(&self.0, pairs).await,
+			Market::Spot => spot::market::prices(&self.0, pairs).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn price(&self, pair: Pair, m: M) -> Result<f64> {
+	async fn price(&self, pair: Pair, m: Self::M) -> Result<f64> {
 		match m {
-			M::Binance(Market::Spot) => spot::market::price(&self.0, pair).await,
-			M::Binance(Market::Futures) => futures::market::price(&self.0, pair).await,
+			Market::Spot => spot::market::price(&self.0, pair).await,
+			Market::Futures => futures::market::price(&self.0, pair).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn asset_balance(&self, asset: Asset, m: M) -> Result<AssetBalance> {
+	async fn asset_balance(&self, asset: Asset, m: Self::M) -> Result<AssetBalance> {
 		match m {
-			M::Binance(Market::Futures) => futures::account::asset_balance(self, asset).await,
+			Market::Futures => futures::account::asset_balance(self, asset).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn balances(&self, m: M) -> Result<Vec<AssetBalance>> {
+	async fn balances(&self, m: Self::M) -> Result<Vec<AssetBalance>> {
 		match m {
-			M::Binance(Market::Futures) => futures::account::balances(&self.0).await,
+			Market::Futures => futures::account::balances(&self.0).await,
 			_ => unimplemented!(),
 		}
 	}
@@ -64,8 +63,9 @@ pub enum Market {
 	Spot,
 	Margin,
 }
-impl Market {
-	pub fn client(&self) -> Box<dyn Exchange> {
-		Box::new(Binance::default())
+impl crate::core::MarketTrait for Market {
+	type Client = Binance;
+	fn client(&self) -> Binance {
+		Binance::default()
 	}
 }
diff --git a/v_exchanges/src/bybit/mod.rs b/v_exchanges/src/bybit/mod.rs
@@ -8,46 +8,48 @@ use eyre::Result;
 use v_exchanges_adapters::Client;
 use v_utils::trades::{Asset, Pair, Timeframe};
 
-use crate::core::{Market as M, AssetBalance, Exchange, Klines, KlinesRequestRange};
+use crate::core::{AssetBalance, Exchange, Klines, KlinesRequestRange};
 
 #[derive(Clone, Debug, Default, Deref, DerefMut)]
 pub struct Bybit(pub Client);
 
 //? 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?
 impl Exchange for Bybit {
+	type M = Market;
+
 	fn auth<S: Into<String>>(&mut self, key: S, secret: S) {
 		self.update_default_option(BybitOption::Key(key.into()));
 		self.update_default_option(BybitOption::Secret(secret.into()));
 	}
 
-	async fn klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange, m: M) -> Result<Klines> {
+	async fn klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange, m: Self::M) -> Result<Klines> {
 		match m {
-			M::Bybit(Market::Linear) => market::klines(&self.0, pair, tf, range).await,
+			Market::Linear => market::klines(&self.0, pair, tf, range).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn price(&self, pair: Pair, m: M) -> Result<f64> {
+	async fn price(&self, pair: Pair, m: Self::M) -> Result<f64> {
 		match m {
-			M::Bybit(Market::Linear) => market::price(&self.0, pair).await,
+			Market::Linear => market::price(&self.0, pair).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn prices(&self, pairs: Option<Vec<Pair>>, m: M) -> Result<Vec<(Pair, f64)>> {
+	async fn prices(&self, pairs: Option<Vec<Pair>>, m: Self::M) -> Result<Vec<(Pair, f64)>> {
 		todo!();
 	}
 
-	async fn asset_balance(&self, asset: Asset, m: M) -> Result<AssetBalance> {
+	async fn asset_balance(&self, asset: Asset, m: Self::M) -> Result<AssetBalance> {
 		match m {
-		M::Bybit(Market::Linear) => account::asset_balance(&self.0, asset).await,
+		Market::Linear => account::asset_balance(&self.0, asset).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn balances(&self, m: M) -> Result<Vec<AssetBalance>> {
+	async fn balances(&self, m: Self::M) -> Result<Vec<AssetBalance>> {
 		match m{
-			M::Bybit(Market::Linear) => account::balances(&self.0).await,
+			Market::Linear => account::balances(&self.0).await,
 			_ => unimplemented!(),
 		}
 	}
@@ -61,8 +63,9 @@ pub enum Market {
 	Spot,
 	Inverse,
 }
-impl Market {
-	pub fn client(&self) -> Box<impl Exchange> {
-		Box::new(Bybit::default())
+impl crate::core::MarketTrait for Market {
+	type Client = Bybit;
+	fn client(&self) -> Bybit {
+		Bybit::default()
 	}
 }
diff --git a/v_exchanges/src/core.rs b/v_exchanges/src/core.rs
diff --git a/v_exchanges/src/lib.rs b/v_exchanges/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -8,50 +8,49 @@ use eyre::Result;`
`8`	`8`	`use v_exchanges_adapters::Client;`
`9`	`9`	`use v_utils::trades::{Asset, Pair, Timeframe};`
`10`	`10`
`11`		`-use crate::core::{AssetBalance, Exchange, Klines, KlinesRequestRange, Market as M};`
	`11`	`+use crate::core::{AssetBalance, Exchange, Klines, KlinesRequestRange};`
`12`	`12`
`13`	`13`	`#[derive(Clone, Debug, Default, Deref, DerefMut)]`
`14`	`14`	`pub struct Binance(pub Client);`
`15`	`15`
`16`	`16`	`//? 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?`
`17`	`17`	`impl Exchange for Binance {`
	`18`	`+ type M = Market;`
	`19`	`+`
`18`	`20`	`fn auth<S: Into<String>>(&mut self, key: S, secret: S) {`
`19`	`21`	`self.update_default_option(BinanceOption::Key(key.into()));`
`20`	`22`	`self.update_default_option(BinanceOption::Secret(secret.into()));`
`21`	`23`	`}`
`22`	`24`
`23`		`- async fn klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange, m: M) -> Result<Klines> {`
`24`		`- match m {`
`25`		`- M::Binance(m) => market::klines(&self.0, pair, tf, range, m).await,`
`26`		`- _ => unimplemented!(),`
`27`		`- }`
	`25`	`+ async fn klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange, m: Self::M) -> Result<Klines> {`
	`26`	`+ market::klines(&self.0, pair, tf, range, m).await`
`28`	`27`	`}`
`29`	`28`
`30`		`- async fn prices(&self, pairs: Option<Vec<Pair>>, m: M) -> Result<Vec<(Pair, f64)>> {`
	`29`	`+ async fn prices(&self, pairs: Option<Vec<Pair>>, m: Self::M) -> Result<Vec<(Pair, f64)>> {`
`31`	`30`	`match m {`
`32`		`- M::Binance(Market::Spot) => spot::market::prices(&self.0, pairs).await,`
	`31`	`+ Market::Spot => spot::market::prices(&self.0, pairs).await,`
`33`	`32`	`_ => unimplemented!(),`
`34`	`33`	`}`
`35`	`34`	`}`
`36`	`35`
`37`		`- async fn price(&self, pair: Pair, m: M) -> Result<f64> {`
	`36`	`+ async fn price(&self, pair: Pair, m: Self::M) -> Result<f64> {`
`38`	`37`	`match m {`
`39`		`- M::Binance(Market::Spot) => spot::market::price(&self.0, pair).await,`
`40`		`- M::Binance(Market::Futures) => futures::market::price(&self.0, pair).await,`
	`38`	`+ Market::Spot => spot::market::price(&self.0, pair).await,`
	`39`	`+ Market::Futures => futures::market::price(&self.0, pair).await,`
`41`	`40`	`_ => unimplemented!(),`
`42`	`41`	`}`
`43`	`42`	`}`
`44`	`43`
`45`		`- async fn asset_balance(&self, asset: Asset, m: M) -> Result<AssetBalance> {`
	`44`	`+ async fn asset_balance(&self, asset: Asset, m: Self::M) -> Result<AssetBalance> {`
`46`	`45`	`match m {`
`47`		`- M::Binance(Market::Futures) => futures::account::asset_balance(self, asset).await,`
	`46`	`+ Market::Futures => futures::account::asset_balance(self, asset).await,`
`48`	`47`	`_ => unimplemented!(),`
`49`	`48`	`}`
`50`	`49`	`}`
`51`	`50`
`52`		`- async fn balances(&self, m: M) -> Result<Vec<AssetBalance>> {`
	`51`	`+ async fn balances(&self, m: Self::M) -> Result<Vec<AssetBalance>> {`
`53`	`52`	`match m {`
`54`		`- M::Binance(Market::Futures) => futures::account::balances(&self.0).await,`
	`53`	`+ Market::Futures => futures::account::balances(&self.0).await,`
`55`	`54`	`_ => unimplemented!(),`
`56`	`55`	`}`
`57`	`56`	`}`
`@@ -64,8 +63,9 @@ pub enum Market {`
`64`	`63`	`Spot,`
`65`	`64`	`Margin,`
`66`	`65`	`}`
`67`		`-impl Market {`
`68`		`- pub fn client(&self) -> Box<dyn Exchange> {`
`69`		`- Box::new(Binance::default())`
	`66`	`+impl crate::core::MarketTrait for Market {`
	`67`	`+ type Client = Binance;`
	`68`	`+ fn client(&self) -> Binance {`
	`69`	`+ Binance::default()`
`70`	`70`	`}`
`71`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,46 +8,48 @@ use eyre::Result;`
`8`	`8`	`use v_exchanges_adapters::Client;`
`9`	`9`	`use v_utils::trades::{Asset, Pair, Timeframe};`
`10`	`10`
`11`		`-use crate::core::{Market as M, AssetBalance, Exchange, Klines, KlinesRequestRange};`
	`11`	`+use crate::core::{AssetBalance, Exchange, Klines, KlinesRequestRange};`
`12`	`12`
`13`	`13`	`#[derive(Clone, Debug, Default, Deref, DerefMut)]`
`14`	`14`	`pub struct Bybit(pub Client);`
`15`	`15`
`16`	`16`	`//? 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?`
`17`	`17`	`impl Exchange for Bybit {`
	`18`	`+ type M = Market;`
	`19`	`+`
`18`	`20`	`fn auth<S: Into<String>>(&mut self, key: S, secret: S) {`
`19`	`21`	`self.update_default_option(BybitOption::Key(key.into()));`
`20`	`22`	`self.update_default_option(BybitOption::Secret(secret.into()));`
`21`	`23`	`}`
`22`	`24`
`23`		`- async fn klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange, m: M) -> Result<Klines> {`
	`25`	`+ async fn klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange, m: Self::M) -> Result<Klines> {`
`24`	`26`	`match m {`
`25`		`- M::Bybit(Market::Linear) => market::klines(&self.0, pair, tf, range).await,`
	`27`	`+ Market::Linear => market::klines(&self.0, pair, tf, range).await,`
`26`	`28`	`_ => unimplemented!(),`
`27`	`29`	`}`
`28`	`30`	`}`
`29`	`31`
`30`		`- async fn price(&self, pair: Pair, m: M) -> Result<f64> {`
	`32`	`+ async fn price(&self, pair: Pair, m: Self::M) -> Result<f64> {`
`31`	`33`	`match m {`
`32`		`- M::Bybit(Market::Linear) => market::price(&self.0, pair).await,`
	`34`	`+ Market::Linear => market::price(&self.0, pair).await,`
`33`	`35`	`_ => unimplemented!(),`
`34`	`36`	`}`
`35`	`37`	`}`
`36`	`38`
`37`		`- async fn prices(&self, pairs: Option<Vec<Pair>>, m: M) -> Result<Vec<(Pair, f64)>> {`
	`39`	`+ async fn prices(&self, pairs: Option<Vec<Pair>>, m: Self::M) -> Result<Vec<(Pair, f64)>> {`
`38`	`40`	`todo!();`
`39`	`41`	`}`
`40`	`42`
`41`		`- async fn asset_balance(&self, asset: Asset, m: M) -> Result<AssetBalance> {`
	`43`	`+ async fn asset_balance(&self, asset: Asset, m: Self::M) -> Result<AssetBalance> {`
`42`	`44`	`match m {`
`43`		`- M::Bybit(Market::Linear) => account::asset_balance(&self.0, asset).await,`
	`45`	`+ Market::Linear => account::asset_balance(&self.0, asset).await,`
`44`	`46`	`_ => unimplemented!(),`
`45`	`47`	`}`
`46`	`48`	`}`
`47`	`49`
`48`		`- async fn balances(&self, m: M) -> Result<Vec<AssetBalance>> {`
	`50`	`+ async fn balances(&self, m: Self::M) -> Result<Vec<AssetBalance>> {`
`49`	`51`	`match m{`
`50`		`- M::Bybit(Market::Linear) => account::balances(&self.0).await,`
	`52`	`+ Market::Linear => account::balances(&self.0).await,`
`51`	`53`	`_ => unimplemented!(),`
`52`	`54`	`}`
`53`	`55`	`}`
`@@ -61,8 +63,9 @@ pub enum Market {`
`61`	`63`	`Spot,`
`62`	`64`	`Inverse,`
`63`	`65`	`}`
`64`		`-impl Market {`
`65`		`- pub fn client(&self) -> Box<impl Exchange> {`
`66`		`- Box::new(Bybit::default())`
	`66`	`+impl crate::core::MarketTrait for Market {`
	`67`	`+ type Client = Bybit;`
	`68`	`+ fn client(&self) -> Bybit {`
	`69`	`+ Bybit::default()`
`67`	`70`	`}`
`68`	`71`	`}`