something something working now

Author: valeratrades

README.md

@@ -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-4850-lightblue)
+![Lines Of Code](https://img.shields.io/badge/LoC-4848-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-->

examples/binance/market_futures.rs

@@ -23,9 +23,9 @@ async fn main() {
 	if let (Ok(key), Ok(secret)) = (env::var("BINANCE_TIGER_READ_KEY"), env::var("BINANCE_TIGER_READ_SECRET")) {
 		c.auth(key, secret.into());
 		c.set_recv_window(10000);
-		let balance_usdt = c.asset_balance("USDT".into(), m).await.unwrap();
+		let balance_usdt = c.asset_balance("USDT".into(), None, m).await.unwrap();
 		dbg!(&balance_usdt);
-		let balances = c.balances(m).await.unwrap();
+		let balances = c.balances(None, m).await.unwrap();
 		dbg!(&balances);
 	} else {
 		eprintln!("BINANCE_TIGER_READ_KEY or BINANCE_TIGER_READ_SECRET is missing, skipping private API methods.");

examples/bybit/market.rs

@@ -27,10 +27,10 @@ async fn private(c: &dyn Exchange, m: AbsMarket) {
 	//	.await
 	//	.unwrap();
 
-	let balances = c.balances(m).await.unwrap();
+	let balances = c.balances(None, m).await.unwrap();
 	dbg!(&balances);
 
-	let balance_usdc = c.asset_balance("USDC".into(), c.source_market()).await.unwrap();
+	let balance_usdc = c.asset_balance("USDC".into(), Some(5000), c.source_market()).await.unwrap();
 	dbg!(&balance_usdc);
 }
 

examples/mexc.rs

@@ -13,7 +13,7 @@ async fn main() {
 	let price = c.price(("BTC", "USDT").into(), m).await.unwrap();
 	dbg!(&price);
 
-	let balances = c.balances(m).await.unwrap();
+	let balances = c.balances(None, m).await.unwrap();
 	dbg!(&balances);
 }
 

v_exchanges/src/binance/futures/account.rs

@@ -13,15 +13,13 @@ use crate::core::{AssetBalance, Balances};
 
 // balance {{{
 //DUP: difficult to escape duplicating half the [balances] method due to a) not requiring usd value b) binance not having individual asset balance endpoint
-pub async fn asset_balance(client: &v_exchanges_adapters::Client, asset: Asset) -> Result<AssetBalance> {
+pub async fn asset_balance(client: &v_exchanges_adapters::Client, asset: Asset, recv_window: Option<u16>) -> Result<AssetBalance> {
 	assert!(client.is_authenticated::<BinanceOption>());
-	let r: Vec<AssetBalanceResponse> = client
-		.get_no_query("/fapi/v3/balance", [
-			BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM),
-			BinanceOption::HttpAuth(BinanceAuth::Sign),
-		])
-		.await
-		.unwrap();
+	let mut options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM), BinanceOption::HttpAuth(BinanceAuth::Sign)];
+	if let Some(rw) = recv_window {
+		options.push(BinanceOption::RecvWindow(rw));
+	}
+	let r: Vec<AssetBalanceResponse> = client.get_no_query("/fapi/v3/balance", options).await.unwrap();
 	let vec_balance: Vec<AssetBalance> = r
 		.into_iter()
 		.map(|r| AssetBalance {
@@ -34,15 +32,13 @@ pub async fn asset_balance(client: &v_exchanges_adapters::Client, asset: Asset)
 	Ok(balance)
 }
 
-pub async fn balances(client: &v_exchanges_adapters::Client, prices: &BTreeMap<Pair, f64>) -> Result<Balances> {
+pub async fn balances(client: &v_exchanges_adapters::Client, recv_window: Option<u16>, prices: &BTreeMap<Pair, f64>) -> Result<Balances> {
 	assert!(client.is_authenticated::<BinanceOption>());
-	let rs: Vec<AssetBalanceResponse> = client
-		.get_no_query("/fapi/v3/balance", [
-			BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM),
-			BinanceOption::HttpAuth(BinanceAuth::Sign),
-		])
-		.await
-		.unwrap();
+	let mut options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM), BinanceOption::HttpAuth(BinanceAuth::Sign)];
+	if let Some(rw) = recv_window {
+		options.push(BinanceOption::RecvWindow(rw));
+	}
+	let rs: Vec<AssetBalanceResponse> = client.get_no_query("/fapi/v3/balance", options).await.unwrap();
 
 	fn usd_value(underlying: f64, asset: Asset, prices: &BTreeMap<Pair, f64>) -> Result<Usd> {
 		if underlying == 0. {

v_exchanges/src/binance/mod.rs

@@ -83,22 +83,22 @@ impl Exchange for Binance {
 		}
 	}
 
-	async fn asset_balance(&self, asset: Asset, am: AbsMarket) -> Result<AssetBalance> {
+	async fn asset_balance(&self, asset: Asset, recv_window: Option<u16>, am: AbsMarket) -> Result<AssetBalance> {
 		match am {
 			AbsMarket::Binance(m) => match m {
-				Market::Futures => futures::account::asset_balance(self, asset).await,
+				Market::Futures => futures::account::asset_balance(self, asset, recv_window).await,
 				_ => unimplemented!(),
 			},
 			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
 		}
 	}
 
-	async fn balances(&self, am: AbsMarket) -> Result<Balances> {
+	async fn balances(&self, recv_window: Option<u16>, am: AbsMarket) -> Result<Balances> {
 		match am {
 			AbsMarket::Binance(m) => match m {
 				Market::Futures => {
 					let prices = self.prices(None, am).await?;
-					futures::account::balances(&self.client, &prices).await
+					futures::account::balances(&self.client, recv_window, &prices).await
 				}
 				_ => unimplemented!(),
 			},

v_exchanges/src/bybit/account.rs

@@ -8,20 +8,22 @@ use v_utils::{macros::ScreamIt, trades::Asset};
 
 use crate::core::{AssetBalance, Balances};
 
-pub async fn asset_balance(client: &v_exchanges_adapters::Client, asset: Asset) -> Result<AssetBalance> {
+pub async fn asset_balance(client: &v_exchanges_adapters::Client, asset: Asset, recv_window: Option<u16>) -> Result<AssetBalance> {
 	assert!(client.is_authenticated::<BybitOption>());
-	let balances: Balances = balances(client).await?;
+	let balances: Balances = balances(client, recv_window).await?;
 	let balance: &AssetBalance = balances.iter().find(|b| b.asset == asset).ok_or_else(|| eyre!("No balance found for asset: {:?}", asset))?;
 	Ok(*balance)
 }
 
 /// Should be calling https://bybit-exchange.github.io/docs/v5/asset/balance/all-balance, but with how I'm registered on bybit, my key doesn't have permissions for that (they require it to be able to `transfer` for some reason)
-pub async fn balances(client: &Client) -> Result<Balances> {
+pub async fn balances(client: &Client, recv_window: Option<u16>) -> Result<Balances> {
 	assert!(client.is_authenticated::<BybitOption>());
 
-	let value: serde_json::Value = client
-		.get("/v5/account/wallet-balance", &[("accountType", "UNIFIED")], [BybitOption::HttpAuth(BybitHttpAuth::V3AndAbove)])
-		.await?;
+	let mut options = vec![BybitOption::HttpAuth(BybitHttpAuth::V3AndAbove)];
+	if let Some(rw) = recv_window {
+		options.push(BybitOption::RecvWindow(rw));
+	}
+	let value: serde_json::Value = client.get("/v5/account/wallet-balance", &[("accountType", "UNIFIED")], options).await?;
 
 	let account_response: AccountResponse = serde_json::from_value(value)?;
 	assert_eq!(account_response.result.list.len(), 1);

v_exchanges/src/bybit/mod.rs

@@ -84,20 +84,20 @@ impl Exchange for Bybit {
 		}
 	}
 
-	async fn asset_balance(&self, asset: Asset, am: AbsMarket) -> Result<AssetBalance> {
+	async fn asset_balance(&self, asset: Asset, recv_window: Option<u16>, am: AbsMarket) -> Result<AssetBalance> {
 		match am {
 			AbsMarket::Bybit(m) => match m {
-				Market::Linear => account::asset_balance(&self.client, asset).await,
+				Market::Linear => account::asset_balance(&self.client, asset, recv_window).await,
 				_ => unimplemented!(),
 			},
 			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),
 		}
 	}
 
-	async fn balances(&self, am: AbsMarket) -> Result<Balances> {
+	async fn balances(&self, recv_window: Option<u16>, am: AbsMarket) -> Result<Balances> {
 		match am {
 			AbsMarket::Bybit(m) => match m {
-				Market::Linear => account::balances(&self.client).await,
+				Market::Linear => account::balances(&self.client, recv_window).await,
 				_ => unimplemented!(),
 			},
 			_ => Err(WrongExchangeError::new(self.exchange_name(), am).into()),

v_exchanges/src/core.rs

@@ -11,6 +11,9 @@ use v_utils::{
 	utils::filter_nulls,
 };
 
+/// Main trait for all standardized exchange interactions
+/// # Other
+/// - each private method provides recv_window
 #[async_trait::async_trait]
 pub trait Exchange: std::fmt::Debug + Send {
 	// dev {{{
@@ -27,6 +30,7 @@ pub trait Exchange: std::fmt::Debug + Send {
 	fn auth(&mut self, key: String, secret: SecretString);
 	/// Set number of **milliseconds** the request is valid for. Recv Window of over a minute does not make sense, thus it's expressed as u16.
 	//Q: really don't think this should be used like that, globally, - if unable to find cases, rm in a month (now is 2025/01/24)
+	#[deprecated(note = "This shouldn't be a global setting, but a per-request one. Use `recv_window` in the request instead.")]
 	fn set_recv_window(&mut self, recv_window: u16);
 	fn set_timeout(&mut self, timeout: std::time::Duration) {
 		self.__client_mut().client.config.timeout = timeout;
@@ -53,9 +57,9 @@ pub trait Exchange: std::fmt::Debug + Send {
 	//TODO!!!: async fn spawn_klines_listener(&self, symbol: Pair, tf: Timeframe) -> mpsc::Receiver<Kline>;
 
 	/// balance of a specific asset. Does not guarantee provision of USD values.
-	async fn asset_balance(&self, asset: Asset, m: AbsMarket) -> Result<AssetBalance>;
+	async fn asset_balance(&self, asset: Asset, recv_window: Option<u16>, m: AbsMarket) -> Result<AssetBalance>;
 	/// vec of _non-zero_ balances exclusively. Provides USD values.
-	async fn balances(&self, m: AbsMarket) -> Result<Balances>;
+	async fn balances(&self, recv_window: Option<u16>, m: AbsMarket) -> Result<Balances>;
 	//? potentially `total_balance`? Would return precompiled USDT-denominated balance of a (bybit::wallet/binance::account)
 	// balances are defined for each margin type: [futures_balance, spot_balance, margin_balance], but note that on some exchanges, (like bybit), some of these may point to the same exact call
 	// to negate confusion could add a `total_balance` endpoint

v_exchanges/src/mexc/account.rs

@@ -6,26 +6,25 @@ use v_utils::prelude::*;
 
 use crate::{AssetBalance, Balances};
 
-pub async fn asset_balance(client: &Client, asset: Asset) -> Result<AssetBalance> {
+pub async fn asset_balance(client: &Client, asset: Asset, recv_window: Option<u16>) -> Result<AssetBalance> {
 	assert!(client.is_authenticated::<MexcOption>());
+	let mut options = vec![MexcOption::HttpUrl(MexcHttpUrl::Futures), MexcOption::HttpAuth(MexcAuth::Sign)];
+	if let Some(rw) = recv_window {
+		options.push(MexcOption::RecvWindow(rw));
+	}
 	let endpoint = format!("/api/v1/private/account/asset/{}", asset);
-	let r: AssetBalanceResponse = client
-		.get_no_query(&endpoint, [MexcOption::HttpUrl(MexcHttpUrl::Futures), MexcOption::HttpAuth(MexcAuth::Sign)])
-		.await
-		.unwrap();
+	let r: AssetBalanceResponse = client.get_no_query(&endpoint, options).await.unwrap();
 
 	Ok(r.data.into())
 }
 
-pub async fn balances(client: &Client) -> Result<Balances> {
+pub async fn balances(client: &Client, recv_window: Option<u16>) -> Result<Balances> {
 	assert!(client.is_authenticated::<MexcOption>());
-	let rs: BalancesResponse = client
-		.get_no_query("/api/v1/private/account/assets", [
-			MexcOption::HttpUrl(MexcHttpUrl::Futures),
-			MexcOption::HttpAuth(MexcAuth::Sign),
-		])
-		.await
-		.unwrap();
+	let mut options = vec![MexcOption::HttpUrl(MexcHttpUrl::Futures), MexcOption::HttpAuth(MexcAuth::Sign)];
+	if let Some(rw) = recv_window {
+		options.push(MexcOption::RecvWindow(rw));
+	}
+	let rs: BalancesResponse = client.get_no_query("/api/v1/private/account/assets", options).await.unwrap();
 
 	let non_zero: Vec<AssetBalance> = rs.data.into_iter().filter(|r| r.equity != 0.).map(|r| r.into()).collect();
 	// dance with tambourine to request for usdt prices of all assets except usdt itself