f Rename PaymentInfo to PaymentDetails (+..InfoStorage to Store)

We avoid the `Info` umbrella term but opt to introduce `PaymentDetails`
to align naming with upcoming `PeerDetails` and `ChannelDetails`.

Author: tnull

src/event.rs

@@ -1,6 +1,6 @@
 use crate::{
-	hex_utils, ChannelManager, Config, Error, KeysManager, NetworkGraph, PaymentDirection,
-	PaymentInfo, PaymentInfoStorage, PaymentStatus, Wallet,
+	hex_utils, ChannelManager, Config, Error, KeysManager, NetworkGraph, PaymentDetails,
+	PaymentDirection, PaymentStatus, PaymentStore, Wallet,
 };
 
 use crate::io::{
@@ -225,7 +225,7 @@ where
 	channel_manager: Arc<ChannelManager>,
 	network_graph: Arc<NetworkGraph>,
 	keys_manager: Arc<KeysManager>,
-	payment_store: Arc<PaymentInfoStorage<K, L>>,
+	payment_store: Arc<PaymentStore<K, L>>,
 	tokio_runtime: Arc<tokio::runtime::Runtime>,
 	logger: L,
 	_config: Arc<Config>,
@@ -239,7 +239,7 @@ where
 	pub fn new(
 		wallet: Arc<Wallet<bdk::database::SqliteDatabase>>, event_queue: Arc<EventQueue<K, L>>,
 		channel_manager: Arc<ChannelManager>, network_graph: Arc<NetworkGraph>,
-		keys_manager: Arc<KeysManager>, payment_store: Arc<PaymentInfoStorage<K, L>>,
+		keys_manager: Arc<KeysManager>, payment_store: Arc<PaymentStore<K, L>>,
 		tokio_runtime: Arc<tokio::runtime::Runtime>, logger: L, _config: Arc<Config>,
 	) -> Self {
 		Self {
@@ -420,16 +420,16 @@ where
 						}
 					}
 					PaymentPurpose::SpontaneousPayment(preimage) => {
-						let payment_info = PaymentInfo {
+						let payment = PaymentDetails {
 							preimage: Some(preimage),
-							payment_hash,
+							hash: payment_hash,
 							secret: None,
 							amount_msat: Some(amount_msat),
 							direction: PaymentDirection::Inbound,
 							status: PaymentStatus::Succeeded,
 						};
 
-						match self.payment_store.insert(payment_info) {
+						match self.payment_store.insert(payment) {
 							Ok(false) => (),
 							Ok(true) => {
 								log_error!(
@@ -457,17 +457,17 @@ where
 					.expect("Failed to push to event queue");
 			}
 			LdkEvent::PaymentSent { payment_preimage, payment_hash, fee_paid_msat, .. } => {
-				if let Some(mut payment_info) = self.payment_store.get(&payment_hash) {
-					payment_info.preimage = Some(payment_preimage);
-					payment_info.status = PaymentStatus::Succeeded;
+				if let Some(mut payment) = self.payment_store.get(&payment_hash) {
+					payment.preimage = Some(payment_preimage);
+					payment.status = PaymentStatus::Succeeded;
 					self.payment_store
-						.insert(payment_info.clone())
+						.insert(payment.clone())
 						.expect("Failed to access payment store");
 					log_info!(
 						self.logger,
 						"Successfully sent payment of {}msat{} from \
 						payment hash {:?} with preimage {:?}",
-						payment_info.amount_msat.unwrap(),
+						payment.amount_msat.unwrap(),
 						if let Some(fee) = fee_paid_msat {
 							format!(" (fee {} msat)", fee)
 						} else {

src/io/utils.rs

@@ -2,7 +2,7 @@ use super::*;
 use crate::WALLET_KEYS_SEED_LEN;
 
 use crate::peer_store::PeerInfoStorage;
-use crate::{EventQueue, PaymentInfo};
+use crate::{EventQueue, PaymentDetails};
 
 use lightning::chain::channelmonitor::ChannelMonitor;
 use lightning::chain::keysinterface::{EntropySource, SignerProvider};
@@ -158,22 +158,20 @@ where
 }
 
 /// Read previously persisted payments information from the store.
-pub(crate) fn read_payment_info<K: Deref>(kv_store: K) -> Result<Vec<PaymentInfo>, std::io::Error>
+pub(crate) fn read_payments<K: Deref>(kv_store: K) -> Result<Vec<PaymentDetails>, std::io::Error>
 where
 	K::Target: KVStore,
 {
 	let mut res = Vec::new();
 
 	for stored_key in kv_store.list(PAYMENT_INFO_PERSISTENCE_NAMESPACE)? {
-		let payment_info =
-			PaymentInfo::read(&mut kv_store.read(PAYMENT_INFO_PERSISTENCE_NAMESPACE, &stored_key)?)
-				.map_err(|_| {
-					std::io::Error::new(
-						std::io::ErrorKind::InvalidData,
-						"Failed to deserialize PaymentInfo",
-					)
-				})?;
-		res.push(payment_info);
+		let payment = PaymentDetails::read(
+			&mut kv_store.read(PAYMENT_INFO_PERSISTENCE_NAMESPACE, &stored_key)?,
+		)
+		.map_err(|_| {
+			std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize Payment")
+		})?;
+		res.push(payment);
 	}
 	Ok(res)
 }

src/lib.rs

@@ -87,8 +87,8 @@ pub use event::Event;
 use event::{EventHandler, EventQueue};
 use io::fs_store::FilesystemStore;
 use io::{KVStore, CHANNEL_MANAGER_PERSISTENCE_KEY, CHANNEL_MANAGER_PERSISTENCE_NAMESPACE};
-use payment_store::PaymentInfoStorage;
-pub use payment_store::{PaymentDirection, PaymentInfo, PaymentStatus};
+use payment_store::PaymentStore;
+pub use payment_store::{PaymentDetails, PaymentDirection, PaymentStatus};
 use peer_store::{PeerInfo, PeerInfoStorage};
 use types::{
 	ChainMonitor, ChannelManager, GossipSync, KeysManager, NetworkGraph, OnionMessenger,
@@ -502,8 +502,8 @@ impl Builder {
 		));
 
 		// Init payment info storage
-		let payment_store = match io::utils::read_payment_info(Arc::clone(&kv_store)) {
-			Ok(payments) => Arc::new(PaymentInfoStorage::from_payments(
+		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),
@@ -591,7 +591,7 @@ pub struct Node {
 	logger: Arc<FilesystemLogger>,
 	scorer: Arc<Mutex<Scorer>>,
 	peer_store: Arc<PeerInfoStorage<Arc<FilesystemStore>, Arc<FilesystemLogger>>>,
-	payment_store: Arc<PaymentInfoStorage<Arc<FilesystemStore>, Arc<FilesystemLogger>>>,
+	payment_store: Arc<PaymentStore<Arc<FilesystemStore>, Arc<FilesystemLogger>>>,
 }
 
 impl Node {
@@ -1023,15 +1023,15 @@ impl Node {
 				let amt_msat = invoice.amount_milli_satoshis().unwrap();
 				log_info!(self.logger, "Initiated sending {}msat to {}", amt_msat, payee_pubkey);
 
-				let payment_info = PaymentInfo {
+				let payment = PaymentDetails {
 					preimage: None,
-					payment_hash,
+					hash: payment_hash,
 					secret: payment_secret,
 					amount_msat: invoice.amount_milli_satoshis(),
 					direction: PaymentDirection::Outbound,
 					status: PaymentStatus::Pending,
 				};
-				self.payment_store.insert(payment_info)?;
+				self.payment_store.insert(payment)?;
 
 				Ok(payment_hash)
 			}
@@ -1118,15 +1118,15 @@ impl Node {
 					payee_pubkey
 				);
 
-				let payment_info = PaymentInfo {
-					payment_hash,
+				let payment = PaymentDetails {
+					hash: payment_hash,
 					preimage: None,
 					secret: payment_secret,
 					direction: PaymentDirection::Outbound,
 					status: PaymentStatus::Pending,
 					amount_msat: Some(amount_msat),
 				};
-				self.payment_store.insert(payment_info)?;
+				self.payment_store.insert(payment)?;
 
 				Ok(payment_hash)
 			}
@@ -1179,30 +1179,30 @@ impl Node {
 			Ok(_payment_id) => {
 				log_info!(self.logger, "Initiated sending {}msat to {}.", amount_msat, node_id);
 
-				let payment_info = PaymentInfo {
-					payment_hash,
+				let payment = PaymentDetails {
+					hash: payment_hash,
 					preimage: Some(payment_preimage),
 					secret: None,
 					status: PaymentStatus::Pending,
 					direction: PaymentDirection::Outbound,
 					amount_msat: Some(amount_msat),
 				};
-				self.payment_store.insert(payment_info)?;
+				self.payment_store.insert(payment)?;
 
 				Ok(payment_hash)
 			}
 			Err(e) => {
 				log_error!(self.logger, "Failed to send payment: {:?}", e);
 
-				let payment_info = PaymentInfo {
-					payment_hash,
+				let payment = PaymentDetails {
+					hash: payment_hash,
 					preimage: Some(payment_preimage),
 					secret: None,
 					status: PaymentStatus::Failed,
 					direction: PaymentDirection::Outbound,
 					amount_msat: Some(amount_msat),
 				};
-				self.payment_store.insert(payment_info)?;
+				self.payment_store.insert(payment)?;
 
 				Err(Error::PaymentFailed)
 			}
@@ -1256,22 +1256,22 @@ impl Node {
 		};
 
 		let payment_hash = PaymentHash((*invoice.payment_hash()).into_inner());
-		let payment_info = PaymentInfo {
+		let payment = PaymentDetails {
+			hash: payment_hash,
 			preimage: None,
-			payment_hash,
 			secret: Some(invoice.payment_secret().clone()),
 			amount_msat,
 			direction: PaymentDirection::Inbound,
 			status: PaymentStatus::Pending,
 		};
 
-		self.payment_store.insert(payment_info)?;
+		self.payment_store.insert(payment)?;
 
 		Ok(invoice)
 	}
 
 	/// Query for information about the status of a specific payment.
-	pub fn payment_info(&self, payment_hash: &PaymentHash) -> Option<PaymentInfo> {
+	pub fn payment(&self, payment_hash: &PaymentHash) -> Option<PaymentDetails> {
 		self.payment_store.get(payment_hash)
 	}
 }