Merge pull request #379 from purefinance/sync

Implemented stop-loss orders for Binance

core/src/balance/changes/tests/calculator_tests_base.rs

@@ -6,9 +6,9 @@ pub mod tests {
     use mmb_domain::exchanges::symbol::{Precision, Symbol};
     use mmb_domain::market::{CurrencyCode, CurrencyPair, ExchangeAccountId};
     use mmb_domain::order::fill::{OrderFill, OrderFillType};
-    use mmb_domain::order::snapshot::{Amount, Price};
+    use mmb_domain::order::snapshot::{Amount, OrderOptions, Price};
     use mmb_domain::order::snapshot::{
-        ClientOrderFillId, ClientOrderId, OrderFillRole, OrderSide, OrderSnapshot, OrderType,
+        ClientOrderFillId, ClientOrderId, OrderFillRole, OrderSide, OrderSnapshot,
     };
     use mmb_utils::cancellation_token::CancellationToken;
     use mmb_utils::hashmap;
@@ -270,11 +270,10 @@ pub mod tests {
         ) -> OrderSnapshot {
             let mut order = OrderSnapshot::with_params(
                 ClientOrderId::unique_id(),
-                OrderType::Limit,
+                OrderOptions::limit(price),
                 None,
                 exchange_account_id,
                 currency_pair,
-                Some(price),
                 amount,
                 trade_side,
                 None,

core/src/balance/manager/balance_manager.rs

@@ -466,25 +466,19 @@ impl BalanceManager {
         if let Some(orders_to_subtract) = orders {
             let mut applied_orders = HashSet::new();
             for order in orders_to_subtract {
-                let (order_type, client_order_id, reservation_id, status) = order.fn_ref(|x| {
-                    (
-                        x.header.order_type,
-                        x.header.client_order_id.clone(),
-                        x.header.reservation_id,
-                        x.props.status,
-                    )
-                });
+                let client_order_id = order.client_order_id();
 
+                let status = order.status();
                 if status.is_finished() || status == OrderStatus::Creating {
                     continue;
                 }
 
-                if order_type == OrderType::Market {
+                if order.header().order_type == OrderType::Market {
                     bail!("Clone doesn't support market orders because we need to know the price")
                 }
 
                 if applied_orders.insert(client_order_id.clone()) {
-                    let reservation_id = match reservation_id {
+                    let reservation_id = match order.header().reservation_id {
                         Some(reservation_id) => reservation_id,
                         None => continue,
                     };

core/src/balance/manager/tests/balance_manager_base.rs

@@ -13,10 +13,9 @@ use itertools::Itertools;
 use mmb_domain::events::{ExchangeBalance, ExchangeBalancesAndPositions};
 use mmb_domain::exchanges::symbol::Symbol;
 use mmb_domain::market::{CurrencyCode, CurrencyPair, ExchangeAccountId};
-use mmb_domain::order::snapshot::{Amount, Price};
+use mmb_domain::order::snapshot::{Amount, Price, UserOrder};
 use mmb_domain::order::snapshot::{
-    ClientOrderId, OrderExecutionType, OrderHeader, OrderSide, OrderSimpleProps, OrderSnapshot,
-    OrderType, ReservationId,
+    ClientOrderId, OrderHeader, OrderSide, OrderSimpleProps, OrderSnapshot, ReservationId,
 };
 use mmb_domain::position::DerivativePosition;
 use mockall_double::double;
@@ -242,26 +241,24 @@ impl BalanceManagerBase {
         order_side: OrderSide,
         reservation_id: ReservationId,
     ) -> OrderSnapshot {
-        self.create_order_by_amount(order_side, Some(dec!(0.2)), dec!(5), reservation_id)
+        self.create_order_by_amount(order_side, dec!(0.2), dec!(5), reservation_id)
     }
 
     pub fn create_order_by_amount(
         &mut self,
         order_side: OrderSide,
-        price: Option<Price>,
+        price: Price,
         amount: Amount,
         reservation_id: ReservationId,
     ) -> OrderSnapshot {
         let order_snapshot = OrderSnapshot {
-            header: OrderHeader::new(
+            header: OrderHeader::with_user_order(
                 ClientOrderId::new(format!("order{}", self.order_index).into()),
                 self.exchange_account_id_1,
                 self.symbol().currency_pair(),
-                OrderType::Limit,
                 order_side,
-                price,
                 amount,
-                OrderExecutionType::None,
+                UserOrder::limit(price),
                 Some(reservation_id),
                 None,
                 "balance_manager_base".into(),

core/src/balance/manager/tests/balance_manager_derivative.rs

@@ -220,13 +220,11 @@ impl BalanceManagerDerivative {
 #[cfg(test)]
 mod tests {
     use std::collections::HashMap;
-    use std::sync::Arc;
 
     use chrono::Utc;
     use mmb_domain::order::snapshot::{Amount, Price};
     use mmb_utils::hashmap;
     use mmb_utils::logger::init_logger;
-    use parking_lot::RwLock;
     use rstest::rstest;
     use rust_decimal::Decimal;
     use rust_decimal_macros::dec;
@@ -1879,13 +1877,13 @@ mod tests {
             .try_reserve(&reserve_parameters, &mut None)
             .expect("in test");
 
-        let mut order = test_object
+        let mut order_snapshot = test_object
             .balance_manager_base
             .create_order(OrderSide::Sell, reservation_id);
-        order.set_status(OrderStatus::Created, Utc::now());
+        order_snapshot.set_status(OrderStatus::Created, Utc::now());
 
         let order_pool = OrdersPool::new();
-        let order_ref = order_pool.add_snapshot_initial(Arc::new(RwLock::new(order.clone())));
+        let order = order_pool.add_snapshot_initial(&order_snapshot);
 
         // ApproveReservation wait on lock after Clone started
         let cloned_balance_manager = BalanceManager::clone_and_subtract_not_approved_data(
@@ -1895,7 +1893,7 @@ mod tests {
                 .as_ref()
                 .expect("in test")
                 .clone(),
-            Some(&mut vec![order_ref].iter()),
+            Some(&mut vec![order].iter()),
         )
         .expect("in test");
 
@@ -1905,9 +1903,9 @@ mod tests {
         assert_eq!(
             test_object
                 .balance_manager_base
-                .get_balance_by_currency_code(BalanceManagerBase::eth(), order.price())
+                .get_balance_by_currency_code(BalanceManagerBase::eth(), order_snapshot.price())
                 .expect("in test"),
-            (dec!(10) - order.amount() / order.price() / dec!(5)) * dec!(0.95)
+            (dec!(10) - order_snapshot.amount() / order_snapshot.price() / dec!(5)) * dec!(0.95)
         );
 
         //cloned BalancedManager should be without reservation
@@ -1917,7 +1915,7 @@ mod tests {
                 .get_balance_by_another_balance_manager_and_currency_code(
                     &cloned_balance_manager.lock(),
                     BalanceManagerBase::eth(),
-                    order.price()
+                    order_snapshot.price()
                 )
                 .expect("in test"),
             dec!(10) * dec!(0.95)
@@ -1966,7 +1964,7 @@ mod tests {
         );
 
         let order_pool = OrdersPool::new();
-        let order_ref = order_pool.add_snapshot_initial(Arc::new(RwLock::new(order)));
+        let order_ref = order_pool.add_snapshot_initial(&order);
 
         // ApproveReservation wait on lock after Clone started
         let cloned_balance_manager = BalanceManager::clone_and_subtract_not_approved_data(