lsp_plugin: add u64 getter and setter to tlvs

We found a situation where we need to set and get u64s rather than tu64s

Signed-off-by: Peter Neuroth <[email protected]>

Author: nepet

plugins/lsps-plugin/src/lsps2/cln.rs

@@ -324,6 +324,32 @@ pub mod tlv {
                 Ok(None)
             }
         }
+
+        /// Insert or override a `u64` value for `type_` (keeps cannonical TLV
+        /// order).
+        pub fn set_u64(&mut self, type_: u64, value: u64) {
+            let enc = value.to_be_bytes().to_vec();
+            if let Some(rec) = self.0.iter_mut().find(|r| r.type_ == type_) {
+                rec.value = enc;
+            } else {
+                self.0.push(TlvRecord { type_, value: enc });
+                self.0.sort_by_key(|r| r.type_);
+            }
+        }
+
+        /// Read a `u64` if present.Returns Ok(None) if the type isn't present.
+        pub fn get_u64(&self, type_: u64) -> Result<Option<u64>, TlvError> {
+            if let Some(rec) = self.0.iter().find(|r| r.type_ == type_) {
+                let value = u64::from_be_bytes(
+                    rec.value[..]
+                        .try_into()
+                        .map_err(|e| TlvError::Other(format!("failed not decode to u64: {e}")))?,
+                );
+                Ok(Some(value))
+            } else {
+                Ok(None)
+            }
+        }
     }
 
     impl Serialize for TlvStream {
@@ -622,6 +648,44 @@ pub mod tlv {
             );
         }
 
+        #[test]
+        fn set_and_get_u64_basic() -> Result<()> {
+            let mut s = TlvStream::default();
+            s.set_u64(42, 123456789);
+            assert_eq!(s.get_u64(42)?, Some(123456789));
+            Ok(())
+        }
+
+        #[test]
+        fn set_u64_overwrite_keeps_order() -> Result<()> {
+            let mut s = TlvStream(vec![
+                TlvRecord {
+                    type_: 1,
+                    value: vec![0xaa],
+                },
+                TlvRecord {
+                    type_: 10,
+                    value: vec![0xbb],
+                },
+            ]);
+
+            // insert between 1 and 10
+            s.set_u64(5, 7);
+            assert_eq!(
+                s.0.iter().map(|r| r.type_).collect::<Vec<_>>(),
+                vec![1, 5, 10]
+            );
+            assert_eq!(s.get_u64(5)?, Some(7));
+
+            // overwrite existing 5 (no duplicate, order preserved)
+            s.set_u64(5, 9);
+            let types: Vec<u64> = s.0.iter().map(|r| r.type_).collect();
+            assert_eq!(types, vec![1, 5, 10]);
+            assert_eq!(s.0.iter().filter(|r| r.type_ == 5).count(), 1);
+            assert_eq!(s.get_u64(5)?, Some(9));
+            Ok(())
+        }
+
         #[test]
         fn set_and_get_tu64_basic() -> Result<()> {
             let mut s = TlvStream::default();
@@ -630,6 +694,13 @@ pub mod tlv {
             Ok(())
         }
 
+        #[test]
+        fn get_u64_missing_returns_none() -> Result<()> {
+            let s = TlvStream::default();
+            assert_eq!(s.get_u64(999)?, None);
+            Ok(())
+        }
+
         #[test]
         fn set_tu64_overwrite_keeps_order() -> Result<()> {
             let mut s = TlvStream(vec![