Modify pending inbound/outbound getters to access dust balances

Author: Antoine Riard

lightning/src/ln/channel.rs

@@ -1751,31 +1751,59 @@ impl<Signer: Sign> Channel<Signer> {
 	}
 
 	/// Returns (inbound_htlc_count, htlc_inbound_value_msat)
-	fn get_inbound_pending_htlc_stats(&self) -> (u32, u64) {
+	fn get_inbound_pending_htlc_stats(&self) -> (u32, u64, u64, u64) {
 		let mut htlc_inbound_value_msat = 0;
+		let mut counterparty_dusted_htlc_msat = 0;
+		let mut holder_dusted_htlc_msat = 0;
+
+		let counterparty_dust_limit_timeout_sat = (self.feerate_per_kw as u64 * HTLC_TIMEOUT_TX_WEIGHT / 1000) + self.counterparty_dust_limit_satoshis;
+		let holder_dust_limit_success_sat = (self.feerate_per_kw as u64 * HTLC_SUCCESS_TX_WEIGHT / 1000) + self.holder_dust_limit_satoshis;
 		for ref htlc in self.pending_inbound_htlcs.iter() {
 			htlc_inbound_value_msat += htlc.amount_msat;
+			if htlc.amount_msat / 1000 < counterparty_dust_limit_timeout_sat {
+				counterparty_dusted_htlc_msat += htlc.amount_msat;
+			}
+			if htlc.amount_msat / 1000 < holder_dust_limit_success_sat {
+				holder_dusted_htlc_msat += htlc.amount_msat;
+			}
 		}
-		(self.pending_inbound_htlcs.len() as u32, htlc_inbound_value_msat)
+		(self.pending_inbound_htlcs.len() as u32, htlc_inbound_value_msat, counterparty_dusted_htlc_msat, holder_dusted_htlc_msat)
 	}
 
-	/// Returns (outbound_htlc_count, htlc_outbound_value_msat) *including* pending adds in our
-	/// holding cell.
-	fn get_outbound_pending_htlc_stats(&self) -> (u32, u64) {
+	/// Returns (outbound_htlc_count, htlc_outbound_value_msat, outbound_dusted_htlc_value_msat) *including*
+	/// pending adds in our holding cell.
+	fn get_outbound_pending_htlc_stats(&self) -> (u32, u64, u64, u64) {
 		let mut htlc_outbound_value_msat = 0;
+		let mut counterparty_dusted_htlc_msat = 0;
+		let mut holder_dusted_htlc_msat = 0;
+
+		let counterparty_dust_limit_success_sat = (self.feerate_per_kw as u64 * HTLC_SUCCESS_TX_WEIGHT / 1000) + self.counterparty_dust_limit_satoshis;
+		let holder_dust_limit_timeout_sat = (self.feerate_per_kw as u64 * HTLC_TIMEOUT_TX_WEIGHT / 1000) + self.holder_dust_limit_satoshis;
 		for ref htlc in self.pending_outbound_htlcs.iter() {
 			htlc_outbound_value_msat += htlc.amount_msat;
+			if htlc.amount_msat / 1000 < counterparty_dust_limit_success_sat {
+				counterparty_dusted_htlc_msat += htlc.amount_msat;
+			}
+			if htlc.amount_msat / 1000 < holder_dust_limit_timeout_sat {
+				holder_dusted_htlc_msat += htlc.amount_msat;
+			}
 		}
 
 		let mut htlc_outbound_count = self.pending_outbound_htlcs.len();
 		for update in self.holding_cell_htlc_updates.iter() {
 			if let &HTLCUpdateAwaitingACK::AddHTLC { ref amount_msat, .. } = update {
 				htlc_outbound_count += 1;
 				htlc_outbound_value_msat += amount_msat;
+				if *amount_msat / 1000 < counterparty_dust_limit_success_sat {
+					counterparty_dusted_htlc_msat += amount_msat;
+				}
+				if *amount_msat / 1000 < holder_dust_limit_timeout_sat {
+					holder_dusted_htlc_msat += amount_msat;
+				}
 			}
 		}
 
-		(htlc_outbound_count as u32, htlc_outbound_value_msat)
+		(htlc_outbound_count as u32, htlc_outbound_value_msat, counterparty_dusted_htlc_msat, holder_dusted_htlc_msat)
 	}
 
 	/// Get the available (ie not including pending HTLCs) inbound and outbound balance in msat.
@@ -2003,7 +2031,8 @@ impl<Signer: Sign> Channel<Signer> {
 			return Err(ChannelError::Close(format!("Remote side tried to send less than our minimum HTLC value. Lower limit: ({}). Actual: ({})", self.holder_htlc_minimum_msat, msg.amount_msat)));
 		}
 
-		let (inbound_htlc_count, htlc_inbound_value_msat) = self.get_inbound_pending_htlc_stats();
+		let (inbound_htlc_count, htlc_inbound_value_msat, on_counterparty_tx_dust_inbound, on_holder_tx_dust_inbound) = self.get_inbound_pending_htlc_stats();
+		let (_, _, on_counterparty_tx_dust_outbound, on_holder_tx_dust_outbound) = self.get_outbound_pending_htlc_stats();
 		if inbound_htlc_count + 1 > OUR_MAX_HTLCS as u32 {
 			return Err(ChannelError::Close(format!("Remote tried to push more than our max accepted HTLCs ({})", OUR_MAX_HTLCS)));
 		}
@@ -4075,7 +4104,8 @@ impl<Signer: Sign> Channel<Signer> {
 			return Err(ChannelError::Ignore("Cannot send an HTLC while disconnected from channel counterparty".to_owned()));
 		}
 
-		let (outbound_htlc_count, htlc_outbound_value_msat) = self.get_outbound_pending_htlc_stats();
+		let (_, _, on_counterparty_tx_dust_inbound, on_holder_tx_dust_inbound) = self.get_inbound_pending_htlc_stats();
+		let (outbound_htlc_count, htlc_outbound_value_msat, on_counterparty_tx_dust_outbound, on_holder_tx_dust_outbound) = self.get_outbound_pending_htlc_stats();
 		if outbound_htlc_count + 1 > self.counterparty_max_accepted_htlcs as u32 {
 			return Err(ChannelError::Ignore(format!("Cannot push more than their max accepted HTLCs ({})", self.counterparty_max_accepted_htlcs)));
 		}