add entrypoint for testing

Author: joemphilips

bindings/Cargo.toml

@@ -11,7 +11,7 @@ crate-type=["staticlib", "cdylib"]
 
 [dependencies]
 lightning = { path = "../lightning" }
-secp256k1 = "0.17.2"
+secp256k1 = "0.15"
 bitcoin = "0.21"
 
 [build-dependencies]

bindings/src/adaptors/mod.rs

@@ -1,21 +1,83 @@
 use std::sync::{Arc};
-use std::time::{SystemTime, UNIX_EPOCH};
 
+use secp256k1::constants::{SECRET_KEY_SIZE, PUBLIC_KEY_SIZE};
 use bitcoin::blockdata::transaction::{Transaction};
+use bitcoin::util::key::PrivateKey;
 
-use lightning::util::config::UserConfig;
 use lightning::util::logger::{Logger, Record};
 
 use lightning::chain::chaininterface::{BroadcasterInterface,FeeEstimator,ConfirmationTarget};
 use lightning::chain::keysinterface::{KeysManager, InMemoryChannelKeys};
 use lightning::chain::transaction::{OutPoint};
 
+use lightning::ln::chan_utils::ChannelPublicKeys;
 use lightning::ln::channelmonitor::{ManyChannelMonitor, ChannelMonitor, HTLCUpdate, ChannelMonitorUpdateErr, ChannelMonitorUpdate};
-use lightning::ln::channelmanager::{ChannelManager};
 
 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)]
+pub struct ChannelPublicKeys{
+	/// The public key which is used to sign all commitment transactions, as it appears in the
+	/// on-chain channel lock-in 2-of-2 multisig output.
+	pub funding_pubkey: PublicKey,
+	/// The base point which is used (with derive_public_revocation_key) to derive per-commitment
+	/// revocation keys. The per-commitment revocation private key is then revealed by the owner of
+	/// a commitment transaction so that their counterparty can claim all available funds if they
+	/// broadcast an old state.
+	pub revocation_basepoint: PublicKey,
+	/// The base point which is used (with derive_public_key) to derive a per-commitment payment
+	/// public key which receives immediately-spendable non-HTLC-encumbered funds.
+	pub payment_basepoint: PublicKey,
+	/// The base point which is used (with derive_public_key) to derive a per-commitment payment
+	/// public key which receives non-HTLC-encumbered funds which are only available for spending
+	/// after some delay (or can be claimed via the revocation path).
+	pub delayed_payment_basepoint: PublicKey,
+	/// The base point which is used (with derive_public_key) to derive a per-commitment public key
+	/// which is used to encumber HTLC-in-flight outputs.
+	pub htlc_basepoint: PublicKey,
+};
+
+*/
+
+#[repr(C)]
+struct FFIInMemoryChannelKeys {
+	/// Private key of anchor tx
+	funding_key: SecretKey,
+	/// Local secret key for blinded revocation pubkey
+	revocation_base_key: SecretKey,
+	/// Local secret key used in commitment tx htlc outputs
+	payment_base_key: SecretKey,
+	/// Local secret key used in HTLC tx
+	delayed_payment_base_key: SecretKey,
+	/// Local htlc secret key used in commitment tx htlc outputs
+	htlc_base_key: SecretKey,
+	/// Commitment seed
+	commitment_seed: [u8; 32],
+	/// Local public keys and basepoints
+	pub(crate) local_channel_pubkeys: ChannelPublicKeys,
+	/// Remote public keys and base points
+	pub(crate) remote_channel_pubkeys: Option<ChannelPublicKeys>,
+	/// The total value of this channel
+    channel_value_satoshis: u64,
+}
+
+// #[repr(c)]
+// struct FFIChannelMonitor {
+// }
+#[repr(C)]
+struct FFIOutPoint {
+    txid: [u8; 32],
+    index: u16
+}
+
 #[repr(C)]
 pub struct FFIManyChannelMonitor {
     add_monitor_ptr: extern "C" fn(&Self, funding_txo: OutPoint, monitor: ChannelMonitor<InMemoryChannelKeys>) -> i32,
@@ -100,6 +162,3 @@ impl Logger for FFILogger {
         (self.log_ptr)(self, record);
     }
 }
-
-type FFIArcChannelManager = ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<KeysManager>, Arc<FFIFeeEstimator>>;
-type FFIArcChannelManagerHandle<'a> = HandleShared<'a, FFIArcChannelManager>;

bindings/src/lib.rs

@@ -22,10 +22,11 @@ mod channelmanager;
 mod error;
 mod handle;
 
+use std::sync::{Arc};
+
 pub use handle::*;
 pub use error::*;
 
-
 ffi_no_catch! {
     fn ffi_last_result(
         message_buf: Out<u8>,
@@ -70,4 +71,51 @@ ffi! {
     fn ffi_test_ok() -> FFIResult {
         FFIResult::ok()
     }
-}
+}
+
+
+#[cfg(debug_assertions)]
+#[repr(C)]
+pub struct FFITestInputStruct {
+    fn_ptr: extern "C" fn(&Self),
+}
+impl FFITestInputStruct {
+    pub fn call(&self) {
+        (self.fn_ptr)(self)
+    }
+}
+
+#[cfg(debug_assertions)]
+pub struct FFITestOutputStruct {
+    field: Arc<FFITestInputStruct>
+}
+
+impl FFITestOutputStruct {
+    fn complete(&self) {
+        println!("finished!");
+    }
+}
+#[cfg(debug_assertions)]
+type FFITestOutputStructHandle<'a> = HandleShared<'a, FFITestOutputStruct>;
+
+#[cfg(debug_assertions)]
+ffi! {
+    fn ffi_test_simple_struct_with_function_pointer(
+        input: Ref<FFITestInputStruct>,
+        output: Out<FFITestOutputStructHandle>
+    ) -> FFIResult {
+        let input_arc = unsafe_block!(" " => input.as_arc());
+        let result = FFITestOutputStruct{ field: input_arc };
+        result.field.call();
+        unsafe_block!("We know output is not null by wrapper macro. And we know `Out` is writable" => output.init(HandleShared::alloc(result)));
+        FFIResult::ok()
+    }
+
+    fn ffi_test_release(handle: FFITestOutputStructHandle) -> FFIResult {
+        unsafe_block!("The upstream caller guarantees the handle will not be accessed after being freed" => FFITestOutputStructHandle::dealloc(handle, |mut handle| {
+            handle.complete();
+
+            FFIResult::ok()
+        }))
+    }
+}