nuke: forgot to remove recv_window for non-sign in definitions themselves

valeratrades · valeratrades · commit a08f4d351b6c · 2025-11-24T23:29:39.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,21 +24,21 @@ eyre = "^0.6.12"
 futures-util = "^0.3.31"
 hex = "^0.4.3"
 hmac = "^0.12.1"
-jiff = "^0.2.15"
+jiff = "^0.2.16"
 reqwest = { version = "^0.12.24", features = ["blocking", "json"] }
 secrecy = "^0.10.3"
 serde = { version = "^1.0.228", features = ["derive"] }
 serde_json = "^1.0.145"
 serde_plain = "^1.0.2" #TEST
 serde_urlencoded = "^0.7.1"
-serde_with = "^3.15.1"
+serde_with = "^3.16.0"
 sha2 = "^0.10.9"
 thiserror = "^2.0.17"
 tokio = { version = "^1.48.0", features = ["sync", "macros", "io-util", "rt", "rt-multi-thread", "time"] } # enable only features that play with wasm.
 tracing = "^0.1.41"
 url = "^2.5.7"
-v_utils = { version = "^2.9.8", path = "../v_utils/v_utils" } #ga: rm path
+v_utils = { version = "^2.9.9", path = "../v_utils/v_utils" } #ga: rm path
 #dynosaur = "^0.2.0"
 
 #[dev-dependencies]
-insta = "1.43.2"
+insta = "1.44.1"
diff --git a/v_exchanges/src/binance/market.rs b/v_exchanges/src/binance/market.rs
@@ -5,29 +5,18 @@ use jiff::Timestamp;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 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::trades::{Kline, Ohlc};
 
 use super::BinanceTimeframe;
 use crate::{
 	ExchangeError, ExchangeName, Instrument, Symbol,
 	core::{Klines, OpenInterest, RequestRange},
-	recv_window_check,
 	utils::join_params,
 };
 
 // klines {{{
-pub async fn klines(
-	client: &v_exchanges_adapters::Client,
-	symbol: Symbol,
-	tf: BinanceTimeframe,
-	range: RequestRange,
-	recv_window: Option<std::time::Duration>,
-) -> Result<Klines, ExchangeError> {
-	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
+pub async fn klines(client: &v_exchanges_adapters::Client, symbol: Symbol, tf: BinanceTimeframe, range: RequestRange) -> Result<Klines, ExchangeError> {
 	//TODO: test if embedding params into the url works more consistently (comp number of pairs axum-site is ablle ot get)
 	range.ensure_allowed(1..=1000, tf.as_ref())?;
 	let range_params = range.serialize(ExchangeName::Binance);
@@ -44,10 +33,7 @@ pub async fn klines(
 		_ => unimplemented!(),
 	};
 
-	let mut options = vec![BinanceOption::HttpUrl(base_url)];
-	if let Some(rw) = recv_window {
-		options.push(BinanceOption::RecvWindow(rw));
-	}
+	let options = vec![BinanceOption::HttpUrl(base_url)];
 	let kline_responses: Vec<KlineResponse> = client.get(&format!("{endpoint_prefix}/klines"), &params, options).await?;
 
 	let r_len = kline_responses.len();
@@ -113,14 +99,7 @@ pub struct KlineResponse {
 //,}}}
 
 // open_interest {{{
-pub async fn open_interest(
-	client: &v_exchanges_adapters::Client,
-	symbol: Symbol,
-	tf: BinanceTimeframe,
-	range: RequestRange,
-	recv_window: Option<std::time::Duration>,
-) -> Result<Vec<OpenInterest>, ExchangeError> {
-	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
+pub async fn open_interest(client: &v_exchanges_adapters::Client, symbol: Symbol, tf: BinanceTimeframe, range: RequestRange) -> Result<Vec<OpenInterest>, ExchangeError> {
 	range.ensure_allowed(1..=500, tf.as_ref())?;
 	let range_params = range.serialize(ExchangeName::Binance);
 	let base_params = json!({
@@ -138,10 +117,7 @@ pub async fn open_interest(
 			})),
 	};
 
-	let mut options = vec![BinanceOption::HttpUrl(base_url)];
-	if let Some(rw) = recv_window {
-		options.push(BinanceOption::RecvWindow(rw));
-	}
+	let options = vec![BinanceOption::HttpUrl(base_url)];
 	let responses: Vec<OpenInterestResponse> = client.get(endpoint, &params, options).await?;
 
 	if responses.is_empty() {
diff --git a/v_exchanges/src/binance/mod.rs b/v_exchanges/src/binance/mod.rs
@@ -31,33 +31,33 @@ 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) -> ExchangeResult<ExchangeInfo> {
 		match instrument {
 			Instrument::Perp => perp::general::exchange_info(self).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	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) -> ExchangeResult<Klines> {
 		match symbol.instrument {
-			Instrument::Spot | Instrument::Margin => market::klines(self, symbol, tf.try_into()?, range, recv_window).await,
-			Instrument::Perp => market::klines(self, symbol, tf.try_into()?, range, recv_window).await,
+			Instrument::Spot | Instrument::Margin => market::klines(self, symbol, tf.try_into()?, range).await,
+			Instrument::Perp => market::klines(self, symbol, tf.try_into()?, range).await,
 			_ => Err(ExchangeError::Method(MethodError::MethodNotImplemented {
 				exchange: self.name(),
 				instrument: symbol.instrument,
 			})),
 		}
 	}
 
-	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) -> ExchangeResult<BTreeMap<Pair, f64>> {
 		match instrument {
 			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) -> ExchangeResult<f64> {
 		match symbol.instrument {
 			Instrument::Spot | Instrument::Margin => spot::market::price(self, symbol.pair).await,
 			Instrument::Perp => perp::market::price(self, symbol.pair).await,
@@ -68,9 +68,9 @@ impl Exchange for Binance {
 		}
 	}
 
-	async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<std::time::Duration>) -> ExchangeResult<Vec<crate::core::OpenInterest>> {
+	async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange) -> ExchangeResult<Vec<crate::core::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(ExchangeError::Method(MethodError::MethodNotSupported {
 				exchange: self.name(),
 				instrument: symbol.instrument,
@@ -88,7 +88,7 @@ impl Exchange for Binance {
 	async fn balances(&self, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<Balances> {
 		match instrument {
 			Instrument::Perp => {
-				let prices = self.prices(None, instrument, recv_window).await?;
+				let prices = self.prices(None, instrument).await?;
 				perp::account::balances(self, recv_window, &prices).await
 			}
 			_ => unimplemented!(),
diff --git a/v_exchanges/src/bybit/mod.rs b/v_exchanges/src/bybit/mod.rs
@@ -30,21 +30,21 @@ 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) -> ExchangeResult<Klines> {
 		match symbol.instrument {
 			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) -> ExchangeResult<f64> {
 		match symbol.instrument {
 			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) -> ExchangeResult<Vec<OpenInterest>> {
 		match symbol.instrument {
 			Instrument::Perp => market::open_interest(self, symbol, tf.try_into()?, range).await,
 			_ => Err(crate::ExchangeError::Method(crate::MethodError::MethodNotSupported {
diff --git a/v_exchanges/src/core.rs b/v_exchanges/src/core.rs
@@ -52,14 +52,14 @@ pub trait Exchange: std::fmt::Debug + Send + Sync + std::ops::Deref<Target = Cli
 
 	#[allow(unused_variables)]
 	#[allow(dead_code)]
-	async fn exchange_info(&self, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<ExchangeInfo> {
+	async fn exchange_info(&self, instrument: Instrument) -> ExchangeResult<ExchangeInfo> {
 		Err(ExchangeError::Method(MethodError::MethodNotSupported { exchange: self.name(), instrument }))
 	}
 
 	//? should I have Self::Pair too? Like to catch the non-existent ones immediately? Although this would increase the error surface on new listings.
 	#[allow(unused_variables)]
 	#[allow(dead_code)]
-	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) -> ExchangeResult<Klines> {
 		Err(ExchangeError::Method(MethodError::MethodNotSupported {
 			exchange: self.name(),
 			instrument: symbol.instrument,
@@ -69,13 +69,13 @@ pub trait Exchange: std::fmt::Debug + Send + Sync + std::ops::Deref<Target = Cli
 	/// If no pairs are specified, returns for all;
 	#[allow(unused_variables)]
 	#[allow(dead_code)]
-	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) -> ExchangeResult<BTreeMap<Pair, f64>> {
 		Err(ExchangeError::Method(MethodError::MethodNotSupported { exchange: self.name(), instrument }))
 	}
 
 	#[allow(unused_variables)]
 	#[allow(dead_code)]
-	async fn price(&self, symbol: Symbol, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
+	async fn price(&self, symbol: Symbol) -> ExchangeResult<f64> {
 		Err(ExchangeError::Method(MethodError::MethodNotSupported {
 			exchange: self.name(),
 			instrument: symbol.instrument,
@@ -86,7 +86,7 @@ pub trait Exchange: std::fmt::Debug + Send + Sync + std::ops::Deref<Target = Cli
 	/// in output vec: greater the index, fresher the data
 	#[allow(unused_variables)]
 	#[allow(dead_code)]
-	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) -> ExchangeResult<Vec<OpenInterest>> {
 		Err(ExchangeError::Method(MethodError::MethodNotSupported {
 			exchange: self.name(),
 			instrument: symbol.instrument,
@@ -378,6 +378,7 @@ define_str_enum! {
 	}
 }
 
+#[derive(Clone, Debug)]
 pub struct Ticker {
 	pub symbol: Symbol,
 	pub exchange_name: ExchangeName,
diff --git a/v_exchanges/src/kucoin/mod.rs b/v_exchanges/src/kucoin/mod.rs
@@ -34,30 +34,30 @@ impl Exchange for Kucoin {
 		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> {
+	async fn exchange_info(&self, instrument: Instrument) -> ExchangeResult<ExchangeInfo> {
 		match instrument {
-			Instrument::Spot => market::exchange_info(self, recv_window).await,
+			Instrument::Spot => market::exchange_info(self, None).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn price(&self, symbol: Symbol, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
+	async fn price(&self, symbol: Symbol) -> ExchangeResult<f64> {
 		match symbol.instrument {
-			Instrument::Spot => market::price(self, symbol.pair, recv_window).await,
+			Instrument::Spot => market::price(self, symbol.pair, None).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	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) -> ExchangeResult<BTreeMap<Pair, f64>> {
 		match instrument {
-			Instrument::Spot => market::prices(self, pairs, recv_window).await,
+			Instrument::Spot => market::prices(self, pairs, None).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	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) -> ExchangeResult<Klines> {
 		match symbol.instrument {
-			Instrument::Spot => market::klines(self, symbol, tf.try_into()?, range, recv_window).await,
+			Instrument::Spot => market::klines(self, symbol, tf.try_into()?, range, None).await,
 			_ => unimplemented!(),
 		}
 	}
diff --git a/v_exchanges/src/mexc/mod.rs b/v_exchanges/src/mexc/mod.rs
@@ -33,14 +33,14 @@ impl Exchange for Mexc {
 		self.update_default_option(MexcOption::RecvWindow(recv_window));
 	}
 
-	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) -> ExchangeResult<BTreeMap<Pair, f64>> {
 		match instrument {
 			Instrument::Perp => unimplemented!("Mexc does not have a multi-asset endpoints for futures"),
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn price(&self, symbol: Symbol, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {
+	async fn price(&self, symbol: Symbol) -> ExchangeResult<f64> {
 		match symbol.instrument {
 			Instrument::Perp => market::price(self, symbol.pair).await,
 			_ => unimplemented!(),

Original file line number	Diff line number	Diff line change
`@@ -31,33 +31,33 @@ impl Exchange for Binance {`
`31`	`31`	`self.update_default_option(BinanceOption::RecvWindow(recv_window));`
`32`	`32`	`}`
`33`	`33`
`34`		`- async fn exchange_info(&self, instrument: Instrument, _recv_window: Option<std::time::Duration>) -> ExchangeResult<ExchangeInfo> {`
	`34`	`+ async fn exchange_info(&self, instrument: Instrument) -> ExchangeResult<ExchangeInfo> {`
`35`	`35`	`match instrument {`
`36`	`36`	`Instrument::Perp => perp::general::exchange_info(self).await,`
`37`	`37`	`_ => unimplemented!(),`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`		`- async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<std::time::Duration>) -> ExchangeResult<Klines> {`
	`41`	`+ async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange) -> ExchangeResult<Klines> {`
`42`	`42`	`match symbol.instrument {`
`43`		`- Instrument::Spot \| Instrument::Margin => market::klines(self, symbol, tf.try_into()?, range, recv_window).await,`
`44`		`- Instrument::Perp => market::klines(self, symbol, tf.try_into()?, range, recv_window).await,`
	`43`	`+ Instrument::Spot \| Instrument::Margin => market::klines(self, symbol, tf.try_into()?, range).await,`
	`44`	`+ Instrument::Perp => market::klines(self, symbol, tf.try_into()?, range).await,`
`45`	`45`	`_ => Err(ExchangeError::Method(MethodError::MethodNotImplemented {`
`46`	`46`	`exchange: self.name(),`
`47`	`47`	`instrument: symbol.instrument,`
`48`	`48`	`})),`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`		`- async fn prices(&self, pairs: Option<Vec<Pair>>, instrument: Instrument, _recv_window: Option<std::time::Duration>) -> ExchangeResult<BTreeMap<Pair, f64>> {`
	`52`	`+ async fn prices(&self, pairs: Option<Vec<Pair>>, instrument: Instrument) -> ExchangeResult<BTreeMap<Pair, f64>> {`
`53`	`53`	`match instrument {`
`54`	`54`	`Instrument::Spot \| Instrument::Margin => spot::market::prices(self, pairs).await,`
`55`	`55`	`Instrument::Perp => perp::market::prices(self, pairs).await,`
`56`	`56`	`_ => Err(ExchangeError::Method(MethodError::MethodNotImplemented { exchange: self.name(), instrument })),`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`- async fn price(&self, symbol: Symbol, _recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {`
	`60`	`+ async fn price(&self, symbol: Symbol) -> ExchangeResult<f64> {`
`61`	`61`	`match symbol.instrument {`
`62`	`62`	`Instrument::Spot \| Instrument::Margin => spot::market::price(self, symbol.pair).await,`
`63`	`63`	`Instrument::Perp => perp::market::price(self, symbol.pair).await,`
`@@ -68,9 +68,9 @@ impl Exchange for Binance {`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`- async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<std::time::Duration>) -> ExchangeResult<Vec<crate::core::OpenInterest>> {`
	`71`	`+ async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange) -> ExchangeResult<Vec<crate::core::OpenInterest>> {`
`72`	`72`	`match symbol.instrument {`
`73`		`- Instrument::Perp => market::open_interest(self, symbol, tf.try_into()?, range, recv_window).await,`
	`73`	`+ Instrument::Perp => market::open_interest(self, symbol, tf.try_into()?, range).await,`
`74`	`74`	`_ => Err(ExchangeError::Method(MethodError::MethodNotSupported {`
`75`	`75`	`exchange: self.name(),`
`76`	`76`	`instrument: symbol.instrument,`
`@@ -88,7 +88,7 @@ impl Exchange for Binance {`
`88`	`88`	`async fn balances(&self, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<Balances> {`
`89`	`89`	`match instrument {`
`90`	`90`	`Instrument::Perp => {`
`91`		`- let prices = self.prices(None, instrument, recv_window).await?;`
	`91`	`+ let prices = self.prices(None, instrument).await?;`
`92`	`92`	`perp::account::balances(self, recv_window, &prices).await`
`93`	`93`	`}`
`94`	`94`	`_ => unimplemented!(),`
Original file line number	Diff line number	Diff line change
`@@ -30,21 +30,21 @@ impl Exchange for Bybit {`
`30`	`30`	`self.update_default_option(BybitOption::RecvWindow(recv_window));`
`31`	`31`	`}`
`32`	`32`
`33`		`- async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, _recv_window: Option<std::time::Duration>) -> ExchangeResult<Klines> {`
	`33`	`+ async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange) -> ExchangeResult<Klines> {`
`34`	`34`	`match symbol.instrument {`
`35`	`35`	`Instrument::Perp => market::klines(self, symbol, tf.try_into()?, range).await,`
`36`	`36`	`_ => unimplemented!(),`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`- async fn price(&self, symbol: Symbol, _recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {`
	`40`	`+ async fn price(&self, symbol: Symbol) -> ExchangeResult<f64> {`
`41`	`41`	`match symbol.instrument {`
`42`	`42`	`Instrument::Perp => market::price(self, symbol.pair).await,`
`43`	`43`	`_ => unimplemented!(),`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`- async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, _recv_window: Option<std::time::Duration>) -> ExchangeResult<Vec<OpenInterest>> {`
	`47`	`+ async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange) -> ExchangeResult<Vec<OpenInterest>> {`
`48`	`48`	`match symbol.instrument {`
`49`	`49`	`Instrument::Perp => market::open_interest(self, symbol, tf.try_into()?, range).await,`
`50`	`50`	`_ => Err(crate::ExchangeError::Method(crate::MethodError::MethodNotSupported {`
Original file line number	Diff line number	Diff line change
`@@ -34,30 +34,30 @@ impl Exchange for Kucoin {`
`34`	`34`	`tracing::warn!("KuCoin does not support configurable recv_window - uses a fixed 5-second tolerance window for all authenticated requests");`
`35`	`35`	`}`
`36`	`36`
`37`		`- async fn exchange_info(&self, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<ExchangeInfo> {`
	`37`	`+ async fn exchange_info(&self, instrument: Instrument) -> ExchangeResult<ExchangeInfo> {`
`38`	`38`	`match instrument {`
`39`		`- Instrument::Spot => market::exchange_info(self, recv_window).await,`
	`39`	`+ Instrument::Spot => market::exchange_info(self, None).await,`
`40`	`40`	`_ => unimplemented!(),`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`		`- async fn price(&self, symbol: Symbol, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {`
	`44`	`+ async fn price(&self, symbol: Symbol) -> ExchangeResult<f64> {`
`45`	`45`	`match symbol.instrument {`
`46`		`- Instrument::Spot => market::price(self, symbol.pair, recv_window).await,`
	`46`	`+ Instrument::Spot => market::price(self, symbol.pair, None).await,`
`47`	`47`	`_ => unimplemented!(),`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`- async fn prices(&self, pairs: Option<Vec<Pair>>, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<BTreeMap<Pair, f64>> {`
	`51`	`+ async fn prices(&self, pairs: Option<Vec<Pair>>, instrument: Instrument) -> ExchangeResult<BTreeMap<Pair, f64>> {`
`52`	`52`	`match instrument {`
`53`		`- Instrument::Spot => market::prices(self, pairs, recv_window).await,`
	`53`	`+ Instrument::Spot => market::prices(self, pairs, None).await,`
`54`	`54`	`_ => unimplemented!(),`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`		`- async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<std::time::Duration>) -> ExchangeResult<Klines> {`
	`58`	`+ async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange) -> ExchangeResult<Klines> {`
`59`	`59`	`match symbol.instrument {`
`60`		`- Instrument::Spot => market::klines(self, symbol, tf.try_into()?, range, recv_window).await,`
	`60`	`+ Instrument::Spot => market::klines(self, symbol, tf.try_into()?, range, None).await,`
`61`	`61`	`_ => unimplemented!(),`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,14 +33,14 @@ impl Exchange for Mexc {`
`33`	`33`	`self.update_default_option(MexcOption::RecvWindow(recv_window));`
`34`	`34`	`}`
`35`	`35`
`36`		`- async fn prices(&self, _pairs: Option<Vec<Pair>>, instrument: Instrument, _recv_window: Option<std::time::Duration>) -> ExchangeResult<BTreeMap<Pair, f64>> {`
	`36`	`+ async fn prices(&self, _pairs: Option<Vec<Pair>>, instrument: Instrument) -> ExchangeResult<BTreeMap<Pair, f64>> {`
`37`	`37`	`match instrument {`
`38`	`38`	`Instrument::Perp => unimplemented!("Mexc does not have a multi-asset endpoints for futures"),`
`39`	`39`	`_ => unimplemented!(),`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`- async fn price(&self, symbol: Symbol, recv_window: Option<std::time::Duration>) -> ExchangeResult<f64> {`
	`43`	`+ async fn price(&self, symbol: Symbol) -> ExchangeResult<f64> {`
`44`	`44`	`match symbol.instrument {`
`45`	`45`	`Instrument::Perp => market::price(self, symbol.pair).await,`
`46`	`46`	`_ => unimplemented!(),`