f rename and fix comment so that it doesnt reference older version of patch

Author: TheBlueMatt

lightning/src/ln/channelmanager.rs

@@ -926,13 +926,13 @@ pub(crate) const MPP_TIMEOUT_TICKS: u8 = 3;
 pub(crate) const IDEMPOTENCY_TIMEOUT_TICKS: u8 = 7;
 
 /// The maximum number of unfunded channels we can have per-peer before we start rejecting new
-/// (inbound) ones. The number of peers without funded channels is limited separately in
-/// [`MAX_NO_CHANNEL_PEERS`].
+/// (inbound) ones. The number of peers with unfunded channels is limited separately in
+/// [`MAX_UNFUNDED_CHANNEL_PEERS`].
 const MAX_UNFUNDED_CHANS_PER_PEER: usize = 4;
 
-/// The maximum number of peers which we do not have a (funded) channel with. Once we reach this
-/// many peers we reject new (inbound) connections.
-const MAX_NO_CHANNEL_PEERS: usize = 50;
+/// The maximum number of peers from which we will allow pending unfunded channels. Once we reach
+/// this many peers we reject new (inbound) channels.
+const MAX_UNFUNDED_CHANNEL_PEERS: usize = 50;
 
 /// Information needed for constructing an invoice route hint for this channel.
 #[derive(Clone, Debug, PartialEq)]
@@ -4251,15 +4251,14 @@ where
 		Ok(())
 	}
 
-	/// Gets the number of peers which match the given filter which have unfunded inbound channels.
+	/// Gets the number of peers which match the given filter which do not have any funded,
+	/// outbound, or 0-conf channels.
 	///
-	/// The filter is called for each node and provided with the number of unfunded channels the
-	/// node has.
-	///
-	/// If the peer in question has funded channels, however, zero will be returned.
-	fn peers_with_unfunded_channels<Filter>(&self, mut filter: Filter) -> usize
+	/// The filter is called for each peer and provided with the number of unfunded, inbound, and
+	/// non-0-conf channels we have with the peer.
+	fn peers_without_funded_channels<Filter>(&self, mut filter: Filter) -> usize
 	where Filter: FnMut(&PublicKey, &PeerState<<SP::Target as SignerProvider>::Signer>, usize) -> bool {
-		let mut peers_with_unfunded_channels = 0;
+		let mut peers_without_funded_channels = 0;
 		let best_block_height = self.best_block.read().unwrap().height();
 		{
 			let peer_state_lock = self.per_peer_state.read().unwrap();
@@ -4275,11 +4274,11 @@ where
 				}
 				if !filter(node_id, &*peer, num_unfunded_channels) { continue; }
 				if num_unfunded_channels == peer.channel_by_id.len() {
-					peers_with_unfunded_channels += 1;
+					peers_without_funded_channels += 1;
 				}
 			}
 		}
-		return peers_with_unfunded_channels;
+		return peers_without_funded_channels;
 	}
 
 	fn internal_open_channel(&self, counterparty_node_id: &PublicKey, msg: &msgs::OpenChannel) -> Result<(), MsgHandleErrInternal> {
@@ -4306,7 +4305,7 @@ where
 		// about peers that never open a channel, so we filter by peers that have at least one
 		// channel, and then limit the number of those with unfunded channels.
 		let mut this_node_unfunded_channels = 0;
-		let peers_with_unfunded_channels = self.peers_with_unfunded_channels(
+		let peers_without_funded_channels = self.peers_without_funded_channels(
 			|node_id, node, unfunded_channels| {
 				if node_id == counterparty_node_id {
 					this_node_unfunded_channels = unfunded_channels;
@@ -4323,7 +4322,7 @@ where
 		// If this peer already has some channels, a new channel won't increase our number of peers
 		// with unfunded channels, so as long as we aren't over the maximum number of unfunded
 		// channels per-peer we can accept channels from a peer with existing ones.
-		if peer_state.channel_by_id.is_empty() && peers_with_unfunded_channels >= MAX_NO_CHANNEL_PEERS {
+		if peer_state.channel_by_id.is_empty() && peers_without_funded_channels >= MAX_UNFUNDED_CHANNEL_PEERS {
 			return Err(MsgHandleErrInternal::send_err_msg_no_close(
 				"Have too many peers with unfunded channels, not accepting new ones".to_owned(),
 				msg.temporary_channel_id.clone()));
@@ -6289,14 +6288,14 @@ where
 		// disconnected peers, we still let new peers connect, but we'll reject new channels from
 		// them.
 		let mut this_peer_has_funded_channels = false;
-		let connected_peers_with_unfunded_channels = self.peers_with_unfunded_channels(
+		let connected_peers_without_funded_channels = self.peers_without_funded_channels(
 			|node_id, node, num_unfunded_channels| {
 				if node_id == counterparty_node_id && num_unfunded_channels != node.channel_by_id.len() {
 					this_peer_has_funded_channels = true;
 				}
 				node.is_connected
 			});
-		if inbound && !this_peer_has_funded_channels && connected_peers_with_unfunded_channels >= MAX_NO_CHANNEL_PEERS {
+		if inbound && !this_peer_has_funded_channels && connected_peers_without_funded_channels >= MAX_UNFUNDED_CHANNEL_PEERS {
 			return Err(());
 		}