Port RiskEngine to Rust (#2035)

nautechsystems · Nov 12, 2024 · 78fdd19 · 78fdd19
1 parent 9e26d37
commit 78fdd19
Show file tree

Hide file tree

Showing 11 changed files with 3,961 additions and 73 deletions.
diff --git a/nautilus_core/adapters/src/tardis/http/client.rs b/nautilus_core/adapters/src/tardis/http/client.rs
@@ -84,8 +84,8 @@ impl TardisHttpClient {
         Ok(Self {
             base_url,
             api_key,
-            normalize_symbols,
             client,
+            normalize_symbols,
         })
     }
 

diff --git a/nautilus_core/common/src/msgbus/mod.rs b/nautilus_core/common/src/msgbus/mod.rs
@@ -552,7 +552,7 @@ mod tests {
         let handler = get_call_check_shareable_handler(None);
 
         msgbus.register(endpoint, handler.clone());
-        assert!(msgbus.get_endpoint(&endpoint).is_some());
+        assert!(msgbus.get_endpoint(endpoint).is_some());
         assert!(!check_handler_was_called(handler.clone()));
 
         // Send a message to the endpoint

diff --git a/nautilus_core/common/src/throttler/callbacks.rs b/nautilus_core/common/src/throttler/callbacks.rs
@@ -30,7 +30,11 @@ impl<T, F> ThrottlerResume<T, F> {
     }
 }
 
-impl<T: 'static, F: Fn(T) + 'static> From<ThrottlerResume<T, F>> for TimeEventCallback {
+impl<T, F> From<ThrottlerResume<T, F>> for TimeEventCallback
+where
+    T: 'static,
+    F: Fn(T) + 'static,
+{
     fn from(value: ThrottlerResume<T, F>) -> Self {
         Self::Rust(Rc::new(move |_event: TimeEvent| {
             value.inner.borrow_mut().is_limiting = false;
@@ -51,7 +55,11 @@ impl<T, F> ThrottlerProcess<T, F> {
     }
 }
 
-impl<T: 'static, F: Fn(T) + 'static> From<ThrottlerProcess<T, F>> for TimeEventCallback {
+impl<T, F> From<ThrottlerProcess<T, F>> for TimeEventCallback
+where
+    T: 'static,
+    F: Fn(T) + 'static,
+{
     fn from(value: ThrottlerProcess<T, F>) -> Self {
         Self::Rust(Rc::new(move |_event: TimeEvent| {
             let process_clone = ThrottlerProcess {

diff --git a/nautilus_core/common/src/throttler/inner.rs b/nautilus_core/common/src/throttler/inner.rs
@@ -160,8 +160,8 @@ impl<T, F> InnerThrottler<T, F> {
 
 impl<T, F> InnerThrottler<T, F>
 where
-    F: Fn(T) + 'static,
     T: 'static,
+    F: Fn(T) + 'static,
 {
     #[inline]
     pub fn send_msg(&mut self, msg: T) {

diff --git a/nautilus_core/common/src/throttler/mod.rs b/nautilus_core/common/src/throttler/mod.rs
@@ -24,6 +24,7 @@ use inner::InnerThrottler;
 use crate::clock::Clock;
 
 /// Represents a throttling limit per interval.
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RateLimit {
     pub limit: usize,
     pub interval_ns: u64,
@@ -100,8 +101,8 @@ impl<T, F> Throttler<T, F> {
 
 impl<T, F> Throttler<T, F>
 where
-    F: Fn(T) + 'static,
     T: 'static,
+    F: Fn(T) + 'static,
 {
     pub fn send(&self, msg: T) {
         let throttler_clone = Self {

diff --git a/nautilus_core/model/src/data/stubs.rs b/nautilus_core/model/src/data/stubs.rs
@@ -299,6 +299,19 @@ pub fn quote_ethusdt_binance() -> QuoteTick {
     }
 }
 
+#[fixture]
+pub fn quote_audusd() -> QuoteTick {
+    QuoteTick {
+        instrument_id: InstrumentId::from("AUD/USD.SIM"),
+        bid_price: Price::from("100.0000"),
+        ask_price: Price::from("101.0000"),
+        bid_size: Quantity::from("1.00000000"),
+        ask_size: Quantity::from("1.00000000"),
+        ts_event: UnixNanos::default(),
+        ts_init: UnixNanos::from(1),
+    }
+}
+
 #[fixture]
 pub fn stub_trade_ethusdt_buyer() -> TradeTick {
     TradeTick {

diff --git a/nautilus_core/model/src/instruments/any.rs b/nautilus_core/model/src/instruments/any.rs
@@ -285,6 +285,66 @@ impl InstrumentAny {
         }
     }
 
+    pub fn max_quantity(&self) -> Option<Quantity> {
+        match self {
+            Self::Betting(inst) => inst.max_quantity(),
+            Self::BinaryOption(inst) => inst.max_quantity(),
+            Self::CryptoFuture(inst) => inst.max_quantity(),
+            Self::CryptoPerpetual(inst) => inst.max_quantity(),
+            Self::CurrencyPair(inst) => inst.max_quantity(),
+            Self::Equity(inst) => inst.max_quantity(),
+            Self::FuturesContract(inst) => inst.max_quantity(),
+            Self::FuturesSpread(inst) => inst.max_quantity(),
+            Self::OptionsContract(inst) => inst.max_quantity(),
+            Self::OptionsSpread(inst) => inst.max_quantity(),
+        }
+    }
+
+    pub fn min_quantity(&self) -> Option<Quantity> {
+        match self {
+            Self::Betting(inst) => inst.min_quantity(),
+            Self::BinaryOption(inst) => inst.min_quantity(),
+            Self::CryptoFuture(inst) => inst.min_quantity(),
+            Self::CryptoPerpetual(inst) => inst.min_quantity(),
+            Self::CurrencyPair(inst) => inst.min_quantity(),
+            Self::Equity(inst) => inst.min_quantity(),
+            Self::FuturesContract(inst) => inst.min_quantity(),
+            Self::FuturesSpread(inst) => inst.min_quantity(),
+            Self::OptionsContract(inst) => inst.min_quantity(),
+            Self::OptionsSpread(inst) => inst.min_quantity(),
+        }
+    }
+
+    pub fn max_notional(&self) -> Option<Money> {
+        match self {
+            Self::Betting(inst) => inst.max_notional(),
+            Self::BinaryOption(inst) => inst.max_notional(),
+            Self::CryptoFuture(inst) => inst.max_notional(),
+            Self::CryptoPerpetual(inst) => inst.max_notional(),
+            Self::CurrencyPair(inst) => inst.max_notional(),
+            Self::Equity(inst) => inst.max_notional(),
+            Self::FuturesContract(inst) => inst.max_notional(),
+            Self::FuturesSpread(inst) => inst.max_notional(),
+            Self::OptionsContract(inst) => inst.max_notional(),
+            Self::OptionsSpread(inst) => inst.max_notional(),
+        }
+    }
+
+    pub fn min_notional(&self) -> Option<Money> {
+        match self {
+            Self::Betting(inst) => inst.min_notional(),
+            Self::BinaryOption(inst) => inst.min_notional(),
+            Self::CryptoFuture(inst) => inst.min_notional(),
+            Self::CryptoPerpetual(inst) => inst.min_notional(),
+            Self::CurrencyPair(inst) => inst.min_notional(),
+            Self::Equity(inst) => inst.min_notional(),
+            Self::FuturesContract(inst) => inst.min_notional(),
+            Self::FuturesSpread(inst) => inst.min_notional(),
+            Self::OptionsContract(inst) => inst.min_notional(),
+            Self::OptionsSpread(inst) => inst.min_notional(),
+        }
+    }
+
     pub fn make_price(&self, value: f64) -> Price {
         match self {
             Self::Betting(inst) => inst.make_price(value),

diff --git a/nautilus_core/model/src/orders/any.rs b/nautilus_core/model/src/orders/any.rs
@@ -56,6 +56,12 @@ pub enum OrderAny {
     TrailingStopMarket(TrailingStopMarketOrder),
 }
 
+impl Default for OrderAny {
+    fn default() -> Self {
+        Self::Limit(LimitOrder::default())
+    }
+}
+
 impl OrderAny {
     /// Applies the given `event` to the order.
     pub fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError> {

diff --git a/nautilus_core/risk/src/engine/config.rs b/nautilus_core/risk/src/engine/config.rs
@@ -22,6 +22,7 @@ use nautilus_core::datetime::NANOSECONDS_IN_SECOND;
 use nautilus_model::identifiers::InstrumentId;
 use rust_decimal::Decimal;
 
+#[derive(Debug)]
 /// Configuration for `RiskEngineConfig` instances.
 pub struct RiskEngineConfig {
     pub bypass: bool,