fix: _

Author: valeratrades

v_exchanges/src/main.rs

@@ -1,3 +1,5 @@
+use std::env;
+
 use v_exchanges_adapters::binance::{BinanceHttpUrl, BinanceOption};
 use v_exchanges_deser::{binance::Client, core::Exchange};
 
@@ -7,8 +9,16 @@ async fn main() {
 	v_utils::utils::init_subscriber(v_utils::utils::LogDestination::xdg("v_exchanges"));
 
 	let mut client = Client::new();
-	client.update_default_option(BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM));
-
+	//client.update_default_option(BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM));
 	let klines = client.klines(("BTC", "USDT").into(), "1m".into(), None, None, None).await.unwrap();
+	//let price = client.price(("BTC", "USDT").into()).await.unwrap();
 	dbg!(&klines);
+
+	//let key = env::var("BINANCE_TIGER_READ_KEY").unwrap();
+	//let secret = env::var("BINANCE_TIGER_READ_SECRET").unwrap();
+	//client.update_default_option(BinanceOption::Key(key));
+	//client.update_default_option(BinanceOption::Secret(secret));
+	//let balance = client.futures_balance("USDT").await.unwrap();
+	//
+	//dbg!(&balance);
 }

v_exchanges_deser/src/binance/futures/account.rs

@@ -0,0 +1,22 @@
+use color_eyre::eyre::Result;
+use serde::Deserialize;
+use v_exchanges_adapters::binance::{BinanceHttpUrl, BinanceOption};
+use v_utils::trades::{Kline, Ohlc, Pair, Timeframe};
+
+//TODO: make a Coin type
+pub async fn futures_balance(client: &v_exchanges_adapters::Client, asset: &str) -> Result<f64> {
+	#[derive(serde::Serialize)]
+	pub struct BalanceParams {
+		pub asset: String,
+	}
+	let mut params = BalanceParams { asset: asset.to_string() };
+
+	let r: AccountResponse = client.get("/fapi/v2/balance", Some(&params), [BinanceOption::Default]).await.unwrap();
+	let balance = r.balance;
+	Ok(balance)
+}
+
+#[derive(Clone, Debug, Default, derive_new::new, Deserialize)]
+struct AccountResponse {
+	pub balance: f64,
+}

v_exchanges_deser/src/binance/futures/market.rs

@@ -4,11 +4,12 @@ use color_eyre::eyre::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use serde_with::{DisplayFromStr, serde_as};
-use v_exchanges_adapters::binance::BinanceOption;
+use v_exchanges_adapters::binance::{BinanceHttpUrl, BinanceOption};
 use v_utils::trades::{Kline, Ohlc, Pair, Timeframe};
 
-use crate::{binance::futures::core::*, core::Klines};
+use crate::core::Klines;
 
+// klines {{{
 pub async fn klines(client: &v_exchanges_adapters::Client, pair: Pair, tf: Timeframe, limit: Option<u32>, start_time: Option<u64>, end_time: Option<u64>) -> Result<Klines> {
 	#[derive(Serialize)]
 	pub struct KlineParams {
@@ -30,7 +31,7 @@ pub async fn klines(client: &v_exchanges_adapters::Client, pair: Pair, tf: Timef
 		end_time,
 	};
 
-	let kline_responses: Vec<KlineResponse> = client.get("/fapi/v1/klines", Some(&params), [BinanceOption::Default]).await.unwrap();
+	let kline_responses: Vec<KlineResponse> = client.get("/fapi/v1/klines", Some(&params), [BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM)]).await.unwrap();
 	let klines: Vec<Kline> = kline_responses.into_iter().map(Kline::from).collect();
 
 	Ok(Klines { v: klines, tf, oi: Vec::new() })
@@ -84,11 +85,45 @@ impl From<KlineResponse> for Kline {
 		}
 	}
 }
+//,}}}
+
+// 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> {
+	#[derive(Serialize)]
+	pub struct PriceParams {
+		pub symbol: String,
+	}
+	let mut params = PriceParams { symbol: pair.to_string() };
+
+	let r: MarkPriceResponse = client.get("/fapi/v1/premiumIndex", Some(&params), [BinanceOption::Default]).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]
-	fn kline_core() {
+	fn klines() {
 		let raw_str = "[1731448080000,\"88591.90\",\"88630.90\",\"88560.00\",\"88574.10\",\"173.581\",1731448139999,\"15378315.48720\",2800,\"113.654\",\"10069629.84420\",\"0\"]";
 		let _: super::Kline = serde_json::from_str(raw_str).unwrap();
 	}

v_exchanges_deser/src/binance/futures/mod.rs

@@ -1,5 +1,6 @@
 mod core;
 pub use core::*;
 
+pub mod account;
 pub mod general;
 pub mod market;

v_exchanges_deser/src/binance/mod.rs

@@ -1,14 +1,21 @@
 pub mod futures;
 use color_eyre::eyre::Result;
-use futures::market::klines;
+use futures::market::{klines, price};
 pub use v_exchanges_adapters::Client; // re-export
 use v_exchanges_adapters::binance;
 use v_utils::trades::{Pair, Timeframe};
 
 use crate::core::{Exchange, Klines};
 
+//? 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<binance::BinanceOptions> for Client {
 	async fn klines(&self, symbol: Pair, tf: Timeframe, limit: Option<u32>, start_time: Option<u64>, end_time: Option<u64>) -> Result<Klines> {
 		klines(&self, symbol, tf, limit, start_time, end_time).await
 	}
+
+	async fn price(&self, symbol: Pair) -> Result<f64> {
+		price(&self, symbol).await
+	}
+
+	//DO: async fn balance(&self,
 }

v_exchanges_deser/src/core.rs

@@ -22,6 +22,14 @@ pub struct Klines {
 pub trait Exchange<O: HandlerOptions> {
 	//? 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 klines(&self, symbol: Pair, tf: Timeframe, limit: Option<u32>, start_time: Option<u64>, end_time: Option<u64>) -> impl std::future::Future<Output = Result<Klines>> + Send;
+	fn price(&self, symbol: 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>;
+
+	//DO: balances
+	// balances are defined for each margin type: [futures_balance, spot_balance, margin_balance], but note that on some exchanges, (like bybit), some of these may point to the same exact call
+	// to negate confusion could add a `total_balance` endpoint
+
+	//? could implement many things that are _explicitly_ combinatorial. I can imagine several cases, where knowing that say the specified limit for the klines is wayyy over the max and that you may be opting into a long wait by calling it, could be useful.
 }