Update for LDK release 0.0.113

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index edb9ab2d501a9ade89d63322c9258bdfe4040b2c..57da6d15fb501ca373c87bc2c3fbac9c72e4193e 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,4 @@
+mod args;
 pub mod bitcoind_client;
 mod cli;
 mod convert;
@@ -27,6 +28,7 @@ use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::onion_message::SimpleArcOnionMessenger;
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
+use lightning::routing::router::DefaultRouter;
 use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::util::config::UserConfig;
 use lightning::util::events::{Event, PaymentPurpose};
@@ -37,7 +39,6 @@ use lightning_block_sync::poll;
 use lightning_block_sync::SpvClient;
 use lightning_block_sync::UnboundedCache;
 use lightning_invoice::payment;
-use lightning_invoice::utils::DefaultRouter;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::FilesystemPersister;
 use rand::{thread_rng, Rng};
@@ -169,7 +170,14 @@ async fn handle_ldk_events(
                                io::stdout().flush().unwrap();
                        }
                }
-               Event::PaymentReceived { payment_hash, purpose, amount_msat } => {
+               Event::PaymentClaimable {
+                       payment_hash,
+                       purpose,
+                       amount_msat,
+                       receiver_node_id: _,
+                       via_channel_id: _,
+                       via_user_channel_id: _,
+               } => {
                        println!(
                                "\nEVENT: received payment from payment hash {} of {} millisatoshis",
                                hex_utils::hex_str(&payment_hash.0),
@@ -183,7 +191,7 @@ async fn handle_ldk_events(
                        };
                        channel_manager.claim_funds(payment_preimage.unwrap());
                }
-               Event::PaymentClaimed { payment_hash, purpose, amount_msat } => {
+               Event::PaymentClaimed { payment_hash, purpose, amount_msat, receiver_node_id: _ } => {
                        println!(
                                "\nEVENT: claimed payment from payment hash {} of {} millisatoshis",
                                hex_utils::hex_str(&payment_hash.0),
@@ -341,6 +349,20 @@ async fn handle_ldk_events(
                                .unwrap();
                        bitcoind_client.broadcast_transaction(&spending_tx);
                }
+               Event::ChannelReady {
+                       ref channel_id,
+                       user_channel_id: _,
+                       ref counterparty_node_id,
+                       channel_type: _,
+               } => {
+                       println!(
+                               "\nEVENT: Channel {} with peer {} is ready to be used!",
+                               hex_utils::hex_str(channel_id),
+                               hex_utils::hex_str(&counterparty_node_id.serialize()),
+                       );
+                       print!("> ");
+                       io::stdout().flush().unwrap();
+               }
                Event::ChannelClosed { channel_id, reason, user_channel_id: _ } => {
                        println!(
                                "\nEVENT: Channel {} closed due to: {:?}",
@@ -354,11 +376,12 @@ async fn handle_ldk_events(
                        // A "real" node should probably "lock" the UTXOs spent in funding transactions until
                        // the funding transaction either confirms, or this event is generated.
                }
+               Event::HTLCIntercepted { .. } => {}
        }
 }
 
 async fn start_ldk() {
-       let args = match cli::parse_startup_args() {
+       let args = match args::parse_startup_args() {
                Ok(user_args) => user_args,
                Err(()) => return,
        };
@@ -507,8 +530,7 @@ async fn start_ldk() {
        // Step 10: Sync ChannelMonitors and ChannelManager to chain tip
        let mut chain_listener_channel_monitors = Vec::new();
        let mut cache = UnboundedCache::new();
-       let mut chain_tip: Option<poll::ValidatedBlockHeader> = None;
-       if restarting_node {
+       let chain_tip = if restarting_node {
                let mut chain_listeners = vec![(
                        channel_manager_blockhash,
                        &channel_manager as &(dyn chain::Listen + Send + Sync),
@@ -529,17 +551,18 @@ async fn start_ldk() {
                                &monitor_listener_info.1 as &(dyn chain::Listen + Send + Sync),
                        ));
                }
-               chain_tip = Some(
-                       init::synchronize_listeners(
-                               bitcoind_client.as_ref(),
-                               args.network,
-                               &mut cache,
-                               chain_listeners,
-                       )
-                       .await
-                       .unwrap(),
-               );
-       }
+
+               init::synchronize_listeners(
+                       bitcoind_client.as_ref(),
+                       args.network,
+                       &mut cache,
+                       chain_listeners,
+               )
+               .await
+               .unwrap()
+       } else {
+               polled_chain_tip
+       };
 
        // Step 11: Give ChannelMonitors to ChainMonitor
        for item in chain_listener_channel_monitors.drain(..) {
@@ -614,9 +637,6 @@ async fn start_ldk() {
        });
 
        // Step 15: Connect and Disconnect Blocks
-       if chain_tip.is_none() {
-               chain_tip = Some(polled_chain_tip);
-       }
        let channel_manager_listener = channel_manager.clone();
        let chain_monitor_listener = chain_monitor.clone();
        let bitcoind_block_source = bitcoind_client.clone();
@@ -624,8 +644,7 @@ async fn start_ldk() {
        tokio::spawn(async move {
                let chain_poller = poll::ChainPoller::new(bitcoind_block_source.as_ref(), network);
                let chain_listener = (chain_monitor_listener, channel_manager_listener);
-               let mut spv_client =
-                       SpvClient::new(chain_tip.unwrap(), chain_poller, &mut cache, &chain_listener);
+               let mut spv_client = SpvClient::new(chain_tip, chain_poller, &mut cache, &chain_listener);
                loop {
                        spv_client.poll_best_tip().await.unwrap();
                        tokio::time::sleep(Duration::from_secs(1)).await;
@@ -644,7 +663,7 @@ async fn start_ldk() {
        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| {
+       let event_handler = move |event: Event| {
                handle.block_on(handle_ldk_events(
                        &channel_manager_event_listener,
                        &bitcoind_rpc,
@@ -653,7 +672,7 @@ async fn start_ldk() {
                        &inbound_pmts_for_events,
                        &outbound_pmts_for_events,
                        network,
-                       event,
+                       &event,
                ));
        };