Continue BitMEX adapter execution

Author: cjdsellers

crates/adapters/bitmex/bin/http.rs

@@ -13,18 +13,13 @@
 //  limitations under the License.
 // -------------------------------------------------------------------------------------------------
 
+// Under development
+#![allow(dead_code)]
+#![allow(unused_variables)]
+
 use std::env;
 
-use nautilus_bitmex::http::{
-    client::BitmexHttpClient,
-    parse::parse_instrument_any,
-    query::{
-        GetExecutionParamsBuilder, GetOrderParamsBuilder, GetPositionParamsBuilder,
-        GetTradeParamsBuilder,
-    },
-};
-use nautilus_core::time::get_atomic_clock_realtime;
-use nautilus_model::{identifiers::InstrumentId, instruments::any::InstrumentAny};
+use nautilus_bitmex::http::client::BitmexHttpClient;
 use tracing::level_filters::LevelFilter;
 
 #[tokio::main]
@@ -37,69 +32,5 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let api_secret = env::var("BITMEX_API_SECRET").expect("environment variable should be set");
     let client = BitmexHttpClient::new(None, Some(api_key), Some(api_secret), false, None);
 
-    match client.get_instruments(false).await {
-        Ok(resp) => {
-            tracing::debug!("{:?}", resp);
-            let ts_init = get_atomic_clock_realtime().get_time_ns();
-            let mut instruments: Vec<InstrumentAny> = Vec::new();
-            for def in resp {
-                tracing::debug!("Parsing {def:?}");
-                if let Some(inst) = parse_instrument_any(&def, ts_init) {
-                    instruments.push(inst);
-                } else {
-                    tracing::warn!(
-                        "Did not parse: symbol={}, type={}",
-                        def.symbol,
-                        def.instrument_type,
-                    );
-                }
-            }
-        }
-        Err(e) => tracing::error!("{e:?}"),
-    }
-
-    let instrument_id = InstrumentId::from("XBTUSD.BITMEX");
-
-    match client.get_instrument(&instrument_id.symbol).await {
-        Ok(resp) => tracing::debug!("{:?}", resp),
-        Err(e) => tracing::error!("{e:?}"),
-    }
-
-    let resp = client.get_wallet().await;
-    match resp {
-        Ok(instrument) => tracing::debug!("{:?}", instrument),
-        Err(e) => tracing::error!("{e:?}"),
-    }
-
-    let params = GetOrderParamsBuilder::default()
-        .symbol("XBTUSD".to_string())
-        .build()?;
-    match client.get_orders(params).await {
-        Ok(resp) => tracing::debug!("{:?}", resp),
-        Err(e) => tracing::error!("{e:?}"),
-    }
-
-    let params = GetTradeParamsBuilder::default()
-        .symbol("XBTUSD".to_string())
-        .build()?;
-    match client.get_trades(params).await {
-        Ok(resp) => tracing::debug!("{:?}", resp),
-        Err(e) => tracing::error!("{e:?}"),
-    }
-
-    let params = GetExecutionParamsBuilder::default()
-        .symbol("XBTUSD".to_string())
-        .build()?;
-    match client.get_executions(params).await {
-        Ok(resp) => tracing::debug!("{:?}", resp),
-        Err(e) => tracing::error!("{e:?}"),
-    }
-
-    let params = GetPositionParamsBuilder::default().build()?;
-    match client.get_positions(params).await {
-        Ok(resp) => tracing::debug!("{:?}", resp),
-        Err(e) => tracing::error!("{e:?}"),
-    }
-
     Ok(())
 }

crates/adapters/bitmex/bin/ws-data.rs

@@ -16,13 +16,9 @@
 use std::env;
 
 use futures_util::StreamExt;
-use nautilus_bitmex::{
-    http::{client::BitmexHttpClient, parse::parse_instrument_any},
-    websocket::client::BitmexWebSocketClient,
-};
-use nautilus_core::time::get_atomic_clock_realtime;
+use nautilus_bitmex::{http::client::BitmexHttpClient, websocket::client::BitmexWebSocketClient};
 use nautilus_model::{data::bar::BarType, identifiers::InstrumentId};
-use tokio::{pin, signal, time::Duration};
+use tokio::time::Duration;
 use tracing::level_filters::LevelFilter;
 
 #[tokio::main]
@@ -63,15 +59,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         Some(60), // timeout_secs
     );
 
-    let instruments_result = http_client
-        .get_instruments(true) // active_only
+    let instruments = http_client
+        .request_instruments(true) // active_only
         .await?;
 
-    let ts_init = get_atomic_clock_realtime().get_time_ns();
-    let instruments: Vec<_> = instruments_result
-        .iter()
-        .filter_map(|inst| parse_instrument_any(inst, ts_init))
-        .collect();
     tracing::info!("Fetched {} instruments", instruments.len());
 
     // Create WebSocket client
@@ -199,8 +190,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing::info!("Press CTRL+C to stop");
 
     // Create a future that completes on CTRL+C
-    let sigint = signal::ctrl_c();
-    pin!(sigint);
+    let sigint = tokio::signal::ctrl_c();
+    tokio::pin!(sigint);
 
     let stream = ws_client.stream();
     tokio::pin!(stream); // Pin the stream to allow polling in the loop

crates/adapters/bitmex/bin/ws-exec.rs

@@ -18,12 +18,8 @@
 #![allow(unused_variables)]
 
 use futures_util::StreamExt;
-use nautilus_bitmex::{
-    http::{client::BitmexHttpClient, parse::parse_instrument_any},
-    websocket::client::BitmexWebSocketClient,
-};
-use nautilus_core::time::get_atomic_clock_realtime;
-use tokio::{pin, signal, time::Duration};
+use nautilus_bitmex::{http::client::BitmexHttpClient, websocket::client::BitmexWebSocketClient};
+use tokio::time::Duration;
 use tracing::level_filters::LevelFilter;
 
 #[tokio::main]
@@ -41,15 +37,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         Some(60), // timeout_secs
     );
 
-    let instruments_result = http_client
-        .get_instruments(true) // active_only
+    let instruments = http_client
+        .request_instruments(true) // active_only
         .await?;
 
-    let ts_init = get_atomic_clock_realtime().get_time_ns();
-    let instruments: Vec<_> = instruments_result
-        .iter()
-        .filter_map(|inst| parse_instrument_any(inst, ts_init))
-        .collect();
     tracing::info!("Fetched {} instruments", instruments.len());
 
     let mut ws_client = BitmexWebSocketClient::new(
@@ -78,8 +69,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .await?;
 
     // Create a future that completes on CTRL+C
-    let sigint = signal::ctrl_c();
-    pin!(sigint);
+    let sigint = tokio::signal::ctrl_c();
+    tokio::pin!(sigint);
 
     let stream = ws_client.stream();
     tokio::pin!(stream); // Pin the stream to allow polling in the loop