Continue Binance adapter in Rust

Author: cjdsellers

Cargo.lock

@@ -91,6 +91,7 @@ pyo3-async-runtimes = { workspace = true, optional = true }
 nautilus-testkit = { workspace = true }
 
 criterion = { workspace = true }
+dotenvy = { workspace = true }
 rstest = { workspace = true }
 rust_decimal_macros = { workspace = true }
 url = { workspace = true }
@@ -105,3 +106,8 @@ doc = false
 name = "binance-spot-ws-data"
 path = "bin/ws_spot_data.rs"
 doc = false
+
+[[example]]
+name = "binance-data-tester"
+path = "examples/node_data_tester.rs"
+doc = false

crates/adapters/binance/Cargo.toml

@@ -0,0 +1,77 @@
+// -------------------------------------------------------------------------------------------------
+//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
+//  https://nautechsystems.io
+//
+//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
+//  You may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+// -------------------------------------------------------------------------------------------------
+
+//! Example demonstrating live data testing with the Binance Spot SBE adapter.
+//!
+//! Run with: `cargo run --example binance-data-tester --package nautilus-binance`
+
+use std::num::NonZeroUsize;
+
+use nautilus_binance::{
+    common::enums::{BinanceEnvironment, BinanceProductType},
+    config::BinanceDataClientConfig,
+    factories::BinanceDataClientFactory,
+};
+use nautilus_common::enums::Environment;
+use nautilus_live::node::LiveNode;
+use nautilus_model::{
+    identifiers::{ClientId, InstrumentId, TraderId},
+    stubs::TestDefault,
+};
+use nautilus_testkit::testers::{DataTester, DataTesterConfig};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    dotenvy::dotenv().ok();
+
+    let environment = Environment::Live;
+    let trader_id = TraderId::test_default();
+    let node_name = "BINANCE-TESTER-001".to_string();
+    let instrument_ids = vec![
+        InstrumentId::from("BTCUSDT.BINANCE"),
+        // InstrumentId::from("ETHUSDT.BINANCE"),
+    ];
+
+    // SBE streams require Ed25519 authentication (not HMAC)
+    // Generate Ed25519 keys in your Binance account API settings
+    let binance_config = BinanceDataClientConfig {
+        product_types: vec![BinanceProductType::Spot],
+        environment: BinanceEnvironment::Mainnet,
+        api_key: None,    // HMAC key for HTTP API (optional)
+        api_secret: None, // HMAC secret for HTTP API (optional)
+        ed25519_api_key: std::env::var("BINANCE_ED25519_API_KEY").ok(),
+        ed25519_api_secret: std::env::var("BINANCE_ED25519_API_SECRET").ok(),
+        ..Default::default()
+    };
+
+    let client_factory = BinanceDataClientFactory::new();
+    let client_id = ClientId::new("BINANCE");
+
+    let mut node = LiveNode::builder(trader_id, environment)?
+        .with_name(node_name)
+        .with_delay_post_stop_secs(2)
+        .add_data_client(None, Box::new(client_factory), Box::new(binance_config))?
+        .build()?;
+
+    let tester_config = DataTesterConfig::new(client_id, instrument_ids)
+        .with_subscribe_book_at_interval(true)
+        .with_book_interval_ms(NonZeroUsize::new(10).unwrap());
+    let tester = DataTester::new(tester_config);
+
+    node.add_actor(tester)?;
+    node.run().await?;
+
+    Ok(())
+}

crates/adapters/binance/examples/node_data_tester.rs

@@ -563,6 +563,31 @@ pub enum BinanceKlineInterval {
     Month1,
 }
 
+impl BinanceKlineInterval {
+    /// Returns the string representation used by Binance API.
+    #[must_use]
+    pub const fn as_str(&self) -> &'static str {
+        match self {
+            Self::Second1 => "1s",
+            Self::Minute1 => "1m",
+            Self::Minute3 => "3m",
+            Self::Minute5 => "5m",
+            Self::Minute15 => "15m",
+            Self::Minute30 => "30m",
+            Self::Hour1 => "1h",
+            Self::Hour2 => "2h",
+            Self::Hour4 => "4h",
+            Self::Hour6 => "6h",
+            Self::Hour8 => "8h",
+            Self::Hour12 => "12h",
+            Self::Day1 => "1d",
+            Self::Day3 => "3d",
+            Self::Week1 => "1w",
+            Self::Month1 => "1M",
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use rstest::rstest;

crates/adapters/binance/src/common/enums.rs

@@ -23,9 +23,10 @@ use std::str::FromStr;
 use anyhow::Context;
 use nautilus_core::nanos::UnixNanos;
 use nautilus_model::{
-    data::{Bar, BarType, TradeTick},
+    data::{Bar, BarSpecification, BarType, TradeTick},
     enums::{
-        AggressorSide, LiquiditySide, OrderSide, OrderStatus, OrderType, TimeInForce, TriggerType,
+        AggressorSide, BarAggregation, LiquiditySide, OrderSide, OrderStatus, OrderType,
+        TimeInForce, TriggerType,
     },
     identifiers::{
         AccountId, ClientOrderId, InstrumentId, OrderListId, Symbol, TradeId, Venue, VenueOrderId,
@@ -42,7 +43,7 @@ use serde_json::Value;
 
 use crate::{
     common::{
-        enums::BinanceContractStatus,
+        enums::{BinanceContractStatus, BinanceKlineInterval},
         fixed::{mantissa_to_price, mantissa_to_quantity},
         sbe::spot::{
             order_side::OrderSide as SbeOrderSide, order_status::OrderStatus as SbeOrderStatus,
@@ -875,6 +876,56 @@ pub fn parse_klines_to_bars(
     Ok(bars)
 }
 
+/// Converts a Nautilus bar specification to a Binance kline interval.
+///
+/// # Errors
+///
+/// Returns an error if the bar specification does not map to a supported
+/// Binance kline interval.
+pub fn bar_spec_to_binance_interval(
+    bar_spec: BarSpecification,
+) -> anyhow::Result<BinanceKlineInterval> {
+    let step = bar_spec.step.get();
+    let interval = match bar_spec.aggregation {
+        BarAggregation::Second => {
+            anyhow::bail!("Binance Spot does not support second-level kline intervals")
+        }
+        BarAggregation::Minute => match step {
+            1 => BinanceKlineInterval::Minute1,
+            3 => BinanceKlineInterval::Minute3,
+            5 => BinanceKlineInterval::Minute5,
+            15 => BinanceKlineInterval::Minute15,
+            30 => BinanceKlineInterval::Minute30,
+            _ => anyhow::bail!("Unsupported minute interval: {step}m"),
+        },
+        BarAggregation::Hour => match step {
+            1 => BinanceKlineInterval::Hour1,
+            2 => BinanceKlineInterval::Hour2,
+            4 => BinanceKlineInterval::Hour4,
+            6 => BinanceKlineInterval::Hour6,
+            8 => BinanceKlineInterval::Hour8,
+            12 => BinanceKlineInterval::Hour12,
+            _ => anyhow::bail!("Unsupported hour interval: {step}h"),
+        },
+        BarAggregation::Day => match step {
+            1 => BinanceKlineInterval::Day1,
+            3 => BinanceKlineInterval::Day3,
+            _ => anyhow::bail!("Unsupported day interval: {step}d"),
+        },
+        BarAggregation::Week => match step {
+            1 => BinanceKlineInterval::Week1,
+            _ => anyhow::bail!("Unsupported week interval: {step}w"),
+        },
+        BarAggregation::Month => match step {
+            1 => BinanceKlineInterval::Month1,
+            _ => anyhow::bail!("Unsupported month interval: {step}M"),
+        },
+        agg => anyhow::bail!("Unsupported bar aggregation for Binance: {agg:?}"),
+    };
+
+    Ok(interval)
+}
+
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
@@ -986,4 +1037,89 @@ mod tests {
                 .contains("Missing PRICE_FILTER")
         );
     }
+
+    mod bar_spec_tests {
+        use std::num::NonZeroUsize;
+
+        use nautilus_model::{
+            data::BarSpecification,
+            enums::{BarAggregation, PriceType},
+        };
+
+        use super::*;
+        use crate::common::enums::BinanceKlineInterval;
+
+        fn make_bar_spec(step: usize, aggregation: BarAggregation) -> BarSpecification {
+            BarSpecification {
+                step: NonZeroUsize::new(step).unwrap(),
+                aggregation,
+                price_type: PriceType::Last,
+            }
+        }
+
+        #[rstest]
+        #[case(1, BarAggregation::Minute, BinanceKlineInterval::Minute1)]
+        #[case(3, BarAggregation::Minute, BinanceKlineInterval::Minute3)]
+        #[case(5, BarAggregation::Minute, BinanceKlineInterval::Minute5)]
+        #[case(15, BarAggregation::Minute, BinanceKlineInterval::Minute15)]
+        #[case(30, BarAggregation::Minute, BinanceKlineInterval::Minute30)]
+        #[case(1, BarAggregation::Hour, BinanceKlineInterval::Hour1)]
+        #[case(2, BarAggregation::Hour, BinanceKlineInterval::Hour2)]
+        #[case(4, BarAggregation::Hour, BinanceKlineInterval::Hour4)]
+        #[case(6, BarAggregation::Hour, BinanceKlineInterval::Hour6)]
+        #[case(8, BarAggregation::Hour, BinanceKlineInterval::Hour8)]
+        #[case(12, BarAggregation::Hour, BinanceKlineInterval::Hour12)]
+        #[case(1, BarAggregation::Day, BinanceKlineInterval::Day1)]
+        #[case(3, BarAggregation::Day, BinanceKlineInterval::Day3)]
+        #[case(1, BarAggregation::Week, BinanceKlineInterval::Week1)]
+        #[case(1, BarAggregation::Month, BinanceKlineInterval::Month1)]
+        fn test_bar_spec_to_binance_interval(
+            #[case] step: usize,
+            #[case] aggregation: BarAggregation,
+            #[case] expected: BinanceKlineInterval,
+        ) {
+            let bar_spec = make_bar_spec(step, aggregation);
+            let result = bar_spec_to_binance_interval(bar_spec).unwrap();
+            assert_eq!(result, expected);
+        }
+
+        #[rstest]
+        fn test_unsupported_second_interval() {
+            let bar_spec = make_bar_spec(1, BarAggregation::Second);
+            let result = bar_spec_to_binance_interval(bar_spec);
+            assert!(result.is_err());
+            assert!(
+                result
+                    .unwrap_err()
+                    .to_string()
+                    .contains("does not support second-level")
+            );
+        }
+
+        #[rstest]
+        fn test_unsupported_minute_interval() {
+            let bar_spec = make_bar_spec(7, BarAggregation::Minute);
+            let result = bar_spec_to_binance_interval(bar_spec);
+            assert!(result.is_err());
+            assert!(
+                result
+                    .unwrap_err()
+                    .to_string()
+                    .contains("Unsupported minute interval")
+            );
+        }
+
+        #[rstest]
+        fn test_unsupported_aggregation() {
+            let bar_spec = make_bar_spec(100, BarAggregation::Tick);
+            let result = bar_spec_to_binance_interval(bar_spec);
+            assert!(result.is_err());
+            assert!(
+                result
+                    .unwrap_err()
+                    .to_string()
+                    .contains("Unsupported bar aggregation")
+            );
+        }
+    }
 }

crates/adapters/binance/src/common/parse.rs

@@ -15,6 +15,10 @@
 
 //! Binance adapter configuration structures.
 
+use std::any::Any;
+
+use nautilus_system::factories::ClientConfig;
+
 use crate::common::enums::{BinanceEnvironment, BinanceProductType};
 
 /// Configuration for Binance data client.
@@ -28,10 +32,14 @@ pub struct BinanceDataClientConfig {
     pub base_url_http: Option<String>,
     /// Optional base URL override for WebSocket.
     pub base_url_ws: Option<String>,
-    /// API key for authenticated endpoints.
+    /// API key for HTTP authenticated endpoints (HMAC).
     pub api_key: Option<String>,
-    /// API secret for request signing.
+    /// API secret for HTTP request signing (HMAC).
     pub api_secret: Option<String>,
+    /// Ed25519 API key for SBE WebSocket streams (required for SBE).
+    pub ed25519_api_key: Option<String>,
+    /// Ed25519 private key (base64) for SBE WebSocket streams (required for SBE).
+    pub ed25519_api_secret: Option<String>,
 }
 
 impl Default for BinanceDataClientConfig {
@@ -43,10 +51,18 @@ impl Default for BinanceDataClientConfig {
             base_url_ws: None,
             api_key: None,
             api_secret: None,
+            ed25519_api_key: None,
+            ed25519_api_secret: None,
         }
     }
 }
 
+impl ClientConfig for BinanceDataClientConfig {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
 /// Configuration for Binance execution client.
 #[derive(Clone, Debug)]
 pub struct BinanceExecClientConfig {
@@ -63,3 +79,9 @@ pub struct BinanceExecClientConfig {
     /// API secret for request signing (required).
     pub api_secret: String,
 }
+
+impl ClientConfig for BinanceExecClientConfig {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}