update

Author: joemphilips

bindings/src/adaptors/mod.rs

@@ -97,9 +97,14 @@ impl From<ConfirmationTarget> for FFIConfirmationTarget {
     }
 }
 
+pub mod FeeEstimatorFn {
+    use super::{FFIConfirmationTarget, FFIFeeEstimator};
+    pub type get_est_sat_per_1000_weight_ptr = extern "cdecl" fn (*const FFIFeeEstimator, FFIConfirmationTarget) -> u64;
+}
+
 #[repr(C)]
 pub struct FFIFeeEstimator {
-    get_est_sat_per_1000_weight_ptr: extern "cdecl" fn (&Self, FFIConfirmationTarget) -> u64,
+    pub get_est_sat_per_1000_weight_ptr: FeeEstimatorFn::get_est_sat_per_1000_weight_ptr,
 }
 
 impl FeeEstimator for FFIFeeEstimator {
@@ -191,9 +196,14 @@ impl<'a, 'b> From<&'a Record<'b>> for FFILogRecord {
     }
 }
 
+pub mod FFILoggerFn {
+    use super::{FFILogRecord, FFILogger};
+    pub type log_extern = extern "cdecl" fn(logger: *const FFILogger, record: *const FFILogRecord);
+}
+
 #[repr(C)]
 pub struct FFILogger {
-    log_ptr: extern "cdecl" fn(*const Self, *const FFILogRecord),
+    pub log_ptr: FFILoggerFn::log_extern,
 }
 
 impl Logger for FFILogger {
@@ -203,7 +213,7 @@ impl Logger for FFILogger {
     }
 }
 
-mod ChainWatchInterfaceFn {
+pub mod ChainWatchInterfaceFn {
     use super::*;
     pub type install_watch_tx_ptr = extern "cdecl" fn(*const FFIChainWatchInterface, *const FFISha256dHash, script_pub_key: *const FFIScript);
     pub type install_watch_outpoint_ptr = extern "cdecl" fn(*const FFIChainWatchInterface, outpoint: *const FFIOutPoint, out_script: *const FFIScript);
@@ -214,11 +224,11 @@ mod ChainWatchInterfaceFn {
 
 #[repr(C)]
 pub struct FFIChainWatchInterface {
-    install_watch_tx_ptr: ChainWatchInterfaceFn::install_watch_tx_ptr,
-    install_watch_outpoint_ptr: ChainWatchInterfaceFn::install_watch_tx_ptr,
-    watch_all_txn_ptr: ChainWatchInterfaceFn::watch_all_txn_ptr,
-    get_chain_utxo_ptr: ChainWatchInterfaceFn::get_chain_utxo_ptr,
-    filter_block_ptr: ChainWatchInterfaceFn::filter_block_ptr,
+    pub install_watch_tx_ptr: ChainWatchInterfaceFn::install_watch_tx_ptr,
+    pub install_watch_outpoint_ptr: ChainWatchInterfaceFn::install_watch_outpoint_ptr,
+    pub watch_all_txn_ptr: ChainWatchInterfaceFn::watch_all_txn_ptr,
+    pub get_chain_utxo_ptr: ChainWatchInterfaceFn::get_chain_utxo_ptr,
+    pub filter_block_ptr: ChainWatchInterfaceFn::filter_block_ptr,
 }
 
 impl ChainWatchInterface for FFIChainWatchInterface {

bindings/src/chainwatcher.rs

@@ -1,11 +1,43 @@
 use crate::adaptors::*;
 use crate::error::FFIResult;
-use crate::handle::{Ref};
+use crate::handle::{Ref, Out,HandleShared};
+
+type ChainWatchInterfaceHandle<'a> = HandleShared<'a, FFIChainWatchInterface>;
 
 ffi! {
-    fn ffi_test_chainwatch_interface(chainwatcher_ptr: Ref<FFIChainWatchInterface>) -> FFIResult {
-        let chainwatcher = unsafe_block!("" => chainwatcher_ptr.as_ref());
-        // chainwatcher.install_watch_tx();
+    fn create_chain_watch_interface(
+        install_watch_tx_ref: Ref<ChainWatchInterfaceFn::install_watch_tx_ptr>,
+        install_watch_outpoint_ref: Ref<ChainWatchInterfaceFn::install_watch_outpoint_ptr>,
+        watch_all_txn_ref: Ref<ChainWatchInterfaceFn::watch_all_txn_ptr>,
+        get_chain_utxo_ref: Ref<ChainWatchInterfaceFn::get_chain_utxo_ptr>,
+        filter_block_ref: Ref<ChainWatchInterfaceFn::filter_block_ptr>,
+        handle: Out<ChainWatchInterfaceHandle>
+    ) -> FFIResult {
+        let install_watch_tx =
+            unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data" => *install_watch_tx_ref.as_ref());
+        let install_watch_outpoint =
+            unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data" => *install_watch_outpoint_ref.as_ref());
+        let watch_all_txn =
+            unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data" => *watch_all_txn_ref.as_ref());
+        let get_chain_utxo =
+            unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data" => *get_chain_utxo_ref.as_ref());
+        let filter_block =
+            unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data" => *filter_block_ref.as_ref());
+        let chain_watch_interface =
+            FFIChainWatchInterface {
+                install_watch_tx_ptr: install_watch_tx,
+                install_watch_outpoint_ptr: install_watch_outpoint,
+                watch_all_txn_ptr: watch_all_txn,
+                get_chain_utxo_ptr: get_chain_utxo,
+                filter_block_ptr: filter_block
+            };
+        unsafe_block!("We know handle is not null by wrapper macro. And we know `Out` is writable" => handle.init(ChainWatchInterfaceHandle::alloc(chain_watch_interface)));
         FFIResult::ok()
     }
+
+    fn release_chain_watch_interface(handle: ChainWatchInterfaceHandle) -> FFIResult {
+        unsafe_block!("The upstream caller guarantees the handle will not be accessed after being freed" => ChainWatchInterfaceHandle::dealloc(handle, |mut handle| {
+            FFIResult::ok()
+        }))
+    }
 }

bindings/src/fee_estimator.rs

@@ -0,0 +1,22 @@
+use crate::adaptors::*;
+use crate::handle::{Ref, Out, HandleShared};
+use crate::error::FFIResult;
+
+type FeeEstimatorHandle<'a> = HandleShared<'a, FFIFeeEstimator>;
+
+ffi! {
+    fn create_fee_estimator(fn_ref: Ref<FeeEstimatorFn::get_est_sat_per_1000_weight_ptr>, out: Out<FeeEstimatorHandle>) -> FFIResult {
+        let func = unsafe_block!("" => *fn_ref.as_ref());
+        let fee_estimator = FFIFeeEstimator {get_est_sat_per_1000_weight_ptr: func};
+        unsafe_block!("We know fee_estimator handle is not null by wrapper macro. And we know `Out` is writable" =>
+            out.init(FeeEstimatorHandle::alloc(fee_estimator))
+        );
+        FFIResult::ok()
+    }
+
+    fn release_fee_estimator(handle: FeeEstimatorHandle) -> FFIResult {
+        unsafe_block!("The upstream caller guarantees the handle will not be accessed after being freed" => FeeEstimatorHandle::dealloc(handle, |mut handle| {
+            FFIResult::ok()
+        }))
+    }
+}

bindings/src/lib.rs

@@ -23,7 +23,12 @@ pub(crate) mod lazy_static;
 pub(crate) mod is_null;
 
 mod adaptors;
+
+mod logger;
 mod broadcaster;
+mod fee_estimator;
+mod chainwatcher;
+
 mod channelmonitor;
 mod channelmanager;
 mod error;

bindings/src/logger.rs

@@ -0,0 +1,19 @@
+use crate::adaptors::*;
+use crate::handle::{Ref, Out, HandleShared};
+use crate::error::FFIResult;
+
+type FFILoggerHandle<'a> = HandleShared<'a, FFILogger>;
+
+ffi! {
+    fn create_logger(log_ref: Ref<FFILoggerFn::log_extern>, out: Out<FFILoggerHandle>) -> FFIResult {
+        let log = unsafe_block!("" => *log_ref.as_ref());
+        unsafe_block!("We know logger handle is not null by wrapper macro. And we know `Out` is writable" => out.init(FFILoggerHandle::alloc( FFILogger { log_ptr: log })));
+        FFIResult::ok()
+    }
+
+    fn release_logger(handle: FFILoggerHandle) -> FFIResult {
+        unsafe_block!("The upstream caller guarantees the handle will not be accessed after being freed" => FFILoggerHandle::dealloc(handle, |mut handle| {
+            FFIResult::ok()
+        }))
+    }
+}