Simplify FFIRoute

* When passing struct through FFI boundary, if the object
  has nested array it will cause headache for preventing it
  from GCed.
  So we just pass binary serialized object and (de)serialize after
  passing. In this case, `FFIRoute`.
* Prepare Debug trait for Route object.

Author: joemphilips

bindings/src/adaptors/primitives.rs

@@ -7,6 +7,8 @@ use crate::FFIResult;
 use lightning::chain::chaininterface::ChainError;
 use lightning::ln::channelmanager::PaymentHash;
 use lightning::ln::router::{RouteHop, Route};
+use lightning::util::ser::Readable;
+use bitcoin_hashes::core::fmt::{Formatter, Error};
 
 macro_rules! array_struct{
     (
@@ -34,6 +36,12 @@ macro_rules! array_struct{
             }
         }
 
+        impl<'a> std::fmt::Debug for $name<'a> {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                hex::encode(self).fmt(f)
+            }
+        }
+
         impl<'a> AsRef<[$ty]> for $name<'a> {
             fn as_ref(&self) -> &[$ty] {
                 unsafe_block!("" => std::slice::from_raw_parts(self.ptr, self.len))
@@ -132,72 +140,14 @@ impl From<FFIChainError> for ChainError {
     }
 }
 
-array_struct!(NodeFeatures, u8);
-
-impl<'a> From<NodeFeatures<'a>>  for lightning::ln::features::NodeFeatures {
-    fn from(value: NodeFeatures<'a>) -> Self {
-        let v = value.as_ref().to_vec();
-        lightning::ln::features::NodeFeatures::from_le_bytes(v)
-    }
-}
-
-array_struct!(ChannelFeatures, u8);
-impl<'a> From<ChannelFeatures<'a>>  for lightning::ln::features::ChannelFeatures {
-    fn from(value: ChannelFeatures<'a>) -> Self {
-        let v = value.as_ref().to_vec();
-        lightning::ln::features::ChannelFeatures::from_le_bytes(v)
-    }
-}
-
-
-
-#[derive(Clone)]
-#[repr(C)]
-pub struct FFIRouteHop<'a> {
-    /// The node_id of the node at this hop.
-    pub pubkey: PublicKey<'a>,
-    /// The node_announcement features of the node at this hop. For the last hop, these may be
-    /// amended to match the features present in the invoice this node generated.
-    pub node_features: NodeFeatures<'a>,
-    /// The channel that should be used from the previous hop to reach this node.
-    pub short_channel_id: u64,
-    /// The channel_announcement features of the channel that should be used from the previous hop
-    /// to reach this node.
-    pub channel_features: ChannelFeatures<'a>,
-    /// The fee taken on this hop. For the last hop, this should be the full value of the payment.
-    pub fee_msat: u64,
-    /// The CLTV delta added for this hop. For the last hop, this should be the full CLTV value
-    /// expected at the destination, in excess of the current block height.
-    pub cltv_expiry_delta: u32,
-}
-
-impl<'a> TryFrom<FFIRouteHop<'a>> for RouteHop {
-    type Error = FFIResult;
-
-    fn try_from(value: FFIRouteHop<'a>) -> Result<Self, Self::Error> {
-        Ok(RouteHop {
-            pubkey: value.pubkey.try_into()?,
-            node_features: value.node_features.into(),
-            short_channel_id: value.short_channel_id,
-            channel_features: value.channel_features.into(),
-            fee_msat: value.fee_msat,
-            cltv_expiry_delta: value.cltv_expiry_delta
-        })
-    }
-}
-
-array_struct!(FFIRoute, FFIRouteHop<'a>);
+array_struct!(FFIRoute, u8);
 
 impl<'a> TryFrom<FFIRoute<'a>> for Route {
-    type Error = FFIResult;
+    type Error = lightning::ln::msgs::DecodeError;
 
     fn try_from(value: FFIRoute<'a>) -> Result<Self, Self::Error> {
-        let r: &[FFIRouteHop] = value.as_ref();
-        let mut hops: Vec<RouteHop> = Vec::with_capacity(r.len());
-        for i in r.iter() {
-            hops.push(i.clone().try_into()?);
-        }
-        Ok(Route { hops })
+        let mut slice = value.as_ref();
+        <Route as Readable>::read(&mut slice)
     }
 }
 

lightning/src/ln/router.rs

@@ -28,7 +28,7 @@ use std::collections::btree_map::Entry as BtreeEntry;
 use std;
 
 /// A hop in a route
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Debug)]
 pub struct RouteHop {
 	/// The node_id of the node at this hop.
 	pub pubkey: PublicKey,
@@ -47,7 +47,16 @@ pub struct RouteHop {
 	pub cltv_expiry_delta: u32,
 }
 
-impl Writeable for Vec<RouteHop> {
+/// A route from us through the network to a destination
+#[derive(Clone, PartialEq, Debug)]
+pub struct Route {
+	/// The list of hops, NOT INCLUDING our own, where the last hop is the destination. Thus, this
+	/// must always be at least length one. By protocol rules, this may not currently exceed 20 in
+	/// length.
+	pub hops: Vec<RouteHop>,
+}
+
+impl Writeable for Route {
 	fn write<W: ::util::ser::Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 		(self.len() as u8).write(writer)?;
 		for hop in self.iter() {