Filter out paid invoices from NWC on startup

Author: benthecarman

mutiny-core/src/lib.rs

@@ -1156,8 +1156,8 @@ impl<S: MutinyStorage> MutinyWallet<S> {
                     log_warn!(logger, "Failed to clear in-active NWC profiles: {e}");
                 }
 
-                if let Err(e) = nostr.clear_expired_nwc_invoices().await {
-                    log_warn!(logger, "Failed to clear expired NWC invoices: {e}");
+                if let Err(e) = nostr.clear_invalid_nwc_invoices(&self_clone).await {
+                    log_warn!(logger, "Failed to clear invalid NWC invoices: {e}");
                 }
 
                 let client = Client::new(nostr.primary_key.clone());

mutiny-core/src/nostr/mod.rs

@@ -1112,23 +1112,45 @@ impl<S: MutinyStorage> NostrManager<S> {
         Ok(())
     }
 
-    /// Goes through all pending NWC invoices and removes the expired ones
-    pub async fn clear_expired_nwc_invoices(&self) -> Result<(), MutinyError> {
+    /// Goes through all pending NWC invoices and removes invoices that are
+    /// expired or have been paid
+    pub async fn clear_invalid_nwc_invoices(
+        &self,
+        invoice_handler: &impl InvoiceHandler,
+    ) -> Result<(), MutinyError> {
         self.pending_nwc_lock.lock().await;
-        let mut invoices: Vec<PendingNwcInvoice> = self
+        let invoices: Vec<PendingNwcInvoice> = self
             .storage
             .get_data(PENDING_NWC_EVENTS_KEY)?
             .unwrap_or_default();
 
-        // remove expired invoices
-        invoices.retain(|x| !x.is_expired());
+        let mut new_invoices = Vec::with_capacity(invoices.len());
+
+        for inv in invoices {
+            // remove expired invoices
+            if inv.is_expired() {
+                continue;
+            }
+
+            // remove paid invoices
+            if invoice_handler
+                .lookup_payment(&inv.invoice.payment_hash().into_32())
+                .await
+                .is_some_and(|p| p.status == HTLCStatus::Succeeded)
+            {
+                continue;
+            }
+
+            // keep the invoice if it is still valid
+            new_invoices.push(inv);
+        }
 
         // sort and dedup
-        invoices.sort();
-        invoices.dedup();
+        new_invoices.sort();
+        new_invoices.dedup();
 
         self.storage
-            .set_data(PENDING_NWC_EVENTS_KEY.to_string(), invoices, None)?;
+            .set_data(PENDING_NWC_EVENTS_KEY.to_string(), new_invoices, None)?;
 
         Ok(())
     }

mutiny-core/src/nostr/nwc.rs

@@ -1795,7 +1795,7 @@ mod wasm_test {
     }
 
     #[test]
-    async fn test_clear_expired_pending_invoices() {
+    async fn test_clear_invalid_pending_invoices() {
         let storage = MemoryStorage::default();
         let xprivkey = ExtendedPrivKey::new_master(Network::Regtest, &[0; 64]).unwrap();
         let stop = Arc::new(AtomicBool::new(false));
@@ -1822,9 +1822,10 @@ mod wasm_test {
             identifier: None,
         };
         // add an unexpired invoice
+        let dummy_invoice = create_dummy_invoice(Some(1_000), Network::Regtest, None).0;
         let unexpired = PendingNwcInvoice {
             index: Some(0),
-            invoice: create_dummy_invoice(Some(1_000), Network::Regtest, None).0,
+            invoice: dummy_invoice.clone(),
             event_id: EventId::all_zeros(),
             pubkey: nostr_manager.public_key,
             identifier: None,
@@ -1841,10 +1842,31 @@ mod wasm_test {
         assert_eq!(pending.len(), 2);
 
         // check that the expired invoice is cleared
-        nostr_manager.clear_expired_nwc_invoices().await.unwrap();
+        let mut node = MockInvoiceHandler::new();
+        node.expect_lookup_payment().return_const(None);
+        nostr_manager
+            .clear_invalid_nwc_invoices(&node)
+            .await
+            .unwrap();
         let pending = nostr_manager.get_pending_nwc_invoices().unwrap();
         assert_eq!(pending.len(), 1);
         assert_eq!(pending[0], unexpired);
+
+        let mut node = MockInvoiceHandler::new();
+        node.expect_lookup_payment()
+            .with(eq(dummy_invoice.payment_hash().into_32()))
+            .returning(move |_| {
+                Some(MutinyInvoice {
+                    status: HTLCStatus::Succeeded,
+                    ..Default::default()
+                })
+            });
+        nostr_manager
+            .clear_invalid_nwc_invoices(&node)
+            .await
+            .unwrap();
+        let pending = nostr_manager.get_pending_nwc_invoices().unwrap();
+        assert!(pending.is_empty());
     }
 
     #[test]