feat: binance: spot prices (kinda)

valeratrades · valeratrades · commit ba5ad5072cef · 2025-01-09T19:13:29.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -13,9 +13,6 @@ tabs_in_doc_comments = "allow"
 
 [workspace.dependencies]
 v_utils = { version = "^2.0", path = "../v_utils/v_utils", features = ["trades", "tracing", "macros"] } #ga: rm path
-
-chrono = "^0.4.39"
-color-eyre = "^0.6.3"
 futures-util = "^0.3.31"
 reqwest = { version = "^0.12.12", features = ["blocking", "json"] }
 serde = { version = "^1.0.217", features = ["derive"] }
@@ -25,9 +22,7 @@ serde_with = "^3.12.0"
 thiserror = "^2.0.9"
 derive_more = { version = "^1.0.0", features = ["deref", "deref_mut"] }
 tokio = { version = "^1.42.0", features = ["full"] }
-tokio-tungstenite = { version = "^0.26.1", features = ["native-tls"] }
 tracing = "^0.1.41"
-url = "^2.5.4"
 hmac = "^0.12.1"
 sha2 = "^0.10.8"
 hex = "^0.4.3"
diff --git a/examples/binance/market_futures.rs b/examples/binance/market_futures.rs
@@ -16,9 +16,6 @@ async fn main() {
 	let price = bn.futures_price(("BTC", "USDT").into()).await.unwrap();
 	dbg!(&klines, price);
 
-	let spot_klines = bn.spot_klines(("BTC", "USDT").into(), "1m".into(), 2.into()).await.unwrap();
-	dbg!(&spot_klines);
-
 	if let (Ok(key), Ok(secret)) = (env::var("BINANCE_TIGER_READ_KEY"), env::var("BINANCE_TIGER_READ_SECRET")) {
 		bn.auth(key, secret);
 		let balance = bn.futures_asset_balance("USDT".into()).await.unwrap();
diff --git a/examples/binance/market_spot.rs b/examples/binance/market_spot.rs
@@ -0,0 +1,17 @@
+use v_exchanges::{binance::Binance, core::Exchange};
+use v_exchanges_adapters::binance::{BinanceHttpUrl, BinanceOption};
+
+#[tokio::main]
+async fn main() {
+	color_eyre::install().unwrap();
+	v_utils::utils::init_subscriber(v_utils::utils::LogDestination::xdg("v_exchanges"));
+
+	let mut bn = Binance::default();
+	bn.update_default_option(BinanceOption::HttpUrl(BinanceHttpUrl::Spot));
+
+	let spot_klines = bn.spot_klines(("BTC", "USDT").into(), "1m".into(), 2.into()).await.unwrap();
+	dbg!(&spot_klines);
+
+	let spot_prices = bn.spot_prices(None).await.unwrap();
+	dbg!(&spot_prices[..5]);
+}
diff --git a/v_exchanges/Cargo.toml b/v_exchanges/Cargo.toml
@@ -24,7 +24,6 @@ rustdoc-args = ["--cfg", "docsrs"]
 ignored = ["derive-new", "color-eyre", "serde", "tokio", "v_utils"]
 
 [dependencies]
-color-eyre.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 serde_plain.workspace = true
@@ -41,9 +40,11 @@ chrono = "0.4.39"
 env_logger = "0.11.5"
 
 insta.workspace = true #dbg (for some reason is not loading in dev-dependencies rn
+eyre = "0.6.12"
 
 [dev-dependencies]
 insta.workspace = true
+color-eyre = "^0.6.3"
 #
 
 [features]
@@ -56,8 +57,12 @@ bitflyer = ["v_exchanges_adapters/bitflyer"]
 coincheck = ["v_exchanges_adapters/coincheck"]
 
 [[example]]
-name = "binance_market"
-path = "../examples/binance/market.rs"
+name = "binance_market_futures"
+path = "../examples/binance/market_futures.rs"
+
+[[example]]
+name = "binance_market_spot"
+path = "../examples/binance/market_spot.rs"
 
 [[example]]
 name = "bybit_market"
diff --git a/v_exchanges/README.md b/v_exchanges/README.md
@@ -0,0 +1 @@
+
diff --git a/v_exchanges/src/binance/futures/account.rs b/v_exchanges/src/binance/futures/account.rs
@@ -1,4 +1,4 @@
-use color_eyre::eyre::Result;
+use eyre::Result;
 use serde::Deserialize;
 use serde_with::{DisplayFromStr, serde_as};
 use v_exchanges_adapters::binance::{BinanceAuth, BinanceHttpUrl, BinanceOption};
diff --git a/v_exchanges/src/binance/futures/market.rs b/v_exchanges/src/binance/futures/market.rs
@@ -1,21 +1,10 @@
-use std::collections::VecDeque;
-
-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::Result;
+use eyre::Result;
 use serde::{Deserialize, Serialize};
-use serde_json::{Value, json};
+use serde_json::json;
 use serde_with::{DisplayFromStr, serde_as};
-use v_exchanges_adapters::{
-	binance::{BinanceHttpUrl, BinanceOption},
-	errors::LimitOutOfRangeError,
-};
-use v_utils::{
-	trades::{Kline, Ohlc, Pair, Timeframe},
-	utils::filter_nulls,
-};
-
-use crate::core::{Klines, KlinesRequestRange};
+use v_exchanges_adapters::binance::{BinanceHttpUrl, BinanceOption};
+use v_utils::trades::Pair;
 
 // price {{{
 //HACK: not sure this is _the_ thing to use for that (throwing away A LOT of data)
diff --git a/v_exchanges/src/binance/futures/mod.rs b/v_exchanges/src/binance/futures/mod.rs
@@ -1,5 +1,4 @@
 pub mod core;
-pub use core::*;
 
 pub mod account;
 pub mod general;
diff --git a/v_exchanges/src/binance/market.rs b/v_exchanges/src/binance/market.rs
@@ -2,7 +2,7 @@ use std::collections::VecDeque;
 
 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::Result;
+use eyre::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use serde_with::{DisplayFromStr, serde_as};
@@ -122,37 +122,6 @@ pub struct KlineResponse {
 }
 //,}}}
 
-//// price {{{
-////HACK: not sure this is _the_ thing to use for that (throwing away A LOT of data)
-//pub async fn price(client: &v_exchanges_adapters::Client, pair: Pair) -> Result<f64> {
-//	let params = json!({
-//		"symbol": pair.to_string(),
-//	});
-//
-//	let r: MarkPriceResponse = client.get("/fapi/v1/premiumIndex", &params, [BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)]).await.unwrap();
-//	let price = r.index_price; // when using this framework, we care for per-exchange price, obviously
-//	Ok(price)
-//}
-//
-//#[serde_as]
-//#[derive(Debug, Serialize, Deserialize, Clone)]
-//#[serde(rename_all = "camelCase")]
-//pub struct MarkPriceResponse {
-//	pub symbol: String,
-//	#[serde_as(as = "DisplayFromStr")]
-//	pub mark_price: f64,
-//	#[serde_as(as = "DisplayFromStr")]
-//	pub index_price: f64,
-//	#[serde_as(as = "DisplayFromStr")]
-//	pub estimated_settle_price: f64,
-//	#[serde_as(as = "DisplayFromStr")]
-//	pub last_funding_rate: f64,
-//	pub next_funding_time: u64,
-//	pub time: u64,
-//}
-//
-////,}}}
-
 #[cfg(test)]
 mod tests {
 	#[test]
diff --git a/v_exchanges/src/binance/mod.rs b/v_exchanges/src/binance/mod.rs
@@ -2,8 +2,8 @@ mod futures;
 mod market;
 mod spot;
 use adapters::binance::BinanceOption;
-use color_eyre::eyre::Result;
 use derive_more::{Deref, DerefMut};
+use eyre::Result;
 use v_exchanges_adapters::Client;
 use v_utils::trades::{Asset, Pair, Timeframe};
 
@@ -19,16 +19,24 @@ impl Exchange for Binance {
 		self.update_default_option(BinanceOption::Secret(secret.into()));
 	}
 
-	async fn spot_klines(&self, symbol: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
-		market::klines(&self.0, symbol, tf, range, Market::Spot).await
+	async fn spot_klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
+		market::klines(&self.0, pair, tf, range, Market::Spot).await
 	}
 
-	async fn futures_klines(&self, symbol: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
-		market::klines(&self.0, symbol, tf, range, Market::Futures).await
+	async fn spot_prices(&self, pairs: Option<Vec<Pair>>) -> Result<Vec<(Pair, f64)>> {
+		spot::market::prices(&self.0, pairs).await
 	}
 
-	async fn futures_price(&self, symbol: Pair) -> Result<f64> {
-		futures::market::price(&self.0, symbol).await
+	async fn spot_price(&self, pair: Pair) -> Result<f64> {
+		spot::market::price(&self.0, pair).await
+	}
+
+	async fn futures_klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
+		market::klines(&self.0, pair, tf, range, Market::Futures).await
+	}
+
+	async fn futures_price(&self, pair: Pair) -> Result<f64> {
+		futures::market::price(&self.0, pair).await
 	}
 
 	async fn futures_asset_balance(&self, asset: Asset) -> Result<AssetBalance> {
diff --git a/v_exchanges/src/binance/spot/market.rs b/v_exchanges/src/binance/spot/market.rs
@@ -0,0 +1,61 @@
+use std::str::FromStr;
+
+use adapters::binance::{BinanceHttpUrl, BinanceOption};
+use eyre::Result;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use serde_with::{DisplayFromStr, serde_as};
+use tracing::instrument;
+use v_utils::trades::Pair;
+
+#[instrument]
+pub async fn prices(client: &v_exchanges_adapters::Client, pairs: Option<Vec<Pair>>) -> Result<Vec<(Pair, f64)>> {
+	let r: PricesResponse = match pairs {
+		//TODO!!!: fix this branch
+		//BUG: doesn't work for some reason
+		Some(pairs) => {
+			let params = json!({
+				"symbols": pairs.into_iter().map(|p| p.to_string()).collect::<Vec<String>>(),
+			});
+			dbg!(&params);
+			client.get("/api/v3/ticker/price", &params, [BinanceOption::HttpUrl(BinanceHttpUrl::Spot)]).await.unwrap()
+		}
+		None => client.get_no_query("/api/v3/ticker/price", [BinanceOption::HttpUrl(BinanceHttpUrl::Spot)]).await.unwrap(),
+	};
+
+	let mut prices = Vec::with_capacity(r.0.len());
+	for p in r.0.into_iter() {
+		match Pair::from_str(&p.symbol) {
+			Ok(pair) => {
+				prices.push((pair, p.price));
+			}
+			Err(e) => {
+				tracing::warn!("Failed to parse pair from string: {}", e);
+				continue;
+			}
+		};
+	}
+	Ok(prices)
+}
+
+pub async fn price(client: &v_exchanges_adapters::Client, pair: Pair) -> Result<f64> {
+	let params = json!({
+		"symbol": pair.to_string(),
+	});
+
+	let r: AssetPriceResponse = client.get("/api/v3/ticker/price", &params, [BinanceOption::HttpUrl(BinanceHttpUrl::Spot)]).await.unwrap();
+	let price = r.price;
+	Ok(price)
+}
+
+#[derive(Clone, Debug, Default, derive_new::new, Deserialize, Serialize)]
+struct PricesResponse(Vec<AssetPriceResponse>);
+
+#[serde_as]
+#[derive(Clone, Debug, Default, derive_new::new, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct AssetPriceResponse {
+	symbol: String,
+	#[serde_as(as = "DisplayFromStr")]
+	price: f64,
+}
diff --git a/v_exchanges/src/binance/spot/mod.rs b/v_exchanges/src/binance/spot/mod.rs
@@ -1 +1 @@
-//pub mod market;
+pub mod market;
diff --git a/v_exchanges/src/bybit/account.rs b/v_exchanges/src/bybit/account.rs
@@ -1,5 +1,4 @@
-
-use color_eyre::eyre::Result;
+use eyre::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use serde_with::{DisplayFromStr, serde_as};
diff --git a/v_exchanges/src/bybit/market.rs b/v_exchanges/src/bybit/market.rs
@@ -1,14 +1,11 @@
 use std::collections::VecDeque;
 
 use chrono::{DateTime, TimeZone};
-use color_eyre::eyre::Result;
+use eyre::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use serde_with::{DisplayFromStr, serde_as};
-use v_exchanges_adapters::{
-	bybit::BybitOption,
-	errors::LimitOutOfRangeError,
-};
+use v_exchanges_adapters::{bybit::BybitOption, errors::LimitOutOfRangeError};
 use v_utils::{
 	trades::{Kline, Ohlc, Pair, Timeframe},
 	utils::filter_nulls,
diff --git a/v_exchanges/src/bybit/mod.rs b/v_exchanges/src/bybit/mod.rs
@@ -2,8 +2,8 @@ mod account;
 mod market;
 
 use adapters::bybit::BybitOption;
-use color_eyre::eyre::Result;
 use derive_more::derive::{Deref, DerefMut};
+use eyre::Result;
 use v_exchanges_adapters::Client;
 use v_utils::trades::{Asset, Pair, Timeframe};
 
@@ -19,7 +19,15 @@ impl Exchange for Bybit {
 		self.update_default_option(BybitOption::Secret(secret.into()));
 	}
 
-	async fn spot_klines(&self, symbol: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
+	async fn spot_klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange) -> Result<Klines> {
+		todo!();
+	}
+
+	async fn spot_prices(&self, pairs: Option<Vec<Pair>>) -> Result<Vec<(Pair, f64)>> {
+		todo!();
+	}
+
+	async fn spot_price(&self, symbol: Pair) -> Result<f64> {
 		todo!();
 	}
 
diff --git a/v_exchanges/src/core.rs b/v_exchanges/src/core.rs
@@ -1,20 +1,23 @@
 use std::collections::VecDeque;
 
 use chrono::{DateTime, TimeDelta, Utc};
-use color_eyre::eyre::Result;
 use derive_more::{Deref, DerefMut};
+use eyre::{Report, Result};
 use v_utils::trades::{Asset, Kline, Pair, Timeframe};
 
 //TODO!!!!!!!!!!!!!: klines switch to defining the range via an Enum over either limit either start and end times
 
 pub trait Exchange {
 	fn auth<S: Into<String>>(&mut self, key: S, secret: S);
 
-	fn spot_klines(&self, symbol: Pair, tf: Timeframe, range: KlinesRequestRange) -> impl std::future::Future<Output = Result<Klines>> + Send;
+	fn spot_klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange) -> impl std::future::Future<Output = Result<Klines>> + Send;
+	fn spot_price(&self, pair: Pair) -> impl std::future::Future<Output = Result<f64>> + Send;
+	/// If no symbols are specified, returns all spot prices.
+	fn spot_prices(&self, pairs: Option<Vec<Pair>>) -> impl std::future::Future<Output = Result<Vec<(Pair, f64)>>> + Send;
 
 	//? 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, range: KlinesRequestRange) -> impl std::future::Future<Output = Result<Klines>> + Send;
-	fn futures_price(&self, symbol: Pair) -> impl std::future::Future<Output = Result<f64>> + Send;
+	fn futures_klines(&self, pair: Pair, tf: Timeframe, range: KlinesRequestRange) -> impl std::future::Future<Output = Result<Klines>> + Send;
+	fn futures_price(&self, pair: Pair) -> impl std::future::Future<Output = Result<f64>> + Send;
 
 	// Defined in terms of actors
 	//TODO!!!: fn spawn_klines_listener(&self, symbol: Pair, tf: Timeframe) -> mpsc::Receiver<Kline>;
@@ -63,7 +66,7 @@ impl Iterator for Klines {
 #[derive(Clone, Debug, Default)]
 pub struct FullKlines(Klines);
 impl TryFrom<Klines> for FullKlines {
-	type Error = color_eyre::eyre::Report;
+	type Error = Report;
 
 	fn try_from(value: Klines) -> Result<Self> {
 		todo!();
diff --git a/v_exchanges_adapters/src/lib.rs b/v_exchanges_adapters/src/lib.rs
@@ -68,7 +68,7 @@ impl Client {
 		O: HttpOption<'a, R, B>,
 		O::RequestHandler: RequestHandler<B>,
 		Self: GetOptions<O::Options>,
-		Q: Serialize + ?Sized, {
+		Q: Serialize + ?Sized + std::fmt::Debug, {
 		self.client.request(method, url, query, body, &O::request_handler(self.merged_options(options))).await
 	}
 
@@ -79,7 +79,7 @@ impl Client {
 		O: HttpOption<'a, R, ()>,
 		O::RequestHandler: RequestHandler<()>,
 		Self: GetOptions<O::Options>,
-		Q: Serialize + ?Sized, {
+		Q: Serialize + ?Sized + std::fmt::Debug, {
 		self.client.get(url, query, &O::request_handler(self.merged_options(options))).await
 	}
 
@@ -140,7 +140,7 @@ impl Client {
 		O: HttpOption<'a, R, ()>,
 		O::RequestHandler: RequestHandler<()>,
 		Self: GetOptions<O::Options>,
-		Q: Serialize + ?Sized, {
+		Q: Serialize + ?Sized + std::fmt::Debug, {
 		self.client.delete(url, query, &O::request_handler(self.merged_options(options))).await
 	}
 
diff --git a/v_exchanges_api_generics/src/http.rs b/v_exchanges_api_generics/src/http.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use color_eyre::eyre::Result;`
	`1`	`+use eyre::Result;`
`2`	`2`	`use serde::Deserialize;`
`3`	`3`	`use serde_with::{DisplayFromStr, serde_as};`
`4`	`4`	`use v_exchanges_adapters::binance::{BinanceAuth, BinanceHttpUrl, BinanceOption};`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`pub mod core;`
`2`		`-pub use core::*;`
`3`	`2`
`4`	`3`	`pub mod account;`
`5`	`4`	`pub mod general;`