plugins: lsps: remove lsps2 module

Separate concerns of the lsps2 modules into their respective layers:
core for tlv, as it is lightning related, not specifically
core-lightning. cln_adapters for core-lightning related types.

Signed-off-by: Peter Neuroth <pet.v.ne@gmail.com>

Author: nepet

plugins/lsps-plugin/src/client.rs

@@ -2,15 +2,19 @@ use anyhow::{anyhow, bail, Context};
 use bitcoin::hashes::{hex::FromHex, sha256, Hash};
 use chrono::{Duration, Utc};
 use cln_lsps::{
-    cln_adapters::{hooks, sender::ClnSender, state::ClientState},
+    cln_adapters::{
+        hooks,
+        sender::ClnSender,
+        state::ClientState,
+        types::{
+            HtlcAcceptedRequest, HtlcAcceptedResponse, InvoicePaymentRequest, OpenChannelRequest,
+        },
+    },
     core::{
         client::LspsClient,
+        tlv::{encode_tu64, TLV_FORWARD_AMT, TLV_PAYMENT_SECRET},
         transport::{MultiplexedTransport, PendingRequests},
     },
-    lsps2::cln::{
-        tlv::encode_tu64, HtlcAcceptedRequest, HtlcAcceptedResponse, InvoicePaymentRequest,
-        OpenChannelRequest, TLV_FORWARD_AMT, TLV_PAYMENT_SECRET,
-    },
     proto::{
         lsps0::{Msat, LSP_FEATURE_BIT},
         lsps2::{compute_opening_fee, Lsps2BuyResponse, Lsps2GetInfoResponse, OpeningFeeParams},

plugins/lsps-plugin/src/cln_adapters/mod.rs

@@ -2,3 +2,4 @@ pub mod hooks;
 pub mod rpc;
 pub mod sender;
 pub mod state;
+pub mod types;

plugins/lsps-plugin/src/cln_adapters/types.rs

@@ -0,0 +1,165 @@
+//! Backfill structs for missing or incomplete Core Lightning types.
+//!
+//! This module provides struct implementations that are not available or
+//! fully accessible in the core-lightning crate, enabling better compatibility
+//! and interoperability with Core Lightning's RPC interface.
+use cln_rpc::primitives::{Amount, ShortChannelId};
+use hex::FromHex;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::core::tlv::TlvStream;
+
+#[derive(Debug, Deserialize)]
+#[allow(unused)]
+pub struct Onion {
+    pub forward_msat: Option<Amount>,
+    #[serde(deserialize_with = "from_hex")]
+    pub next_onion: Vec<u8>,
+    pub outgoing_cltv_value: Option<u32>,
+    pub payload: TlvStream,
+    // pub payload: TlvStream,
+    #[serde(deserialize_with = "from_hex")]
+    pub shared_secret: Vec<u8>,
+    pub short_channel_id: Option<ShortChannelId>,
+    pub total_msat: Option<Amount>,
+    #[serde(rename = "type")]
+    pub type_: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[allow(unused)]
+pub struct Htlc {
+    pub amount_msat: Amount,
+    pub cltv_expiry: u32,
+    pub cltv_expiry_relative: u16,
+    pub id: u64,
+    #[serde(deserialize_with = "from_hex")]
+    pub payment_hash: Vec<u8>,
+    pub short_channel_id: ShortChannelId,
+    pub extra_tlvs: Option<TlvStream>,
+}
+
+#[derive(Debug, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum HtlcAcceptedResult {
+    Continue,
+    Fail,
+    Resolve,
+}
+
+impl std::fmt::Display for HtlcAcceptedResult {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            HtlcAcceptedResult::Continue => "continue",
+            HtlcAcceptedResult::Fail => "fail",
+            HtlcAcceptedResult::Resolve => "resolve",
+        };
+        write!(f, "{s}")
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct HtlcAcceptedRequest {
+    pub htlc: Htlc,
+    pub onion: Onion,
+    pub forward_to: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct HtlcAcceptedResponse {
+    pub result: HtlcAcceptedResult,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub payment_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none", serialize_with = "to_hex")]
+    pub payload: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none", serialize_with = "to_hex")]
+    pub forward_to: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none", serialize_with = "to_hex")]
+    pub extra_tlvs: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub failure_message: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none", serialize_with = "to_hex")]
+    pub failure_onion: Option<Vec<u8>>,
+}
+
+impl HtlcAcceptedResponse {
+    pub fn continue_(
+        payload: Option<Vec<u8>>,
+        forward_to: Option<Vec<u8>>,
+        extra_tlvs: Option<Vec<u8>>,
+    ) -> Self {
+        Self {
+            result: HtlcAcceptedResult::Continue,
+            payment_key: None,
+            payload,
+            forward_to,
+            extra_tlvs,
+            failure_message: None,
+            failure_onion: None,
+        }
+    }
+
+    pub fn fail(failure_message: Option<String>, failure_onion: Option<Vec<u8>>) -> Self {
+        Self {
+            result: HtlcAcceptedResult::Fail,
+            payment_key: None,
+            payload: None,
+            forward_to: None,
+            extra_tlvs: None,
+            failure_message,
+            failure_onion,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct InvoicePaymentRequest {
+    pub payment: InvoicePaymentRequestPayment,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct InvoicePaymentRequestPayment {
+    pub label: String,
+    pub preimage: String,
+    pub msat: u64,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct OpenChannelRequest {
+    pub openchannel: OpenChannelRequestOpenChannel,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct OpenChannelRequestOpenChannel {
+    pub id: String,
+    pub funding_msat: u64,
+    pub push_msat: u64,
+    pub dust_limit_msat: u64,
+    pub max_htlc_value_in_flight_msat: u64,
+    pub channel_reserve_msat: u64,
+    pub htlc_minimum_msat: u64,
+    pub feerate_per_kw: u32,
+    pub to_self_delay: u32,
+    pub max_accepted_htlcs: u32,
+    pub channel_flags: u64,
+}
+
+/// Deserializes a lowercase hex string to a `Vec<u8>`.
+pub fn from_hex<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de::Error;
+    String::deserialize(deserializer)
+        .and_then(|string| Vec::from_hex(string).map_err(|err| Error::custom(err.to_string())))
+}
+
+pub fn to_hex<S>(bytes: &Option<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match bytes {
+        Some(data) => serializer.serialize_str(&hex::encode(data)),
+        None => serializer.serialize_none(),
+    }
+}

plugins/lsps-plugin/src/core/lsps2/htlc.rs

@@ -1,6 +1,9 @@
 use crate::{
-    core::lsps2::provider::{DatastoreProvider, LightningProvider, Lsps2OfferProvider},
-    lsps2::cln::{HtlcAcceptedRequest, HtlcAcceptedResponse, TLV_FORWARD_AMT},
+    cln_adapters::types::{HtlcAcceptedRequest, HtlcAcceptedResponse},
+    core::{
+        lsps2::provider::{DatastoreProvider, LightningProvider, Lsps2OfferProvider},
+        tlv::TLV_FORWARD_AMT,
+    },
     proto::{
         lsps0::Msat,
         lsps2::{
@@ -195,10 +198,8 @@ impl<A: DatastoreProvider + Lsps2OfferProvider + LightningProvider> HtlcAccepted
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::lsps2::cln::tlv::TlvStream;
-    use crate::lsps2::cln::Htlc;
-    use crate::lsps2::cln::HtlcAcceptedResult;
-    use crate::lsps2::cln::Onion;
+    use crate::cln_adapters::types::{Htlc, HtlcAcceptedResult, Onion};
+    use crate::core::tlv::TlvStream;
     use crate::proto::lsps0::{Msat, Ppm, ShortChannelId};
     use crate::proto::lsps2::{
         DatastoreEntry, Lsps2PolicyGetChannelCapacityResponse, Lsps2PolicyGetInfoRequest,

plugins/lsps-plugin/src/core/mod.rs

@@ -2,4 +2,5 @@ pub mod client;
 pub mod lsps2;
 pub mod router;
 pub mod server;
+pub mod tlv;
 pub mod transport;