Make `ldk-sample` `Send` + `Sync`

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index 1fddf8b91b3226074560f88132c089f4c737eae0..6cff9f152492058c156e7fb1cf48ccb4e3910f38 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -24,6 +24,7 @@ use lightning::ln::channelmanager::{
 };
 use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler, SimpleArcPeerManager};
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
+use lightning::onion_message::SimpleArcOnionMessenger;
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
 use lightning::routing::scoring::ProbabilisticScorer;
@@ -112,6 +113,8 @@ type Router = DefaultRouter<Arc<NetworkGraph>, Arc<FilesystemLogger>>;
 
 pub(crate) type NetworkGraph = gossip::NetworkGraph<Arc<FilesystemLogger>>;
 
+type OnionMessenger = SimpleArcOnionMessenger<FilesystemLogger>;
+
 async fn handle_ldk_events(
        channel_manager: &Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
        network_graph: &NetworkGraph, keys_manager: &KeysManager,
@@ -506,8 +509,10 @@ async fn start_ldk() {
        let mut cache = UnboundedCache::new();
        let mut chain_tip: Option<poll::ValidatedBlockHeader> = None;
        if restarting_node {
-               let mut chain_listeners =
-                       vec![(channel_manager_blockhash, &channel_manager as &dyn chain::Listen)];
+               let mut chain_listeners = vec![(
+                       channel_manager_blockhash,
+                       &channel_manager as &(dyn chain::Listen + Send + Sync),
+               )];
 
                for (blockhash, channel_monitor) in channelmonitors.drain(..) {
                        let outpoint = channel_monitor.get_funding_txo().0;
@@ -519,8 +524,10 @@ async fn start_ldk() {
                }
 
                for monitor_listener_info in chain_listener_channel_monitors.iter_mut() {
-                       chain_listeners
-                               .push((monitor_listener_info.0, &monitor_listener_info.1 as &dyn chain::Listen));
+                       chain_listeners.push((
+                               monitor_listener_info.0,
+                               &monitor_listener_info.1 as &(dyn chain::Listen + Send + Sync),
+                       ));
                }
                chain_tip = Some(
                        init::synchronize_listeners(
@@ -554,18 +561,23 @@ 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 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);
        let lightning_msg_handler = MessageHandler {
                chan_handler: channel_manager.clone(),
                route_handler: gossip_sync.clone(),
+               onion_message_handler: onion_messenger.clone(),
        };
        let peer_manager: Arc<PeerManager> = Arc::new(PeerManager::new(
                lightning_msg_handler,
                keys_manager.get_node_secret(Recipient::Node).unwrap(),
+               current_time,
                &ephemeral_bytes,
                logger.clone(),
-               Arc::new(IgnoringMessageHandler {}),
+               IgnoringMessageHandler {},
        ));
 
        // ## Running LDK
@@ -721,14 +733,14 @@ async fn start_ldk() {
        // some public channels, and is only useful if we have public listen address(es) to announce.
        // In a production environment, this should occur only after the announcement of new channels
        // to avoid churn in the global network graph.
-       let chan_manager = Arc::clone(&channel_manager);
+       let peer_man = Arc::clone(&peer_manager);
        let network = args.network;
        if !args.ldk_announced_listen_addr.is_empty() {
                tokio::spawn(async move {
                        let mut interval = tokio::time::interval(Duration::from_secs(60));
                        loop {
                                interval.tick().await;
-                               chan_manager.broadcast_node_announcement(
+                               peer_man.broadcast_node_announcement(
                                        [0; 3],
                                        args.ldk_announced_node_name,
                                        args.ldk_announced_listen_addr.clone(),
@@ -744,6 +756,7 @@ async fn start_ldk() {
                Arc::clone(&channel_manager),
                Arc::clone(&keys_manager),
                Arc::clone(&network_graph),
+               Arc::clone(&onion_messenger),
                inbound_payments,
                outbound_payments,
                ldk_data_dir.clone(),