nuke: recv_window on non-sign methods

Author: valeratrades

Cargo.lock

@@ -31,9 +31,9 @@ impl Exchange for Binance {
 		self.update_default_option(BinanceOption::RecvWindow(recv_window));
 	}
 
-	async fn exchange_info(&self, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<ExchangeInfo> {
+	async fn exchange_info(&self, instrument: Instrument, _recv_window: Option<std::time::Duration>) -> ExchangeResult<ExchangeInfo> {
 		match instrument {
-			Instrument::Perp => perp::general::exchange_info(self, recv_window).await,
+			Instrument::Perp => perp::general::exchange_info(self).await,
 			_ => unimplemented!(),
 		}
 	}
@@ -49,18 +49,18 @@ impl Exchange for Binance {
 		}
 	}
 
-	async fn prices(&self, pairs: Option<Vec<Pair>>, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<BTreeMap<Pair, f64>> {
+	async fn prices(&self, pairs: Option<Vec<Pair>>, instrument: Instrument, _recv_window: Option<std::time::Duration>) -> ExchangeResult<BTreeMap<Pair, f64>> {
 		match instrument {
-			Instrument::Spot | Instrument::Margin => spot::market::prices(self, pairs, recv_window).await,
-			Instrument::Perp => perp::market::prices(self, pairs, recv_window).await,
+			Instrument::Spot | Instrument::Margin => spot::market::prices(self, pairs).await,
+			Instrument::Perp => perp::market::prices(self, pairs).await,
 			_ => Err(ExchangeError::Method(MethodError::MethodNotImplemented { exchange: self.name(), instrument })),
 		}
 	}
 
-	async fn price(&self, symbol: Symbol, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
+	async fn price(&self, symbol: Symbol, _recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
 		match symbol.instrument {
-			Instrument::Spot | Instrument::Margin => spot::market::price(self, symbol.pair, recv_window).await,
-			Instrument::Perp => perp::market::price(self, symbol.pair, recv_window).await,
+			Instrument::Spot | Instrument::Margin => spot::market::price(self, symbol.pair).await,
+			Instrument::Perp => perp::market::price(self, symbol.pair).await,
 			_ => Err(ExchangeError::Method(MethodError::MethodNotImplemented {
 				exchange: self.name(),
 				instrument: symbol.instrument,

v_exchanges/src/binance/mod.rs

@@ -1,25 +1,19 @@
-use adapters::binance::{BinanceHttpUrl, BinanceOption, BinanceOptions};
+use adapters::binance::{BinanceHttpUrl, BinanceOption};
 use eyre::Result;
 use jiff::Timestamp;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use serde_with::{DisplayFromStr, serde_as};
-use v_exchanges_adapters::GetOptions;
 use v_utils::trades::Pair;
 
 use crate::{
 	ExchangeError,
 	core::{ExchangeInfo, PairInfo},
-	recv_window_check,
 };
 //TODO: general endpoints, like ping and exchange info
 
-pub async fn exchange_info(client: &v_exchanges_adapters::Client, recv_window: Option<std::time::Duration>) -> Result<ExchangeInfo, ExchangeError> {
-	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
-	let mut options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)];
-	if let Some(rw) = recv_window {
-		options.push(BinanceOption::RecvWindow(rw));
-	}
+pub async fn exchange_info(client: &v_exchanges_adapters::Client) -> Result<ExchangeInfo, ExchangeError> {
+	let options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)];
 	let r: BinanceExchangeFutures = client.get_no_query("/fapi/v1/exchangeInfo", options).await?;
 	Ok(r.into())
 }

v_exchanges/src/binance/perp/general.rs

@@ -1,37 +1,26 @@
 use adapters::Client;
 //HACK: Methods should be implemented on the central interface struct, following <https://github.com/wisespace-io/binance-rs>.
 use serde_with::{DisplayFromStr, serde_as};
-use v_exchanges_adapters::{
-	GetOptions,
-	binance::{BinanceHttpUrl, BinanceOption, BinanceOptions},
-};
+use v_exchanges_adapters::binance::{BinanceHttpUrl, BinanceOption};
 use v_utils::prelude::*;
 
-use crate::{ExchangeResult, recv_window_check};
+use crate::ExchangeResult;
 
 // price {{{
 //HACK: should use /fapi/v2/ticker/price instead
-pub async fn price(client: &Client, pair: Pair, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
-	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
+pub async fn price(client: &Client, pair: Pair) -> ExchangeResult<f64> {
 	let params = json!({
 		"symbol": pair.fmt_binance(),
 	});
 
-	let mut options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)];
-	if let Some(rw) = recv_window {
-		options.push(BinanceOption::RecvWindow(rw));
-	}
+	let options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)];
 	let r: MarkPriceResponse = client.get("/fapi/v1/premiumIndex", &params, options).await?;
 	let price = r.index_price; // when using this framework, we care for per-exchange price, obviously
 	Ok(price)
 }
 
-pub async fn prices(client: &Client, pairs: Option<Vec<Pair>>, recv_window: Option<std::time::Duration>) -> ExchangeResult<BTreeMap<Pair, f64>> {
-	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
-	let mut options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)];
-	if let Some(rw) = recv_window {
-		options.push(BinanceOption::RecvWindow(rw));
-	}
+pub async fn prices(client: &Client, pairs: Option<Vec<Pair>>) -> ExchangeResult<BTreeMap<Pair, f64>> {
+	let options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)];
 	let rs: Vec<PriceObject> = match pairs {
 		Some(pairs) => {
 			let params = json!({

v_exchanges/src/binance/perp/market.rs

@@ -1,22 +1,17 @@
 use std::{collections::BTreeMap, str::FromStr};
 
-use adapters::binance::{BinanceHttpUrl, BinanceOption, BinanceOptions};
+use adapters::binance::{BinanceHttpUrl, BinanceOption};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use serde_with::{DisplayFromStr, serde_as};
 use tracing::instrument;
-use v_exchanges_adapters::GetOptions;
 use v_utils::trades::Pair;
 
-use crate::{ExchangeResult, recv_window_check};
+use crate::ExchangeResult;
 
 #[instrument(skip_all, fields(?pairs))]
-pub async fn prices(client: &v_exchanges_adapters::Client, pairs: Option<Vec<Pair>>, recv_window: Option<std::time::Duration>) -> ExchangeResult<BTreeMap<Pair, f64>> {
-	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
-	let mut options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::Spot)];
-	if let Some(rw) = recv_window {
-		options.push(BinanceOption::RecvWindow(rw));
-	}
+pub async fn prices(client: &v_exchanges_adapters::Client, pairs: Option<Vec<Pair>>) -> ExchangeResult<BTreeMap<Pair, f64>> {
+	let options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::Spot)];
 	let r: PricesResponse = match pairs {
 		//TODO!!!: fix this branch
 		//BUG: doesn't work for some reason
@@ -46,16 +41,12 @@ pub async fn prices(client: &v_exchanges_adapters::Client, pairs: Option<Vec<Pai
 	Ok(prices)
 }
 
-pub async fn price(client: &v_exchanges_adapters::Client, pair: Pair, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
-	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
+pub async fn price(client: &v_exchanges_adapters::Client, pair: Pair) -> ExchangeResult<f64> {
 	let params = json!({
 		"symbol": pair.fmt_binance(),
 	});
 
-	let mut options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::Spot)];
-	if let Some(rw) = recv_window {
-		options.push(BinanceOption::RecvWindow(rw));
-	}
+	let options = vec![BinanceOption::HttpUrl(BinanceHttpUrl::Spot)];
 	let r: AssetPriceResponse = client.get("/api/v3/ticker/price", &params, options).await.unwrap();
 	let price = r.price;
 	Ok(price)

v_exchanges/src/binance/spot/market.rs

@@ -4,10 +4,7 @@ use jiff::Timestamp;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use serde_with::{DisplayFromStr, serde_as};
-use v_exchanges_adapters::{
-	GetOptions,
-	bybit::{BybitOption, BybitOptions},
-};
+use v_exchanges_adapters::bybit::BybitOption;
 use v_utils::{
 	trades::{Kline, Ohlc, Pair},
 	utils::filter_nulls,
@@ -17,12 +14,10 @@ use super::{BybitInterval, BybitIntervalTime};
 use crate::{
 	ExchangeName, ExchangeResult, Instrument, Symbol,
 	core::{Klines, OpenInterest, RequestRange},
-	recv_window_check,
 };
 
 // klines {{{
-pub async fn klines(client: &v_exchanges_adapters::Client, symbol: Symbol, tf: BybitInterval, range: RequestRange, recv_window: Option<std::time::Duration>) -> ExchangeResult<Klines> {
-	recv_window_check!(recv_window, GetOptions::<BybitOptions>::default_options(client));
+pub async fn klines(client: &v_exchanges_adapters::Client, symbol: Symbol, tf: BybitInterval, range: RequestRange) -> ExchangeResult<Klines> {
 	range.ensure_allowed(1..=1000, &tf)?;
 	let range_json = range.serialize(ExchangeName::Bybit);
 	let base_params = filter_nulls(json!({
@@ -36,10 +31,7 @@ pub async fn klines(client: &v_exchanges_adapters::Client, symbol: Symbol, tf: B
 	base_map.extend(range_map.clone());
 	let params = filter_nulls(serde_json::Value::Object(base_map));
 
-	let mut options = vec![BybitOption::None];
-	if let Some(rw) = recv_window {
-		options.push(BybitOption::RecvWindow(rw));
-	}
+	let options = vec![BybitOption::None];
 	let kline_response: KlineResponse = client.get("/v5/market/kline", &params, options).await.unwrap();
 
 	let mut klines = VecDeque::with_capacity(kline_response.result.list.len());
@@ -96,16 +88,12 @@ pub struct KlineData(
 //,}}}
 
 // price {{{
-pub async fn price(client: &v_exchanges_adapters::Client, pair: Pair, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
-	recv_window_check!(recv_window, GetOptions::<BybitOptions>::default_options(client));
+pub async fn price(client: &v_exchanges_adapters::Client, pair: Pair) -> ExchangeResult<f64> {
 	let params = filter_nulls(json!({
 		"category": "linear",
 		"symbol": pair.fmt_bybit(),
 	}));
-	let mut options = vec![BybitOption::None];
-	if let Some(rw) = recv_window {
-		options.push(BybitOption::RecvWindow(rw));
-	}
+	let options = vec![BybitOption::None];
 	let response: MarketTickerResponse = client.get("/v5/market/tickers", &params, options).await?;
 	Ok(response.result.list[0].last_price)
 }
@@ -171,14 +159,7 @@ pub struct MarketTickerData {
 //,}}}
 
 // open_interest {{{
-pub async fn open_interest(
-	client: &v_exchanges_adapters::Client,
-	symbol: Symbol,
-	tf: BybitIntervalTime,
-	range: RequestRange,
-	recv_window: Option<std::time::Duration>,
-) -> ExchangeResult<Vec<OpenInterest>> {
-	recv_window_check!(recv_window, GetOptions::<BybitOptions>::default_options(client));
+pub async fn open_interest(client: &v_exchanges_adapters::Client, symbol: Symbol, tf: BybitIntervalTime, range: RequestRange) -> ExchangeResult<Vec<OpenInterest>> {
 	range.ensure_allowed(1..=200, &tf)?;
 	let range_json = range.serialize(ExchangeName::Bybit);
 
@@ -193,10 +174,7 @@ pub async fn open_interest(
 	base_map.extend(range_map.clone());
 	let params = filter_nulls(serde_json::Value::Object(base_map));
 
-	let mut options = vec![BybitOption::None];
-	if let Some(rw) = recv_window {
-		options.push(BybitOption::RecvWindow(rw));
-	}
+	let options = vec![BybitOption::None];
 	let response: OpenInterestResponse = client.get("/v5/market/open-interest", &params, options).await?;
 
 	if response.result.list.is_empty() {
@@ -209,10 +187,7 @@ pub async fn open_interest(
 			"category": "linear",
 			"symbol": symbol.pair.fmt_bybit(),
 		}));
-		let mut options = vec![BybitOption::None];
-		if let Some(rw) = recv_window {
-			options.push(BybitOption::RecvWindow(rw));
-		}
+		let options = vec![BybitOption::None];
 		let ticker_response: MarketTickerResponse = client.get("/v5/market/tickers", &params, options).await?;
 		Some(ticker_response.result.list[0].last_price)
 	} else {

v_exchanges/src/bybit/market.rs

@@ -30,23 +30,23 @@ impl Exchange for Bybit {
 		self.update_default_option(BybitOption::RecvWindow(recv_window));
 	}
 
-	async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<std::time::Duration>) -> ExchangeResult<Klines> {
+	async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, _recv_window: Option<std::time::Duration>) -> ExchangeResult<Klines> {
 		match symbol.instrument {
-			Instrument::Perp => market::klines(self, symbol, tf.try_into()?, range, recv_window).await,
+			Instrument::Perp => market::klines(self, symbol, tf.try_into()?, range).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn price(&self, symbol: Symbol, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
+	async fn price(&self, symbol: Symbol, _recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
 		match symbol.instrument {
-			Instrument::Perp => market::price(self, symbol.pair, recv_window).await,
+			Instrument::Perp => market::price(self, symbol.pair).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<std::time::Duration>) -> ExchangeResult<Vec<OpenInterest>> {
+	async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, _recv_window: Option<std::time::Duration>) -> ExchangeResult<Vec<OpenInterest>> {
 		match symbol.instrument {
-			Instrument::Perp => market::open_interest(self, symbol, tf.try_into()?, range, recv_window).await,
+			Instrument::Perp => market::open_interest(self, symbol, tf.try_into()?, range).await,
 			_ => Err(crate::ExchangeError::Method(crate::MethodError::MethodNotSupported {
 				exchange: self.name(),
 				instrument: symbol.instrument,

v_exchanges/src/bybit/mod.rs

@@ -40,7 +40,7 @@ pub async fn balances(client: &Client, recv_window: Option<std::time::Duration>)
 		}
 		// Fetch price for non-stablecoin assets
 		let usdt_pair = Pair::new(asset, "USDT".into());
-		let usdt_price = market::price(client, usdt_pair, recv_window)
+		let usdt_price = market::price(client, usdt_pair, None)
 			.await
 			.map_err(|e| eyre!("Failed to fetch USDT price for {asset} (balance: {underlying}): {e}"))?;
 		Ok((underlying * usdt_price).into())

v_exchanges/src/kucoin/account.rs

@@ -31,7 +31,7 @@ impl Exchange for Kucoin {
 	}
 
 	fn set_recv_window(&mut self, _recv_window: std::time::Duration) {
-		tracing::warn!("Kucoin does not support recv_window as a global setting");
+		tracing::warn!("KuCoin does not support configurable recv_window - uses a fixed 5-second tolerance window for all authenticated requests");
 	}
 
 	async fn exchange_info(&self, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<ExchangeInfo> {

v_exchanges/src/kucoin/mod.rs

@@ -39,7 +39,7 @@ pub async fn balances(client: &Client, recv_window: Option<std::time::Duration>)
 			if b.asset == "USDT" {
 				Box::pin(async move { Ok(1.) }) as Pin<Box<dyn Future<Output = ExchangeResult<f64>> + Send>>
 			} else {
-				Box::pin(super::market::price(client, (b.asset, "USDT".into()).into(), recv_window)) as Pin<Box<dyn Future<Output = ExchangeResult<f64>> + Send>>
+				Box::pin(super::market::price(client, (b.asset, "USDT".into()).into())) as Pin<Box<dyn Future<Output = ExchangeResult<f64>> + Send>>
 			}
 		})
 		.collect();