chore: switch to generic KlinesRangeRequest

valeratrades · valeratrades · commit 83d8e67b1657 · 2025-01-03T18:40:50.000Z
diff --git a/examples/binance/market.rs b/examples/binance/market.rs
@@ -12,7 +12,7 @@ async fn main() {
 
 	b.update_default_option(BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM));
 
-	let klines = b.futures_klines(("BTC", "USDT").into(), "1m".into(), 2, None, None).await.unwrap();
+	let klines = b.futures_klines(("BTC", "USDT").into(), "1m".into(), 2.into()).await.unwrap();
 	let price = b.futures_price(("BTC", "USDT").into()).await.unwrap();
 	dbg!(&klines, price);
 
diff --git a/examples/bybit/market.rs b/examples/bybit/market.rs
@@ -16,7 +16,7 @@ async fn main() {
 	//	.expect("failed to get ticker");
 	//println!("Ticker:\n{ticker}");
 
-	let klines = bb.futures_klines(("BTC", "USDT").into(), "1m".into(), 2, None, None).await.unwrap();
+	let klines = bb.futures_klines(("BTC", "USDT").into(), "1m".into(), 2.into()).await.unwrap();
 	dbg!(&klines);
 
 	if let (Ok(key), Ok(secret)) = (env::var("BYBIT_TIGER_READ_KEY"), env::var("BYBIT_TIGER_READ_SECRET")) {
diff --git a/v_exchanges/src/binance/futures/market.rs b/v_exchanges/src/binance/futures/market.rs
@@ -1,3 +1,5 @@
+use std::fmt;
+
 use chrono::{DateTime, TimeZone, Utc};
 //HACK: Methods should be implemented on the central interface struct, following <https://github.com/wisespace-io/binance-rs>.
 use color_eyre::eyre::{self, Error, Result};
@@ -11,17 +13,52 @@ use v_utils::{
 	utils::filter_nulls,
 };
 
-use crate::core::Klines;
+use crate::core::{Klines, KlinesRequestRange};
+
+//MOVE: centralized error module
+#[derive(Debug)]
+struct LimitOutOfRangeError {
+	allowed: std::ops::RangeInclusive<u32>,
+	provided: u32,
+}
+impl fmt::Display for LimitOutOfRangeError {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "Limit out of range. Allowed: {:?}, provided: {}", self.allowed, self.provided)
+	}
+}
+impl std::error::Error for LimitOutOfRangeError {}
 
 // klines {{{
-pub async fn klines(client: &v_exchanges_adapters::Client, pair: Pair, tf: Timeframe, limit: u32, start_time: Option<u64>, end_time: Option<u64>) -> Result<Klines> {
-	let mut params = filter_nulls(json!({
+pub async fn klines(client: &v_exchanges_adapters::Client, pair: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
+	let range_json = match range {
+		KlinesRequestRange::StartEnd { start, end } => json!({
+			"startTime": start.timestamp_millis(),
+			"endTime": end.timestamp_millis(),
+		}),
+		KlinesRequestRange::Limit(limit) => {
+			let allowed_range = 1..=1000;
+			if !allowed_range.contains(&limit) {
+				return Err(LimitOutOfRangeError {
+					allowed: allowed_range,
+					provided: limit,
+				}
+				.into());
+			}
+			json!({
+				"limit": limit,
+			})
+		}
+	};
+	let mut base_params = filter_nulls(json!({
 		"symbol": pair.to_string(),
 		"interval": tf.format_binance()?,
-		"limit": limit,
-		"startTime": start_time,
-		"endTime": end_time,
 	}));
+
+	let mut base_map = base_params.as_object().unwrap().clone();
+	let range_map = range_json.as_object().unwrap();
+	base_map.extend(range_map.clone());
+	let params = filter_nulls(serde_json::Value::Object(base_map));
+
 	let kline_responses: Vec<KlineResponse> = client.get("/fapi/v1/klines", &params, [BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)]).await.unwrap();
 
 	let r_len = kline_responses.len();
diff --git a/v_exchanges/src/binance/mod.rs b/v_exchanges/src/binance/mod.rs
@@ -7,15 +7,15 @@ use v_utils::{
 	trades::{Asset, Pair, Timeframe},
 };
 
-use crate::core::{AssetBalance, Exchange, Klines};
+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 {
-	async fn futures_klines(&self, symbol: Pair, tf: Timeframe, limit: u32, start_time: Option<u64>, end_time: Option<u64>) -> Result<Klines> {
-		futures::market::klines(&self.0, symbol, tf, limit, start_time, end_time).await
+	async fn futures_klines(&self, symbol: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
+		futures::market::klines(&self.0, symbol, tf, range).await
 	}
 
 	async fn futures_price(&self, symbol: Pair) -> Result<f64> {
diff --git a/v_exchanges/src/bybit/market.rs b/v_exchanges/src/bybit/market.rs
@@ -12,7 +12,7 @@ use v_utils::{
 	utils::filter_nulls,
 };
 
-use crate::core::Klines;
+use crate::core::{Klines, KlinesRequestRange};
 
 //MOVE: centralized error module
 #[derive(Debug)]
@@ -27,20 +27,37 @@ impl fmt::Display for LimitOutOfRangeError {
 }
 impl std::error::Error for LimitOutOfRangeError {}
 
-pub async fn klines(client: &v_exchanges_adapters::Client, pair: Pair, tf: Timeframe, limit: u32, start_time: Option<u64>, end_time: Option<u64>) -> Result<Klines> {
-	let range = 1..=1000;
-	if !range.contains(&limit) {
-		return Err(LimitOutOfRangeError { allowed: range, provided: limit }.into());
-	}
-
-	let mut params = filter_nulls(json!({
+pub async fn klines(client: &v_exchanges_adapters::Client, pair: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
+	let range_json = match range {
+		KlinesRequestRange::StartEnd { start, end } => json!({
+			"startTime": start.timestamp_millis(),
+			"endTime": end.timestamp_millis(),
+		}),
+		KlinesRequestRange::Limit(limit) => {
+			let allowed_range = 1..=1000;
+			if !allowed_range.contains(&limit) {
+				return Err(LimitOutOfRangeError {
+					allowed: allowed_range,
+					provided: limit,
+				}
+				.into());
+			}
+			json!({
+				"limit": limit,
+			})
+		}
+	};
+	let mut base_params = filter_nulls(json!({
 		"category": "linear", // can be ["linear", "inverse", "spot"] afaiu, could drive some generics with this later, but for now hardcode
 		"symbol": pair.to_string(),
 		"interval": tf.format_bybit()?,
-		"limit": limit,
-		"startTime": start_time,
-		"endTime": end_time,
 	}));
+
+	let mut base_map = base_params.as_object().unwrap().clone();
+	let range_map = range_json.as_object().unwrap();
+	base_map.extend(range_map.clone());
+	let params = filter_nulls(serde_json::Value::Object(base_map));
+
 	let kline_response: KlineResponse = client.get("/v5/market/kline", &params, [BybitOption::Default]).await.unwrap();
 
 	let mut klines = Vec::new();
diff --git a/v_exchanges/src/bybit/mod.rs b/v_exchanges/src/bybit/mod.rs
@@ -6,15 +6,15 @@ use derive_more::derive::{Deref, DerefMut};
 use v_exchanges_adapters::{Client, bybit};
 use v_utils::trades::{Asset, Pair, Timeframe};
 
-use crate::core::{AssetBalance, Exchange, Klines};
+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 {
-	async fn futures_klines(&self, symbol: Pair, tf: Timeframe, limit: u32, start_time: Option<u64>, end_time: Option<u64>) -> Result<Klines> {
-		market::klines(&self.0, symbol, tf, limit, start_time, end_time).await
+	async fn futures_klines(&self, symbol: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
+		market::klines(&self.0, symbol, tf, range).await
 	}
 
 	async fn futures_price(&self, symbol: Pair) -> Result<f64> {
diff --git a/v_exchanges/src/core.rs b/v_exchanges/src/core.rs
@@ -8,7 +8,7 @@ use v_utils::trades::{Asset, Kline, Pair, Timeframe};
 
 pub trait Exchange {
 	//? should I have Self::Pair too? Like to catch the non-existent ones immediately? Although this would increase the error surface on new listings.
-	fn futures_klines(&self, symbol: Pair, tf: Timeframe, limit: u32, start_time: Option<u64>, end_time: Option<u64>) -> impl std::future::Future<Output = Result<Klines>> + Send;
+	fn futures_klines(&self, symbol: Pair, tf: Timeframe, range: KlinesRequestRange) -> impl std::future::Future<Output = Result<Klines>> + Send;
 	fn futures_price(&self, symbol: Pair) -> impl std::future::Future<Output = Result<f64>> + Send;
 
 	// Defined in terms of actors
@@ -45,13 +45,41 @@ pub struct Klines {
 //? not sure what to do about oi here
 /// [Kline]s series that is _guaranteed to not have any gaps in kline data_.
 #[derive(Clone, Debug, Default)]
-struct FullKlines(Klines);
+pub struct FullKlines(Klines);
 impl TryFrom<Klines> for FullKlines {
 	type Error = color_eyre::eyre::Report;
 	fn try_from(value: Klines) -> Result<Self> {
 	  todo!();
 	}
 }
+
+#[derive(Clone, Debug, Copy)]
+pub enum KlinesRequestRange {
+	/// Preferred way of defining the range
+	StartEnd{start: DateTime<Utc>, end: DateTime<Utc>},
+	/// For quick and dirty
+	Limit(u32),
+}
+impl Default for KlinesRequestRange {
+	fn default() -> Self {
+	  KlinesRequestRange::StartEnd { start: DateTime::default(), end: DateTime::default() }
+	}
+}
+impl From<u32> for KlinesRequestRange {
+	fn from(value: u32) -> Self {
+	  KlinesRequestRange::Limit(value)
+	}
+}
+impl From<(DateTime<Utc>, DateTime<Utc>)> for KlinesRequestRange {
+	fn from(value: (DateTime<Utc>, DateTime<Utc>)) -> Self {
+	  KlinesRequestRange::StartEnd { start: value.0, end: value.1 }
+	}
+}
+impl From<(i64, i64)> for KlinesRequestRange {
+	fn from(value: (i64, i64)) -> Self {
+	  KlinesRequestRange::StartEnd { start: DateTime::from_timestamp_millis(value.0).unwrap(), end: DateTime::from_timestamp_millis(value.1).unwrap()}
+	}
+}
 //,}}}
 
 #[derive(Clone, Debug, Default, Copy)]
