Update to v0.0.110

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index edcec9b4ade5d6dcf01666e18a90146dc8b7b492..1fddf8b91b3226074560f88132c089f4c737eae0 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -30,7 +30,7 @@ use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::util::config::UserConfig;
 use lightning::util::events::{Event, PaymentPurpose};
 use lightning::util::ser::ReadableArgs;
-use lightning_background_processor::BackgroundProcessor;
+use lightning_background_processor::{BackgroundProcessor, GossipSync};
 use lightning_block_sync::init;
 use lightning_block_sync::poll;
 use lightning_block_sync::SpvClient;
@@ -39,7 +39,6 @@ use lightning_invoice::payment;
 use lightning_invoice::utils::DefaultRouter;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::FilesystemPersister;
-use lightning_rapid_gossip_sync::RapidGossipSync;
 use rand::{thread_rng, Rng};
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
@@ -111,31 +110,13 @@ pub(crate) type InvoicePayer<E> = payment::InvoicePayer<
 
 type Router = DefaultRouter<Arc<NetworkGraph>, Arc<FilesystemLogger>>;
 
-type GossipSync<P, G, A, L> =
-       lightning_background_processor::GossipSync<P, Arc<RapidGossipSync<G, L>>, G, A, L>;
-
 pub(crate) type NetworkGraph = gossip::NetworkGraph<Arc<FilesystemLogger>>;
 
-struct NodeAlias<'a>(&'a [u8; 32]);
-
-impl fmt::Display for NodeAlias<'_> {
-       fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-               let alias = self
-                       .0
-                       .iter()
-                       .map(|b| *b as char)
-                       .take_while(|c| *c != '\0')
-                       .filter(|c| c.is_ascii_graphic() || *c == ' ')
-                       .collect::<String>();
-               write!(f, "{}", alias)
-       }
-}
-
 async fn handle_ldk_events(
-       channel_manager: Arc<ChannelManager>, bitcoind_client: Arc<BitcoindClient>,
-       network_graph: Arc<NetworkGraph>, 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 {
@@ -260,6 +241,8 @@ async fn handle_ldk_events(
                }
                Event::PaymentPathSuccessful { .. } => {}
                Event::PaymentPathFailed { .. } => {}
+               Event::ProbeSuccessful { .. } => {}
+               Event::ProbeFailed { .. } => {}
                Event::PaymentFailed { payment_hash, .. } => {
                        print!(
                                "\nEVENT: Failed to send payment to payment hash {:?}: exhausted payment retry attempts",
@@ -290,11 +273,11 @@ async fn handle_ldk_events(
                                        None => String::new(),
                                        Some(channel) => {
                                                match nodes.get(&NodeId::from_pubkey(&channel.counterparty.node_id)) {
-                                                       None => " from private node".to_string(),
+                                                       None => "private node".to_string(),
                                                        Some(node) => match &node.announcement_info {
-                                                               None => " from unnamed node".to_string(),
+                                                               None => "unnamed node".to_string(),
                                                                Some(announcement) => {
-                                                                       format!(" from node {}", NodeAlias(&announcement.alias))
+                                                                       format!("node {}", announcement.alias)
                                                                }
                                                        },
                                                }
@@ -307,9 +290,9 @@ async fn handle_ldk_events(
                                        .unwrap_or_default()
                        };
                        let from_prev_str =
-                               format!("{}{}", node_str(prev_channel_id), channel_str(prev_channel_id));
+                               format!(" from {}{}", 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));
+                               format!(" to {}{}", node_str(next_channel_id), channel_str(next_channel_id));
 
                        let from_onchain_str = if *claim_from_onchain_tx {
                                "from onchain downstream claim"
@@ -330,6 +313,7 @@ async fn handle_ldk_events(
                        print!("> ");
                        io::stdout().flush().unwrap();
                }
+               Event::HTLCHandlingFailed { .. } => {}
                Event::PendingHTLCsForwardable { time_forwardable } => {
                        let forwarding_channel_manager = channel_manager.clone();
                        let min = time_forwardable.as_millis() as u64;
@@ -474,7 +458,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())) {
@@ -646,12 +630,12 @@ async fn start_ldk() {
        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(),
-                       network_graph_events.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,
                ));
@@ -677,7 +661,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
@@ -689,7 +673,7 @@ async fn start_ldk() {
                invoice_payer.clone(),
                chain_monitor.clone(),
                channel_manager.clone(),
-               GossipSync::P2P(gossip_sync.clone()),
+               GossipSync::p2p(gossip_sync.clone()),
                peer_manager.clone(),
                logger.clone(),
                Some(scorer.clone()),