WIP: Adding tower messages

This involved LDK related work to use the macros in `teos-common::lightning_messages`.
LDK fork used: https://github.com/meryacine/rust-lightning/tree/expose-tlv-macros
The LDK fork above is implementing what's missing in this issue: lightningdevkit/rust-lightning#1539. which is expected to land in LDK v0.1

Author: mariocynicys

teos-common/Cargo.toml

@@ -15,5 +15,5 @@ rand = "0.8.4"
 chacha20poly1305 = "0.8.0"
 
 # Bitcoin and Lightning
-bitcoin = "0.27"
-lightning = "0.0.105"
+bitcoin = "0.28.1"
+lightning = { git = "https://github.com/meryacine/rust-lightning", branch = "expose-tlv-macros" }

teos-common/src/lib.rs

@@ -6,6 +6,7 @@ pub mod appointment;
 pub mod constants;
 pub mod cryptography;
 pub mod errors;
+pub mod lightning_messages;
 pub mod receipts;
 
 use std::fmt;

teos-common/src/lightning_messages.rs

@@ -0,0 +1,283 @@
+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::util::ser;
+
+// To use (de)serialization macros.
+use lightning::*;
+
+use crate::appointment::{Locator, LOCATOR_LEN};
+
+/// A wrapper around a vector inside a lightning message.
+/// This wrapper mainly exists because we cannot implement LDK's (de)serialization traits
+/// for Vec (since neither the traits nor Vec are defined in our crate (the orphan rule)).
+pub struct LightningVec<T>(Vec<T>);
+
+// Implement Deref for our wrapper so we can call Vec methods on it directly.
+impl<T> std::ops::Deref for LightningVec<T> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+// fmt 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)
+    }
+}
+
+/// The register message sent by the user to subscribe for the watching service.
+#[derive(Debug)]
+pub struct Register {
+    pub pubkey: PublicKey,
+    pub appointment_slots: u32,
+    pub subscription_period: u32,
+}
+
+/// The subscription details message that is sent to the user after registering or toping up.
+/// This message is the response to the register message.
+#[derive(Debug)]
+pub struct SubscriptionDetails {
+    pub appointment_max_size: u16,
+    pub amount_msat: u32,
+    // Optional TLV.
+    pub signature: Option<String>,
+}
+
+/// The add/update appointment message sent by the user.
+#[derive(Debug)]
+pub struct AddUpdateAppointment {
+    pub locator: Locator,
+    // NOTE: LDK will prefix varying size fields (e.g. vectors and strings) with their length.
+    pub encrypted_blob: Vec<u8>,
+    pub signature: String,
+    // Optional TLV.
+    pub to_self_delay: Option<u64>,
+}
+
+/// The appointment accepted message that is sent after an accepted add/update appointment message.
+#[derive(Debug)]
+pub struct AppointmentAccepted {
+    pub locator: Locator,
+    pub start_block: u32,
+    // Optional TLV.
+    pub receipt_signature: Option<String>,
+}
+
+/// The appointment rejected message that is sent if an add/update appointment message was rejected.
+#[derive(Debug)]
+pub struct AppointmentRejected {
+    pub locator: Locator,
+    pub rcode: u16,
+    pub reason: String,
+}
+
+/// The get appointment message sent by the user to retrieve a previously sent appointment from the tower.
+#[derive(Debug)]
+pub struct GetAppointment {
+    pub locator: Locator,
+    pub signature: String,
+}
+
+/// The appointment found message sent by the tower after a get appointment message.
+#[derive(Debug)]
+pub struct AppointmentFound {
+    pub locator: Locator,
+    pub encrypted_blob: Vec<u8>,
+}
+
+/// The tracker found message sent by the tower when the requested appointment has been acted upon.
+#[derive(Debug)]
+pub struct TrackerFound {
+    pub dispute_txid: Txid,
+    pub penalty_txid: Txid,
+    pub penalty_rawtx: Vec<u8>,
+}
+
+/// The appointment not found message sent by the tower in response to a get appointment message
+/// whose locator didn't match any known appointment.
+#[derive(Debug)]
+pub struct AppointmentNotFound {
+    pub locator: Locator,
+}
+
+/// The get subscription info message (a TEOS custom message, not a bolt13 one).
+#[derive(Debug)]
+pub struct GetSubscriptionInfo {
+    pub signature: String,
+}
+
+/// The user subscription info message sent by the tower in response to get subscription info message.
+#[derive(Debug)]
+pub struct UserSubscriptionInfo {
+    pub available_slots: u32,
+    pub subscription_expiry: u32,
+    pub locators: LightningVec<Locator>,
+}
+
+// Deserialization for a Locator inside a lightning message.
+impl ser::Readable for Locator {
+    fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+        let mut buf = [0; LOCATOR_LEN];
+        reader.read_exact(&mut buf)?;
+        let locator =
+            Self::deserialize(&buf).map_err(|_| DecodeError::Io(io::ErrorKind::InvalidData))?;
+        Ok(locator)
+    }
+}
+
+// Serialization for a Locator inside a lighting message.
+impl ser::Writeable for Locator {
+    fn write<W: ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+        writer.write_all(&self.serialize())?;
+        Ok(())
+    }
+}
+
+// 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> {
+        let len: u16 = ser::Readable::read(reader)?;
+        let mut locators = Vec::with_capacity(len as usize);
+        for _ in 0..len {
+            locators.push(ser::Readable::read(reader)?);
+        }
+        Ok(Self(locators))
+    }
+}
+
+// Serialization for a vector of Locators inside a lighting message.
+impl ser::Writeable for LightningVec<Locator> {
+    fn write<W: ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+        (self.len() as u16).write(writer)?;
+        for locator in self.iter() {
+            locator.write(writer)?;
+        }
+        Ok(())
+    }
+}
+
+impl_writeable_msg!(Register, {
+    pubkey,
+    appointment_slots,
+    subscription_period
+}, {});
+
+impl_writeable_msg!(SubscriptionDetails, {
+    appointment_max_size,
+    amount_msat,
+}, {
+    (1, signature, option),
+});
+
+impl_writeable_msg!(AddUpdateAppointment, {
+    locator,
+    encrypted_blob,
+    signature,
+}, {
+    (1, to_self_delay, option),
+});
+
+impl_writeable_msg!(AppointmentAccepted, {
+    locator,
+    start_block,
+}, {
+    (1, receipt_signature, option),
+});
+
+impl_writeable_msg!(AppointmentRejected, {
+    locator,
+    rcode,
+    reason,
+}, {});
+
+impl_writeable_msg!(GetAppointment, {
+    locator,
+    signature,
+}, {});
+
+impl_writeable_msg!(AppointmentFound, {
+    locator,
+    encrypted_blob,
+}, {});
+
+impl_writeable_msg!(TrackerFound, {
+    dispute_txid,
+    penalty_txid,
+    penalty_rawtx,
+}, {});
+
+impl_writeable_msg!(AppointmentNotFound, {
+    locator,
+}, {});
+
+impl_writeable_msg!(GetSubscriptionInfo, {
+    signature,
+}, {});
+
+impl_writeable_msg!(UserSubscriptionInfo, {
+    available_slots,
+    subscription_expiry,
+    locators,
+}, {});
+
+#[derive(Debug)]
+pub enum TowerMessage {
+    // Register messages
+    Register(Register),
+    SubscriptionDetails(SubscriptionDetails),
+    // Appointment submission messages
+    AddUpdateAppointment(AddUpdateAppointment),
+    AppointmentAccepted(AppointmentAccepted),
+    AppointmentRejected(AppointmentRejected),
+    // Appointment fetching messages
+    GetAppointment(GetAppointment),
+    AppointmentFound(AppointmentFound),
+    TrackerFound(TrackerFound),
+    AppointmentNotFound(AppointmentNotFound),
+    // User subscription messages
+    GetSubscriptionInfo(GetSubscriptionInfo),
+    UserSubscriptionInfo(UserSubscriptionInfo),
+}
+
+impl 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,
+        }
+    }
+}
+
+impl ser::Writeable for TowerMessage {
+    fn write<W: ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+        match self {
+            TowerMessage::Register(msg) => msg.write(writer),
+            TowerMessage::SubscriptionDetails(msg) => msg.write(writer),
+            TowerMessage::AddUpdateAppointment(msg) => msg.write(writer),
+            TowerMessage::AppointmentAccepted(msg) => msg.write(writer),
+            TowerMessage::AppointmentRejected(msg) => msg.write(writer),
+            TowerMessage::GetAppointment(msg) => msg.write(writer),
+            TowerMessage::AppointmentFound(msg) => msg.write(writer),
+            TowerMessage::TrackerFound(msg) => msg.write(writer),
+            TowerMessage::AppointmentNotFound(msg) => msg.write(writer),
+            TowerMessage::GetSubscriptionInfo(msg) => msg.write(writer),
+            TowerMessage::UserSubscriptionInfo(msg) => msg.write(writer),
+        }
+    }
+}