change count to retry_count being stored in PaymentAttempts

Author: kafaichoi

lightning-invoice/src/payment.rs

@@ -194,17 +194,15 @@ where
 /// be retried.
 #[derive(Clone, Copy)]
 struct PaymentAttempts<T: Time> {
-	/// This should be >= 1 as we only insert PaymentAttempts for a PaymentHash if there is at least
-	/// one attempt.
-	count: usize,
+	retry_count: usize,
 	/// This field is only used when retry is [`Retry::Timeout`] which is only build with feature std
 	first_attempted_at: T
 }
 
 impl<T: Time> PaymentAttempts<T> {
 	fn new() -> Self {
 		PaymentAttempts {
-			count: 1,
+			retry_count: 0,
 			first_attempted_at: T::now()
 		}
 	}
@@ -216,13 +214,13 @@ impl<T: Time> Debug for PaymentAttempts<T> {
 		return write!(
 			f,
 			"attempts: {}",
-			self.count
+			self.retry_count + 1
 		);
 		#[cfg(not(feature = "no-std"))]
 		return write!(
 			f,
 			"attempts: {}, duration: {:?}",
-			self.count,
+			self.retry_count + 1,
 			T::now().duration_since(self.first_attempted_at)
 		);
 	}
@@ -280,8 +278,7 @@ pub enum Retry {
 impl Retry {
 	fn is_retryable_now<T: Time>(&self, attempts: &PaymentAttempts<T>) -> bool {
 		match self {
-			Retry::Attempts(0) => false,
-			Retry::Attempts(max_retry_count) => max_retry_count + 1 > attempts.count,
+			Retry::Attempts(max_retry_count) => max_retry_count > &attempts.retry_count,
 			#[cfg(feature = "std")]
 			Retry::Timeout(max_duration) => *max_duration >= T::now().duration_since(attempts.first_attempted_at)
 		}
@@ -438,7 +435,7 @@ where
 					let mut payment_cache = self.payment_cache.lock().unwrap();
 					let payment_attempts = payment_cache.get_mut(&payment_hash).unwrap();
 					if self.retry.is_retryable_now(payment_attempts) {
-						payment_attempts.count += 1;
+						payment_attempts.retry_count += 1;
 						core::mem::drop(payment_cache);
 						Ok(self.pay_internal(params, payment_hash, send_payment)?)
 					} else {
@@ -471,12 +468,17 @@ where
 		let attempts = *self.payment_cache.lock().unwrap()
 			.entry(payment_hash)
 			.and_modify(|attempts| {
-				attempts.count += 1;
+				attempts.retry_count += 1;
 			})
 			.or_insert(PaymentAttempts::new());
 
+		let prevoius_retry_count = match attempts.retry_count {
+			0 => 0,
+			retry_count => retry_count - 1
+		};
+
 		if ! self.retry.is_retryable_now(&PaymentAttempts{
-			count: attempts.count -1,
+			retry_count: prevoius_retry_count,
 			..attempts
 		}) {
 			log_trace!(self.logger, "Payment {} exceeded maximum attempts; not retrying ({:?})", log_bytes!(payment_hash.0), attempts);
@@ -584,7 +586,7 @@ where
 				let mut payment_cache = self.payment_cache.lock().unwrap();
 				let attempts = payment_cache
 					.remove(payment_hash)
-					.map_or(1, |attempts| attempts.count + 1);
+					.map_or(1, |attempts| attempts.retry_count + 1);
 				log_trace!(self.logger, "Payment {} succeeded (attempts: {})", log_bytes!(payment_hash.0), attempts);
 			},
 			_ => {},