update ffi for BasicMPP

Author: joemphilips

bindings/src/adaptors/mod.rs

@@ -442,7 +442,7 @@ impl RoutingMessageHandler for FFIRoutingMsgHandler {
         unimplemented!()
     }
 
-    fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(ChannelAnnouncement, ChannelUpdate, ChannelUpdate)> {
+    fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)> {
         unimplemented!()
     }
 

bindings/src/adaptors/primitives.rs

@@ -5,7 +5,7 @@ use bitcoin::blockdata::transaction::{Transaction};
 use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 use crate::FFIResult;
 use lightning::chain::chaininterface::ChainError;
-use lightning::ln::channelmanager::PaymentHash;
+use lightning::ln::channelmanager::{PaymentHash, PaymentSecret};
 use lightning::ln::router::{RouteHop, Route};
 use lightning::util::ser::{Readable, Writeable};
 use bitcoin_hashes::core::fmt::{Formatter, Error};
@@ -123,6 +123,17 @@ impl<'a> From<Sha256dHash> for FFISha256dHash<'a> {
     }
 }
 
+array_struct!(FFISecret, u8);
+
+impl<'a> TryFrom<FFISecret<'a>> for PaymentSecret {
+    type Error = FFIResult;
+
+    fn try_from(ffi_secret: FFISecret) -> Result<PaymentSecret, Self::Error> {
+        let s = unsafe_block!("" => std::slice::from_raw_parts(ffi_secret.ptr, ffi_secret.len));
+        let s:[u8; 32] = s.try_into().map_err(|_| FFIResult::invalid_data_length())?;
+        Ok(PaymentSecret(s))
+    }
+}
 
 array_struct!(FFIScript, u8);
 impl<'a> FFIScript<'a> {
@@ -169,11 +180,11 @@ impl From<FFIChainError> for ChainError {
 array_struct!(FFIRoute, u8);
 
 impl<'a> TryFrom<FFIRoute<'a>> for Route {
-    type Error = lightning::ln::msgs::DecodeError;
+    type Error = FFIResult;
 
     fn try_from(value: FFIRoute<'a>) -> Result<Self, Self::Error> {
         let mut slice = value.as_ref();
-        <Route as Readable>::read(&mut slice)
+        <Route as Readable>::read(&mut slice).map_err(|_| FFIResult::deserialization_failure())
     }
 }
 
@@ -184,16 +195,15 @@ array_struct!(FFIEvents, u8);
 /// General purpose byte array which has to cross ffi-boundary
 array_struct!(FFIBytes, u8);
 
-impl<'a> TryFrom<Vec<Event>> for FFIEvents<'a> {
-    type Error = lightning::ln::msgs::DecodeError;
+impl<'a> From<Vec<Event>> for FFIEvents<'a> {
 
-    fn try_from(value: Vec<Event>) -> Result<Self, Self::Error> {
+    fn from(value: Vec<Event>) -> Self {
         let len = value.len();
         let mut result_vec: Vec<u8> = Vec::with_capacity(len * std::mem::size_of::<Event>());
         for e in value {
             result_vec.extend(e.encode());
         }
         let r = result_vec.into_boxed_slice();
-        Ok(r.into())
+        r.into()
     }
 }

bindings/src/channelmanager.rs

@@ -15,14 +15,15 @@ use crate::{
     error::FFIResult,
     handle::{Out, Ref, HandleShared},
     adaptors::*,
-    adaptors::primitives::{FFISha256dHash, FFIRoute, FFIEvents},
+    adaptors::primitives::{FFISha256dHash, FFIRoute, FFIEvents, FFISecret},
     channelmonitor::{FFIManyChannelMonitor},
 };
 use lightning::util::events::EventsProvider;
 
 pub type FFIArcChannelManager = ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<KeysManager>, Arc<FFIFeeEstimator>>;
 pub type FFIArcChannelManagerHandle<'a> = HandleShared<'a, FFIArcChannelManager>;
 
+
 pub(crate) fn construct_channel_manager(
     seed_ptr: Ref<u8>,
     seed_len: usize,
@@ -129,16 +130,20 @@ ffi! {
         unsafe_block!("We know chan_man is not null by wrapper macro. And we know `Out` is writable" => chan_man.init(HandleShared::alloc(chan_man_raw)));
         FFIResult::ok()
     }
-    fn send_payment(handle: FFIArcChannelManagerHandle, route_ref: Ref<FFIRoute>, payment_hash_ref: Ref<FFISha256dHash>) -> FFIResult {
+
+    fn send_payment(handle: FFIArcChannelManagerHandle, route_ref: Ref<FFIRoute>, payment_hash_ref: Ref<FFISha256dHash>, payment_secret_ref: Ref<FFISecret>) -> FFIResult {
         let chan_man = unsafe_block!("We know handle points to valid channel_manager" => handle.as_ref());
         let route_ffi: &FFIRoute = unsafe_block!("We know it points to valid route data" => route_ref.as_ref());
         let payment_hash_ffi: &FFISha256dHash = unsafe_block!("We know it points to valid hash data" => payment_hash_ref.as_ref());
         let payment_hash: PaymentHash = payment_hash_ffi.clone().try_into()?;
+        let payment_secret: &FFISecret = unsafe_block!("We know it points to valid payment_secret data or empty 32 bytes" => payment_secret_ref.as_ref());
+        let maybe_secret = if payment_secret.as_ref().is_empty() { None } else { Some(payment_secret.deep_copy().try_into()?) };
         let route: Route = route_ffi.clone().try_into()?;
-        chan_man.send_payment(route, payment_hash)?;
+        chan_man.send_payment(&route, payment_hash, &maybe_secret)?;
         FFIResult::ok()
     }
 
+
     fn get_and_clear_pending_events(handle: FFIArcChannelManagerHandle, events: Out<FFIEvents>) -> FFIResult {
         let chan_man: &FFIArcChannelManager = unsafe_block!("We know handle points to valid channel_manager" => handle.as_ref());
         let e = chan_man.get_and_clear_pending_events().try_into()?;

bindings/src/error.rs

@@ -34,6 +34,8 @@ pub enum Kind {
     Ok,
     EmptyPointerProvided,
     InvalidDataLength,
+    /// Indicates we have passed byte array from wrapper which is not rust-lightning compatible.
+    DeserializationFailure,
     /// Return this when buffer for allocating error message is too small.
     /// When this is the last error, the caller should try to increase the buffer size and call the function again.
     BufferTooSmall,
@@ -134,6 +136,14 @@ impl FFIResult {
         self.kind == Kind::EmptyPointerProvided
     }
 
+    pub(super) fn deserialization_failure() -> Self {
+        FFIResult { kind: Kind::DeserializationFailure, id: next_err_id() }
+    }
+
+    pub fn is_deserialization_failure(&self) -> bool {
+        self.kind == Kind::DeserializationFailure
+    }
+
     pub(super) fn buffer_too_small() -> Self {
         FFIResult { kind: Kind::BufferTooSmall, id: next_err_id() }
     }
@@ -165,6 +175,7 @@ impl FFIResult {
             Kind::Ok => None,
             Kind::EmptyPointerProvided => Some("a required pointer argument was null"),
             Kind::InvalidDataLength => Some("provided data buffer has invalid length"),
+            Kind::DeserializationFailure => Some("Failed to deserialize byte array passed to ffi"),
             Kind::InternalError => Some("An internal error occured"),
             Kind::BufferTooSmall => Some("buffer was too small"),
         }

lightning/src/ln/channelmanager.rs

@@ -50,6 +50,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
 use std::marker::{Sync, Send};
 use std::ops::Deref;
+use bitcoin_hashes::core::fmt::{Formatter, Error};
 
 // We hold various information about HTLC relay in the HTLC objects in Channel itself:
 //
@@ -518,6 +519,14 @@ pub enum PaymentSendFailure {
 	PartialFailure(Vec<Result<(), APIError>>),
 }
 
+impl std::fmt::Display for PaymentSendFailure {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+	}
+}
+
+impl std::error::Error for PaymentSendFailure {}
+
 macro_rules! handle_error {
 	($self: ident, $internal: expr, $their_node_id: expr) => {
 		match $internal {