add entrpoint for getting pending events from chanman

Author: joemphilips

bindings/src/adaptors/mod.rs

@@ -17,6 +17,8 @@ use lightning::ln::channelmonitor::{ManyChannelMonitor, ChannelMonitor, HTLCUpda
 
 pub mod primitives;
 use primitives::*;
+use lightning::util::ser::{Writeable, Writer};
+use std::io::Error;
 
 pub mod broadcaster_fn {
     use crate::adaptors::primitives::FFITransaction;
@@ -224,5 +226,3 @@ impl ChainWatchInterface for FFIChainWatchInterface {
     }
 }
 
-pub mod block_notifier_fn {
-}

bindings/src/adaptors/primitives.rs

@@ -7,8 +7,10 @@ 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 lightning::util::ser::{Readable, Writeable};
 use bitcoin_hashes::core::fmt::{Formatter, Error};
+use lightning::util::events::Event;
+use lightning::ln::msgs::DecodeError;
 
 macro_rules! array_struct{
     (
@@ -36,6 +38,16 @@ macro_rules! array_struct{
             }
         }
 
+        impl<'a> From<Box<[$ty]>> for $name<'a> {
+            fn from(slice: Box<[$ty]>) -> Self {
+                $name::new(
+                    slice.as_ptr(),
+                    slice.len(),
+                )
+            }
+        }
+
+
         impl<'a> std::fmt::Debug for $name<'a> {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 hex::encode(self).fmt(f)
@@ -47,7 +59,6 @@ macro_rules! array_struct{
                 unsafe_block!("" => std::slice::from_raw_parts(self.ptr, self.len))
             }
         }
-
     }
 }
 
@@ -153,3 +164,19 @@ impl<'a> TryFrom<FFIRoute<'a>> for Route {
 
 array_struct!(FFITransaction, u8);
 array_struct!(FFIBlock, u8);
+array_struct!(FFIEvents, u8);
+
+
+impl<'a> TryFrom<Vec<Event>> for FFIEvents<'a> {
+    type Error = lightning::ln::msgs::DecodeError;
+
+    fn try_from(value: Vec<Event>) -> Result<Self, Self::Error> {
+        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())
+    }
+}

bindings/src/channelmanager.rs

@@ -15,13 +15,15 @@ use crate::{
     error::FFIResult,
     handle::{Out, Ref, HandleShared},
     adaptors::*,
-    adaptors::primitives::{FFISha256dHash, FFIRoute},
+    adaptors::primitives::{FFISha256dHash, FFIRoute, FFIEvents},
     channelmonitor::{FFIManyChannelMonitor},
 };
+use lightning::util::events::EventsProvider;
 
 type FFIArcChannelManager = ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<KeysManager>, Arc<FFIFeeEstimator>>;
 type FFIArcChannelManagerHandle<'a> = HandleShared<'a, FFIArcChannelManager>;
 
+
 ffi! {
 
     fn create_channel_manager(
@@ -103,6 +105,13 @@ ffi! {
         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()?;
+        unsafe_block!("We know out parameter is writable" => events.init(e));
+        FFIResult::ok()
+    }
+
     fn release_ffi_channel_manager(handle: FFIArcChannelManagerHandle) -> FFIResult {
         unsafe_block!("The upstream caller guarantees the handle will not be accessed after being freed" => FFIArcChannelManagerHandle::dealloc(handle, |mut handle| {
             FFIResult::ok()