cleanup: rename variables and remove unused deps

Author: joemphilips

bindings/Cargo.toml

@@ -18,7 +18,4 @@ 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/bindings.h

@@ -1,28 +1,18 @@
-use std::sync::{Arc};
-use std::ffi::{CStr, CString, NulError};
-use std::convert::TryFrom;
-
-use libc::c_char;
+use std::ffi::{CString};
 
 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, Level};
 
 use lightning::chain::chaininterface::{BroadcasterInterface,FeeEstimator,ConfirmationTarget, ChainWatchInterface, ChainError};
-use lightning::chain::keysinterface::{KeysManager, InMemoryChannelKeys};
+use lightning::chain::keysinterface::{InMemoryChannelKeys};
 use lightning::chain::transaction::{OutPoint};
 
-use lightning::ln::chan_utils::ChannelPublicKeys;
 use lightning::ln::channelmonitor::{ManyChannelMonitor, ChannelMonitor, HTLCUpdate, ChannelMonitorUpdateErr, ChannelMonitorUpdate};
 
-use crate::error::FFIResult;
-use crate::handle::{Out, Ref, RefMut,HandleShared};
-
 pub mod primitives;
 use primitives::*;
 
@@ -61,14 +51,14 @@ impl ManyChannelMonitor<InMemoryChannelKeys> for FFIManyChannelMonitor {
     }
 }
 
-pub mod BroadcasterFn {
+pub mod broadcaster_fn {
     use crate::adaptors::primitives::FFITransaction;
-    pub type broadcast_transaction_ptr = extern "cdecl" fn(tx: *const FFITransaction);
+    pub type BroadcastTransactionPtr = extern "cdecl" fn(tx: *const FFITransaction);
 }
 
 #[repr(C)]
 pub struct FFIBroadCaster {
-  pub broadcast_transaction_ptr: BroadcasterFn::broadcast_transaction_ptr,
+  pub broadcast_transaction_ptr: broadcaster_fn::BroadcastTransactionPtr,
 }
 
 impl BroadcasterInterface for FFIBroadCaster {
@@ -97,14 +87,14 @@ impl From<ConfirmationTarget> for FFIConfirmationTarget {
     }
 }
 
-pub mod FeeEstimatorFn {
+pub mod fee_estimator_fn {
     use super::{FFIConfirmationTarget, FFIFeeEstimator};
-    pub type get_est_sat_per_1000_weight_ptr = extern "cdecl" fn (*const FFIFeeEstimator, FFIConfirmationTarget) -> u64;
+    pub type GetEstSatPer1000WeightPtr = extern "cdecl" fn (*const FFIFeeEstimator, FFIConfirmationTarget) -> u64;
 }
 
 #[repr(C)]
 pub struct FFIFeeEstimator {
-    pub get_est_sat_per_1000_weight_ptr: FeeEstimatorFn::get_est_sat_per_1000_weight_ptr,
+    pub get_est_sat_per_1000_weight_ptr: fee_estimator_fn::GetEstSatPer1000WeightPtr,
 }
 
 impl FeeEstimator for FFIFeeEstimator {
@@ -182,9 +172,9 @@ impl<'a> From<Record<'a>> for FFILogRecord {
         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,
+            args,
+            module_path,
+            file,
             line: rec.line,
         }
     }
@@ -196,14 +186,14 @@ impl<'a, 'b> From<&'a Record<'b>> for FFILogRecord {
     }
 }
 
-pub mod FFILoggerFn {
+pub mod ffilogger_fn {
     use super::{FFILogRecord, FFILogger};
-    pub type log_extern = extern "cdecl" fn(logger: *const FFILogger, record: *const FFILogRecord);
+    pub type LogExtern = extern "cdecl" fn(logger: *const FFILogger, record: *const FFILogRecord);
 }
 
 #[repr(C)]
 pub struct FFILogger {
-    pub log_ptr: FFILoggerFn::log_extern,
+    pub log_ptr: ffilogger_fn::LogExtern,
 }
 
 impl Logger for FFILogger {
@@ -213,30 +203,31 @@ impl Logger for FFILogger {
     }
 }
 
-pub mod ChainWatchInterfaceFn {
+pub mod chain_watch_interface_fn {
     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);
+    pub type InstallWatchTxPtr = extern "cdecl" fn(*const FFIChainWatchInterface, *const FFISha256dHash, script_pub_key: *const FFIScript);
+    pub type InstallWatchOutpointPtr = extern "cdecl" fn(*const FFIChainWatchInterface, outpoint: *const FFIOutPoint, out_script: *const FFIScript);
+    pub type WatchAllTxnPtr = extern "cdecl" fn(*const FFIChainWatchInterface);
+    pub type GetChainUtxoPtr = extern "cdecl" fn(*const FFIChainWatchInterface, genesis_hash: *const FFISha256dHash, unspent_tx_output_identifier: u64, err: *mut ChainError, script: *mut FFITxOut);
+    pub type FilterBlockPtr = extern "cdecl" fn(*const FFIChainWatchInterface, *const FFIBlock);
 }
 
 #[repr(C)]
 pub struct FFIChainWatchInterface {
-    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,
+    pub install_watch_tx_ptr: chain_watch_interface_fn::InstallWatchTxPtr,
+    pub install_watch_outpoint_ptr: chain_watch_interface_fn::InstallWatchOutpointPtr,
+    pub watch_all_txn_ptr: chain_watch_interface_fn::WatchAllTxnPtr,
+    pub get_chain_utxo_ptr: chain_watch_interface_fn::GetChainUtxoPtr,
+    pub filter_block_ptr: chain_watch_interface_fn::FilterBlockPtr,
 }
 
 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")
+        let ffi_outpoint = FFIOutPoint { txid: outpoint.0.into(), index: outpoint.1 };
+        (self.install_watch_outpoint_ptr)(self, &ffi_outpoint as *const _, &out_script.into() as *const _)
     }
 	fn watch_all_txn(&self) {
         unimplemented!()

bindings/build.rs

@@ -1,12 +1,12 @@
 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::blockdata::transaction::{Transaction};
 use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 
 macro_rules! array_struct{
-    ($name:ident, $ty:ty) => {
+    (
+        $(#[$outer:meta])*
+        $name:ident, $ty:ty) => {
         #[repr(C)]
         pub struct $name<'a> {
             ptr: *const $ty,
@@ -21,10 +21,10 @@ macro_rules! array_struct{
     }
 }
 
-/// The length must be `secp256k1::constants::SECRET_KEY_SIZE` ,
+#[doc="The length must be `secp256k1::constants::SECRET_KEY_SIZE`"]
 array_struct!(SecretKey, u8);
 
-/// The length must be `secp256k1::constants::PUBLIC_KEY_SIZE` ,
+#[doc="The length must be `secp256k1::constants::PUBLIC_KEY_SIZE`"]
 array_struct!(PublicKey, u8);
 
 array_struct!(FFISha256dHash, u8);
@@ -65,7 +65,7 @@ impl<'a> From<&Script> for FFIScript<'a> {
 #[repr(C)]
 pub struct FFIOutPoint<'a> {
 	pub txid: FFISha256dHash<'a>,
-	pub index: u16,
+	pub index: u32,
 }
 
 #[repr(C)]

bindings/hoge.rs

@@ -3,14 +3,10 @@
 /// ChannelMonitor or ChannelManager and hold a reference to it.
 /// However, sometimes it is useful for testing.
 
-use std::sync::Arc;
 use crate::adaptors::*;
-use bitcoin::Transaction;
 use crate::handle::{Ref, Out, HandleShared};
 use crate::error::FFIResult;
 
-use lightning::chain::chaininterface::{BroadcasterInterface};
-
 type FFIBroadCasterHandle<'a> = HandleShared<'a, FFIBroadCaster>;
 
 #[cfg(feature = "debug_assertions")]
@@ -31,7 +27,7 @@ type BroadcasterWrapperHandle<'a> = HandleShared<'a, BroadcasterWrapper>;
 
 
 ffi! {
-    fn create_broadcaster(broadcast_transaction_ptr: Ref<BroadcasterFn::broadcast_transaction_ptr>, out: Out<FFIBroadCasterHandle>) -> FFIResult {
+    fn create_broadcaster(broadcast_transaction_ptr: Ref<broadcaster_fn::BroadcastTransactionPtr>, 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)));

bindings/src/adaptors/mod.rs

@@ -6,11 +6,11 @@ type ChainWatchInterfaceHandle<'a> = HandleShared<'a, FFIChainWatchInterface>;
 
 ffi! {
     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>,
+        install_watch_tx_ref: Ref<chain_watch_interface_fn::InstallWatchTxPtr>,
+        install_watch_outpoint_ref: Ref<chain_watch_interface_fn::InstallWatchOutpointPtr>,
+        watch_all_txn_ref: Ref<chain_watch_interface_fn::WatchAllTxnPtr>,
+        get_chain_utxo_ref: Ref<chain_watch_interface_fn::GetChainUtxoPtr>,
+        filter_block_ref: Ref<chain_watch_interface_fn::FilterBlockPtr>,
         handle: Out<ChainWatchInterfaceHandle>
     ) -> FFIResult {
         let install_watch_tx =

bindings/src/adaptors/primitives.rs

@@ -1,20 +1,18 @@
-use bitcoin::blockdata::transaction::Transaction;
 use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use lightning::util::config::UserConfig;
 use lightning::chain::keysinterface::{KeysManager, InMemoryChannelKeys};
 use lightning::ln::channelmanager::{ChannelManager};
-use lightning::chain::chaininterface::{BroadcasterInterface};
 
-use crate::handle::{Out, Ref, RefMut,HandleShared};
+use crate::handle::{Out, Ref, HandleShared};
 use crate::error::FFIResult;
 use crate::adaptors::*;
 
 type FFIArcChannelManager = ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<KeysManager>, Arc<FFIFeeEstimator>>;
 type FFIArcChannelManagerHandle<'a> = HandleShared<'a, FFIArcChannelManager>;
 
-/// We wanted to use `ffi` macro here, but Arc<dyn Logger> does not support unwind safety.
+// We wanted to use `ffi` macro here, but Arc<dyn Logger> does not support unwind safety.
 ffi_no_catch!{
     fn create_ffi_channel_manager(
         seed_ptr: Ref<u8>,

bindings/src/broadcaster.rs

@@ -1,13 +1,9 @@
 use std::sync::Arc;
 
-use bitcoin::blockdata::transaction::Transaction;
-
-use lightning::chain::transaction::OutPoint;
 use lightning::chain::keysinterface::{InMemoryChannelKeys};
 use lightning::ln::channelmonitor::SimpleManyChannelMonitor;
 
 use crate::adaptors::{FFIBroadCaster, FFIFeeEstimator, FFILogger, FFIChainWatchInterface};
-use crate::adaptors::primitives::{FFIScript, FFIOutPoint, FFIBlock, FFISha256dHash, FFITxOut, FFITransaction};
 use crate::error::FFIResult;
 use crate::handle::{Ref, HandleShared, Out};
 

bindings/src/chainwatcher.rs

@@ -2,10 +2,7 @@
 
 use std::error::Error;
 use std::cell::RefCell;
-use std::slice;
-use std::ptr;
 use std::ops::Try;
-use std::fmt;
 use std::fmt::Write;
 use std::panic::{catch_unwind, UnwindSafe};
 use std::any::Any;

bindings/src/channelmanager.rs

@@ -5,7 +5,7 @@ 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 {
+    fn create_fee_estimator(fn_ref: Ref<fee_estimator_fn::GetEstSatPer1000WeightPtr>, 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" =>

bindings/src/channelmonitor.rs

@@ -7,7 +7,6 @@ use std::cell::UnsafeCell;
 use std::collections::HashMap;
 use std::ops::{Deref, DerefMut};
 
-use crate::utils::macros;
 use crate::lazy_static;
 
 type ThreadId = usize;

bindings/src/error.rs

@@ -37,8 +37,6 @@ mod handle;
 #[cfg(feature = "debug_assertions")]
 mod ffi_test_utils;
 
-use std::sync::{Arc};
-
 pub use handle::*;
 pub use error::*;
 

bindings/src/fee_estimator.rs

@@ -5,7 +5,7 @@ use crate::error::FFIResult;
 type FFILoggerHandle<'a> = HandleShared<'a, FFILogger>;
 
 ffi! {
-    fn create_logger(log_ref: Ref<FFILoggerFn::log_extern>, out: Out<FFILoggerHandle>) -> FFIResult {
+    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 })));
         FFIResult::ok()

bindings/src/handle/thread_bound.rs

@@ -474,7 +474,7 @@ impl Writeable for InputMaterial  {
 				writer.write_all(&byte_utils::be64_to_array(*amount))?;
 			}
 		}
-		Ok(())
+	Ok(())
 	}
 }