X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=src%2Fln%2Fchannel.rs;h=1d736d41d6f799569a633e2c9de8b6895d28e34c;hb=84d779a65170676e0945d1b9c467703ee86ef817;hp=f5dc76d4511702988deaea3f9ffb4f2b61e650af;hpb=e5974ce643927eeef4bac1f7d917bc027465b2aa;p=rust-lightning

diff --git a/src/ln/channel.rs b/src/ln/channel.rs
index f5dc76d4..1d736d41 100644
--- a/src/ln/channel.rs
+++ b/src/ln/channel.rs
@@ -1469,42 +1469,23 @@ impl Channel {
 		Ok(())
 	}
 
-	/// Returns (inbound_htlc_count, outbound_htlc_count, htlc_outbound_value_msat, htlc_inbound_value_msat)
-	/// If its for a remote update check, we need to be more lax about checking against messages we
-	/// sent but they may not have received/processed before they sent this message. Further, for
-	/// our own sends, we're more conservative and even consider things they've removed against
-	/// totals, though there is little reason to outside of further avoiding any race condition
-	/// issues.
-	fn get_pending_htlc_stats(&self, for_remote_update_check: bool) -> (u32, u32, u64, u64) {
-		//TODO: Can probably split this into inbound/outbound
-		let mut inbound_htlc_count: u32 = 0;
-		let mut outbound_htlc_count: u32 = 0;
-		let mut htlc_outbound_value_msat = 0;
+	/// Returns (inbound_htlc_count, htlc_inbound_value_msat)
+	fn get_inbound_pending_htlc_stats(&self) -> (u32, u64) {
 		let mut htlc_inbound_value_msat = 0;
 		for ref htlc in self.pending_inbound_htlcs.iter() {
-			match htlc.state {
-				InboundHTLCState::RemoteAnnounced => {},
-				InboundHTLCState::AwaitingRemoteRevokeToAnnounce => {},
-				InboundHTLCState::AwaitingAnnouncedRemoteRevoke => {},
-				InboundHTLCState::Committed => {},
-				InboundHTLCState::LocalRemoved => {},
-			}
-			inbound_htlc_count += 1;
 			htlc_inbound_value_msat += htlc.amount_msat;
 		}
+		(self.pending_inbound_htlcs.len() as u32, htlc_inbound_value_msat)
+	}
+
+	/// Returns (outbound_htlc_count, htlc_outbound_value_msat)
+	fn get_outbound_pending_htlc_stats(&self) -> (u32, u64) {
+		let mut htlc_outbound_value_msat = 0;
 		for ref htlc in self.pending_outbound_htlcs.iter() {
-			match htlc.state {
-				OutboundHTLCState::LocalAnnounced => { if for_remote_update_check { continue; } },
-				OutboundHTLCState::Committed => {},
-				OutboundHTLCState::RemoteRemoved => { if for_remote_update_check { continue; } },
-				OutboundHTLCState::AwaitingRemoteRevokeToRemove => { if for_remote_update_check { continue; } },
-				OutboundHTLCState::AwaitingRemovedRemoteRevoke => { if for_remote_update_check { continue; } },
-			}
-			outbound_htlc_count += 1;
 			htlc_outbound_value_msat += htlc.amount_msat;
 		}
 
-		(inbound_htlc_count, outbound_htlc_count, htlc_outbound_value_msat, htlc_inbound_value_msat)
+		(self.pending_outbound_htlcs.len() as u32, htlc_outbound_value_msat)
 	}
 
 	pub fn update_add_htlc(&mut self, msg: &msgs::UpdateAddHTLC, pending_forward_state: PendingHTLCStatus) -> Result<(), HandleError> {
@@ -1521,7 +1502,7 @@ impl Channel {
 			return Err(HandleError{err: "Remote side tried to send less than our minimum HTLC value", action: None});
 		}
 
-		let (inbound_htlc_count, _, _, htlc_inbound_value_msat) = self.get_pending_htlc_stats(true);
+		let (inbound_htlc_count, htlc_inbound_value_msat) = self.get_inbound_pending_htlc_stats();
 		if inbound_htlc_count + 1 > OUR_MAX_HTLCS as u32 {
 			return Err(HandleError{err: "Remote tried to push more than our max accepted HTLCs", action: None});
 		}
@@ -2800,7 +2781,7 @@ impl Channel {
 			return Err(HandleError{err: "Cannot send an HTLC while disconnected", action: Some(ErrorAction::IgnoreError)});
 		}
 
-		let (_, outbound_htlc_count, htlc_outbound_value_msat, _) = self.get_pending_htlc_stats(false);
+		let (outbound_htlc_count, htlc_outbound_value_msat) = self.get_outbound_pending_htlc_stats();
 		if outbound_htlc_count + 1 > self.their_max_accepted_htlcs as u32 {
 			return Err(HandleError{err: "Cannot push more than their max accepted HTLCs", action: None});
 		}