refactor: recv_window to std::time::Duration + fixes of some old code

Author: valeratrades

Cargo.lock

@@ -1,4 +1,4 @@
-use std::{env, str::FromStr as _};
+use std::{env, str::FromStr as _, time::Duration};
 
 use v_exchanges::prelude::*;
 
@@ -20,9 +20,9 @@ async fn main() {
 
 	if let (Ok(key), Ok(secret)) = (env::var("BINANCE_TIGER_READ_PUBKEY"), env::var("BINANCE_TIGER_READ_SECRET")) {
 		binance.auth(key, secret.into());
-		let balance_usdt = binance.asset_balance("USDT".into(), symbol.instrument, Some(10_000)).await.unwrap();
+		let balance_usdt = binance.asset_balance("USDT".into(), symbol.instrument, Some(Duration::from_millis(10_000))).await.unwrap();
 		dbg!(&balance_usdt);
-		let balances = binance.balances(symbol.instrument, Some(10_000)).await.unwrap();
+		let balances = binance.balances(symbol.instrument, Some(Duration::from_millis(10_000))).await.unwrap();
 		dbg!(&balances);
 	} else {
 		eprintln!("BINANCE_TIGER_READ_PUBKEY or BINANCE_TIGER_READ_SECRET is missing, skipping private API methods.");

examples/binance/market_perp.rs

@@ -1,10 +1,6 @@
-use std::env;
+use std::{env, time::Duration};
 
-use v_exchanges::{
-	Binance,
-	binance::perp::account::{IncomeRequest, OrderRequest, OrderType, PositionSide, TimeInForce},
-	prelude::*,
-};
+use v_exchanges::{Binance, binance::perp::account::IncomeRequest, prelude::*};
 
 #[tokio::main]
 async fn main() {
@@ -26,7 +22,7 @@ async fn main() {
 			page: None,
 		};
 
-		match v_exchanges::binance::perp::account::income_history(&binance, income_req, Some(5000)).await {
+		match v_exchanges::binance::perp::account::income_history(&binance, income_req, Some(Duration::from_millis(5000))).await {
 			Ok(records) => {
 				println!("Found {} income records:", records.len());
 				for record in records.iter().take(5) {
@@ -58,7 +54,7 @@ async fn main() {
 			new_client_order_id: None,
 		};
 
-		match v_exchanges::binance::perp::account::place_order(&binance, order_req, Some(5000)).await {
+		match v_exchanges::binance::perp::account::place_order(&binance, order_req, Some(Duration::from_millis(5000))).await {
 			Ok(response) => {
 				println!("Order placed successfully!");
 				println!("  Order ID: {}", response.order_id);

examples/binance/orders.rs

@@ -1,4 +1,4 @@
-use std::{env, str::FromStr as _};
+use std::{env, str::FromStr as _, time::Duration};
 
 use v_exchanges::{Bybit, prelude::*};
 
@@ -35,7 +35,7 @@ async fn private(c: &dyn Exchange, symbol: Symbol) {
 	let balances = c.balances(symbol.instrument, None).await.unwrap();
 	println!("{balances:?}");
 
-	let balance_usdc = c.asset_balance("USDC".into(), symbol.instrument, Some(5000)).await.unwrap();
+	let balance_usdc = c.asset_balance("USDC".into(), symbol.instrument, Some(Duration::from_millis(5000))).await.unwrap();
 	println!("{balance_usdc:?}");
 }
 

examples/bybit/market.rs

@@ -1,4 +1,4 @@
-use std::env;
+use std::{env, time::Duration};
 
 use v_exchanges::prelude::*;
 
@@ -27,7 +27,7 @@ async fn check_binance() {
 			let mut binance = ExchangeName::Binance.init_client();
 			binance.auth(key, secret.into());
 
-			match binance.balances(Instrument::Perp, Some(5000)).await {
+			match binance.balances(Instrument::Perp, Some(Duration::from_millis(5000))).await {
 				Ok(_) => println!("✅ Binance: API key is valid and active"),
 				Err(e) => println!("❌ Binance: API key error - {}", e),
 			}
@@ -47,7 +47,7 @@ async fn check_bybit() {
 			let mut bybit = ExchangeName::Bybit.init_client();
 			bybit.auth(key, secret.into());
 
-			match bybit.balances(Instrument::Perp, Some(5000)).await {
+			match bybit.balances(Instrument::Perp, Some(Duration::from_millis(5000))).await {
 				Ok(_) => println!("✅ Bybit: API key is valid and active"),
 				Err(e) => println!("❌ Bybit: API key error - {}", e),
 			}
@@ -113,7 +113,7 @@ async fn check_mexc() {
 			let mut mexc = ExchangeName::Mexc.init_client();
 			mexc.auth(key, secret.into());
 
-			match mexc.balances(Instrument::Perp, Some(5000)).await {
+			match mexc.balances(Instrument::Perp, Some(Duration::from_millis(5000))).await {
 				Ok(_) => println!("✅ MEXC: API key is valid and active"),
 				Err(e) => {
 					let err_str = e.to_string();

examples/healthcheck.rs

@@ -26,8 +26,8 @@ ignored = ["derive-new", "color-eyre", "serde", "tokio", "v_utils"]
 [features]
 default = ["major", "data"]
 
-full = ["major", "data", "bitflyer", "coincheck"]
-major = ["binance", "bybit", "kucoin", "mexc"]
+full = ["major", "data", "mexc", "kucoin", "bitflyer", "coincheck"]
+major = ["binance", "bybit"]
 
 binance = ["v_exchanges_adapters/binance"]
 bybit = ["v_exchanges_adapters/bybit"]

v_exchanges/Cargo.toml

@@ -20,7 +20,13 @@ use crate::{
 };
 
 // klines {{{
-pub async fn klines(client: &v_exchanges_adapters::Client, symbol: Symbol, tf: BinanceTimeframe, range: RequestRange, recv_window: Option<u16>) -> Result<Klines, ExchangeError> {
+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));
 	//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())?;
@@ -112,7 +118,7 @@ pub async fn open_interest(
 	symbol: Symbol,
 	tf: BinanceTimeframe,
 	range: RequestRange,
-	recv_window: Option<u16>,
+	recv_window: Option<std::time::Duration>,
 ) -> Result<Vec<OpenInterest>, ExchangeError> {
 	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
 	range.ensure_allowed(1..=500, tf.as_ref())?;

v_exchanges/src/binance/market.rs

@@ -27,18 +27,18 @@ impl Exchange for Binance {
 		self.update_default_option(BinanceOption::Secret(secret));
 	}
 
-	fn set_recv_window(&mut self, recv_window: u16) {
+	fn set_recv_window(&mut self, recv_window: std::time::Duration) {
 		self.update_default_option(BinanceOption::RecvWindow(recv_window));
 	}
 
-	async fn exchange_info(&self, instrument: Instrument, recv_window: Option<u16>) -> 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,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<u16>) -> ExchangeResult<Klines> {
+	async fn klines(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<std::time::Duration>) -> 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,
@@ -49,15 +49,15 @@ impl Exchange for Binance {
 		}
 	}
 
-	async fn prices(&self, pairs: Option<Vec<Pair>>, instrument: Instrument, recv_window: Option<u16>) -> 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,
 			_ => Err(ExchangeError::Method(MethodError::MethodNotImplemented { exchange: self.name(), instrument })),
 		}
 	}
 
-	async fn price(&self, symbol: Symbol, recv_window: Option<u16>) -> 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,
@@ -68,7 +68,7 @@ impl Exchange for Binance {
 		}
 	}
 
-	async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<u16>) -> ExchangeResult<Vec<crate::core::OpenInterest>> {
+	async fn open_interest(&self, symbol: Symbol, tf: Timeframe, range: RequestRange, recv_window: Option<std::time::Duration>) -> ExchangeResult<Vec<crate::core::OpenInterest>> {
 		match symbol.instrument {
 			Instrument::Perp => market::open_interest(self, symbol, tf.try_into()?, range, recv_window).await,
 			_ => Err(ExchangeError::Method(MethodError::MethodNotSupported {
@@ -78,14 +78,14 @@ impl Exchange for Binance {
 		}
 	}
 
-	async fn asset_balance(&self, asset: Asset, instrument: Instrument, recv_window: Option<u16>) -> ExchangeResult<AssetBalance> {
+	async fn asset_balance(&self, asset: Asset, instrument: Instrument, recv_window: Option<std::time::Duration>) -> ExchangeResult<AssetBalance> {
 		match instrument {
 			Instrument::Perp => perp::account::asset_balance(self, asset, recv_window).await,
 			_ => unimplemented!(),
 		}
 	}
 
-	async fn balances(&self, instrument: Instrument, recv_window: Option<u16>) -> ExchangeResult<Balances> {
+	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?;

v_exchanges/src/binance/mod.rs

@@ -17,7 +17,7 @@ use crate::{
 
 // 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, recv_window: Option<u16>) -> ExchangeResult<AssetBalance> {
+pub async fn asset_balance(client: &v_exchanges_adapters::Client, asset: Asset, recv_window: Option<std::time::Duration>) -> ExchangeResult<AssetBalance> {
 	use v_exchanges_adapters::GetOptions;
 	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
 	assert!(client.is_authenticated::<BinanceOption>());
@@ -38,7 +38,7 @@ pub async fn asset_balance(client: &v_exchanges_adapters::Client, asset: Asset,
 	Ok(balance)
 }
 
-pub async fn balances(client: &v_exchanges_adapters::Client, recv_window: Option<u16>, prices: &BTreeMap<Pair, f64>) -> ExchangeResult<Balances> {
+pub async fn balances(client: &v_exchanges_adapters::Client, recv_window: Option<std::time::Duration>, prices: &BTreeMap<Pair, f64>) -> ExchangeResult<Balances> {
 	use v_exchanges_adapters::GetOptions;
 	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
 	assert!(client.is_authenticated::<BinanceOption>());
@@ -87,7 +87,7 @@ pub async fn balances(client: &v_exchanges_adapters::Client, recv_window: Option
 // Order Placement {{{
 
 /// Place a new order on Binance Futures
-pub async fn place_order(client: &v_exchanges_adapters::Client, request: OrderRequest, recv_window: Option<u16>) -> ExchangeResult<OrderResponse> {
+pub async fn place_order(client: &v_exchanges_adapters::Client, request: OrderRequest, recv_window: Option<std::time::Duration>) -> ExchangeResult<OrderResponse> {
 	use v_exchanges_adapters::GetOptions;
 	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
 	assert!(client.is_authenticated::<BinanceOption>());
@@ -145,7 +145,7 @@ pub async fn place_order(client: &v_exchanges_adapters::Client, request: OrderRe
 // Income History {{{
 
 /// Query income history
-pub async fn income_history(client: &v_exchanges_adapters::Client, request: IncomeRequest, recv_window: Option<u16>) -> ExchangeResult<Vec<IncomeRecord>> {
+pub async fn income_history(client: &v_exchanges_adapters::Client, request: IncomeRequest, recv_window: Option<std::time::Duration>) -> ExchangeResult<Vec<IncomeRecord>> {
 	use v_exchanges_adapters::GetOptions;
 	recv_window_check!(recv_window, GetOptions::<BinanceOptions>::default_options(client));
 	assert!(client.is_authenticated::<BinanceOption>());

v_exchanges/src/binance/perp/account.rs

@@ -14,7 +14,7 @@ use crate::{
 };
 //TODO: general endpoints, like ping and exchange info
 
-pub async fn exchange_info(client: &v_exchanges_adapters::Client, recv_window: Option<u16>) -> Result<ExchangeInfo, ExchangeError> {
+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 {