WIP: Add a public Type trait

Author: mariocynicys

teos-common/src/lightning_messages.rs

@@ -1,14 +1,12 @@
+//! Watchtower custom lightning messages that implement LDK's Readable & Writeable traits.
+
+use crate::appointment::{Locator, LOCATOR_LEN};
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::Txid;
-use lightning::ln::msgs::DecodeError;
-use lightning::ln::peer_handler::{CustomMessageHandler, PeerManager};
-use lightning::ln::wire::{CustomMessageReader, Type};
+use lightning::ln::msgs;
+use lightning::ln::wire;
 use lightning::util::ser;
-
-// To use (de)serialization macros.
-use lightning::*;
-
-use crate::appointment::{Locator, LOCATOR_LEN};
+use std::io;
 
 /// A wrapper around a vector inside a lightning message.
 /// This wrapper mainly exists because we cannot implement LDK's (de)serialization traits
@@ -24,13 +22,27 @@ impl<T> std::ops::Deref for LightningVec<T> {
     }
 }
 
-// fmt the inner Vec.
+// Only format the inner Vec.
 impl<T: std::fmt::Debug> std::fmt::Debug for LightningVec<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.0.fmt(f)
     }
 }
 
+/// A trait that associates a u16 [`Type::TYPE`] constant with a lightning message.
+pub trait Type {
+    /// The type identifying the message payload.
+    const TYPE: u16;
+}
+
+macro_rules! set_msg_type {
+    ($st: ident, $type: expr) => {
+        impl Type for $st {
+            const TYPE: u16 = $type;
+        }
+    };
+}
+
 /// The register message sent by the user to subscribe for the watching service.
 #[derive(Debug)]
 pub struct Register {
@@ -122,11 +134,11 @@ pub struct UserSubscriptionInfo {
 
 // Deserialization for a Locator inside a lightning message.
 impl ser::Readable for Locator {
-    fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+    fn read<R: io::Read>(reader: &mut R) -> Result<Self, msgs::DecodeError> {
         let mut buf = [0; LOCATOR_LEN];
         reader.read_exact(&mut buf)?;
         let locator =
-            Self::deserialize(&buf).map_err(|_| DecodeError::Io(io::ErrorKind::InvalidData))?;
+            Self::deserialize(&buf).map_err(|_| msgs::DecodeError::Io(io::ErrorKind::InvalidData))?;
         Ok(locator)
     }
 }
@@ -141,7 +153,7 @@ impl ser::Writeable for Locator {
 
 // Deserialization for a vector of Locators inside a lightning message.
 impl ser::Readable for LightningVec<Locator> {
-    fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+    fn read<R: io::Read>(reader: &mut R) -> Result<Self, msgs::DecodeError> {
         let len: u16 = ser::Readable::read(reader)?;
         let mut locators = Vec::with_capacity(len as usize);
         for _ in 0..len {
@@ -162,70 +174,83 @@ impl ser::Writeable for LightningVec<Locator> {
     }
 }
 
-impl_writeable_msg!(Register, {
+lightning::impl_writeable_msg!(Register, {
     pubkey,
     appointment_slots,
     subscription_period
 }, {});
 
-impl_writeable_msg!(SubscriptionDetails, {
+lightning::impl_writeable_msg!(SubscriptionDetails, {
     appointment_max_size,
     amount_msat,
 }, {
     (1, signature, option),
 });
 
-impl_writeable_msg!(AddUpdateAppointment, {
+lightning::impl_writeable_msg!(AddUpdateAppointment, {
     locator,
     encrypted_blob,
     signature,
 }, {
     (1, to_self_delay, option),
 });
 
-impl_writeable_msg!(AppointmentAccepted, {
+lightning::impl_writeable_msg!(AppointmentAccepted, {
     locator,
     start_block,
 }, {
     (1, receipt_signature, option),
 });
 
-impl_writeable_msg!(AppointmentRejected, {
+lightning::impl_writeable_msg!(AppointmentRejected, {
     locator,
     rcode,
     reason,
 }, {});
 
-impl_writeable_msg!(GetAppointment, {
+lightning::impl_writeable_msg!(GetAppointment, {
     locator,
     signature,
 }, {});
 
-impl_writeable_msg!(AppointmentFound, {
+lightning::impl_writeable_msg!(AppointmentFound, {
     locator,
     encrypted_blob,
 }, {});
 
-impl_writeable_msg!(TrackerFound, {
+lightning::impl_writeable_msg!(TrackerFound, {
     dispute_txid,
     penalty_txid,
     penalty_rawtx,
 }, {});
 
-impl_writeable_msg!(AppointmentNotFound, {
+lightning::impl_writeable_msg!(AppointmentNotFound, {
     locator,
 }, {});
 
-impl_writeable_msg!(GetSubscriptionInfo, {
+lightning::impl_writeable_msg!(GetSubscriptionInfo, {
     signature,
 }, {});
 
-impl_writeable_msg!(UserSubscriptionInfo, {
+lightning::impl_writeable_msg!(UserSubscriptionInfo, {
     available_slots,
     subscription_expiry,
     locators,
 }, {});
 
+set_msg_type!(Register, 48848);
+set_msg_type!(SubscriptionDetails, 48850);
+set_msg_type!(AddUpdateAppointment, 48852);
+set_msg_type!(AppointmentAccepted, 48854);
+set_msg_type!(AppointmentRejected, 48856);
+set_msg_type!(GetAppointment, 48858);
+set_msg_type!(AppointmentFound, 48860);
+set_msg_type!(TrackerFound, 48862);
+set_msg_type!(AppointmentNotFound, 48864);
+// Let these messages get odd types since they are auxiliary messages.
+set_msg_type!(GetSubscriptionInfo, 48865);
+set_msg_type!(UserSubscriptionInfo, 48867);
+
 #[derive(Debug)]
 pub enum TowerMessage {
     // Register messages
@@ -245,21 +270,20 @@ pub enum TowerMessage {
     UserSubscriptionInfo(UserSubscriptionInfo),
 }
 
-impl Type for TowerMessage {
+impl wire::Type for TowerMessage {
     fn type_id(&self) -> u16 {
         match self {
-            TowerMessage::Register(..) => 48848,
-            TowerMessage::SubscriptionDetails(..) => 48850,
-            TowerMessage::AddUpdateAppointment(..) => 48852,
-            TowerMessage::AppointmentAccepted(..) => 48854,
-            TowerMessage::AppointmentRejected(..) => 48856,
-            TowerMessage::GetAppointment(..) => 48858,
-            TowerMessage::AppointmentFound(..) => 48860,
-            TowerMessage::TrackerFound(..) => 48862,
-            TowerMessage::AppointmentNotFound(..) => 48864,
-            // Let these messages get odd types since they are auxiliary messages.
-            TowerMessage::GetSubscriptionInfo(..) => 48865,
-            TowerMessage::UserSubscriptionInfo(..) => 48867,
+            TowerMessage::Register(..) => Register::TYPE,
+            TowerMessage::SubscriptionDetails(..) => SubscriptionDetails::TYPE,
+            TowerMessage::AddUpdateAppointment(..) => AddUpdateAppointment::TYPE,
+            TowerMessage::AppointmentAccepted(..) => AppointmentAccepted::TYPE,
+            TowerMessage::AppointmentRejected(..) => AppointmentRejected::TYPE,
+            TowerMessage::GetAppointment(..) => GetAppointment::TYPE,
+            TowerMessage::AppointmentFound(..) => AppointmentFound::TYPE,
+            TowerMessage::TrackerFound(..) => TrackerFound::TYPE,
+            TowerMessage::AppointmentNotFound(..) => AppointmentNotFound::TYPE,
+            TowerMessage::GetSubscriptionInfo(..) => GetSubscriptionInfo::TYPE,
+            TowerMessage::UserSubscriptionInfo(..) => UserSubscriptionInfo::TYPE,
         }
     }
 }