Bundle all settlement related messages in a individual enums

Once these messages are handled by dedicated actors, this will reduce
the amount to runtime errors a la "this message should be handled by
someone else".

See #696.

daemon/src/maker_cfd.rs

@@ -634,7 +634,10 @@ where
             .takers
             .send(maker_inc_connections::TakerMessage {
                 taker_id,
-                msg: wire::MakerToTaker::ConfirmSettlement(order_id),
+                msg: wire::MakerToTaker::Settlement {
+                    order_id,
+                    msg: wire::maker_to_taker::Settlement::Confirm,
+                },
             })
             .await?
         {
@@ -672,7 +675,10 @@ where
         self.takers
             .send(maker_inc_connections::TakerMessage {
                 taker_id,
-                msg: wire::MakerToTaker::RejectSettlement(order_id),
+                msg: wire::MakerToTaker::Settlement {
+                    order_id,
+                    msg: wire::maker_to_taker::Settlement::Reject,
+                },
             })
             .await??;
 
@@ -1123,12 +1129,15 @@ where
             wire::TakerToMaker::TakeOrder { order_id, quantity } => {
                 log_error!(self.handle_take_order(taker_id, order_id, quantity))
             }
-            wire::TakerToMaker::ProposeSettlement {
+            wire::TakerToMaker::Settlement {
                 order_id,
+                msg:
+                    wire::taker_to_maker::Settlement::Propose {
                         timestamp,
                         taker,
                         maker,
                         price,
+                    },
             } => {
                 log_error!(self.handle_propose_settlement(
                     taker_id,
@@ -1141,9 +1150,9 @@ where
                     }
                 ))
             }
-            wire::TakerToMaker::InitiateSettlement {
+            wire::TakerToMaker::Settlement {
                 order_id,
-                sig_taker,
+                msg: wire::taker_to_maker::Settlement::Initiate { sig_taker },
             } => {
                 log_error!(self.handle_initiate_settlement(taker_id, order_id, sig_taker))
             }

daemon/src/taker_cfd.rs

@@ -243,12 +243,14 @@ impl<O, M, W> Actor<O, M, W> {
             .await?;
 
         self.conn_actor
-            .send(wire::TakerToMaker::ProposeSettlement {
+            .send(wire::TakerToMaker::Settlement {
                 order_id: proposal.order_id,
+                msg: wire::taker_to_maker::Settlement::Propose {
                     timestamp: proposal.timestamp,
                     taker: proposal.taker,
                     maker: proposal.maker,
                     price: proposal.price,
+                },
             })
             .await?;
         Ok(())
@@ -654,9 +656,9 @@ where
         // deadlock otherwise.
         #[allow(clippy::disallowed_method)]
         self.conn_actor
-            .do_send_async(wire::TakerToMaker::InitiateSettlement {
+            .do_send_async(wire::TakerToMaker::Settlement {
                 order_id,
-                sig_taker,
+                msg: wire::taker_to_maker::Settlement::Initiate { sig_taker },
             })
             .await?;
 
@@ -708,10 +710,16 @@ where
             wire::MakerToTaker::CurrentOrder(current_order) => {
                 log_error!(self.handle_new_order(current_order))
             }
-            wire::MakerToTaker::ConfirmSettlement(order_id) => {
+            wire::MakerToTaker::Settlement {
+                order_id,
+                msg: wire::maker_to_taker::Settlement::Confirm,
+            } => {
                 log_error!(self.handle_settlement_accepted(order_id, ctx))
             }
-            wire::MakerToTaker::RejectSettlement(order_id) => {
+            wire::MakerToTaker::Settlement {
+                order_id,
+                msg: wire::maker_to_taker::Settlement::Reject,
+            } => {
                 log_error!(self.handle_settlement_rejected(order_id))
             }
             wire::MakerToTaker::ConfirmRollOver {

daemon/src/wire.rs

@@ -18,16 +18,14 @@ use std::ops::RangeInclusive;
 use std::sync::{Arc, Mutex};
 use tokio_util::codec::{Decoder, Encoder, LengthDelimitedCodec};
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(tag = "type", content = "payload")]
-#[allow(clippy::large_enum_variant)]
-pub enum TakerToMaker {
-    TakeOrder {
-        order_id: OrderId,
-        quantity: Usd,
-    },
-    ProposeSettlement {
-        order_id: OrderId,
+pub mod taker_to_maker {
+    use super::*;
+
+    #[derive(Debug, Serialize, Deserialize)]
+    #[serde(tag = "type", content = "payload")]
+    #[allow(clippy::large_enum_variant)]
+    pub enum Settlement {
+        Propose {
             timestamp: Timestamp,
             #[serde(with = "::bdk::bitcoin::util::amount::serde::as_btc")]
             taker: Amount,
@@ -35,10 +33,20 @@ pub enum TakerToMaker {
             maker: Amount,
             price: Price,
         },
-    InitiateSettlement {
-        order_id: OrderId,
+        Initiate {
             sig_taker: Signature,
         },
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type", content = "payload")]
+#[allow(clippy::large_enum_variant)]
+pub enum TakerToMaker {
+    TakeOrder {
+        order_id: OrderId,
+        quantity: Usd,
+    },
     ProposeRollOver {
         order_id: OrderId,
         timestamp: Timestamp,
@@ -48,17 +56,20 @@ pub enum TakerToMaker {
         msg: SetupMsg,
     },
     RollOverProtocol(RollOverMsg),
+    Settlement {
+        order_id: OrderId,
+        msg: taker_to_maker::Settlement,
+    },
 }
 
 impl fmt::Display for TakerToMaker {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             TakerToMaker::TakeOrder { .. } => write!(f, "TakeOrder"),
-            TakerToMaker::ProposeSettlement { .. } => write!(f, "ProposeSettlement"),
-            TakerToMaker::InitiateSettlement { .. } => write!(f, "InitiateSettlement"),
             TakerToMaker::Protocol { .. } => write!(f, "Protocol"),
             TakerToMaker::ProposeRollOver { .. } => write!(f, "ProposeRollOver"),
             TakerToMaker::RollOverProtocol(_) => write!(f, "RollOverProtocol"),
+            TakerToMaker::Settlement { .. } => write!(f, "Settlement"),
         }
     }
 }
@@ -72,8 +83,6 @@ pub enum MakerToTaker {
     CurrentOrder(Option<Order>),
     ConfirmOrder(OrderId), // TODO: Include payout curve in "accept" message from maker
     RejectOrder(OrderId),
-    ConfirmSettlement(OrderId),
-    RejectSettlement(OrderId),
     InvalidOrderId(OrderId),
     Protocol {
         order_id: OrderId,
@@ -85,6 +94,21 @@ pub enum MakerToTaker {
         oracle_event_id: BitMexPriceEventId,
     },
     RejectRollOver(OrderId),
+    Settlement {
+        order_id: OrderId,
+        msg: maker_to_taker::Settlement,
+    },
+}
+
+pub mod maker_to_taker {
+    use super::*;
+
+    #[derive(Debug, Serialize, Deserialize)]
+    #[serde(tag = "type", content = "payload")]
+    pub enum Settlement {
+        Confirm,
+        Reject,
+    }
 }
 
 impl fmt::Display for MakerToTaker {
@@ -94,13 +118,12 @@ impl fmt::Display for MakerToTaker {
             MakerToTaker::CurrentOrder(_) => write!(f, "CurrentOrder"),
             MakerToTaker::ConfirmOrder(_) => write!(f, "ConfirmOrder"),
             MakerToTaker::RejectOrder(_) => write!(f, "RejectOrder"),
-            MakerToTaker::ConfirmSettlement(_) => write!(f, "ConfirmSettlement"),
-            MakerToTaker::RejectSettlement(_) => write!(f, "RejectSettlement"),
             MakerToTaker::InvalidOrderId(_) => write!(f, "InvalidOrderId"),
             MakerToTaker::Protocol { .. } => write!(f, "Protocol"),
             MakerToTaker::ConfirmRollOver { .. } => write!(f, "ConfirmRollOver"),
             MakerToTaker::RejectRollOver(_) => write!(f, "RejectRollOver"),
             MakerToTaker::RollOverProtocol(_) => write!(f, "RollOverProtocol"),
+            MakerToTaker::Settlement { .. } => write!(f, "Settlement"),
         }
     }
 }