f Expose methods to remove and list filtered payments

Author: tnull

src/lib.rs

@@ -503,11 +503,9 @@ impl Builder {
 
 		// Init payment info storage
 		let payment_store = match io::utils::read_payments(Arc::clone(&kv_store)) {
-			Ok(payments) => Arc::new(PaymentStore::from_payments(
-				payments,
-				Arc::clone(&kv_store),
-				Arc::clone(&logger),
-			)),
+			Ok(payments) => {
+				Arc::new(PaymentStore::new(payments, Arc::clone(&kv_store), Arc::clone(&logger)))
+			}
 			Err(e) => {
 				log_error!(logger, "Failed to read payment information: {}", e.to_string());
 				panic!("Failed to read payment information: {}", e.to_string());
@@ -1270,10 +1268,38 @@ impl Node {
 		Ok(invoice)
 	}
 
-	/// Query for information about the status of a specific payment.
+	/// Retrieve the details of a specific payment with the given hash.
+	///
+	/// Returns `Some` if the payment was known and `None` otherwise.
 	pub fn payment(&self, payment_hash: &PaymentHash) -> Option<PaymentDetails> {
 		self.payment_store.get(payment_hash)
 	}
+
+	/// Remove the payment with the given hash from the store.
+	///
+	/// Returns `true` if the payment was present and `false` otherwise.
+	pub fn remove_payment(&self, payment_hash: &PaymentHash) -> Result<bool, Error> {
+		self.payment_store.remove(&payment_hash)
+	}
+
+	/// Retrieves all payments that match the given predicate.
+	///
+	/// For example, you could retrieve all stored outbound payments as follows:
+	/// ```
+	/// # use ldk_node::{Builder, Config, PaymentDirection};
+	/// # use ldk_node::bitcoin::Network;
+	/// # let mut config = Config::default();
+	/// # config.network = Network::Regtest;
+	/// # config.storage_dir_path = "/tmp/ldk_node_test/".to_string();
+	/// # let builder = Builder::from_config(config);
+	/// # let node = builder.build();
+	/// node.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound);
+	/// ```
+	pub fn list_payments_with_filter<F: FnMut(&&PaymentDetails) -> bool>(
+		&self, f: F,
+	) -> Vec<PaymentDetails> {
+		self.payment_store.list_filter(f)
+	}
 }
 
 async fn connect_peer_if_necessary(

src/payment_store.rs

@@ -84,12 +84,7 @@ where
 	K::Target: KVStore,
 	L::Target: Logger,
 {
-	pub(crate) fn new(kv_store: K, logger: L) -> Self {
-		let payments = Mutex::new(HashMap::new());
-		Self { payments, kv_store, logger }
-	}
-
-	pub(crate) fn from_payments(payments: Vec<PaymentDetails>, kv_store: K, logger: L) -> Self {
+	pub(crate) fn new(payments: Vec<PaymentDetails>, kv_store: K, logger: L) -> Self {
 		let payments = Mutex::new(HashMap::from_iter(
 			payments.into_iter().map(|payment| (payment.hash, payment)),
 		));
@@ -105,7 +100,7 @@ where
 		Ok(updated)
 	}
 
-	pub(crate) fn remove(&self, hash: &PaymentHash) -> Result<(), Error> {
+	pub(crate) fn remove(&self, hash: &PaymentHash) -> Result<bool, Error> {
 		let store_key = hex_utils::to_string(&hash.0);
 		self.kv_store.remove(PAYMENT_INFO_PERSISTENCE_NAMESPACE, &store_key).map_err(|e| {
 			log_error!(
@@ -116,8 +111,7 @@ where
 				e
 			);
 			Error::PersistenceFailed
-		})?;
-		Ok(())
+		})
 	}
 
 	pub(crate) fn get(&self, hash: &PaymentHash) -> Option<PaymentDetails> {
@@ -160,6 +154,19 @@ where
 		Ok(updated)
 	}
 
+	pub(crate) fn list_filter<F: FnMut(&&PaymentDetails) -> bool>(
+		&self, f: F,
+	) -> Vec<PaymentDetails> {
+		self.payments
+			.lock()
+			.unwrap()
+			.iter()
+			.map(|(_, p)| p)
+			.filter(f)
+			.cloned()
+			.collect::<Vec<PaymentDetails>>()
+	}
+
 	fn write_info_and_commit(
 		&self, hash: &PaymentHash, payment: &PaymentDetails,
 	) -> Result<(), Error> {
@@ -209,7 +216,7 @@ mod tests {
 	fn persistence_guard_persists_on_drop() {
 		let store = Arc::new(TestStore::new());
 		let logger = Arc::new(TestLogger::new());
-		let payment_store = PaymentStore::new(Arc::clone(&store), logger);
+		let payment_store = PaymentStore::new(Vec::new(), Arc::clone(&store), logger);
 
 		let hash = PaymentHash([42u8; 32]);
 		assert!(!payment_store.contains(&hash));

src/test/functional_tests.rs

@@ -78,6 +78,22 @@ fn channel_full_cycle() {
 	println!("\nA send_payment");
 	let payment_hash = node_a.send_payment(invoice.clone()).unwrap();
 
+	let outbound_payments_a =
+		node_a.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound);
+	assert_eq!(outbound_payments_a.len(), 1);
+
+	let inbound_payments_a =
+		node_a.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound);
+	assert_eq!(inbound_payments_a.len(), 0);
+
+	let outbound_payments_b =
+		node_b.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound);
+	assert_eq!(outbound_payments_b.len(), 0);
+
+	let inbound_payments_b =
+		node_b.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound);
+	assert_eq!(inbound_payments_b.len(), 1);
+
 	expect_event!(node_a, PaymentSuccessful);
 	expect_event!(node_b, PaymentReceived);
 	assert_eq!(node_a.payment(&payment_hash).unwrap().status, PaymentStatus::Succeeded);