Handle `Event::ConnectionNeeded` for onion message sending

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index 6480805d92759eed4d90407ada06a3f6eb7f202f..6b4dbdd4260e5779ebe537ce74df3bfb8670188e 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -25,7 +25,7 @@ use lightning::ln::channelmanager::{
 use lightning::ln::msgs::DecodeError;
 use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler, SimpleArcPeerManager};
 use lightning::ln::{ChannelId, PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning::onion_message::{DefaultMessageRouter, SimpleArcOnionMessenger};
+use lightning::onion_message::messenger::{DefaultMessageRouter, SimpleArcOnionMessenger};
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
 use lightning::routing::router::DefaultRouter;
@@ -51,6 +51,7 @@ use std::fs;
 use std::fs::File;
 use std::io;
 use std::io::Write;
+use std::net::ToSocketAddrs;
 use std::path::Path;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, RwLock};
@@ -145,11 +146,6 @@ pub(crate) type GossipVerifier = lightning_block_sync::gossip::GossipVerifier<
        lightning_block_sync::gossip::TokioSpawner,
        Arc<lightning_block_sync::rpc::RpcClient>,
        Arc<FilesystemLogger>,
-       SocketDescriptor,
-       Arc<ChannelManager>,
-       Arc<OnionMessenger>,
-       IgnoringMessageHandler,
-       Arc<KeysManager>,
 >;
 
 pub(crate) type PeerManager = SimpleArcPeerManager<
@@ -177,11 +173,11 @@ pub(crate) type BumpTxEventHandler = BumpTransactionEventHandler<
 >;
 
 async fn handle_ldk_events(
-       channel_manager: &Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
+       channel_manager: Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
        network_graph: &NetworkGraph, keys_manager: &KeysManager,
-       bump_tx_event_handler: &BumpTxEventHandler,
+       bump_tx_event_handler: &BumpTxEventHandler, peer_manager: Arc<PeerManager>,
        inbound_payments: Arc<Mutex<InboundPaymentInfoStorage>>,
-       outbound_payments: Arc<Mutex<OutboundPaymentInfoStorage>>, fs_store: &Arc<FilesystemStore>,
+       outbound_payments: Arc<Mutex<OutboundPaymentInfoStorage>>, fs_store: Arc<FilesystemStore>,
        network: Network, event: Event,
 ) {
        match event {
@@ -195,12 +191,12 @@ async fn handle_ldk_events(
                        // Construct the raw transaction with one output, that is paid the amount of the
                        // channel.
                        let addr = WitnessProgram::from_scriptpubkey(
-                               &output_script[..],
+                               &output_script.as_bytes(),
                                match network {
                                        Network::Bitcoin => bitcoin_bech32::constants::Network::Bitcoin,
-                                       Network::Testnet => bitcoin_bech32::constants::Network::Testnet,
                                        Network::Regtest => bitcoin_bech32::constants::Network::Regtest,
                                        Network::Signet => bitcoin_bech32::constants::Network::Signet,
+                                       Network::Testnet | _ => bitcoin_bech32::constants::Network::Testnet,
                                },
                        )
                        .expect("Lightning funding tx should always be to a SegWit output")
@@ -213,7 +209,7 @@ async fn handle_ldk_events(
                        // satisfied.
                        let funded_tx = bitcoind_client.fund_raw_transaction(raw_tx).await;
 
-                       // Sign the final funding transaction and broadcast it.
+                       // Sign the final funding transaction and give it to LDK, who will eventually broadcast it.
                        let signed_tx = bitcoind_client.sign_raw_transaction_with_wallet(funded_tx.hex).await;
                        assert_eq!(signed_tx.complete, true);
                        let final_tx: Transaction =
@@ -500,6 +496,7 @@ async fn handle_ldk_events(
                        user_channel_id: _,
                        counterparty_node_id,
                        channel_capacity_sats: _,
+                       channel_funding_txo: _,
                } => {
                        println!(
                                "\nEVENT: Channel {} with counterparty {} closed due to: {:?}",
@@ -516,6 +513,20 @@ async fn handle_ldk_events(
                }
                Event::HTLCIntercepted { .. } => {}
                Event::BumpTransaction(event) => bump_tx_event_handler.handle_event(&event),
+               Event::ConnectionNeeded { node_id, addresses } => {
+                       tokio::spawn(async move {
+                               for address in addresses {
+                                       if let Ok(sockaddrs) = address.to_socket_addrs() {
+                                               for addr in sockaddrs {
+                                                       let pm = Arc::clone(&peer_manager);
+                                                       if cli::connect_peer_if_necessary(node_id, addr, pm).await.is_ok() {
+                                                               return;
+                                                       }
+                                               }
+                                       }
+                               }
+                       });
+               }
        }
 }
 
@@ -539,6 +550,7 @@ async fn start_ldk() {
                args.bitcoind_rpc_port,
                args.bitcoind_rpc_username.clone(),
                args.bitcoind_rpc_password.clone(),
+               args.network,
                tokio::runtime::Handle::current(),
                Arc::clone(&logger),
        )
@@ -556,9 +568,9 @@ async fn start_ldk() {
        if bitcoind_chain
                != match args.network {
                        bitcoin::Network::Bitcoin => "main",
-                       bitcoin::Network::Testnet => "test",
                        bitcoin::Network::Regtest => "regtest",
                        bitcoin::Network::Signet => "signet",
+                       bitcoin::Network::Testnet | _ => "test",
                } {
                println!(
                        "Chain argument ({}) didn't match bitcoind chain ({})",
@@ -777,7 +789,7 @@ async fn start_ldk() {
                Arc::clone(&keys_manager),
                Arc::clone(&keys_manager),
                Arc::clone(&logger),
-               Arc::new(DefaultMessageRouter {}),
+               Arc::new(DefaultMessageRouter::new(Arc::clone(&network_graph))),
                Arc::clone(&channel_manager),
                IgnoringMessageHandler {},
        ));
@@ -888,6 +900,7 @@ async fn start_ldk() {
        let inbound_payments_event_listener = Arc::clone(&inbound_payments);
        let outbound_payments_event_listener = Arc::clone(&outbound_payments);
        let fs_store_event_listener = Arc::clone(&fs_store);
+       let peer_manager_event_listener = Arc::clone(&peer_manager);
        let network = args.network;
        let event_handler = move |event: Event| {
                let channel_manager_event_listener = Arc::clone(&channel_manager_event_listener);
@@ -898,16 +911,18 @@ async fn start_ldk() {
                let inbound_payments_event_listener = Arc::clone(&inbound_payments_event_listener);
                let outbound_payments_event_listener = Arc::clone(&outbound_payments_event_listener);
                let fs_store_event_listener = Arc::clone(&fs_store_event_listener);
+               let peer_manager_event_listener = Arc::clone(&peer_manager_event_listener);
                async move {
                        handle_ldk_events(
-                               &channel_manager_event_listener,
+                               channel_manager_event_listener,
                                &bitcoind_client_event_listener,
                                &network_graph_event_listener,
                                &keys_manager_event_listener,
                                &bump_tx_event_handler,
+                               peer_manager_event_listener,
                                inbound_payments_event_listener,
                                outbound_payments_event_listener,
-                               &fs_store_event_listener,
+                               fs_store_event_listener,
                                network,
                                event,
                        )
@@ -939,6 +954,7 @@ async fn start_ldk() {
                        })
                },
                false,
+               || Some(SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap()),
        ));
 
        // Regularly reconnect to channel peers.