externalize KeysInterface

Author: joemphilips

bindings/src/adaptors/mod.rs

@@ -7,8 +7,9 @@ use std::{
 };
 
 use bitcoin::hash_types::{BlockHash, Txid};
-use bitcoin::{blockdata::transaction::Transaction, blockdata::script::Script, blockdata::block::Block, consensus::serialize as bitcoin_serialize, Network};
+use bitcoin::{blockdata::transaction::Transaction, blockdata::script::Script, blockdata::block::Block, consensus::serialize as bitcoin_serialize, consensus::deserialize as bitcoin_deserialize, Network};
 use bitcoin::secp256k1;
+use bitcoin::secp256k1::{Secp256k1, Signing};
 
 use lightning::{
     chain::chaininterface::{BroadcasterInterface, FeeEstimator, ConfirmationTarget, ChainWatchInterface, ChainError},
@@ -22,6 +23,12 @@ use lightning::{
 pub mod primitives;
 use primitives::*;
 use std::sync::Arc;
+use lightning::chain::keysinterface::{ChannelKeys, InMemoryChannelKeys, KeysInterface};
+use bitcoin::secp256k1::{SecretKey, PublicKey};
+use bitcoin::secp256k1::Error::InvalidMessage;
+use bitcoin::util::key::Error::Secp256k1 as Secp256k1Error;
+use lightning::util::ser::Readable;
+use lightning::ln::msgs::DecodeError;
 
 type Cstr = NonNull<i8>;
 
@@ -285,6 +292,145 @@ impl ChainWatchInterface for FFIChainWatchInterface {
     }
 }
 
+#[repr(C)]
+pub struct FFIChannelKeys {
+    funding_key: [u8; 32],
+    revocation_base_key: [u8; 32],
+    payment_key: [u8; 32],
+    delayed_payment_base_key: [u8; 32],
+    htlc_base_key: [u8; 32],
+    commitment_seed: [u8; 32],
+    channel_value_satoshis: u64,
+    key_derivation_params_1: u64,
+    key_derivation_params_2: u64,
+}
+
+impl FFIChannelKeys {
+    fn to_in_memory_channel_keys<C: Signing>(&self, ctx: &Secp256k1<C>) -> InMemoryChannelKeys {
+        InMemoryChannelKeys::new(
+            ctx,
+            secp256k1::key::SecretKey::from_slice(&self.funding_key).unwrap(),
+            secp256k1::key::SecretKey::from_slice(&self.revocation_base_key).unwrap(),
+            secp256k1::key::SecretKey::from_slice(&self.payment_key).unwrap(),
+            secp256k1::key::SecretKey::from_slice(&self.delayed_payment_base_key).unwrap(),
+            secp256k1::key::SecretKey::from_slice(&self.htlc_base_key).unwrap(),
+                self.commitment_seed,
+            self.channel_value_satoshis,
+            (self.key_derivation_params_1, self.key_derivation_params_2)
+        )
+    }
+}
+
+impl Readable for FFIChannelKeys {
+    fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+        let funding_key = Readable::read(reader)?;
+        let revocation_base_key = Readable::read(reader)?;
+        let payment_key = Readable::read(reader)?;
+        let delayed_payment_base_key = Readable::read(reader)?;
+        let htlc_base_key = Readable::read(reader)?;
+        let commitment_seed = Readable::read(reader)?;
+        let channel_value_satoshis = Readable::read(reader)?;
+        let key_derivation_params_1 = Readable::read(reader)?;
+        let key_derivation_params_2 = Readable::read(reader)?;
+        Ok (FFIChannelKeys{
+            funding_key,
+            revocation_base_key,
+            payment_key,
+            delayed_payment_base_key,
+            htlc_base_key,
+            commitment_seed,
+            channel_value_satoshis,
+            key_derivation_params_1,
+            key_derivation_params_2,
+        })
+    }
+}
+
+pub mod keys_interface_fn {
+    use super::{Bytes32, FFIChannelKeys, Bool};
+    pub type GetNodeSecret = extern "cdecl" fn (*mut [u8; 32]);
+    pub type GetDestinationScript = extern "cdecl" fn (script_ptr: *mut u8, script_len: *mut usize);
+    pub type GetShutdownPubKey = extern "cdecl" fn (pk_ptr: *mut [u8; 33]);
+    pub type GetChannelKeys = extern "cdecl" fn (inbound: Bool, satoshis: u64, ffi_channel_keys_ptr: *mut [u8; 216]);
+    pub type GetOnionRand = extern "cdecl" fn (secret: *mut [u8; 32], prng_seed: *mut [u8; 32]);
+    pub type GetChannelId = extern "cdecl" fn(channel_id: *mut [u8; 32]);
+}
+
+pub struct FFIKeysInterface {
+    pub get_node_secret_ptr: keys_interface_fn::GetNodeSecret,
+    pub get_destination_script_ptr: keys_interface_fn::GetDestinationScript,
+    pub get_shutdown_pubkey_ptr: keys_interface_fn::GetShutdownPubKey,
+    pub get_channel_keys_ptr: keys_interface_fn::GetChannelKeys,
+    pub get_onion_rand_ptr: keys_interface_fn::GetOnionRand,
+    pub get_channel_id_ptr: keys_interface_fn::GetChannelId,
+    secp_ctx: Secp256k1<secp256k1::SignOnly>,
+}
+
+impl FFIKeysInterface {
+    pub fn new(
+        get_node_secret_ptr: keys_interface_fn::GetNodeSecret,
+        get_destination_script_ptr: keys_interface_fn::GetDestinationScript,
+        get_shutdown_pubkey_ptr: keys_interface_fn::GetShutdownPubKey,
+        get_channel_keys_ptr: keys_interface_fn::GetChannelKeys,
+        get_onion_rand_ptr: keys_interface_fn::GetOnionRand,
+        get_channel_id_ptr: keys_interface_fn::GetChannelId
+    ) -> Self {
+        FFIKeysInterface {
+            get_node_secret_ptr,
+            get_destination_script_ptr,
+            get_shutdown_pubkey_ptr,
+            get_channel_keys_ptr,
+            get_onion_rand_ptr,
+            get_channel_id_ptr,
+            secp_ctx: Secp256k1::signing_only()
+        }
+    }
+}
+
+impl KeysInterface for FFIKeysInterface {
+    type ChanKeySigner = InMemoryChannelKeys;
+
+    fn get_node_secret(&self) -> SecretKey {
+        let mut secret = [0u8; 32];
+        (self.get_node_secret_ptr)(&mut secret as *mut _);
+        SecretKey::from_slice(&secret).unwrap()
+    }
+
+    fn get_destination_script(&self) -> Script {
+        let mut script_ptr = [0u8; 512];
+        let mut script_len: &mut usize = &mut usize::MAX;
+        (self.get_destination_script_ptr)(script_ptr.as_mut_ptr(), script_len as *mut _);
+        let s = bitcoin::consensus::Decodable::consensus_decode(&script_ptr[..(*script_len)]).expect("Failed to deserialize script");
+        s
+    }
+
+    fn get_shutdown_pubkey(&self) -> PublicKey {
+        let mut pk = [0u8; 33];
+        (self.get_shutdown_pubkey_ptr)(&mut pk as *mut _);
+        PublicKey::from_slice(&pk).unwrap()
+    }
+
+    fn get_channel_keys(&self, inbound: bool, channel_value_satoshis: u64) -> Self::ChanKeySigner {
+        let mut channel_keys_b = [0u8; 216];
+        (self.get_channel_keys_ptr)(if inbound { Bool::True } else { Bool::False }, channel_value_satoshis, &mut channel_keys_b as *mut _);
+        let ffi_channel_keys: FFIChannelKeys = Readable::read(&mut channel_keys_b.as_ref()).expect("Failed to deserialize channel keys");
+        ffi_channel_keys.to_in_memory_channel_keys(&self.secp_ctx)
+    }
+
+    fn get_onion_rand(&self) -> (SecretKey, [u8; 32]) {
+        let mut secret = [0; 32];
+        let mut prng_seed = [0; 32];
+        (self.get_onion_rand_ptr)(&mut secret as *mut _, &mut prng_seed as *mut _);
+        (SecretKey::from_slice(&secret).unwrap(), prng_seed)
+    }
+
+    fn get_channel_id(&self) -> [u8; 32] {
+        let mut channel_id = [0; 32];
+        (self.get_channel_id_ptr)(&mut channel_id as *mut _);
+        channel_id
+    }
+}
+
 pub mod socket_descriptor_fn {
     use super::FFIBytes;
     pub type SendData = extern "cdecl" fn (data: FFIBytes, resume_read: u8) -> usize;

bindings/src/channelmanager.rs

@@ -14,7 +14,7 @@ use lightning::{
         channelmonitor::SimpleManyChannelMonitor
     },
     chain::{
-        keysinterface::{KeysManager, InMemoryChannelKeys},
+        keysinterface::{InMemoryChannelKeys},
         transaction::OutPoint
     },
     routing::router::Route,
@@ -38,7 +38,7 @@ use crate::{
 };
 
 pub type FFIManyChannelMonitor = SimpleManyChannelMonitor<OutPoint, InMemoryChannelKeys, Arc<FFIBroadCaster>, Arc<FFIFeeEstimator>, Arc<FFILogger>, Arc<FFIChainWatchInterface>>;
-pub type FFIArcChannelManager = ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<KeysManager>, Arc<FFIFeeEstimator>, Arc<FFILogger>>;
+pub type FFIArcChannelManager = ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<FFIKeysInterface>, Arc<FFIFeeEstimator>, Arc<FFILogger>>;
 pub type FFIArcChannelManagerHandle<'a> = HandleShared<'a, FFIArcChannelManager>;
 
 fn fail_htlc_backwards_inner(payment_hash: Ref<Bytes32>, payment_secret: &Option<PaymentSecret>, handle: FFIArcChannelManagerHandle) -> Result<bool, FFIResult> {
@@ -73,7 +73,6 @@ fn send_payment_inner(handle: FFIArcChannelManagerHandle, route_ref: Ref<FFIRout
 }
 
 pub(crate) fn construct_channel_manager(
-    seed: Ref<Bytes32>,
     ffi_network: FFINetwork,
     cfg: Ref<UserConfig>,
 
@@ -84,6 +83,8 @@ pub(crate) fn construct_channel_manager(
     filter_block: &chain_watch_interface_fn::FilterBlock,
     reentered: &chain_watch_interface_fn::ReEntered,
 
+    keys_interface: Arc<FFIKeysInterface>,
+
     broadcast_transaction_ptr: Ref<broadcaster_fn::BroadcastTransactionPtr>,
     log_ref: &ffilogger_fn::LogExtern,
     get_est_sat_per_1000_weight_ptr: Ref<fee_estimator_fn::GetEstSatPer1000WeightPtr>,
@@ -92,7 +93,6 @@ pub(crate) fn construct_channel_manager(
 ) -> FFIArcChannelManager {
     let network = ffi_network.to_network();
     let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-    let mut seed: [u8; 32] = unsafe_block!("it points to valid length buffer" => seed.as_ref()).clone().bytes;
 
     let logger_arc = Arc::new( FFILogger{ log_ptr: *log_ref } );
 
@@ -114,7 +114,6 @@ pub(crate) fn construct_channel_manager(
     let fee_est_fn_ref = unsafe_block!("" => get_est_sat_per_1000_weight_ptr.as_ref());
     let fee_est = FFIFeeEstimator{ get_est_sat_per_1000_weight_ptr: *fee_est_fn_ref };
 
-    let keyman = Arc::new(KeysManager::new(&seed, network, now.as_secs(), now.subsec_nanos()));
     let cfg = unsafe_block!("" => cfg.as_ref());
 
     let monitor =
@@ -126,7 +125,7 @@ pub(crate) fn construct_channel_manager(
         monitor,
         broadcaster,
         logger_arc,
-        keyman,
+        keys_interface,
         cfg.clone(),
         cur_block_height
     )
@@ -135,7 +134,6 @@ pub(crate) fn construct_channel_manager(
 ffi! {
 
     fn create_channel_manager(
-        seed: Ref<Bytes32>,
         network_ref: Ref<FFINetwork>,
         cfg: Ref<UserConfig>,
 
@@ -146,6 +144,13 @@ ffi! {
         filter_block_ptr: Ref<chain_watch_interface_fn::FilterBlock>,
         reentered_ptr: Ref<chain_watch_interface_fn::ReEntered>,
 
+        get_node_secret_ptr: Ref<keys_interface_fn::GetNodeSecret>,
+        get_destination_script_ptr: Ref<keys_interface_fn::GetDestinationScript>,
+        get_shutdown_key_ptr: Ref<keys_interface_fn::GetShutdownPubKey>,
+        get_channel_keys_ptr: Ref<keys_interface_fn::GetChannelKeys>,
+        get_onion_rand_ptr: Ref<keys_interface_fn::GetOnionRand>,
+        get_channel_id_ptr: Ref<keys_interface_fn::GetChannelId>,
+
         broadcast_transaction_ptr: Ref<broadcaster_fn::BroadcastTransactionPtr>,
         log_ptr: Ref<ffilogger_fn::LogExtern>,
         get_est_sat_per_1000_weight_ptr: Ref<fee_estimator_fn::GetEstSatPer1000WeightPtr>,
@@ -161,9 +166,23 @@ ffi! {
         let filter_block_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => filter_block_ptr.as_ref());
         let reentered_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => reentered_ptr.as_ref());
 
+        let get_node_secret_ref = unsafe_block!("function pointer lives as long as KeysInterface and it points to valid data" => get_node_secret_ptr.as_ref());
+        let get_destination_script_ref = unsafe_block!("function pointer lives as long as KeysInterface and it points to valid data" => get_destination_script_ptr.as_ref());
+        let get_shutdown_key_ref = unsafe_block!("function pointer lives as long as KeysInterface and it points to valid data" => get_shutdown_key_ptr.as_ref());
+        let get_channel_keys_ref = unsafe_block!("function pointer lives as long as KeysInterface and it points to valid data" => get_channel_keys_ptr.as_ref());
+        let get_onion_rand_ref = unsafe_block!("function pointer lives as long as KeysInterface and it points to valid data" => get_onion_rand_ptr.as_ref());
+        let get_channel_id_ref = unsafe_block!("function pointer lives as long as KeysInterface and it points to valid data" => get_channel_id_ptr.as_ref());
+        let keys_interface = FFIKeysInterface::new(
+            *get_node_secret_ref,
+            *get_destination_script_ref,
+            *get_shutdown_key_ref,
+            *get_channel_keys_ref,
+            *get_onion_rand_ref,
+            *get_channel_id_ref,
+        );
+
         let chan_man_raw =
             construct_channel_manager(
-                seed,
                 network,
                 cfg,
 
@@ -174,6 +193,8 @@ ffi! {
                 filter_block_ref,
                 reentered_ref,
 
+                Arc::new(keys_interface),
+
                 broadcast_transaction_ptr,
                 log_ref,
                 get_est_sat_per_1000_weight_ptr,