Split payments hashmap into inbound and outbound

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index 87ad4e9a718997f48c58af19aa32688c1944791d..700112920c6cb860f6e52e5632fe01a92d351d95 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -51,12 +51,6 @@ use std::sync::{Arc, Mutex};
 use std::time::{Duration, SystemTime};
 use tokio::sync::mpsc;
 
-#[derive(PartialEq)]
-pub(crate) enum HTLCDirection {
-       Inbound,
-       Outbound,
-}
-
 pub(crate) enum HTLCStatus {
        Pending,
        Succeeded,
@@ -77,7 +71,6 @@ impl fmt::Display for MillisatAmount {
 pub(crate) struct PaymentInfo {
        preimage: Option<PaymentPreimage>,
        secret: Option<PaymentSecret>,
-       direction: HTLCDirection,
        status: HTLCStatus,
        amt_msat: MillisatAmount,
 }
@@ -108,7 +101,7 @@ pub(crate) type ChannelManager =
 async fn handle_ldk_events(
        channel_manager: Arc<ChannelManager>, chain_monitor: Arc<ChainMonitor>,
        bitcoind_client: Arc<BitcoindClient>, keys_manager: Arc<KeysManager>,
-       payment_storage: PaymentInfoStorage, network: Network,
+       inbound_payments: PaymentInfoStorage, outbound_payments: PaymentInfoStorage, network: Network,
 ) {
        loop {
                let loop_channel_manager = channel_manager.clone();
@@ -157,7 +150,7 @@ async fn handle_ldk_events(
                                                .unwrap();
                                }
                                Event::PaymentReceived { payment_hash, .. } => {
-                                       let mut payments = payment_storage.lock().unwrap();
+                                       let mut payments = inbound_payments.lock().unwrap();
                                        if let Some(payment) = payments.get_mut(&payment_hash) {
                                                assert!(loop_channel_manager.claim_funds(
                                                        payment.preimage.unwrap().clone(),
@@ -182,7 +175,6 @@ async fn handle_ldk_events(
                                                        PaymentInfo {
                                                                preimage: None,
                                                                secret: None,
-                                                               direction: HTLCDirection::Inbound,
                                                                status: HTLCStatus::Failed,
                                                                amt_msat: MillisatAmount(None),
                                                        },
@@ -191,7 +183,7 @@ async fn handle_ldk_events(
                                }
                                Event::PaymentSent { payment_preimage } => {
                                        let hashed = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
-                                       let mut payments = payment_storage.lock().unwrap();
+                                       let mut payments = outbound_payments.lock().unwrap();
                                        for (payment_hash, payment) in payments.iter_mut() {
                                                if *payment_hash == hashed {
                                                        payment.preimage = Some(payment_preimage);
@@ -221,7 +213,7 @@ async fn handle_ldk_events(
                                        print!("> ");
                                        io::stdout().flush().unwrap();
 
-                                       let mut payments = payment_storage.lock().unwrap();
+                                       let mut payments = outbound_payments.lock().unwrap();
                                        if payments.contains_key(&payment_hash) {
                                                let payment = payments.get_mut(&payment_hash).unwrap();
                                                payment.status = HTLCStatus::Failed;
@@ -505,8 +497,10 @@ async fn start_ldk() {
        let chain_monitor_event_listener = chain_monitor.clone();
        let keys_manager_listener = keys_manager.clone();
        // TODO: persist payment info to disk
-       let payment_info: PaymentInfoStorage = Arc::new(Mutex::new(HashMap::new()));
-       let payment_info_for_events = payment_info.clone();
+       let inbound_payments: PaymentInfoStorage = Arc::new(Mutex::new(HashMap::new()));
+       let outbound_payments: PaymentInfoStorage = Arc::new(Mutex::new(HashMap::new()));
+       let inbound_pmts_for_events = inbound_payments.clone();
+       let outbound_pmts_for_events = outbound_payments.clone();
        let network = args.network;
        let bitcoind_rpc = bitcoind_client.clone();
        tokio::spawn(async move {
@@ -515,7 +509,8 @@ async fn start_ldk() {
                        chain_monitor_event_listener,
                        bitcoind_rpc,
                        keys_manager_listener,
-                       payment_info_for_events,
+                       inbound_pmts_for_events,
+                       outbound_pmts_for_events,
                        network,
                )
                .await;
@@ -546,7 +541,8 @@ async fn start_ldk() {
                peer_manager.clone(),
                channel_manager.clone(),
                router.clone(),
-               payment_info,
+               inbound_payments,
+               outbound_payments,
                keys_manager.get_node_secret(),
                event_ntfn_sender,
                ldk_data_dir.clone(),