Merge pull request #114 from TheBlueMatt/2023-08-last-ditch-write

Attempt a last-ditch ChannelManager persistence if the BP exits

diff --combined src/main.rs
index 9fd11904f734d7cb80987d98f9970604dd64e4ee,3f01cfe26a2d35ef49cd456c634c282a8af152a9..d438682f7a9dd355a119746943b6a3f0256008eb
--- 1/src/main.rs
--- 2/src/main.rs
+++ b/src/main.rs
@@@ -16,7 -16,6 +16,7 @@@ use bitcoin_bech32::WitnessProgram
  use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
  use lightning::chain::{chainmonitor, ChannelMonitorUpdateStatus};
  use lightning::chain::{Filter, Watch};
 +use lightning::events::bump_transaction::{BumpTransactionEventHandler, Wallet};
  use lightning::events::{Event, PaymentFailureReason, PaymentPurpose};
  use lightning::ln::channelmanager::{self, RecentPaymentDetails};
  use lightning::ln::channelmanager::{
@@@ -142,17 -141,10 +142,17 @@@ pub(crate) type NetworkGraph = gossip::
  
  type OnionMessenger = SimpleArcOnionMessenger<FilesystemLogger>;
  
 +pub(crate) type BumpTxEventHandler = BumpTransactionEventHandler<
 +      Arc<BitcoindClient>,
 +      Arc<Wallet<Arc<BitcoindClient>, Arc<FilesystemLogger>>>,
 +      Arc<KeysManager>,
 +      Arc<FilesystemLogger>,
 +>;
 +
  async fn handle_ldk_events(
        channel_manager: &Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
        network_graph: &NetworkGraph, keys_manager: &KeysManager,
 -      inbound_payments: Arc<Mutex<PaymentInfoStorage>>,
 +      bump_tx_event_handler: &BumpTxEventHandler, inbound_payments: Arc<Mutex<PaymentInfoStorage>>,
        outbound_payments: Arc<Mutex<PaymentInfoStorage>>, persister: &Arc<FilesystemPersister>,
        network: Network, event: Event,
  ) {
@@@ -286,34 -278,8 +286,34 @@@
                        }
                        persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound).unwrap();
                }
 -              Event::OpenChannelRequest { .. } => {
 -                      // Unreachable, we don't set manually_accept_inbound_channels
 +              Event::OpenChannelRequest {
 +                      ref temporary_channel_id, ref counterparty_node_id, ..
 +              } => {
 +                      let mut random_bytes = [0u8; 16];
 +                      random_bytes.copy_from_slice(&keys_manager.get_secure_random_bytes()[..16]);
 +                      let user_channel_id = u128::from_be_bytes(random_bytes);
 +                      let res = channel_manager.accept_inbound_channel(
 +                              temporary_channel_id,
 +                              counterparty_node_id,
 +                              user_channel_id,
 +                      );
 +
 +                      if let Err(e) = res {
 +                              print!(
 +                                      "\nEVENT: Failed to accept inbound channel ({}) from {}: {:?}",
 +                                      hex_utils::hex_str(&temporary_channel_id[..]),
 +                                      hex_utils::hex_str(&counterparty_node_id.serialize()),
 +                                      e,
 +                              );
 +                      } else {
 +                              print!(
 +                                      "\nEVENT: Accepted inbound channel ({}) from {}",
 +                                      hex_utils::hex_str(&temporary_channel_id[..]),
 +                                      hex_utils::hex_str(&counterparty_node_id.serialize()),
 +                              );
 +                      }
 +                      print!("> ");
 +                      io::stdout().flush().unwrap();
                }
                Event::PaymentPathSuccessful { .. } => {}
                Event::PaymentPathFailed { .. } => {}
@@@ -463,7 -429,7 +463,7 @@@
                        // the funding transaction either confirms, or this event is generated.
                }
                Event::HTLCIntercepted { .. } => {}
 -              Event::BumpTransaction(_) => {}
 +              Event::BumpTransaction(event) => bump_tx_event_handler.handle_event(&event),
        }
  }
  
@@@ -566,13 -532,6 +566,13 @@@ async fn start_ldk() 
        let cur = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
        let keys_manager = Arc::new(KeysManager::new(&keys_seed, cur.as_secs(), cur.subsec_nanos()));
  
 +      let bump_tx_event_handler = Arc::new(BumpTransactionEventHandler::new(
 +              Arc::clone(&broadcaster),
 +              Arc::new(Wallet::new(Arc::clone(&bitcoind_client), Arc::clone(&logger))),
 +              Arc::clone(&keys_manager),
 +              Arc::clone(&logger),
 +      ));
 +
        // Step 7: Read ChannelMonitor state from disk
        let mut channelmonitors =
                persister.read_channelmonitors(keys_manager.clone(), keys_manager.clone()).unwrap();
@@@ -607,8 -566,6 +607,8 @@@
        // 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) = {
                if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir.clone())) {
@@@ -821,7 -778,6 +821,7 @@@
                let bitcoind_client_event_listener = Arc::clone(&bitcoind_client_event_listener);
                let network_graph_event_listener = Arc::clone(&network_graph_event_listener);
                let keys_manager_event_listener = Arc::clone(&keys_manager_event_listener);
 +              let bump_tx_event_handler = Arc::clone(&bump_tx_event_handler);
                let inbound_payments_event_listener = Arc::clone(&inbound_payments_event_listener);
                let outbound_payments_event_listener = Arc::clone(&outbound_payments_event_listener);
                let persister_event_listener = Arc::clone(&persister_event_listener);
@@@ -831,7 -787,6 +831,7 @@@
                                &bitcoind_client_event_listener,
                                &network_graph_event_listener,
                                &keys_manager_event_listener,
 +                              &bump_tx_event_handler,
                                inbound_payments_event_listener,
                                outbound_payments_event_listener,
                                &persister_event_listener,
@@@ -959,12 -914,11 +959,11 @@@
  
        // 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;
                },
        }
  
@@@ -973,6 -927,21 +972,21 @@@
        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();