Replace OUR_MAX_HTLCS with config knob

Writes an even TLV if the value isn't 50

Author: swilliamson5

lightning/src/ln/channel.rs

@@ -530,6 +530,7 @@ pub(super) struct Channel<Signer: ChannelSigner> {
 	cur_holder_commitment_transaction_number: u64,
 	cur_counterparty_commitment_transaction_number: u64,
 	value_to_self_msat: u64, // Excluding all pending_htlcs, excluding fees
+	max_accepted_htlcs: u16,
 	pending_inbound_htlcs: Vec<InboundHTLCOutput>,
 	pending_outbound_htlcs: Vec<OutboundHTLCOutput>,
 	holding_cell_htlc_updates: Vec<HTLCUpdateAwaitingACK>,
@@ -653,7 +654,6 @@ pub(super) struct Channel<Signer: ChannelSigner> {
 	pub counterparty_max_accepted_htlcs: u16,
 	#[cfg(not(test))]
 	counterparty_max_accepted_htlcs: u16,
-	//implied by OUR_MAX_HTLCS: max_accepted_htlcs: u16,
 	minimum_depth: Option<u32>,
 
 	counterparty_forwarding_info: Option<CounterpartyForwardingInfo>,
@@ -756,7 +756,6 @@ struct CommitmentTxInfoCached {
 	feerate: u32,
 }
 
-pub const OUR_MAX_HTLCS: u16 = 50; //TODO
 
 pub(crate) fn commitment_tx_base_weight(opt_anchors: bool) -> u64 {
 	const COMMITMENT_TX_BASE_WEIGHT: u64 = 724;
@@ -1027,6 +1026,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
 			value_to_self_msat,
 
+			max_accepted_htlcs: 50,
 			pending_inbound_htlcs: Vec::new(),
 			pending_outbound_htlcs: Vec::new(),
 			holding_cell_htlc_updates: Vec::new(),
@@ -1373,6 +1373,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
 			value_to_self_msat: msg.push_msat,
 
+			max_accepted_htlcs: msg.max_accepted_htlcs,
 			pending_inbound_htlcs: Vec::new(),
 			pending_outbound_htlcs: Vec::new(),
 			holding_cell_htlc_updates: Vec::new(),
@@ -2874,8 +2875,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 		let inbound_stats = self.get_inbound_pending_htlc_stats(None);
 		let outbound_stats = self.get_outbound_pending_htlc_stats(None);
-		if inbound_stats.pending_htlcs + 1 > OUR_MAX_HTLCS as u32 {
-			return Err(ChannelError::Close(format!("Remote tried to push more than our max accepted HTLCs ({})", OUR_MAX_HTLCS)));
+		if inbound_stats.pending_htlcs + 1 > self.max_accepted_htlcs as u32 {
+			return Err(ChannelError::Close(format!("Remote tried to push more than our max accepted HTLCs ({})", self.max_accepted_htlcs)));
 		}
 		if inbound_stats.pending_htlcs_value_msat + msg.amount_msat > self.holder_max_htlc_value_in_flight_msat {
 			return Err(ChannelError::Close(format!("Remote HTLC add would put them over our max HTLC value ({})", self.holder_max_htlc_value_in_flight_msat)));
@@ -5313,7 +5314,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			htlc_minimum_msat: self.holder_htlc_minimum_msat,
 			feerate_per_kw: self.feerate_per_kw as u32,
 			to_self_delay: self.get_holder_selected_contest_delay(),
-			max_accepted_htlcs: OUR_MAX_HTLCS,
+			max_accepted_htlcs: self.max_accepted_htlcs,
 			funding_pubkey: keys.funding_pubkey,
 			revocation_basepoint: keys.revocation_basepoint,
 			payment_point: keys.payment_point,
@@ -5380,7 +5381,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			htlc_minimum_msat: self.holder_htlc_minimum_msat,
 			minimum_depth: self.minimum_depth.unwrap(),
 			to_self_delay: self.get_holder_selected_contest_delay(),
-			max_accepted_htlcs: OUR_MAX_HTLCS,
+			max_accepted_htlcs: self.max_accepted_htlcs,
 			funding_pubkey: keys.funding_pubkey,
 			revocation_basepoint: keys.revocation_basepoint,
 			payment_point: keys.payment_point,
@@ -6275,6 +6276,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
 		self.cur_counterparty_commitment_transaction_number.write(writer)?;
 		self.value_to_self_msat.write(writer)?;
 
+		self.max_accepted_htlcs.write(writer)?;
 		let mut dropped_inbound_htlcs = 0;
 		for htlc in self.pending_inbound_htlcs.iter() {
 			if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
@@ -6521,6 +6523,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
 			(23, channel_ready_event_emitted, option),
 			(25, user_id_high_opt, option),
 			(27, self.channel_keys_id, required),
+			(28, Some(self.max_accepted_htlcs), option),
 			(29, self.temporary_channel_id, option),
 			(31, channel_pending_event_emitted, option),
 		});
@@ -6588,8 +6591,10 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 		let cur_counterparty_commitment_transaction_number = Readable::read(reader)?;
 		let value_to_self_msat = Readable::read(reader)?;
 
+		let max_accepted_htlcs = Readable::read(reader)?;
 		let pending_inbound_htlc_count: u64 = Readable::read(reader)?;
-		let mut pending_inbound_htlcs = Vec::with_capacity(cmp::min(pending_inbound_htlc_count as usize, OUR_MAX_HTLCS as usize));
+
+		let mut pending_inbound_htlcs = Vec::with_capacity(cmp::min(pending_inbound_htlc_count as usize, max_accepted_htlcs as usize));
 		for _ in 0..pending_inbound_htlc_count {
 			pending_inbound_htlcs.push(InboundHTLCOutput {
 				htlc_id: Readable::read(reader)?,
@@ -6607,7 +6612,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 		}
 
 		let pending_outbound_htlc_count: u64 = Readable::read(reader)?;
-		let mut pending_outbound_htlcs = Vec::with_capacity(cmp::min(pending_outbound_htlc_count as usize, OUR_MAX_HTLCS as usize));
+		let mut pending_outbound_htlcs = Vec::with_capacity(cmp::min(pending_outbound_htlc_count as usize, max_accepted_htlcs as usize));
 		for _ in 0..pending_outbound_htlc_count {
 			pending_outbound_htlcs.push(OutboundHTLCOutput {
 				htlc_id: Readable::read(reader)?,
@@ -6636,7 +6641,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 		}
 
 		let holding_cell_htlc_update_count: u64 = Readable::read(reader)?;
-		let mut holding_cell_htlc_updates = Vec::with_capacity(cmp::min(holding_cell_htlc_update_count as usize, OUR_MAX_HTLCS as usize*2));
+		let mut holding_cell_htlc_updates = Vec::with_capacity(cmp::min(holding_cell_htlc_update_count as usize, max_accepted_htlcs as usize*2));
 		for _ in 0..holding_cell_htlc_update_count {
 			holding_cell_htlc_updates.push(match <u8 as Readable>::read(reader)? {
 				0 => HTLCUpdateAwaitingACK::AddHTLC {
@@ -6669,13 +6674,13 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 		let monitor_pending_commitment_signed = Readable::read(reader)?;
 
 		let monitor_pending_forwards_count: u64 = Readable::read(reader)?;
-		let mut monitor_pending_forwards = Vec::with_capacity(cmp::min(monitor_pending_forwards_count as usize, OUR_MAX_HTLCS as usize));
+		let mut monitor_pending_forwards = Vec::with_capacity(cmp::min(monitor_pending_forwards_count as usize, max_accepted_htlcs as usize));
 		for _ in 0..monitor_pending_forwards_count {
 			monitor_pending_forwards.push((Readable::read(reader)?, Readable::read(reader)?));
 		}
 
 		let monitor_pending_failures_count: u64 = Readable::read(reader)?;
-		let mut monitor_pending_failures = Vec::with_capacity(cmp::min(monitor_pending_failures_count as usize, OUR_MAX_HTLCS as usize));
+		let mut monitor_pending_failures = Vec::with_capacity(cmp::min(monitor_pending_failures_count as usize, max_accepted_htlcs as usize));
 		for _ in 0..monitor_pending_failures_count {
 			monitor_pending_failures.push((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?));
 		}
@@ -6898,6 +6903,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 			cur_counterparty_commitment_transaction_number,
 			value_to_self_msat,
 
+			max_accepted_htlcs,
 			pending_inbound_htlcs,
 			pending_outbound_htlcs,
 			holding_cell_htlc_updates,

lightning/src/ln/functional_tests.rs

@@ -1107,7 +1107,7 @@ fn holding_cell_htlc_counting() {
 	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
 
 	let mut payments = Vec::new();
-	for _ in 0..crate::ln::channel::OUR_MAX_HTLCS {
+	for _ in 0..50 {
 		let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[1], nodes[2], 100000);
 		nodes[1].node.send_payment_with_route(&route, payment_hash,
 			RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap();
@@ -6278,11 +6278,11 @@ fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() {
 		onion_routing_packet: onion_packet.clone(),
 	};
 
-	for i in 0..super::channel::OUR_MAX_HTLCS {
+	for i in 0..50 {
 		msg.htlc_id = i as u64;
 		nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
 	}
-	msg.htlc_id = (super::channel::OUR_MAX_HTLCS) as u64;
+	msg.htlc_id = (50) as u64;
 	nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
 
 	assert!(nodes[1].node.list_channels().is_empty());