msggen: Map the extratlvs field of keysend

Changelog-Added: cln-rpc: `keysend` now exposes the `extratlvs` field

cln-grpc/proto/primitives.proto

@@ -72,4 +72,13 @@ message Routehint {
 }
 message RoutehintList {
 	repeated Routehint hints = 2;
-}
+}
+
+
+message TlvEntry {
+	uint64 type = 1;
+	bytes value = 2;
+}
+message TlvStream {
+	repeated TlvEntry entries = 1;
+}

cln-grpc/src/pb.rs

@@ -114,20 +114,40 @@ impl From<RouteHop> for cln_rpc::primitives::Routehop {
         }
     }
 }
+
 impl From<Routehint> for cln_rpc::primitives::Routehint {
     fn from(c: Routehint) -> Self {
         Self {
             hops: c.hops.into_iter().map(|h| h.into()).collect(),
         }
     }
 }
+
 impl From<RoutehintList> for cln_rpc::primitives::RoutehintList {
     fn from(c: RoutehintList) -> Self {
         Self {
             hints: c.hints.into_iter().map(|h| h.into()).collect(),
         }
     }
 }
+
+impl From<TlvStream> for cln_rpc::primitives::TlvStream {
+    fn from(s: TlvStream) -> Self {
+        Self {
+            entries: s.entries.into_iter().map(|e| e.into()).collect(),
+        }
+    }
+}
+
+impl From<TlvEntry> for cln_rpc::primitives::TlvEntry {
+    fn from(e: TlvEntry) -> Self {
+        Self {
+            typ: e.r#type,
+            value: e.value,
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

cln-grpc/src/test.rs

@@ -278,6 +278,7 @@ fn test_keysend() {
                 }],
                 }],
             }),
+	    extratlvs: None,
         };
 
     let u: cln_rpc::model::KeysendRequest = g.into();

cln-rpc/src/primitives.rs

@@ -548,6 +548,19 @@ mod test {
         let serialized: String = serde_json::to_string(&od).unwrap();
         assert_eq!(a, serialized);
     }
+
+    #[test]
+    fn tlvstream() {
+	let stream = TlvStream {
+	    entries: vec![
+		TlvEntry { typ: 31337, value: vec![1,2,3,4,5]},
+			   TlvEntry { typ: 42, value: vec![]},
+	    ],
+	};
+
+	let res = serde_json::to_string(&stream).unwrap();
+        assert_eq!(res, "{\"31337\":\"0102030405\",\"42\":\"\"}");
+    }
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -623,4 +636,50 @@ impl Display for RpcError {
     }
 }
 
-impl std::error::Error for RpcError {}
+impl std::error::Error for RpcError {}
+
+#[derive(Clone, Debug)]
+pub struct TlvEntry {
+    pub typ: u64,
+    pub value: Vec<u8>,
+}
+
+#[derive(Clone, Debug)]
+pub struct TlvStream {
+    pub entries: Vec<TlvEntry>,
+}
+
+impl<'de> Deserialize<'de> for TlvStream {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let map: std::collections::HashMap<u64, String> = Deserialize::deserialize(deserializer)?;
+
+        let entries = map
+            .iter()
+            .map(|(k, v)| TlvEntry {
+                typ: *k,
+                value: hex::decode(v).unwrap(),
+            })
+            .collect();
+
+        Ok(TlvStream { entries })
+    }
+}
+
+impl Serialize for TlvStream {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        use serde::ser::SerializeMap;
+
+        let mut map = serializer.serialize_map(Some(self.entries.len()))?;
+        for e in &self.entries {
+            map.serialize_key(&e.typ)?;
+            map.serialize_value(&hex::encode(&e.value))?;
+        }
+        map.end()
+    }
+}

contrib/msggen/msggen/gen/grpc.py

@@ -440,6 +440,7 @@ def generate_composite(self, prefix, field: CompositeField) -> None:
                     'hash': f'Sha256::from_slice(&c.{name}).unwrap()',
                     'hash?': f'c.{name}.map(|v| Sha256::from_slice(&v).unwrap())',
                     'txid': f'hex::encode(&c.{name})',
+                    'TlvStream?': f'c.{name}.map(|s| s.into())',
                 }.get(
                     typ,
                     f'c.{name}'  # default to just assignment

contrib/msggen/msggen/model.py

@@ -343,7 +343,21 @@ def __str__(self):
 DatastoreKeyField = ArrayField(itemtype=PrimitiveField("string", None, None), dims=1, path=None, description=None)
 InvoiceExposeprivatechannelsField = PrimitiveField("boolean", None, None)
 PayExclude = ArrayField(itemtype=PrimitiveField("string", None, None), dims=1, path=None, description=None)
-RoutehintListField = PrimitiveField("RoutehintList", None, None)
+RoutehintListField = PrimitiveField(
+    "RoutehintList",
+    None,
+    None
+)
+
+# TlvStreams are special, they don't have preset dict-keys, rather
+# they can specify `u64` keys pointing to hex payloads. So the schema
+# has to rely on additionalProperties to make it work.
+TlvStreamField = PrimitiveField(
+    "TlvStream",
+    None,
+    None
+)
+
 # Override fields with manually managed types, fieldpath -> field mapping
 overrides = {
     'Invoice.label': InvoiceLabelField,
@@ -355,6 +369,7 @@ def __str__(self):
     'Invoice.exposeprivatechannels': InvoiceExposeprivatechannelsField,
     'Pay.exclude': PayExclude,
     'KeySend.routehints': RoutehintListField,
+    'KeySend.extratlvs': TlvStreamField,
 }