update

Author: joemphilips

bindings/src/adaptors/mod.rs

@@ -126,41 +126,20 @@ impl From<Level> for FFILogLevel {
 }
 
 #[repr(C)]
+#[derive(Debug)]
 pub struct FFILogRecord {
 	/// The verbosity level of the message.
 	pub level: FFILogLevel,
 	/// The message body.
-	pub args: CString,
+	pub args: *const i8,
 	/// The module path of the message.
-	pub module_path: CString,
+	pub module_path: *const i8,
 	/// The source file containing the message.
-	pub file: CString,
+	pub file: *const i8,
 	/// The line containing the message.
 	pub line: u32,
 }
 
-
-impl<'a> From<Record<'a>> for FFILogRecord {
-    fn from(rec: Record<'a>) -> Self {
-        let args = CString::new(std::fmt::format(rec.args)).unwrap_or(CString::new("Record.args contains null char in the middle").unwrap());
-        let module_path = CString::new(rec.module_path).unwrap_or(CString::new("Record.module_path contains null char in the middle").unwrap());
-        let file = CString::new(rec.file).unwrap_or(CString::new("Record.file contains null char in the middle").unwrap());
-        FFILogRecord {
-            level: rec.level.into(),
-            args,
-            module_path,
-            file,
-            line: rec.line,
-        }
-    }
-}
-
-impl<'a, 'b> From<&'a Record<'b>> for FFILogRecord {
-    fn from(rec: &'a Record) -> Self {
-        rec.into()
-    }
-}
-
 pub mod ffilogger_fn {
     use super::{FFILogRecord, FFILogger};
     pub type LogExtern = extern "cdecl" fn(record: *const FFILogRecord);
@@ -172,9 +151,21 @@ pub struct FFILogger {
 }
 
 impl Logger for FFILogger {
-	fn log(&self, record: &Record) {
-        let ffi_record: FFILogRecord = record.into();
+	fn log(&self, rec: &Record) {
+        let args = CString::new(std::fmt::format(rec.args)).unwrap_or(CString::new("Record.args contains null char in the middle").unwrap());
+        let module_path = CString::new(rec.module_path).unwrap_or(CString::new("Record.module_path contains null char in the middle").unwrap());
+        let file = CString::new(rec.file).unwrap_or(CString::new("Record.file contains null char in the middle").unwrap());
+        let ffi_record =
+            FFILogRecord {
+                level: rec.level.into(),
+                args: args.as_ptr(),
+                module_path: module_path.as_ptr(),
+                file: file.as_ptr(),
+                line: rec.line,
+            };
+        println!("Going to call log callback with {:?}", ffi_record);
         (self.log_ptr)(&ffi_record as *const _);
+        println!("rust: finished calling logger");
     }
 }
 
@@ -183,7 +174,7 @@ pub mod chain_watch_interface_fn {
     pub type InstallWatchTxPtr = extern "cdecl" fn(*const FFISha256dHash, script_pub_key: *const FFIScript);
     pub type InstallWatchOutpointPtr = extern "cdecl" fn(outpoint: *const FFIOutPoint, out_script: *const FFIScript);
     pub type WatchAllTxnPtr = extern "cdecl" fn();
-    pub type GetChainUtxoPtr = extern "cdecl" fn(genesis_hash: *const FFISha256dHash, unspent_tx_output_identifier: u64, err: *mut ChainError, script: *mut FFITxOut);
+    pub type GetChainUtxoPtr = extern "cdecl" fn(genesis_hash: *const FFISha256dHash, unspent_tx_output_identifier: u64, err: *mut FFIChainError, script: *mut FFITxOut);
     pub type FilterBlockPtr = extern "cdecl" fn(*const FFIBlock);
 }
 
@@ -210,10 +201,20 @@ impl ChainWatchInterface for FFIChainWatchInterface {
         (self.install_watch_outpoint_ptr)(&ffi_outpoint as *const _, &ffi_outscript as *const _)
     }
     fn watch_all_txn(&self) {
-        unimplemented!()
+        (self.watch_all_txn_ptr)()
     }
     fn get_chain_utxo(&self, genesis_hash: Sha256dHash, unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> {
-        unimplemented!()
+        let err = std::ptr::null_mut();
+        let tx_out = std::ptr::null_mut();
+        (self.get_chain_utxo_ptr)(&genesis_hash.into(), unspent_tx_output_identifier, err, tx_out);
+        if err.is_null() {
+            let tx_out: FFITxOut = unsafe_block!("We know the caller has set the value into the tx_out" => (*tx_out).clone());
+            Ok((tx_out.script_pubkey.to_script(), tx_out.value))
+        }
+        else {
+            let e = unsafe_block!("we know the error is not a null pointer" => (*err).clone());
+            Err(e.into())
+        }
     }
     fn filter_block<'a>(&self, block: &'a Block) -> (Vec<&'a Transaction>, Vec<u32>) {
         unimplemented!()

bindings/src/adaptors/primitives.rs

@@ -3,12 +3,14 @@ use bitcoin::blockdata::script::Script;
 use bitcoin::blockdata::transaction::{Transaction};
 use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 use crate::FFIResult;
+use lightning::chain::chaininterface::ChainError;
 
 macro_rules! array_struct{
     (
         $(#[$meta:meta])*
         $name:ident, $ty:ty) => {
         $(#[$meta])*
+        #[derive(Clone)]
         #[repr(C)]
         pub struct $name<'a> {
             ptr: *const $ty,
@@ -61,18 +63,47 @@ impl<'a> From<Sha256dHash> for FFISha256dHash<'a> {
 
 
 array_struct!(FFIScript, u8);
+impl<'a> FFIScript<'a> {
+    pub fn to_script(&self) -> Script {
+        unimplemented!()
+    }
+}
 
+#[derive(Clone)]
 #[repr(C)]
 pub struct FFIOutPoint<'a> {
 	pub txid: FFISha256dHash<'a>,
 	pub index: u32,
 }
 
+#[derive(Clone)]
 #[repr(C)]
 pub struct FFITxOut<'a> {
-    value: u64,
-    script_pubkey: FFIScript<'a>,
+    pub value: u64,
+    pub script_pubkey: FFIScript<'a>,
+}
+
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+pub enum FFIChainError {
+    /// Client doesn't support UTXO lookup (but the chain hash matches our genesis block hash)
+    NotSupported,
+    /// Chain isn't the one watched
+    NotWatched,
+    /// Tx doesn't exist or is unconfirmed
+    UnknownTx,
 }
 
+impl From<FFIChainError> for ChainError {
+    fn from(e: FFIChainError) -> Self {
+        match e {
+            FFIChainError::NotSupported => ChainError::NotSupported,
+            FFIChainError::NotWatched => ChainError::NotWatched,
+            FFIChainError::UnknownTx => ChainError::UnknownTx,
+        }
+    }
+}
+
+
 array_struct!(FFITransaction, u8);
 array_struct!(FFIBlock, u8);

bindings/src/block_notirifer.rs

@@ -1,4 +1,4 @@
 
 use crate::handle::HandleShared;
 
-pub type FFIBlockNotifierHandle = HandleShared<'a, >;
+pub type FFIBlockNotifierHandle = HandleShared<'a, FFIBlockNotifier>;

bindings/src/logger.rs

@@ -7,8 +7,8 @@ pub type FFILoggerHandle<'a> = HandleShared<'a, FFILogger>;
 
 ffi! {
     fn create_logger(log_ref: Ref<ffilogger_fn::LogExtern>, 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 })));
+        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()
     }
 
@@ -26,7 +26,9 @@ use lightning::util::logger::{Record, Level};
 ffi! {
     fn test_logger(handle: FFILoggerHandle) -> FFIResult {
         let logger: &FFILogger = unsafe_block!("" => handle.as_ref());
-        logger.log(&Record::new(Level::Warn, std::format_args!("{}", "warn message for ffi."), "module_path", "logger.rs", 29));
+        let r: Record = Record::new(Level::Warn, std::format_args!("{}", "warn message for ffi."), "module_path", "logger.rs", 29);
+        logger.log(&r);
+        println!("rust: finished calling test_logger");
         FFIResult::ok()
     }
 }

lightning/src/chain/chaininterface.rs

@@ -23,7 +23,6 @@ use std::panic::{UnwindSafe, RefUnwindSafe};
 use std::ptr;
 
 /// Used to give chain error details upstream
-#[repr(C)]
 pub enum ChainError {
 	/// Client doesn't support UTXO lookup (but the chain hash matches our genesis block hash)
 	NotSupported,