docs: _

Author: valeratrades

Cargo.lock

@@ -29,3 +29,7 @@ Implementation of each exchange's interactions, consists of blocks for
 #### models
 any models shared across different markets (futures, spot, margin, etc), are defined in well a shared `models/` directory at the root of associated exchange's directory. Say if `KlinesResponse` matches for
 `/binance/futures/market.rs` and `/binance/spot/market.rs`, the model is defined and exported from `/binance/models/market.rs`
+
+
+#### data endpoints
+Some exchanges provide specialized `data` endpoints. Those can't be part of `Exchange` trait, but then I just trivially expose them natively on the associated structs of each exchange, without any traits whatsoever. 

docs/ARCHITECTURE.md

@@ -1,7 +1,6 @@
 use std::env;
 
 use v_exchanges::{binance::Binance, core::Exchange};
-use v_exchanges_adapters::binance::{BinanceHttpUrl, BinanceOption};
 
 #[tokio::main]
 async fn main() {
@@ -10,8 +9,6 @@ async fn main() {
 
 	let mut bn = Binance::default();
 
-	bn.update_default_option(BinanceOption::HttpUrl(BinanceHttpUrl::FuturesUsdM));
-
 	let klines = bn.futures_klines(("BTC", "USDT").into(), "1m".into(), 2.into()).await.unwrap();
 	let price = bn.futures_price(("BTC", "USDT").into()).await.unwrap();
 	dbg!(&klines, price);

examples/binance/market_futures.rs

@@ -1,13 +1,10 @@
 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 bn = Binance::default();
 
 	let spot_klines = bn.spot_klines(("BTC", "USDT").into(), "1m".into(), 2.into()).await.unwrap();
 	dbg!(&spot_klines);

examples/binance/market_spot.rs

@@ -8,7 +8,7 @@ use serde_with::{DisplayFromStr, serde_as};
 use tracing::instrument;
 use v_utils::trades::Pair;
 
-#[instrument]
+#[instrument(skip_all, fields(?pairs))]
 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

v_exchanges/src/binance/spot/market.rs

@@ -171,6 +171,8 @@ where
 		config
 	}
 
+	//XXX: could print creds
+	#[tracing::instrument(skip_all, fields(?builder))]
 	fn build_request(&self, mut builder: RequestBuilder, request_body: &Option<B>, _: u8) -> Result<Request, Self::BuildError> {
 		if let Some(body) = request_body {
 			let encoded = serde_urlencoded::to_string(body).or(Err("could not serialize body as application/x-www-form-urlencoded"))?;

v_exchanges_adapters/src/exchanges/binance.rs

@@ -34,7 +34,7 @@ impl Client {
 	///
 	/// The request is passed to `handler` before being sent, and the response is passed to `handler` before being returned.
 	/// Note, that as stated in the docs for [RequestBuilder::query()], parameter `query` only accepts a **sequence of** key-value pairs.
-	#[instrument(skip_all, fields(?url, request_builder = Empty))] //TODO: get all generics to impl std::fmt::Debug
+	#[instrument(skip_all, fields(?url, ?query, request_builder = Empty))] //TODO: get all generics to impl std::fmt::Debug
 	pub async fn request<Q, B, H>(&self, method: Method, url: &str, query: Option<&Q>, body: Option<B>, handler: &H) -> Result<H::Successful, RequestError<H::BuildError, H::Unsuccessful>>
 	where
 		Q: Serialize + ?Sized + std::fmt::Debug,
@@ -43,18 +43,15 @@ impl Client {
 		config.verify();
 
 		let url = config.url_prefix + url;
-		dbg!(&url);
 
 		for i in 1..=config.max_try {
 			//HACK: hate to create a new request every time, but I haven't yet figured out how to provide by reference
 			let mut request_builder = self.client.request(method.clone(), url.clone()).timeout(config.timeout);
-			dbg!(&query);
 			if let Some(query) = query {
 				request_builder = request_builder.query(query);
 			}
 			Span::current().record("request_builder", format!("{:?}", request_builder));
 
-			dbg!(&request_builder);
 			let request = handler.build_request(request_builder, &body, i).map_err(RequestError::BuildRequestError)?;
 			match self.client.execute(request).await {
 				Ok(mut response) => {