fucke yeah coffee

contracts/cosmwasm/order/src/errors.rs

@@ -12,3 +12,10 @@ pub fn filled_order_cannot_be_cross_chain_routed() -> StdError {
     StdError::generic_err("Filled order cannot be cross chain routed")
 }
 
+
+
+pub fn partial_cross_chain_not_implemented() -> StdError {
+    StdError::generic_err("Partial cross chain not implemented")
+}
+
+

contracts/cosmwasm/order/src/events.rs

@@ -38,6 +38,15 @@ pub mod order {
             .add_attribute("solver_address", solver_address.clone())
             .add_attribute("solution_block_added", solution_block_added.to_string())
     }
+
+    pub fn mantis_order_routed_full(
+        order: &OrderItem,
+        solver_address: &String,
+    ) -> Event {
+        Event::new("mantis-order-routed-full")
+            .add_attribute("order_id", order.order_id.to_string())
+            .add_attribute("solver_address", solver_address.clone())
+    }    
 }
 
 pub mod solution {

contracts/cosmwasm/order/src/lib.rs

@@ -468,7 +468,9 @@ impl OrderContract<'_> {
     fn pre_fill_remotely<'a>(
         &self,
         ctx: ExecCtx<'a>,
+        storage: &mut dyn Storage,
         optimal_price: Ratio,
+        solver_address: String,
         solution_id: SolutionHash,
         solver_orders: Vec<SolvedOrder>,
         pair: DenomPair,
@@ -478,10 +480,22 @@ impl OrderContract<'_> {
         for order in solver_orders.iter() {
             if let Some(cross_chain_part) = order.solution.cross_chain_part {
                 match cross_chain_part {
-                    OrderAmount::All => todo!(),
-                    OrderAmount::Part(_, _) => return Err(errors::partial_cross_chain_not_implemented())
+                    OrderAmount::Part(_, _) => return Err(errors::partial_cross_chain_not_implemented()),
+                    OrderAmount::All => {
+                        if order.given().denom == pair.0 {
+                            routed_a_amount += order.given().amount.u128();
+                        } else {
+                            routed_b_amount += order.given().amount.u128();
+                        }
+                        self.orders.remove(storage, order.order.order_id.u128());
+                        (
+                            mantis_order_routed_full(&order, &solver_address),
+                            false,
+                        )
+                    }
                 }
             }
+
             let order_id = order.order.order_id.u128();
 
             let mut item: OrderItem = self.orders.load(ctx.deps.storage, order_id)?;

contracts/cosmwasm/order/src/types.rs

@@ -395,6 +395,23 @@ pub struct CowFillResult {
     pub event: Event,
 }
 
+pub struct CvmFillResult {
+    pub tracking: TrackedOrderItem,
+    pub remaining: Option<OrderItem>,
+    pub event: Event,
+}
+
+impl CvmFillResult {
+    pub fn new(tracking: TrackedOrderItem, event: Event) -> Self {
+        Self {
+            tracking,
+            remaining : None,
+            event,
+        }
+    }
+}
+
+
 pub type Denom = String;
 pub type DenomPair = (Denom, Denom);
 pub type SolverAddress = String;