wip: working with vanilla ldk

This is just a test on how to make work lnprototest
with vanilla ldk.

Looks like that we should change the code inside the KeyManager?
but how?

Signed-off-by: Vincenzo Palazzo <[email protected]>

lampo-common/src/keys.rs

@@ -1,10 +1,13 @@
 use std::{sync::Arc, time::SystemTime};
 
-use crate::ldk::sign::KeysManager;
+use bitcoin::secp256k1::{Secp256k1, SecretKey};
+use lightning::sign::{InMemorySigner, NodeSigner, OutputSpender, SignerProvider};
+
+use crate::ldk::sign::{EntropySource, KeysManager};
 
 /// Lampo keys implementations
 pub struct LampoKeys {
-    pub keys_manager: Arc<KeysManager>,
+    pub keys_manager: Arc<LampoKeysManager>,
 }
 
 impl LampoKeys {
@@ -15,7 +18,7 @@ impl LampoKeys {
             .unwrap();
 
         LampoKeys {
-            keys_manager: Arc::new(KeysManager::new(
+            keys_manager: Arc::new(LampoKeysManager::new(
                 &seed,
                 start_time.as_secs(),
                 start_time.subsec_nanos(),
@@ -32,7 +35,8 @@ impl LampoKeys {
 
         let keys = channels_keys.split('/').collect::<Vec<_>>();
 
-        let mut manager = KeysManager::new(&seed, start_time.as_secs(), start_time.subsec_nanos());
+        let mut manager =
+            LampoKeysManager::new(&seed, start_time.as_secs(), start_time.subsec_nanos());
         manager.set_channels_keys(
             keys[1].to_string(),
             keys[2].to_string(),
@@ -46,7 +50,192 @@ impl LampoKeys {
         }
     }
 
-    pub fn inner(&self) -> Arc<KeysManager> {
+    pub fn inner(&self) -> Arc<LampoKeysManager> {
         self.keys_manager.clone()
     }
 }
+
+pub struct LampoKeysManager {
+    pub(crate) inner: KeysManager,
+
+    funding_key: Option<SecretKey>,
+    revocation_base_secret: Option<SecretKey>,
+    payment_base_secret: Option<SecretKey>,
+    delayed_payment_base_secret: Option<SecretKey>,
+    htlc_base_secret: Option<SecretKey>,
+    shachain_seed: Option<[u8; 32]>,
+}
+
+impl LampoKeysManager {
+    pub fn new(seed: &[u8; 32], starting_time_secs: u64, starting_time_nanos: u32) -> Self {
+        let inner = KeysManager::new(seed, starting_time_secs, starting_time_nanos);
+        Self {
+            inner,
+            funding_key: None,
+            revocation_base_secret: None,
+            payment_base_secret: None,
+            delayed_payment_base_secret: None,
+            htlc_base_secret: None,
+            shachain_seed: None,
+        }
+    }
+
+    // FIXME: put this under a debug a feature flag like `unsafa_channel_keys`
+    #[cfg(debug_assertions)]
+    pub fn set_channels_keys(
+        &mut self,
+        funding_key: String,
+        revocation_base_secret: String,
+        payment_base_secret: String,
+        delayed_payment_base_secret: String,
+        htlc_base_secret: String,
+        _shachain_seed: String,
+    ) {
+        use std::str::FromStr;
+
+        self.funding_key = Some(SecretKey::from_str(&funding_key).unwrap());
+        self.revocation_base_secret = Some(SecretKey::from_str(&revocation_base_secret).unwrap());
+        self.payment_base_secret = Some(SecretKey::from_str(&payment_base_secret).unwrap());
+        self.delayed_payment_base_secret =
+            Some(SecretKey::from_str(&delayed_payment_base_secret).unwrap());
+        self.htlc_base_secret = Some(SecretKey::from_str(&htlc_base_secret).unwrap());
+        self.shachain_seed = Some(self.inner.get_secure_random_bytes())
+    }
+}
+
+impl EntropySource for LampoKeysManager {
+    fn get_secure_random_bytes(&self) -> [u8; 32] {
+        self.inner.get_secure_random_bytes()
+    }
+}
+
+impl NodeSigner for LampoKeysManager {
+    fn ecdh(
+        &self,
+        recipient: lightning::sign::Recipient,
+        other_key: &bitcoin::secp256k1::PublicKey,
+        tweak: Option<&bitcoin::secp256k1::Scalar>,
+    ) -> Result<bitcoin::secp256k1::ecdh::SharedSecret, ()> {
+        self.inner.ecdh(recipient, other_key, tweak)
+    }
+
+    fn get_inbound_payment_key_material(&self) -> lightning::sign::KeyMaterial {
+        self.inner.get_inbound_payment_key_material()
+    }
+
+    fn get_node_id(
+        &self,
+        recipient: lightning::sign::Recipient,
+    ) -> Result<bitcoin::secp256k1::PublicKey, ()> {
+        self.inner.get_node_id(recipient)
+    }
+
+    fn sign_bolt12_invoice(
+        &self,
+        invoice: &lightning::offers::invoice::UnsignedBolt12Invoice,
+    ) -> Result<bitcoin::secp256k1::schnorr::Signature, ()> {
+        self.inner.sign_bolt12_invoice(invoice)
+    }
+
+    fn sign_bolt12_invoice_request(
+        &self,
+        invoice_request: &lightning::offers::invoice_request::UnsignedInvoiceRequest,
+    ) -> Result<bitcoin::secp256k1::schnorr::Signature, ()> {
+        self.inner.sign_bolt12_invoice_request(invoice_request)
+    }
+
+    fn sign_gossip_message(
+        &self,
+        msg: lightning::ln::msgs::UnsignedGossipMessage,
+    ) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
+        self.inner.sign_gossip_message(msg)
+    }
+
+    fn sign_invoice(
+        &self,
+        hrp_bytes: &[u8],
+        invoice_data: &[bitcoin::bech32::u5],
+        recipient: lightning::sign::Recipient,
+    ) -> Result<bitcoin::secp256k1::ecdsa::RecoverableSignature, ()> {
+        self.inner.sign_invoice(hrp_bytes, invoice_data, recipient)
+    }
+}
+
+impl OutputSpender for LampoKeysManager {
+    fn spend_spendable_outputs<C: bitcoin::secp256k1::Signing>(
+        &self,
+        descriptors: &[&lightning::sign::SpendableOutputDescriptor],
+        outputs: Vec<bitcoin::TxOut>,
+        change_destination_script: bitcoin::ScriptBuf,
+        feerate_sat_per_1000_weight: u32,
+        locktime: Option<bitcoin::absolute::LockTime>,
+        secp_ctx: &bitcoin::secp256k1::Secp256k1<C>,
+    ) -> Result<bitcoin::Transaction, ()> {
+        self.inner.spend_spendable_outputs(
+            descriptors,
+            outputs,
+            change_destination_script,
+            feerate_sat_per_1000_weight,
+            locktime,
+            secp_ctx,
+        )
+    }
+}
+
+impl SignerProvider for LampoKeysManager {
+    // FIXME: this should be the same of the inner
+    type EcdsaSigner = InMemorySigner;
+
+    fn derive_channel_signer(
+        &self,
+        channel_value_satoshis: u64,
+        channel_keys_id: [u8; 32],
+    ) -> Self::EcdsaSigner {
+        if self.funding_key.is_some() {
+            // FIXME(vincenzopalazzo): make this a general
+            let commitment_seed = [
+                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+            ];
+            return InMemorySigner::new(
+                &Secp256k1::new(),
+                self.funding_key.unwrap(),
+                self.revocation_base_secret.unwrap(),
+                self.payment_base_secret.unwrap(),
+                self.delayed_payment_base_secret.unwrap(),
+                self.htlc_base_secret.unwrap(),
+                commitment_seed,
+                channel_value_satoshis,
+                channel_keys_id,
+                self.shachain_seed.unwrap(),
+            );
+        }
+        self.inner
+            .derive_channel_signer(channel_value_satoshis, channel_keys_id)
+    }
+
+    fn generate_channel_keys_id(
+        &self,
+        inbound: bool,
+        channel_value_satoshis: u64,
+        user_channel_id: u128,
+    ) -> [u8; 32] {
+        self.inner
+            .generate_channel_keys_id(inbound, channel_value_satoshis, user_channel_id)
+    }
+
+    fn get_destination_script(&self, channel_keys_id: [u8; 32]) -> Result<bitcoin::ScriptBuf, ()> {
+        self.inner.get_destination_script(channel_keys_id)
+    }
+
+    fn get_shutdown_scriptpubkey(&self) -> Result<lightning::ln::script::ShutdownScript, ()> {
+        self.inner.get_shutdown_scriptpubkey()
+    }
+
+    fn read_chan_signer(
+        &self,
+        reader: &[u8],
+    ) -> Result<Self::EcdsaSigner, lightning::ln::msgs::DecodeError> {
+        self.inner.read_chan_signer(reader)
+    }
+}

lampod/src/ln/channel_manager.rs

@@ -13,6 +13,7 @@ use lampo_common::error;
 use lampo_common::event::onchain::OnChainEvent;
 use lampo_common::event::Event;
 use lampo_common::handler::Handler;
+use lampo_common::keys::LampoKeysManager;
 use lampo_common::ldk::chain::chainmonitor::ChainMonitor;
 use lampo_common::ldk::chain::channelmonitor::ChannelMonitor;
 use lampo_common::ldk::chain::{BestBlock, Confirm, Filter, Watch};
@@ -26,7 +27,6 @@ use lampo_common::ldk::routing::scoring::{
     ProbabilisticScorer, ProbabilisticScoringDecayParameters, ProbabilisticScoringFeeParameters,
 };
 use lampo_common::ldk::sign::InMemorySigner;
-use lampo_common::ldk::sign::KeysManager;
 use lampo_common::ldk::util::persist::read_channel_monitors;
 use lampo_common::ldk::util::ser::ReadableArgs;
 use lampo_common::model::request;
@@ -50,9 +50,9 @@ pub type LampoChainMonitor = ChainMonitor<
 pub type LampoArcChannelManager<M, T, F, L> = ChannelManager<
     Arc<M>,
     Arc<T>,
-    Arc<KeysManager>,
-    Arc<KeysManager>,
-    Arc<KeysManager>,
+    Arc<LampoKeysManager>,
+    Arc<LampoKeysManager>,
+    Arc<LampoKeysManager>,
     Arc<F>,
     Arc<LampoRouter>,
     Arc<L>,
@@ -66,7 +66,7 @@ pub type LampoScorer = ProbabilisticScorer<Arc<LampoGraph>, Arc<LampoLogger>>;
 pub type LampoRouter = DefaultRouter<
     Arc<LampoGraph>,
     Arc<LampoLogger>,
-    Arc<KeysManager>,
+    Arc<LampoKeysManager>,
     Arc<Mutex<LampoScorer>>,
     ProbabilisticScoringFeeParameters,
     LampoScorer,
@@ -256,7 +256,7 @@ impl LampoChannelManager {
         DefaultRouter<
             Arc<LampoGraph>,
             Arc<LampoLogger>,
-            Arc<KeysManager>,
+            Arc<LampoKeysManager>,
             Arc<Mutex<LampoScorer>>,
             ProbabilisticScoringFeeParameters,
             LampoScorer,

lampod/src/ln/offchain_manager.rs

@@ -19,6 +19,7 @@ use lampo_common::bitcoin::hashes::Hash;
 use lampo_common::bitcoin::secp256k1::PublicKey as pubkey;
 use lampo_common::conf::LampoConf;
 use lampo_common::error;
+use lampo_common::keys::LampoKeysManager;
 use lampo_common::ldk;
 use lampo_common::ldk::ln::channelmanager::Retry;
 use lampo_common::ldk::ln::channelmanager::{PaymentId, RecipientOnionFields};
@@ -27,15 +28,14 @@ use lampo_common::ldk::offers::offer::Amount;
 use lampo_common::ldk::offers::offer::Offer;
 use lampo_common::ldk::routing::router::{PaymentParameters, RouteParameters};
 use lampo_common::ldk::sign::EntropySource;
-use lampo_common::ldk::sign::KeysManager;
 
 use super::LampoChannelManager;
 use crate::chain::LampoChainManager;
 use crate::utils::logger::LampoLogger;
 
 pub struct OffchainManager {
     channel_manager: Arc<LampoChannelManager>,
-    keys_manager: Arc<KeysManager>,
+    keys_manager: Arc<LampoKeysManager>,
     logger: Arc<LampoLogger>,
     lampo_conf: Arc<LampoConf>,
     chain_manager: Arc<LampoChainManager>,
@@ -44,7 +44,7 @@ pub struct OffchainManager {
 impl OffchainManager {
     // FIXME: use the build pattern here
     pub fn new(
-        keys_manager: Arc<KeysManager>,
+        keys_manager: Arc<LampoKeysManager>,
         channel_manager: Arc<LampoChannelManager>,
         logger: Arc<LampoLogger>,
         lampo_conf: Arc<LampoConf>,

lampod/src/ln/peer_manager.rs

@@ -7,6 +7,7 @@ use async_trait::async_trait;
 
 use lampo_common::conf::LampoConf;
 use lampo_common::error;
+use lampo_common::keys::LampoKeysManager;
 use lampo_common::ldk;
 use lampo_common::ldk::blinded_path::EmptyNodeIdLookUp;
 use lampo_common::ldk::ln::peer_handler::MessageHandler;
@@ -15,7 +16,6 @@ use lampo_common::ldk::net;
 use lampo_common::ldk::net::SocketDescriptor;
 use lampo_common::ldk::onion_message::messenger::{DefaultMessageRouter, OnionMessenger};
 use lampo_common::ldk::routing::gossip::{NetworkGraph, P2PGossipSync};
-use lampo_common::ldk::sign::KeysManager;
 use lampo_common::model::Connect;
 use lampo_common::types::NodeId;
 
@@ -29,11 +29,11 @@ use super::events::PeerEvents;
 use super::peer_event;
 
 pub type LampoArcOnionMessenger<L> = OnionMessenger<
-    Arc<KeysManager>,
-    Arc<KeysManager>,
+    Arc<LampoKeysManager>,
+    Arc<LampoKeysManager>,
     Arc<L>,
     EmptyNodeIdLookUp,
-    Arc<DefaultMessageRouter<Arc<LampoGraph>, Arc<L>, Arc<KeysManager>>>,
+    Arc<DefaultMessageRouter<Arc<LampoGraph>, Arc<L>, Arc<LampoKeysManager>>>,
     IgnoringMessageHandler,
     IgnoringMessageHandler,
 >;
@@ -45,7 +45,7 @@ pub type SimpleArcPeerManager<M, T, L> = PeerManager<
     Arc<LampoArcOnionMessenger<L>>,
     Arc<L>,
     IgnoringMessageHandler,
-    Arc<KeysManager>,
+    Arc<LampoKeysManager>,
 >;
 
 type InnerLampoPeerManager =