revert to inital cython implementation

crates/execution/src/matching_engine/engine.rs

@@ -860,6 +860,10 @@ impl OrderMatchingEngine {
 
         // Immediately fill marketable order
         self.fill_market_order(order);
+
+        if order.is_open() {
+            self.accept_order(order);
+        }
     }
 
     fn process_stop_market_order(&mut self, order: &mut OrderAny) {
@@ -1376,9 +1380,6 @@ impl OrderMatchingEngine {
             if order.filled_qty() == Quantity::zero(order.filled_qty().precision)
                 && order.order_type() == OrderType::MarketToLimit
             {
-                // Matching engine should the first accept order then update limit price
-                self.accept_order(order);
-
                 self.generate_order_updated(order, order.quantity(), Some(fill_px), None);
                 initial_market_to_limit_fill = true;
             }

crates/execution/src/matching_engine/tests.rs

@@ -2532,26 +2532,26 @@ fn test_process_market_to_limit_orders_not_fully_filled(
     engine_l2.process_order(&mut market_to_limit_order, account_id);
 
     // Check sequence of events for MARKET-TO-LIMIT order being not fully filled
-    // 1. OrderAccepted - order fill be transformed to limit so we must receive accepted event
-    // 2. OrderUpdated - order was updated to new limix price where market order stopped filling
-    // 3. OrderFilled - after inclusion in book we emit order filled event for market order at start
+    // 1. OrderUpdated - order was updated to new limix price where market order stopped filling
+    // 2. OrderFilled - market order which was filled emits filled event
+    // 3. OrderAccepted - remaining quantity of market order is accepted as limit order
     let saved_messages = get_order_event_handler_messages(order_event_handler);
     assert_eq!(saved_messages.len(), 3);
     let order_event_first = saved_messages.first().unwrap();
-    let order_accepted = match order_event_first {
-        OrderEventAny::Accepted(order_accepted) => order_accepted,
-        _ => panic!("Expected OrderAccepted event in first message"),
+    let order_updated = match order_event_first {
+        OrderEventAny::Updated(order) => order,
+        _ => panic!("Expected OrderUpdated event in first message"),
     };
-    assert_eq!(order_accepted.client_order_id, client_order_id);
+    assert_eq!(order_updated.client_order_id, client_order_id);
     let order_event_second = saved_messages.get(1).unwrap();
-    let order_updated = match order_event_second {
-        OrderEventAny::Updated(order_updated) => order_updated,
-        _ => panic!("Expected OrderUpdated event in second message"),
+    let order_filled = match order_event_second {
+        OrderEventAny::Filled(order) => order,
+        _ => panic!("Expected OrderFilled event in second message"),
     };
-    assert_eq!(order_updated.client_order_id, client_order_id);
+    assert_eq!(order_filled.client_order_id, client_order_id);
     let order_event_third = saved_messages.get(2).unwrap();
-    let order_filled = match order_event_third {
-        OrderEventAny::Filled(order_filled) => order_filled,
+    let order_accepted = match order_event_third {
+        OrderEventAny::Accepted(order) => order,
         _ => panic!("Expected OrderFilled event in third message"),
     };
     assert_eq!(order_filled.client_order_id, client_order_id);

crates/model/src/orders/base.rs

@@ -113,6 +113,7 @@ impl OrderStatus {
             (Self::Submitted, OrderEventAny::Canceled(_)) => Self::Canceled,  // FOK and IOC cases
             (Self::Submitted, OrderEventAny::Accepted(_)) => Self::Accepted,
             (Self::Submitted, OrderEventAny::Filled(_)) => Self::Filled,
+            (Self::Submitted, OrderEventAny::Updated(_)) => Self::Submitted,
             (Self::Accepted, OrderEventAny::Rejected(_)) => Self::Rejected,  // StopLimit order
             (Self::Accepted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
             (Self::Accepted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
@@ -147,6 +148,7 @@ impl OrderStatus {
             (Self::PartiallyFilled, OrderEventAny::Canceled(_)) => Self::Canceled,
             (Self::PartiallyFilled, OrderEventAny::Expired(_)) => Self::Expired,
             (Self::PartiallyFilled, OrderEventAny::Filled(_)) => Self::Filled,
+            (Self::PartiallyFilled, OrderEventAny::Accepted(_)) => Self::Accepted,
             _ => return Err(OrderError::InvalidStateTransition),
         };
         Ok(new_state)

nautilus_trader/backtest/matching_engine.pyx

@@ -1013,6 +1013,9 @@ cdef class OrderMatchingEngine:
         # Immediately fill marketable order
         self.fill_market_order(order)
 
+        if order.is_open_c():
+            self.accept_order(order)
+
     cdef void _process_limit_order(self, LimitOrder order):
         # Check AT_THE_OPEN/AT_THE_CLOSE time in force
         if order.time_in_force == TimeInForce.AT_THE_OPEN or order.time_in_force == TimeInForce.AT_THE_CLOSE:
@@ -1829,7 +1832,6 @@ cdef class OrderMatchingEngine:
 
             if order.filled_qty._mem.raw == 0:
                 if order.order_type == OrderType.MARKET_TO_LIMIT:
-                    self.accept_order(order)
                     self._generate_order_updated(
                         order,
                         qty=order.quantity,