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,
-                timestamp,
-                taker,
-                maker,
-                price,
+                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,
-                timestamp: proposal.timestamp,
-                taker: proposal.taker,
-                maker: proposal.maker,
-                price: proposal.price,
+                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,6 +18,27 @@ use std::ops::RangeInclusive;
 use std::sync::{Arc, Mutex};
 use tokio_util::codec::{Decoder, Encoder, LengthDelimitedCodec};
 
+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,
+            #[serde(with = "::bdk::bitcoin::util::amount::serde::as_btc")]
+            maker: Amount,
+            price: Price,
+        },
+        Initiate {
+            sig_taker: Signature,
+        },
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "type", content = "payload")]
 #[allow(clippy::large_enum_variant)]
@@ -26,19 +47,6 @@ pub enum TakerToMaker {
         order_id: OrderId,
         quantity: Usd,
     },
-    ProposeSettlement {
-        order_id: OrderId,
-        timestamp: Timestamp,
-        #[serde(with = "::bdk::bitcoin::util::amount::serde::as_btc")]
-        taker: Amount,
-        #[serde(with = "::bdk::bitcoin::util::amount::serde::as_btc")]
-        maker: Amount,
-        price: Price,
-    },
-    InitiateSettlement {
-        order_id: OrderId,
-        sig_taker: Signature,
-    },
     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"),
         }
     }
 }