support BlockNotifier for ffi

Author: joemphilips

bindings/src/adaptors/mod.rs

@@ -13,7 +13,7 @@ use bitcoin::secp256k1;
 use lightning::{
     chain::chaininterface::{BroadcasterInterface, FeeEstimator, ConfirmationTarget, ChainWatchInterface, ChainError},
     util::logger::{Logger, Record, Level},
-    util::ser::{Writeable, Writer},
+    util::ser::{Writer},
     ln::peer_handler::SocketDescriptor,
     ln::msgs::ErrorAction,
     chain::chaininterface::ChainWatchInterfaceUtil,

bindings/src/adaptors/primitives.rs

@@ -1,6 +1,7 @@
 use std::{
     convert::{TryFrom},
-    fmt::{Formatter}
+    fmt::{Formatter},
+    io::{Error}
 };
 
 use bitcoin::{
@@ -16,16 +17,14 @@ use lightning::{
     routing::router::{Route},
     util::ser::{Readable, Writeable},
     util::events::Event,
-    chain::transaction::OutPoint
+    chain::transaction::OutPoint,
+    ln::channelmanager::PaymentPreimage,
+    util::ser::Writer
 };
 use crate::{
     FFIResult,
     is_null::IsNull
 };
-use lightning::ln::channelmanager::PaymentPreimage;
-use std::io::{Error, Read};
-use lightning::ln::msgs::DecodeError;
-use lightning::util::ser::Writer;
 
 #[derive(Debug, Clone)]
 #[repr(C)]

bindings/src/blocknotifier.rs

@@ -0,0 +1,105 @@
+use std::sync::Arc;
+use lightning::chain::chaininterface::{BlockNotifier, ChainListener};
+use crate::{
+    HandleShared,
+    FFIResult,
+    Ref,
+    Out,
+    channelmanager::{FFIArcChannelManagerHandle, FFIArcChannelManager},
+    adaptors::{chain_watch_interface_fn, FFIChainWatchInterface}
+};
+use crate::adaptors::{FFINetwork, ffilogger_fn, FFILogger};
+use bitcoin::BlockHeader;
+
+type FFIBlockNotifier = BlockNotifier<'static, Arc<dyn ChainListener>, Arc<FFIChainWatchInterface>>;
+type FFIBlockNotifierHandle<'a> = HandleShared<'a, FFIBlockNotifier>;
+
+ffi! {
+
+    fn create_block_notifier(
+        network_ref: FFINetwork,
+        log_ptr: Ref<ffilogger_fn::LogExtern>,
+        install_watch_tx_ptr: Ref<chain_watch_interface_fn::InstallWatchTxPtr>,
+        install_watch_outpoint_ptr: Ref<chain_watch_interface_fn::InstallWatchOutpointPtr>,
+        watch_all_txn_ptr: Ref<chain_watch_interface_fn::WatchAllTxnPtr>,
+        get_chain_utxo_ptr: Ref<chain_watch_interface_fn::GetChainUtxoPtr>,
+        handle: Out<FFIBlockNotifierHandle>
+    ) -> FFIResult {
+        let network = network_ref.to_network();
+        let log_ref = unsafe_block!("" => log_ptr.as_ref());
+        let logger_arc = Arc::new( FFILogger{ log_ptr: *log_ref } );
+
+        let install_watch_tx_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => install_watch_tx_ptr.as_ref());
+        let install_watch_outpoint_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => install_watch_outpoint_ptr.as_ref());
+        let watch_all_txn_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => watch_all_txn_ptr.as_ref());
+        let get_chain_utxo_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => get_chain_utxo_ptr.as_ref());
+        let chain_watch_interface_arc =
+            Arc::new(FFIChainWatchInterface::new(
+                *install_watch_tx_ref,
+                *install_watch_outpoint_ref,
+                *watch_all_txn_ref,
+                *get_chain_utxo_ref,
+                network,
+                logger_arc.clone()
+            ));
+        let block_notifier = FFIBlockNotifier::new(chain_watch_interface_arc);
+        unsafe_block!("We know handle is not null by wrapper macro. And we know `Out` is writable" => handle.init(HandleShared::alloc(block_notifier)));
+        FFIResult::ok()
+    }
+
+    fn register_channel_manager(
+        channel_manager: FFIArcChannelManagerHandle,
+        handle: FFIBlockNotifierHandle
+    ) -> FFIResult {
+        let chan_man: Arc<FFIArcChannelManager> = unsafe_block!("We know the handle points to valid channel_manager" => channel_manager.as_arc());
+        let block_notifier: &FFIBlockNotifier = unsafe_block!("We know the handle pointers to valid block notifier" => handle.as_ref());
+        block_notifier.register_listener(chan_man);
+        FFIResult::ok()
+    }
+
+    fn unregister_channel_manager(
+        channel_manager: FFIArcChannelManagerHandle,
+        handle: FFIBlockNotifierHandle
+    ) -> FFIResult {
+        let chan_man: Arc<FFIArcChannelManager> = unsafe_block!("We know the handle points to valid channel_manager" => channel_manager.as_arc());
+        let block_notifier: &FFIBlockNotifier = unsafe_block!("We know the handle pointers to valid block notifier" => handle.as_ref());
+        block_notifier.unregister_listener(chan_man);
+        FFIResult::ok()
+    }
+
+    fn block_connected(
+        block_ptr: Ref<u8>,
+        block_len: usize,
+        height: u32,
+        handle: FFIBlockNotifierHandle) -> FFIResult {
+        let block_notifier: &FFIBlockNotifier = unsafe_block!("We know the handle pointers to valid block notifier" => handle.as_ref());
+        let block_bytes = unsafe_block!("block_ptr points to valid buffer of block_len length" => block_ptr.as_bytes(block_len));
+        let block = bitcoin::consensus::deserialize(block_bytes)?;
+        block_notifier.block_connected(&block, height);
+        FFIResult::ok()
+    }
+
+    fn block_disconnected(
+        block_header_ptr: Ref<u8>,
+        block_header_len: usize,
+        height: u32,
+        handle: FFIBlockNotifierHandle
+    ) -> FFIResult {
+        let block_notifier: &FFIBlockNotifier = unsafe_block!("We know the handle pointers to valid block notifier" => handle.as_ref());
+
+        let block_header_bytes: &[u8] = unsafe_block!("We know it points to valid buffer of specified length" => block_header_ptr.as_bytes(block_header_len));
+        let block_header: BlockHeader = bitcoin::consensus::encode::deserialize(block_header_bytes)?;
+        block_notifier.block_disconnected(&block_header, height);
+        FFIResult::ok()
+    }
+
+    fn release_block_notifier(handle: FFIBlockNotifierHandle) -> FFIResult {
+        unsafe_block!("The upstream caller guarantees the handle will not be accessed after being freed" => FFIBlockNotifierHandle::dealloc(handle, |mut handle| {
+            // We keep reference to listeners from wrapper side (as a `SafeHandle`
+            // to a `ChannelManager`) so that we can call methods
+            // on it. So disposing it is their job. Not ours.
+            std::mem::forget(handle.listeners);
+            FFIResult::ok()
+        }))
+    }
+}

bindings/src/channelmanager.rs

@@ -4,7 +4,7 @@ use std::{
     time::{SystemTime, UNIX_EPOCH}
 };
 
-use bitcoin::secp256k1;
+use bitcoin::{secp256k1, BlockHeader, Transaction};
 use lightning::{
     util::{
         config::UserConfig,
@@ -19,6 +19,8 @@ use lightning::{
         transaction::OutPoint
     },
     routing::router::Route,
+    ln::channelmanager::{PaymentSecret, PaymentPreimage},
+    chain::chaininterface::ChainListener
 };
 
 use crate::{
@@ -36,7 +38,14 @@ use crate::{
     },
     utils::into_fixed_buffer,
 };
-use lightning::ln::channelmanager::{PaymentSecret, PaymentPreimage};
+
+#[inline]
+pub fn slice_to_be32(v: &[u8]) -> u32 {
+    ((v[0] as u32) << 8*3) |
+        ((v[1] as u32) << 8*2) |
+        ((v[2] as u32) << 8*1) |
+        ((v[3] as u32) << 8*0)
+}
 
 pub type FFIManyChannelMonitor = SimpleManyChannelMonitor<OutPoint, InMemoryChannelKeys, Arc<FFIBroadCaster>, Arc<FFIFeeEstimator>, Arc<FFILogger>, Arc<FFIChainWatchInterface>>;
 pub type FFIArcChannelManager = ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<KeysManager>, Arc<FFIFeeEstimator>, Arc<FFILogger>>;

bindings/src/is_null.rs

@@ -44,3 +44,4 @@ impl<T: ?Sized> IsNull for *mut T {
 }
 
 never_null!(usize, isize, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, bool);
+never_null!(crate::adaptors::FFINetwork);

bindings/src/lib.rs

@@ -26,6 +26,7 @@ mod adaptors;
 
 mod channelmanager;
 mod peermanager;
+mod blocknotifier;
 mod error;
 mod handle;
 

lightning/src/chain/chaininterface.rs

@@ -238,7 +238,8 @@ pub type BlockNotifierRef<'a, C> = BlockNotifier<'a, &'a ChainListener, C>;
 /// you should default to using a BlockNotifierRef, and use a BlockNotifierArc instead when you
 /// require ChainListeners with static lifetimes, such as when you're using lightning-net-tokio.
 pub struct BlockNotifier<'a, CL: Deref<Target = ChainListener + 'a> + 'a, C: Deref> where C::Target: ChainWatchInterface {
-	listeners: Mutex<Vec<CL>>,
+	/// Listeners to which we notify about information for a new block.
+	pub listeners: Mutex<Vec<CL>>,
 	chain_monitor: C,
 	phantom: PhantomData<&'a ()>,
 }