Make Modify orders set the new quantity and remove Cancel orders

ma2bd · ma2bd · commit cc96bfaeed79 · 2025-11-17T20:32:34.000-05:00
diff --git a/examples/matching-engine/src/contract.rs b/examples/matching-engine/src/contract.rs
@@ -14,7 +14,7 @@ use linera_sdk::{
 use matching_engine::{
     MatchingEngineAbi, Message, Operation, Order, OrderNature, Parameters, PendingOrderInfo, Price,
 };
-use state::{MatchingEngineState, ModifyQuantity, Transfer};
+use state::{MatchingEngineState, Transfer};
 
 pub struct MatchingEngineContract {
     state: MatchingEngineState,
@@ -77,7 +77,7 @@ impl Contract for MatchingEngineContract {
                     .await
                     .expect("Failed to read existing order IDs");
                 for order_id in order_ids {
-                    match self.state.modify_order(order_id, ModifyQuantity::All).await {
+                    match self.state.modify_order(order_id, Amount::ZERO).await {
                         Some(transfer) => self.send_to(transfer),
                         // Orders with amount zero may have been cleared in an earlier iteration.
                         None => continue,
@@ -138,24 +138,16 @@ impl Contract for MatchingEngineContract {
                     .expect("Failed to load pending orders")
                     .expect("Account should have pending orders");
 
-                // Update the pending order
-                if let Some(order) = pending_orders.get_mut(&order_id) {
-                    order.quantity = new_quantity;
+                if new_quantity == Amount::ZERO {
+                    // Remove the pending order
+                    pending_orders.remove(&order_id);
+                } else {
+                    // Update the pending order
+                    if let Some(order) = pending_orders.get_mut(&order_id) {
+                        order.quantity = new_quantity;
+                    }
                 }
             }
-            Message::OrderRemoved { owner, order_id } => {
-                // This message is received on the sender chain from the matching engine
-                let pending_orders = self
-                    .state
-                    .pending_orders
-                    .get_mut(&owner)
-                    .await
-                    .expect("Failed to load pending orders")
-                    .expect("Account should have pending orders");
-
-                // Remove the pending order
-                pending_orders.remove(&order_id);
-            }
         }
     }
 
@@ -239,9 +231,10 @@ impl MatchingEngineContract {
                 let matching_engine_chain = self.runtime.chain_id();
                 for (filled_chain_id, filled_owner, filled_order_id) in filled_orders {
                     if filled_chain_id != matching_engine_chain {
-                        let removal_message = Message::OrderRemoved {
+                        let removal_message = Message::OrderUpdated {
                             owner: filled_owner,
                             order_id: filled_order_id,
+                            new_quantity: Amount::ZERO,
                         };
                         self.runtime
                             .prepare_message(removal_message)
@@ -278,7 +271,11 @@ impl MatchingEngineContract {
                     }
                 }
             }
-            Order::Cancel { owner, order_id } => {
+            Order::Modify {
+                owner,
+                order_id,
+                new_quantity,
+            } => {
                 self.state.check_order_id(&order_id, &owner).await;
                 let key_book = self
                     .state
@@ -291,16 +288,21 @@ impl MatchingEngineContract {
 
                 let transfer = self
                     .state
-                    .modify_order(order_id, ModifyQuantity::All)
+                    .modify_order(order_id, new_quantity)
                     .await
-                    .expect("Order is not present therefore cannot be cancelled");
+                    .expect("Failed to modify order");
                 self.send_to(transfer);
 
-                // Send removal notification to the sender chain (if different from matching engine chain)
+                // Order still exists with reduced amount
                 if sender_chain_id != self.runtime.chain_id() {
-                    let removal_message = Message::OrderRemoved { owner, order_id };
+                    // Send update notification to the sender chain (if different from matching engine chain)
+                    let update_message = Message::OrderUpdated {
+                        owner,
+                        order_id,
+                        new_quantity,
+                    };
                     self.runtime
-                        .prepare_message(removal_message)
+                        .prepare_message(update_message)
                         .with_authentication()
                         .send_to(sender_chain_id);
                 } else {
@@ -311,77 +313,9 @@ impl MatchingEngineContract {
                         .await
                         .expect("Failed to load pending orders")
                         .expect("Account should have pending orders");
-                    // Remove the pending order
-                    pending_orders.remove(&order_id);
-                }
-            }
-            Order::Modify {
-                owner,
-                order_id,
-                reduce_quantity,
-            } => {
-                self.state.check_order_id(&order_id, &owner).await;
-                let key_book = self
-                    .state
-                    .orders
-                    .get(&order_id)
-                    .await
-                    .expect("Failed to load order")
-                    .expect("Order should exist");
-                let sender_chain_id = key_book.account.chain_id;
-
-                let transfer = self
-                    .state
-                    .modify_order(order_id, ModifyQuantity::Partial(reduce_quantity))
-                    .await
-                    .expect("Order is not present therefore cannot be cancelled");
-                self.send_to(transfer);
-
-                // Get the remaining quantity after modification
-                if let Some(new_quantity) = self.state.get_order_quantity(&order_id).await {
-                    // Order still exists with reduced amount
-                    if sender_chain_id != self.runtime.chain_id() {
-                        // Send update notification to the sender chain (if different from matching engine chain)
-                        let update_message = Message::OrderUpdated {
-                            owner,
-                            order_id,
-                            new_quantity,
-                        };
-                        self.runtime
-                            .prepare_message(update_message)
-                            .with_authentication()
-                            .send_to(sender_chain_id);
-                    } else {
-                        let pending_orders = self
-                            .state
-                            .pending_orders
-                            .get_mut(&owner)
-                            .await
-                            .expect("Failed to load pending orders")
-                            .expect("Account should have pending orders");
-                        // Update the pending order
-                        if let Some(order) = pending_orders.get_mut(&order_id) {
-                            order.quantity = new_quantity;
-                        }
-                    }
-                } else {
-                    // Order was fully cancelled
-                    if sender_chain_id != self.runtime.chain_id() {
-                        let removal_message = Message::OrderRemoved { owner, order_id };
-                        self.runtime
-                            .prepare_message(removal_message)
-                            .with_authentication()
-                            .send_to(sender_chain_id);
-                    } else {
-                        let pending_orders = self
-                            .state
-                            .pending_orders
-                            .get_mut(&owner)
-                            .await
-                            .expect("Failed to load pending orders")
-                            .expect("Account should have pending orders");
-                        // Remove the pending order
-                        pending_orders.remove(&order_id);
+                    // Update the pending order
+                    if let Some(order) = pending_orders.get_mut(&order_id) {
+                        order.quantity = new_quantity;
                     }
                 }
             }
diff --git a/examples/matching-engine/src/lib.rs b/examples/matching-engine/src/lib.rs
@@ -136,23 +136,19 @@ scalar!(OrderNature);
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum Order {
-    /// Insertion of an order
+    /// Insert an order
     Insert {
         owner: AccountOwner,
         quantity: Amount,
         nature: OrderNature,
         price: Price,
     },
-    /// Cancelling of an order
-    Cancel {
-        owner: AccountOwner,
-        order_id: OrderId,
-    },
-    /// Modifying order (only decreasing is allowed)
+    /// Modify an order. The quantity can only be decreased. If nul, the order is
+    /// canceled.
     Modify {
         owner: AccountOwner,
         order_id: OrderId,
-        reduce_quantity: Amount,
+        new_quantity: Amount,
     },
 }
 
@@ -163,7 +159,6 @@ impl Order {
     pub fn owner(&self) -> AccountOwner {
         match self {
             Order::Insert { owner, .. } => *owner,
-            Order::Cancel { owner, .. } => *owner,
             Order::Modify { owner, .. } => *owner,
         }
     }
@@ -177,10 +172,7 @@ impl Order {
         // Get the quantity/amount to check based on the order type
         let quantity = match self {
             Order::Insert { quantity, .. } => *quantity,
-            Order::Modify {
-                reduce_quantity, ..
-            } => *reduce_quantity,
-            Order::Cancel { .. } => return Ok(()), // No quantity to check
+            Order::Modify { new_quantity, .. } => *new_quantity,
         };
 
         // Calculate the minimum precision unit allowed
@@ -284,17 +276,12 @@ pub enum Message {
         order_id: OrderId,
         order_info: PendingOrderInfo,
     },
-    /// Notification sent from the matching engine when an order is modified or cancelled.
+    /// Notification sent from the matching engine when an order is modified, filled, or cancelled.
     OrderUpdated {
         owner: AccountOwner,
         order_id: OrderId,
         new_quantity: Amount,
     },
-    /// Notification sent from the matching engine when an order is fully cancelled or filled.
-    OrderRemoved {
-        owner: AccountOwner,
-        order_id: OrderId,
-    },
 }
 
 #[cfg(test)]
@@ -333,19 +320,23 @@ mod tests {
         let modify_valid = Order::Modify {
             owner,
             order_id: 1,
-            reduce_quantity: Amount::from_attos(200),
+            new_quantity: Amount::from_attos(200),
         };
         assert!(modify_valid.check_precision(price_decimals).is_ok());
 
         let modify_invalid = Order::Modify {
             owner,
             order_id: 1,
-            reduce_quantity: Amount::from_attos(199),
+            new_quantity: Amount::from_attos(199),
         };
         assert!(modify_invalid.check_precision(price_decimals).is_err());
 
-        // Test Cancel order (should always succeed)
-        let cancel_order = Order::Cancel { owner, order_id: 1 };
+        // Test order cancellation.
+        let cancel_order = Order::Modify {
+            owner,
+            order_id: 1,
+            new_quantity: Amount::ZERO,
+        };
         assert!(cancel_order.check_precision(price_decimals).is_ok());
 
         // Test with price_decimals = 0 (any quantity should be valid)
diff --git a/examples/matching-engine/src/state.rs b/examples/matching-engine/src/state.rs
@@ -140,35 +140,13 @@ impl MatchingEngineState {
         }
     }
 
-    /// Gets the current amount of an order from the order book.
-    /// Returns None if the order doesn't exist or has been fully filled/cancelled.
-    pub async fn get_order_quantity(&mut self, order_id: &OrderId) -> Option<Amount> {
-        let key_book = self.orders.get(order_id).await.ok()??;
-
-        // Find the order in the appropriate price level
-        match key_book.nature {
-            OrderNature::Bid => {
-                let view = self.bid_level(&key_book.price.to_bid()).await;
-                let mut iter = view.queue.iter_mut().await.expect("Failed to iterate");
-                iter.find(|order| order.order_id == *order_id)
-                    .map(|order| order.quantity)
-            }
-            OrderNature::Ask => {
-                let view = self.ask_level(&key_book.price.to_ask()).await;
-                let mut iter = view.queue.iter_mut().await.expect("Failed to iterate");
-                iter.find(|order| order.order_id == *order_id)
-                    .map(|order| order.quantity)
-            }
-        }
-    }
-
     /// Modifies the order from the order_id.
     /// This means that some transfers have to be done and the size depends
     /// whether ask or bid.
     pub async fn modify_order(
         &mut self,
         order_id: OrderId,
-        cancel_quantity: ModifyQuantity,
+        new_quantity: Amount,
     ) -> Option<Transfer> {
         let key_book = self
             .orders
@@ -179,7 +157,7 @@ impl MatchingEngineState {
             OrderNature::Bid => {
                 let view = self.bid_level(&key_book.price.to_bid()).await;
                 let (cancel_quantity, remove_order_id) =
-                    view.modify_order_level(order_id, cancel_quantity).await?;
+                    view.modify_order_level(order_id, new_quantity).await?;
                 if remove_order_id {
                     self.remove_order_id((key_book.account.owner, order_id))
                         .await;
@@ -196,7 +174,7 @@ impl MatchingEngineState {
             OrderNature::Ask => {
                 let view = self.ask_level(&key_book.price.to_ask()).await;
                 let (cancel_quantity, remove_order_id) =
-                    view.modify_order_level(order_id, cancel_quantity).await?;
+                    view.modify_order_level(order_id, new_quantity).await?;
                 if remove_order_id {
                     self.remove_order_id((key_book.account.owner, order_id))
                         .await;
@@ -427,15 +405,6 @@ pub struct Transfer {
     pub token_idx: u32,
 }
 
-/// An order can be cancelled which removes it totally or
-/// modified which is a partial cancellation. The size of the
-/// order can never increase.
-#[derive(Clone, Debug)]
-pub enum ModifyQuantity {
-    All,
-    Partial(Amount),
-}
-
 impl LevelView {
     fn parameters(&self) -> Parameters {
         *self.context().extra()
@@ -610,24 +579,20 @@ impl LevelView {
     pub async fn modify_order_level(
         &mut self,
         order_id: OrderId,
-        reduce_quantity: ModifyQuantity,
+        new_quantity: Amount,
     ) -> Option<(Amount, bool)> {
         let mut iter = self
             .queue
             .iter_mut()
             .await
             .expect("Failed to load iterator over level queue");
         let state_order = iter.find(|order| order.order_id == order_id)?;
-        let new_quantity = match reduce_quantity {
-            ModifyQuantity::All => Amount::ZERO,
-            ModifyQuantity::Partial(reduce_quantity) => state_order
-                .quantity
-                .try_sub(reduce_quantity)
-                .expect("Attempt to cancel a larger quantity than available"),
-        };
-        let corr_reduce_quantity = state_order.quantity.try_sub(new_quantity).unwrap();
+        let cancel_quantity = state_order
+            .quantity
+            .try_sub(new_quantity)
+            .expect("Attempt to increase quantity");
         state_order.quantity = new_quantity;
         self.remove_zero_orders_from_level().await;
-        Some((corr_reduce_quantity, new_quantity == Amount::ZERO))
+        Some((cancel_quantity, new_quantity == Amount::ZERO))
     }
 }
diff --git a/examples/matching-engine/tests/transaction.rs b/examples/matching-engine/tests/transaction.rs
@@ -246,9 +246,10 @@ async fn single_transaction() {
     }
 
     // Cancel A's order.
-    let order = Order::Cancel {
+    let order = Order::Modify {
         owner: owner_a,
         order_id: order_ids_a[0],
+        new_quantity: Amount::ZERO,
     };
     let operation = Operation::ExecuteOrder { order };
     let order_certificate = user_chain_a
diff --git a/linera-service/tests/linera_net_tests.rs b/linera-service/tests/linera_net_tests.rs
