fix Clarify units (msat&sats), other minor

Author: optout21

lightning/src/ln/channel.rs

@@ -10853,6 +10853,7 @@ where
 
 	/// Compute the channel balances (local & remote, in msats) by taking into account fees,
 	/// anchor values, and dust limits.
+	/// Pending HTLCs are not taken into account, this method should be used when there is no such,
 	/// e.g. in quiescence state
 	#[cfg(splicing)]
 	fn compute_balances_less_fees(
@@ -11091,59 +11092,58 @@ where
 		))
 	}
 
-	/// Check that post-splicing balance meets reserve requirements, but only if it met it pre-splice as well
 	/// Check that post-splicing balance meets reserve requirements, but only if it met it pre-splice as well.
-	/// Returns the minimum channel reserve (sats)
+	/// In case of error, it returns the minimum channel reserve that was violated (in sats)
 	#[cfg(splicing)]
-	pub fn check_splice_balance_meets_v2_reserve_requirement_noerr(
-		&self, pre_balance: u64, post_balance: u64, pre_channel_value: u64,
-		post_channel_value: u64, dust_limit: u64,
+	pub fn check_splice_balance_meets_v2_reserve_requirement(
+		&self, pre_balance_msat: u64, post_balance_msat: u64, pre_channel_value_sats: u64,
+		post_channel_value_sats: u64, dust_limit_sats: u64,
 	) -> Result<(), u64> {
 		let post_channel_reserve_sats =
-			get_v2_channel_reserve_satoshis(post_channel_value, dust_limit);
-		if post_balance >= post_channel_reserve_sats * 1000 {
+			get_v2_channel_reserve_satoshis(post_channel_value_sats, dust_limit_sats);
+		if post_balance_msat >= (post_channel_reserve_sats * 1000) {
 			return Ok(());
 		}
 		// We're not allowed to dip below the reserve once we've been above,
 		// check differently for originally v1 and v2 channels
 		if self.is_v2_established() {
 			let pre_channel_reserve_sats =
-				get_v2_channel_reserve_satoshis(pre_channel_value, dust_limit);
-			if pre_balance >= pre_channel_reserve_sats * 1000 {
+				get_v2_channel_reserve_satoshis(pre_channel_value_sats, dust_limit_sats);
+			if pre_balance_msat >= (pre_channel_reserve_sats * 1000) {
 				return Err(post_channel_reserve_sats);
 			}
 		} else {
-			if pre_balance >= self.funding.holder_selected_channel_reserve_satoshis * 1000 {
+			if pre_balance_msat >= (self.funding.holder_selected_channel_reserve_satoshis * 1000) {
 				return Err(post_channel_reserve_sats);
 			}
 			if let Some(cp_reserve) = self.funding.counterparty_selected_channel_reserve_satoshis {
-				if pre_balance >= cp_reserve * 1000 {
+				if pre_balance_msat >= (cp_reserve * 1000) {
 					return Err(post_channel_reserve_sats);
 				}
 			}
 		}
 		// Make sure we either remain with the same balance or move towards the reserve.
-		if post_balance >= pre_balance {
+		if post_balance_msat >= pre_balance_msat {
 			Ok(())
 		} else {
 			Err(post_channel_reserve_sats)
 		}
 	}
 
-	/// Check that balances meet the channel reserve requirements or violates them (below reserve).
+	/// Check that balances (self and counterparty) meet the channel reserve requirements or violates them (below reserve).
 	/// The channel value is an input as opposed to using from the FundingScope, so that this can be used in case of splicing
 	/// to check with new channel value (before being committed to it).
 	#[cfg(splicing)]
 	pub fn check_splice_balances_meet_v2_reserve_requirements(
 		&self, self_balance_pre_msat: u64, self_balance_post_msat: u64,
 		counterparty_balance_pre_msat: u64, counterparty_balance_post_msat: u64,
-		channel_value_pre: u64, channel_value_post: u64,
+		channel_value_pre_sats: u64, channel_value_post_sats: u64,
 	) -> Result<(), ChannelError> {
-		let is_ok_self = self.check_splice_balance_meets_v2_reserve_requirement_noerr(
+		let is_ok_self = self.check_splice_balance_meets_v2_reserve_requirement(
 			self_balance_pre_msat,
 			self_balance_post_msat,
-			channel_value_pre,
-			channel_value_post,
+			channel_value_pre_sats,
+			channel_value_post_sats,
 			self.context.holder_dust_limit_satoshis,
 		);
 		if let Err(channel_reserve_self) = is_ok_self {
@@ -11152,11 +11152,11 @@ where
 				self_balance_post_msat, channel_reserve_self,
 			)));
 		}
-		let is_ok_cp = self.check_splice_balance_meets_v2_reserve_requirement_noerr(
+		let is_ok_cp = self.check_splice_balance_meets_v2_reserve_requirement(
 			counterparty_balance_pre_msat,
 			counterparty_balance_post_msat,
-			channel_value_pre,
-			channel_value_post,
+			channel_value_pre_sats,
+			channel_value_post_sats,
 			self.context.counterparty_dust_limit_satoshis,
 		);
 		if let Err(channel_reserve_cp) = is_ok_cp {