update

Author: joemphilips

bindings/Cargo.toml

@@ -18,6 +18,7 @@ secp256k1 = "0.15"
 bitcoin = "0.21"
 bitcoin_hashes = "0.7"
 hex = { version = "0.3", optional = true }
+libc = "0.2.68"
 
 [build-dependencies]
 cbindgen = "0.13.1"

bindings/hoge.rs

@@ -1,13 +1,19 @@
 use std::sync::{Arc};
+use std::ffi::{CStr, CString, NulError};
+use std::convert::TryFrom;
 
-use secp256k1::constants::{SECRET_KEY_SIZE, PUBLIC_KEY_SIZE};
+use libc::c_char;
+
+use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 use bitcoin::util::key::PrivateKey;
 use bitcoin::blockdata::transaction::Transaction;
+use bitcoin::blockdata::script::Script;
+use bitcoin::blockdata::block::Block;
 use bitcoin::consensus::encode::serialize;
 
-use lightning::util::logger::{Logger, Record};
+use lightning::util::logger::{Logger, Record, Level};
 
-use lightning::chain::chaininterface::{BroadcasterInterface,FeeEstimator,ConfirmationTarget};
+use lightning::chain::chaininterface::{BroadcasterInterface,FeeEstimator,ConfirmationTarget, ChainWatchInterface, ChainError};
 use lightning::chain::keysinterface::{KeysManager, InMemoryChannelKeys};
 use lightning::chain::transaction::{OutPoint};
 
@@ -17,17 +23,8 @@ use lightning::ln::channelmonitor::{ManyChannelMonitor, ChannelMonitor, HTLCUpda
 use crate::error::FFIResult;
 use crate::handle::{Out, Ref, RefMut,HandleShared};
 
-#[repr(transparent)]
-struct SecretKey([u8; SECRET_KEY_SIZE]);
-
-#[repr(transparent)]
-struct PublicKey([u8; PUBLIC_KEY_SIZE]);
-
-#[repr(C)]
-struct FFIOutPoint {
-    txid: [u8; 32],
-    index: u16
-}
+pub mod primitives;
+use primitives::*;
 
 #[repr(C)]
 pub struct FFIManyChannelMonitor {
@@ -64,26 +61,50 @@ impl ManyChannelMonitor<InMemoryChannelKeys> for FFIManyChannelMonitor {
     }
 }
 
+pub mod BroadcasterFn {
+    use crate::adaptors::primitives::FFITransaction;
+    pub type broadcast_transaction_ptr = extern "cdecl" fn(tx: *const FFITransaction);
+}
+
 #[repr(C)]
 pub struct FFIBroadCaster {
-  broadcast_transaction_ptr: extern "cdecl" fn(tx: *const u8, tx_len: u64),
+  pub broadcast_transaction_ptr: BroadcasterFn::broadcast_transaction_ptr,
 }
 
 impl BroadcasterInterface for FFIBroadCaster {
     fn broadcast_transaction(&self, tx: &Transaction) {
-        let b_tx = serialize(tx);
-        (self.broadcast_transaction_ptr)(b_tx.as_ptr(), b_tx.len() as u64)
+        (self.broadcast_transaction_ptr)(&tx.into() as *const _)
+    }
+}
+
+#[repr(C)]
+pub enum FFIConfirmationTarget {
+	/// We are happy with this transaction confirming slowly when feerate drops some.
+	Background,
+	/// We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
+	Normal,
+	/// We'd like this transaction to confirm in the next few blocks.
+	HighPriority,
+}
+
+impl From<ConfirmationTarget> for FFIConfirmationTarget {
+    fn from(target: ConfirmationTarget) -> FFIConfirmationTarget {
+        match target {
+            ConfirmationTarget::Background => FFIConfirmationTarget::Background,
+            ConfirmationTarget::Normal => FFIConfirmationTarget::Normal,
+            ConfirmationTarget::HighPriority => FFIConfirmationTarget::HighPriority,
+        }
     }
 }
 
 #[repr(C)]
 pub struct FFIFeeEstimator {
-    get_est_sat_per_1000_weight_ptr: extern "cdecl" fn (&Self, ConfirmationTarget) -> u64,
+    get_est_sat_per_1000_weight_ptr: extern "cdecl" fn (&Self, FFIConfirmationTarget) -> u64,
 }
 
 impl FeeEstimator for FFIFeeEstimator {
 	fn get_est_sat_per_1000_weight(&self, confirmation_target: ConfirmationTarget) -> u64 {
-        (self.get_est_sat_per_1000_weight_ptr)(self, confirmation_target)
+        (self.get_est_sat_per_1000_weight_ptr)(self, confirmation_target.into())
     }
 }
 
@@ -104,13 +125,119 @@ impl FFINetwork {
     }
 }
 
+#[derive(Debug)]
+#[repr(C)]
+pub enum FFILogLevel {
+	///Designates logger being silent
+	Off,
+	/// Designates very serious errors
+	Error,
+	/// Designates hazardous situations
+	Warn,
+	/// Designates useful information
+	Info,
+	/// Designates lower priority information
+	Debug,
+	/// Designates very low priority, often extremely verbose, information
+	Trace,
+}
+
+impl From<Level> for FFILogLevel {
+    fn from(level: Level) -> FFILogLevel {
+        match level {
+            Level::Off => FFILogLevel::Off,
+            Level::Error => FFILogLevel::Error,
+            Level::Warn => FFILogLevel::Warn,
+            Level::Info => FFILogLevel::Info,
+            Level::Debug => FFILogLevel::Debug,
+            Level::Trace => FFILogLevel::Trace
+        }
+    }
+}
+
+#[repr(C)]
+pub struct FFILogRecord {
+	/// The verbosity level of the message.
+	pub level: FFILogLevel,
+	/// The message body.
+	pub args: CString,
+	/// The module path of the message.
+	pub module_path: CString,
+	/// The source file containing the message.
+	pub file: CString,
+	/// 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: args,
+            module_path: module_path,
+            file: file,
+            line: rec.line,
+        }
+    }
+}
+
+impl<'a, 'b> From<&'a Record<'b>> for FFILogRecord {
+    fn from(rec: &'a Record) -> Self {
+        rec.into()
+    }
+}
+
 #[repr(C)]
 pub struct FFILogger {
-    log_ptr: fn(&Self, &Record),
+    log_ptr: extern "cdecl" fn(*const Self, *const FFILogRecord),
 }
 
 impl Logger for FFILogger {
 	fn log(&self, record: &Record) {
-        (self.log_ptr)(self, record);
+        let ffi_record: FFILogRecord = record.into();
+        (self.log_ptr)(self, &ffi_record as *const _);
     }
 }
+
+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);
+    pub type watch_all_txn_ptr = extern "cdecl" fn(*const FFIChainWatchInterface);
+    pub type get_chain_utxo_ptr = extern "cdecl" fn(*const FFIChainWatchInterface, genesis_hash: *const FFISha256dHash, unspent_tx_output_identifier: u64, err: *mut ChainError, script: *mut FFITxOut);
+    pub type filter_block_ptr = extern "cdecl" fn(*const FFIChainWatchInterface, *const FFIBlock);
+}
+
+#[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,
+}
+
+impl ChainWatchInterface for FFIChainWatchInterface {
+	fn install_watch_tx(&self, txid: &Sha256dHash, script_pub_key: &Script) {
+        (self.install_watch_tx_ptr)(self, &txid.into() as *const _, &script_pub_key.into() as *const _)
+    }
+	fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32), out_script: &Script) {
+        unimplemented!("TODO")
+    }
+	fn watch_all_txn(&self) {
+        unimplemented!()
+    }
+	fn get_chain_utxo(&self, genesis_hash: Sha256dHash, unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> {
+        unimplemented!()
+    }
+	fn filter_block<'a>(&self, block: &'a Block) -> (Vec<&'a Transaction>, Vec<u32>) {
+        unimplemented!()
+    }
+	fn reentered(&self) -> usize {
+        unimplemented!()
+    }
+}

bindings/src/adaptors/mod.rs

@@ -0,0 +1,87 @@
+use bitcoin::consensus::serialize;
+use secp256k1::constants::{SECRET_KEY_SIZE, PUBLIC_KEY_SIZE};
+use bitcoin::blockdata::script::Script;
+use bitcoin::blockdata::transaction::{Transaction, TxIn, TxOut};
+use bitcoin::blockdata::block::Block;
+use bitcoin_hashes::sha256d::Hash as Sha256dHash;
+
+macro_rules! array_struct{
+    ($name:ident, $ty:ty) => {
+        #[repr(C)]
+        pub struct $name {
+            ptr: *const $ty,
+            len: u64,
+        }
+    }
+}
+
+/// The length must be `secp256k1::constants::SECRET_KEY_SIZE` ,
+array_struct!(SecretKey, u8);
+
+/// The length must be `secp256k1::constants::PUBLIC_KEY_SIZE` ,
+array_struct!(PublicKey, u8);
+
+array_struct!(FFISha256dHash, u8);
+
+impl From<&Sha256dHash> for FFISha256dHash {
+    fn from(hash: &Sha256dHash) -> Self {
+        let len = hash.len() as u64;
+        let ptr = hash.as_ptr();
+        FFISha256dHash { ptr: ptr, len: len, }
+    }
+}
+
+impl From<Sha256dHash> for FFISha256dHash {
+    fn from(hash: Sha256dHash) -> Self {
+        let len = hash.len() as u64; let ptr = hash.as_ptr();
+        FFISha256dHash{ ptr: ptr, len: len, }
+    }
+}
+
+
+array_struct!(FFIScript, u8);
+
+impl From<Script> for FFIScript {
+    fn from(script: Script) -> Self {
+        let len = script.len() as u64;
+        let ptr = script.as_bytes().as_ptr();
+        FFIScript { ptr: ptr, len: len, }
+    }
+}
+impl From<&Script> for FFIScript {
+    fn from(script: &Script) -> Self {
+        let len = script.len() as u64;
+        let ptr = script.as_bytes().as_ptr();
+        FFIScript { ptr: ptr, len: len, }
+    }
+}
+
+#[repr(C)]
+pub struct FFIOutPoint {
+	pub txid: FFISha256dHash,
+	pub index: u16,
+}
+
+#[repr(C)]
+pub struct FFITxOut {
+    value: u64,
+    script_pubkey: FFIScript,
+}
+
+array_struct!(FFITransaction, u8);
+impl From<Transaction> for FFITransaction {
+    fn from(tx: Transaction) -> Self {
+        let txb = serialize(&tx);
+        FFITransaction {
+            ptr: txb.as_ptr(),
+            len: txb.len() as u64,
+        }
+    }
+}
+impl From<&Transaction> for FFITransaction {
+    fn from(tx: &Transaction) -> Self {
+        Self::from(tx.clone())
+    }
+}
+
+array_struct!(FFIBlock, u8);

bindings/src/adaptors/primitives.rs

@@ -0,0 +1,60 @@
+/// functions for managing broadcaster.
+/// Usually, you don't have to have a handler to the broadcaster in a wrapper side. Just create
+/// ChannelMonitor or ChannelManager and hold a reference to it.
+/// However, sometimes it is useful for testing.
+
+use crate::adaptors::*;
+use crate::handle::{Ref, Out, HandleShared};
+use crate::error::FFIResult;
+
+#[cfg(feature = "debug_assertions")]
+#[repr(C)]
+struct BroadcasterWrapper {
+    broadcaster: Arc<FFIBroadCaster>,
+}
+
+#[cfg(feature = "debug_assertions")]
+impl BroadcasterWrapper {
+    pub fn broadcast(&self, tx: &tx) {
+        self.broadcaster.broadcast_transaction(&tx)
+    }
+}
+type FFIBroadCasterHandle<'a> = HandleShared<'a, FFIBroadCaster>;
+
+ffi! {
+    fn create_broadcaster(broadcast_transaction_ptr: Ref<BroadcasterFn::broadcast_transaction_ptr>, out: Out<FFIBroadCasterHandle>) -> FFIResult {
+        let broadcast_transaction = unsafe_block!("" => *broadcast_transaction_ptr.as_ref());
+        let broadcaster = FFIBroadCaster{ broadcast_transaction_ptr: broadcast_transaction };
+        unsafe_block!("" => out.init(HandleShared::alloc(broadcaster)));
+        FFIResult::ok()
+    }
+
+    fn release_broadcaster(handle: FFIBroadCasterHandle) -> FFIResult {
+        unsafe_block!("The upstream caller guarantees the handle will not be accessed after being freed" => FFIBroadCasterHandle::dealloc(handle, |mut handle| {
+            FFIResult::ok()
+        }))
+    }
+}
+
+#[cfg(feature = "debug_assertions")]
+ffi! {
+    fn ffi_test_broadcaster(broadcaster_ptr: Ref<FFIBroadCaster>) -> FFIResult {
+        let broadcaster = unsafe_block!("" => broadcaster_ptr.as_ref());
+        let tx: Transaction = bitcoin::consensus::deserialize(&hex::decode("020000000001031cfbc8f54fbfa4a33a30068841371f80dbfe166211242213188428f437445c91000000006a47304402206fbcec8d2d2e740d824d3d36cc345b37d9f65d665a99f5bd5c9e8d42270a03a8022013959632492332200c2908459547bf8dbf97c65ab1a28dec377d6f1d41d3d63e012103d7279dfb90ce17fe139ba60a7c41ddf605b25e1c07a4ddcb9dfef4e7d6710f48feffffff476222484f5e35b3f0e43f65fc76e21d8be7818dd6a989c160b1e5039b7835fc00000000171600140914414d3c94af70ac7e25407b0689e0baa10c77feffffffa83d954a62568bbc99cc644c62eb7383d7c2a2563041a0aeb891a6a4055895570000000017160014795d04cc2d4f31480d9a3710993fbd80d04301dffeffffff06fef72f000000000017a91476fd7035cd26f1a32a5ab979e056713aac25796887a5000f00000000001976a914b8332d502a529571c6af4be66399cd33379071c588ac3fda0500000000001976a914fc1d692f8de10ae33295f090bea5fe49527d975c88ac522e1b00000000001976a914808406b54d1044c429ac54c0e189b0d8061667e088ac6eb68501000000001976a914dfab6085f3a8fb3e6710206a5a959313c5618f4d88acbba20000000000001976a914eb3026552d7e3f3073457d0bee5d4757de48160d88ac0002483045022100bee24b63212939d33d513e767bc79300051f7a0d433c3fcf1e0e3bf03b9eb1d70220588dc45a9ce3a939103b4459ce47500b64e23ab118dfc03c9caa7d6bfc32b9c601210354fd80328da0f9ae6eef2b3a81f74f9a6f66761fadf96f1d1d22b1fd6845876402483045022100e29c7e3a5efc10da6269e5fc20b6a1cb8beb92130cc52c67e46ef40aaa5cac5f0220644dd1b049727d991aece98a105563416e10a5ac4221abac7d16931842d5c322012103960b87412d6e169f30e12106bdf70122aabb9eb61f455518322a18b920a4dfa887d30700")?)?;
+        broadcaster.broadcast_transaction(&tx);
+        FFIResult::ok()
+    }
+    fn ffi_test_broadcaster_in_wrapper(broadcaster_ptr: Ref<FFIBroadCaster>, out: Out<BroadcasterWrapper>) -> FFIResult {
+        let broadcaster = unsafe_block!("" => broadcaster_ptr.as_arc());
+        let wrapper_raw = BroadcasterWrapper{ broadcaster: broadcaster };
+        let tx: Transaction = bitcoin::consensus::deserialize(&hex::decode("020000000001031cfbc8f54fbfa4a33a30068841371f80dbfe166211242213188428f437445c91000000006a47304402206fbcec8d2d2e740d824d3d36cc345b37d9f65d665a99f5bd5c9e8d42270a03a8022013959632492332200c2908459547bf8dbf97c65ab1a28dec377d6f1d41d3d63e012103d7279dfb90ce17fe139ba60a7c41ddf605b25e1c07a4ddcb9dfef4e7d6710f48feffffff476222484f5e35b3f0e43f65fc76e21d8be7818dd6a989c160b1e5039b7835fc00000000171600140914414d3c94af70ac7e25407b0689e0baa10c77feffffffa83d954a62568bbc99cc644c62eb7383d7c2a2563041a0aeb891a6a4055895570000000017160014795d04cc2d4f31480d9a3710993fbd80d04301dffeffffff06fef72f000000000017a91476fd7035cd26f1a32a5ab979e056713aac25796887a5000f00000000001976a914b8332d502a529571c6af4be66399cd33379071c588ac3fda0500000000001976a914fc1d692f8de10ae33295f090bea5fe49527d975c88ac522e1b00000000001976a914808406b54d1044c429ac54c0e189b0d8061667e088ac6eb68501000000001976a914dfab6085f3a8fb3e6710206a5a959313c5618f4d88acbba20000000000001976a914eb3026552d7e3f3073457d0bee5d4757de48160d88ac0002483045022100bee24b63212939d33d513e767bc79300051f7a0d433c3fcf1e0e3bf03b9eb1d70220588dc45a9ce3a939103b4459ce47500b64e23ab118dfc03c9caa7d6bfc32b9c601210354fd80328da0f9ae6eef2b3a81f74f9a6f66761fadf96f1d1d22b1fd6845876402483045022100e29c7e3a5efc10da6269e5fc20b6a1cb8beb92130cc52c67e46ef40aaa5cac5f0220644dd1b049727d991aece98a105563416e10a5ac4221abac7d16931842d5c322012103960b87412d6e169f30e12106bdf70122aabb9eb61f455518322a18b920a4dfa887d30700")?)?;
+        let wrapper = out.init(wrapper_raw);
+        wrapper.broadcast(&tx);
+    }
+
+    fn ffi_test_chainwatch_interface(chainwatcher_ptr: Ref<FFIChainWatchInterface>) -> FFIResult {
+        let chainwatcher = unsafe_block!("" => chainwatcher_ptr.as_ref());
+        // chainwatcher.install_watch_tx();
+        FFIResult::ok()
+    }
+}

bindings/src/broadcaster.rs

@@ -0,0 +1,11 @@
+use crate::adaptors::*;
+use crate::error::FFIResult;
+use crate::handle::{Ref};
+
+ffi! {
+    fn ffi_test_chainwatch_interface(chainwatcher_ptr: Ref<FFIChainWatchInterface>) -> FFIResult {
+        let chainwatcher = unsafe_block!("" => chainwatcher_ptr.as_ref());
+        // chainwatcher.install_watch_tx();
+        FFIResult::ok()
+    }
+}