Update to LDK 0.0.112

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index 6cff9f152492058c156e7fb1cf48ccb4e3910f38..4314ac87131dc05ee92f56b51ebfc36e5f3336f2 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -15,8 +15,8 @@ use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use lightning::chain;
 use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
-use lightning::chain::chainmonitor;
 use lightning::chain::keysinterface::{InMemorySigner, KeysInterface, KeysManager, Recipient};
+use lightning::chain::{chainmonitor, ChannelMonitorUpdateStatus};
 use lightning::chain::{BestBlock, Filter, Watch};
 use lightning::ln::channelmanager;
 use lightning::ln::channelmanager::{
@@ -43,12 +43,12 @@ use lightning_persister::FilesystemPersister;
 use rand::{thread_rng, Rng};
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::convert::TryInto;
 use std::fmt;
 use std::fs;
 use std::fs::File;
 use std::io;
 use std::io::Write;
-use std::ops::Deref;
 use std::path::Path;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
@@ -101,16 +101,15 @@ pub(crate) type PeerManager = SimpleArcPeerManager<
 pub(crate) type ChannelManager =
        SimpleArcChannelManager<ChainMonitor, BitcoindClient, BitcoindClient, FilesystemLogger>;
 
-pub(crate) type InvoicePayer<E> = payment::InvoicePayer<
-       Arc<ChannelManager>,
-       Router,
-       Arc<Mutex<ProbabilisticScorer<Arc<NetworkGraph>, Arc<FilesystemLogger>>>>,
+pub(crate) type InvoicePayer<E> =
+       payment::InvoicePayer<Arc<ChannelManager>, Router, Arc<FilesystemLogger>, E>;
+
+type Router = DefaultRouter<
+       Arc<NetworkGraph>,
        Arc<FilesystemLogger>,
-       E,
+       Arc<Mutex<ProbabilisticScorer<Arc<NetworkGraph>, Arc<FilesystemLogger>>>>,
 >;
 
-type Router = DefaultRouter<Arc<NetworkGraph>, Arc<FilesystemLogger>>;
-
 pub(crate) type NetworkGraph = gossip::NetworkGraph<Arc<FilesystemLogger>>;
 
 type OnionMessenger = SimpleArcOnionMessenger<FilesystemLogger>;
@@ -531,7 +530,7 @@ async fn start_ldk() {
                }
                chain_tip = Some(
                        init::synchronize_listeners(
-                               &mut bitcoind_client.deref(),
+                               bitcoind_client.as_ref(),
                                args.network,
                                &mut cache,
                                chain_listeners,
@@ -545,7 +544,10 @@ async fn start_ldk() {
        for item in chain_listener_channel_monitors.drain(..) {
                let channel_monitor = item.1 .0;
                let funding_outpoint = item.2;
-               chain_monitor.watch_channel(funding_outpoint, channel_monitor).unwrap();
+               assert_eq!(
+                       chain_monitor.watch_channel(funding_outpoint, channel_monitor),
+                       ChannelMonitorUpdateStatus::Completed
+               );
        }
 
        // Step 11: Optional: Initialize the P2PGossipSync
@@ -561,8 +563,11 @@ async fn start_ldk() {
 
        // Step 12: Initialize the PeerManager
        let channel_manager: Arc<ChannelManager> = Arc::new(channel_manager);
-       let onion_messenger: Arc<OnionMessenger> =
-               Arc::new(OnionMessenger::new(keys_manager.clone(), logger.clone()));
+       let onion_messenger: Arc<OnionMessenger> = Arc::new(OnionMessenger::new(
+               Arc::clone(&keys_manager),
+               Arc::clone(&logger),
+               IgnoringMessageHandler {},
+       ));
        let mut ephemeral_bytes = [0; 32];
        let current_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs();
        rand::thread_rng().fill_bytes(&mut ephemeral_bytes);
@@ -574,7 +579,7 @@ async fn start_ldk() {
        let peer_manager: Arc<PeerManager> = Arc::new(PeerManager::new(
                lightning_msg_handler,
                keys_manager.get_node_secret(Recipient::Node).unwrap(),
-               current_time,
+               current_time.try_into().unwrap(),
                &ephemeral_bytes,
                logger.clone(),
                IgnoringMessageHandler {},
@@ -609,16 +614,14 @@ async fn start_ldk() {
 
        // Step 14: Connect and Disconnect Blocks
        if chain_tip.is_none() {
-               chain_tip =
-                       Some(init::validate_best_block_header(&mut bitcoind_client.deref()).await.unwrap());
+               chain_tip = Some(init::validate_best_block_header(bitcoind_client.as_ref()).await.unwrap());
        }
        let channel_manager_listener = channel_manager.clone();
        let chain_monitor_listener = chain_monitor.clone();
        let bitcoind_block_source = bitcoind_client.clone();
        let network = args.network;
        tokio::spawn(async move {
-               let mut derefed = bitcoind_block_source.deref();
-               let chain_poller = poll::ChainPoller::new(&mut derefed, network);
+               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);
@@ -666,11 +669,11 @@ async fn start_ldk() {
                network_graph.clone(),
                logger.clone(),
                keys_manager.get_secure_random_bytes(),
+               scorer.clone(),
        );
        let invoice_payer = Arc::new(InvoicePayer::new(
                channel_manager.clone(),
                router,
-               scorer.clone(),
                logger.clone(),
                event_handler,
                payment::Retry::Timeout(Duration::from_secs(10)),
@@ -761,6 +764,7 @@ async fn start_ldk() {
                outbound_payments,
                ldk_data_dir.clone(),
                network,
+               Arc::clone(&logger),
        )
        .await;
 
@@ -775,5 +779,28 @@ async fn start_ldk() {
 
 #[tokio::main]
 pub async fn main() {
+       #[cfg(not(target_os = "windows"))]
+       {
+               // Catch Ctrl-C with a dummy signal handler.
+               unsafe {
+                       let mut new_action: libc::sigaction = core::mem::zeroed();
+                       let mut old_action: libc::sigaction = core::mem::zeroed();
+
+                       extern "C" fn dummy_handler(
+                               _: libc::c_int, _: *const libc::siginfo_t, _: *const libc::c_void,
+                       ) {
+                       }
+
+                       new_action.sa_sigaction = dummy_handler as libc::sighandler_t;
+                       new_action.sa_flags = libc::SA_SIGINFO;
+
+                       libc::sigaction(
+                               libc::SIGINT,
+                               &new_action as *const libc::sigaction,
+                               &mut old_action as *mut libc::sigaction,
+                       );
+               }
+       }
+
        start_ldk().await;
 }