Merge pull request #120 from benthecarman/fee-sniping

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index f1e1cbfedc300e563dba70e19007839af334d9ea..40240a729711bd33d5c708730b2fb8a44c24615a 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -607,6 +607,7 @@ async fn start_ldk() {
        // Step 11: Initialize the ChannelManager
        let mut user_config = UserConfig::default();
        user_config.channel_handshake_limits.force_announced_channel_preference = false;
+       user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
        user_config.manually_accept_inbound_channels = true;
        let mut restarting_node = true;
        let (channel_manager_blockhash, channel_manager) = {
@@ -942,28 +943,33 @@ async fn start_ldk() {
        ));
 
        // Start the CLI.
-       let cli_poll = tokio::spawn(cli::poll_for_user_input(
-               Arc::clone(&peer_manager),
-               Arc::clone(&channel_manager),
-               Arc::clone(&keys_manager),
-               Arc::clone(&network_graph),
-               Arc::clone(&onion_messenger),
-               inbound_payments,
-               outbound_payments,
-               ldk_data_dir,
-               network,
-               Arc::clone(&logger),
-               Arc::clone(&persister),
-       ));
+       let cli_channel_manager = Arc::clone(&channel_manager);
+       let cli_persister = Arc::clone(&persister);
+       let cli_logger = Arc::clone(&logger);
+       let cli_peer_manager = Arc::clone(&peer_manager);
+       let cli_poll = tokio::task::spawn_blocking(move || {
+               cli::poll_for_user_input(
+                       cli_peer_manager,
+                       cli_channel_manager,
+                       keys_manager,
+                       network_graph,
+                       onion_messenger,
+                       inbound_payments,
+                       outbound_payments,
+                       ldk_data_dir,
+                       network,
+                       cli_logger,
+                       cli_persister,
+               )
+       });
 
        // Exit if either CLI polling exits or the background processor exits (which shouldn't happen
        // unless we fail to write to the filesystem).
+       let mut bg_res = Ok(Ok(()));
        tokio::select! {
                _ = cli_poll => {},
-               bg_res = &mut background_processor => {
-                       stop_listen_connect.store(true, Ordering::Release);
-                       peer_manager.disconnect_all_peers();
-                       panic!("ERR: background processing stopped with result {:?}, exiting", bg_res);
+               bg_exit = &mut background_processor => {
+                       bg_res = bg_exit;
                },
        }
 
@@ -972,6 +978,21 @@ async fn start_ldk() {
        stop_listen_connect.store(true, Ordering::Release);
        peer_manager.disconnect_all_peers();
 
+       if let Err(e) = bg_res {
+               let persist_res = persister.persist("manager", &*channel_manager).unwrap();
+               use lightning::util::logger::Logger;
+               lightning::log_error!(
+                       &*logger,
+                       "Last-ditch ChannelManager persistence result: {:?}",
+                       persist_res
+               );
+               panic!(
+                       "ERR: background processing stopped with result {:?}, exiting.\n\
+                       Last-ditch ChannelManager persistence result {:?}",
+                       e, persist_res
+               );
+       }
+
        // Stop the background processor.
        if !bp_exit.is_closed() {
                bp_exit.send(()).unwrap();