Update code and Cargo.toml to LDK 0.0.109

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index 1c1d7941011ae0602d174d9481e079a638d26110..bfe5bff311517794daa5f7a0207e34955a49af3f 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -24,9 +24,8 @@ use lightning::ln::channelmanager::{
 };
 use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler, SimpleArcPeerManager};
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning::log_bytes;
 use lightning::routing::gossip;
-use lightning::routing::gossip::P2PGossipSync;
+use lightning::routing::gossip::{NodeId, P2PGossipSync};
 use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::util::config::UserConfig;
 use lightning::util::events::{Event, PaymentPurpose};
@@ -118,9 +117,10 @@ type GossipSync<P, G, A, L> =
 pub(crate) type NetworkGraph = gossip::NetworkGraph<Arc<FilesystemLogger>>;
 
 async fn handle_ldk_events(
-       channel_manager: Arc<ChannelManager>, bitcoind_client: Arc<BitcoindClient>,
-       keys_manager: Arc<KeysManager>, inbound_payments: PaymentInfoStorage,
-       outbound_payments: PaymentInfoStorage, network: Network, event: &Event,
+       channel_manager: &Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
+       network_graph: &NetworkGraph, keys_manager: &KeysManager,
+       inbound_payments: &PaymentInfoStorage, outbound_payments: &PaymentInfoStorage,
+       network: Network, event: &Event,
 ) {
        match event {
                Event::FundingGenerationReady {
@@ -265,12 +265,37 @@ async fn handle_ldk_events(
                        fee_earned_msat,
                        claim_from_onchain_tx,
                } => {
-                       let from_channel_str = prev_channel_id
-                               .map(|channel_id| format!(" from channel {}", log_bytes!(channel_id)))
-                               .unwrap_or_default();
-                       let to_channel_str = next_channel_id
-                               .map(|channel_id| format!(" to channel {}", log_bytes!(channel_id)))
-                               .unwrap_or_default();
+                       let read_only_network_graph = network_graph.read_only();
+                       let nodes = read_only_network_graph.nodes();
+                       let channels = channel_manager.list_channels();
+
+                       let node_str = |channel_id: &Option<[u8; 32]>| match channel_id {
+                               None => String::new(),
+                               Some(channel_id) => match channels.iter().find(|c| c.channel_id == *channel_id) {
+                                       None => String::new(),
+                                       Some(channel) => {
+                                               match nodes.get(&NodeId::from_pubkey(&channel.counterparty.node_id)) {
+                                                       None => " from private node".to_string(),
+                                                       Some(node) => match &node.announcement_info {
+                                                               None => " from unnamed node".to_string(),
+                                                               Some(announcement) => {
+                                                                       format!(" from node {}", announcement.alias)
+                                                               }
+                                                       },
+                                               }
+                                       }
+                               },
+                       };
+                       let channel_str = |channel_id: &Option<[u8; 32]>| {
+                               channel_id
+                                       .map(|channel_id| format!(" with channel {}", hex_utils::hex_str(&channel_id)))
+                                       .unwrap_or_default()
+                       };
+                       let from_prev_str =
+                               format!("{}{}", node_str(prev_channel_id), channel_str(prev_channel_id));
+                       let to_next_str =
+                               format!("{}{}", node_str(next_channel_id), channel_str(next_channel_id));
+
                        let from_onchain_str = if *claim_from_onchain_tx {
                                "from onchain downstream claim"
                        } else {
@@ -279,12 +304,12 @@ async fn handle_ldk_events(
                        if let Some(fee_earned) = fee_earned_msat {
                                println!(
                                        "\nEVENT: Forwarded payment{}{}, earning {} msat {}",
-                                       from_channel_str, to_channel_str, fee_earned, from_onchain_str
+                                       from_prev_str, to_next_str, fee_earned, from_onchain_str
                                );
                        } else {
                                println!(
                                        "\nEVENT: Forwarded payment{}{}, claiming onchain {}",
-                                       from_channel_str, to_channel_str, from_onchain_str
+                                       from_prev_str, to_next_str, from_onchain_str
                                );
                        }
                        print!("> ");
@@ -434,7 +459,7 @@ async fn start_ldk() {
 
        // Step 8: Initialize the ChannelManager
        let mut user_config = UserConfig::default();
-       user_config.peer_channel_config_limits.force_announced_channel_preference = false;
+       user_config.channel_handshake_limits.force_announced_channel_preference = false;
        let mut restarting_node = true;
        let (channel_manager_blockhash, channel_manager) = {
                if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir.clone())) {
@@ -602,14 +627,16 @@ async fn start_ldk() {
        let outbound_pmts_for_events = outbound_payments.clone();
        let network = args.network;
        let bitcoind_rpc = bitcoind_client.clone();
+       let network_graph_events = network_graph.clone();
        let handle = tokio::runtime::Handle::current();
        let event_handler = move |event: &Event| {
                handle.block_on(handle_ldk_events(
-                       channel_manager_event_listener.clone(),
-                       bitcoind_rpc.clone(),
-                       keys_manager_listener.clone(),
-                       inbound_pmts_for_events.clone(),
-                       outbound_pmts_for_events.clone(),
+                       &channel_manager_event_listener,
+                       &bitcoind_rpc,
+                       &network_graph_events,
+                       &keys_manager_listener,
+                       &inbound_pmts_for_events,
+                       &outbound_pmts_for_events,
                        network,
                        event,
                ));
@@ -635,7 +662,7 @@ async fn start_ldk() {
                scorer.clone(),
                logger.clone(),
                event_handler,
-               payment::Retry::Attempts(5),
+               payment::Retry::Timeout(Duration::from_secs(10)),
        ));
 
        // Step 18: Persist ChannelManager and NetworkGraph