Merge branch 'main' into 2024-04-ext-test

Author: devrandom

fuzz/src/chanmon_consistency.rs

@@ -981,7 +981,9 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 	lock_fundings!(nodes);
 
 	let chan_a = nodes[0].list_usable_channels()[0].short_channel_id.unwrap();
+	let chan_a_id = nodes[0].list_usable_channels()[0].channel_id;
 	let chan_b = nodes[2].list_usable_channels()[0].short_channel_id.unwrap();
+	let chan_b_id = nodes[2].list_usable_channels()[0].channel_id;
 
 	let mut p_id: u8 = 0;
 	let mut p_idx: u64 = 0;
@@ -1042,6 +1044,10 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 							if Some(*node_id) == expect_drop_id { panic!("peer_disconnected should drop msgs bound for the disconnected peer"); }
 							*node_id == a_id
 						},
+						events::MessageSendEvent::SendStfu { ref node_id, .. } => {
+							if Some(*node_id) == expect_drop_id { panic!("peer_disconnected should drop msgs bound for the disconnected peer"); }
+							*node_id == a_id
+						},
 						events::MessageSendEvent::SendChannelReady { .. } => continue,
 						events::MessageSendEvent::SendAnnouncementSignatures { .. } => continue,
 						events::MessageSendEvent::SendChannelUpdate { ref node_id, ref msg } => {
@@ -1104,7 +1110,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 							for (idx, dest) in nodes.iter().enumerate() {
 								if dest.get_our_node_id() == node_id {
 									for update_add in update_add_htlcs.iter() {
-										out.locked_write(format!("Delivering update_add_htlc to node {}.\n", idx).as_bytes());
+										out.locked_write(format!("Delivering update_add_htlc from node {} to node {}.\n", $node, idx).as_bytes());
 										if !$corrupt_forward {
 											dest.handle_update_add_htlc(nodes[$node].get_our_node_id(), update_add);
 										} else {
@@ -1119,19 +1125,19 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 										}
 									}
 									for update_fulfill in update_fulfill_htlcs.iter() {
-										out.locked_write(format!("Delivering update_fulfill_htlc to node {}.\n", idx).as_bytes());
+										out.locked_write(format!("Delivering update_fulfill_htlc from node {} to node {}.\n", $node, idx).as_bytes());
 										dest.handle_update_fulfill_htlc(nodes[$node].get_our_node_id(), update_fulfill);
 									}
 									for update_fail in update_fail_htlcs.iter() {
-										out.locked_write(format!("Delivering update_fail_htlc to node {}.\n", idx).as_bytes());
+										out.locked_write(format!("Delivering update_fail_htlc from node {} to node {}.\n", $node, idx).as_bytes());
 										dest.handle_update_fail_htlc(nodes[$node].get_our_node_id(), update_fail);
 									}
 									for update_fail_malformed in update_fail_malformed_htlcs.iter() {
-										out.locked_write(format!("Delivering update_fail_malformed_htlc to node {}.\n", idx).as_bytes());
+										out.locked_write(format!("Delivering update_fail_malformed_htlc from node {} to node {}.\n", $node, idx).as_bytes());
 										dest.handle_update_fail_malformed_htlc(nodes[$node].get_our_node_id(), update_fail_malformed);
 									}
 									if let Some(msg) = update_fee {
-										out.locked_write(format!("Delivering update_fee to node {}.\n", idx).as_bytes());
+										out.locked_write(format!("Delivering update_fee from node {} to node {}.\n", $node, idx).as_bytes());
 										dest.handle_update_fee(nodes[$node].get_our_node_id(), &msg);
 									}
 									let processed_change = !update_add_htlcs.is_empty() || !update_fulfill_htlcs.is_empty() ||
@@ -1148,7 +1154,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 										} });
 										break;
 									}
-									out.locked_write(format!("Delivering commitment_signed to node {}.\n", idx).as_bytes());
+									out.locked_write(format!("Delivering commitment_signed from node {} to node {}.\n", $node, idx).as_bytes());
 									dest.handle_commitment_signed(nodes[$node].get_our_node_id(), &commitment_signed);
 									break;
 								}
@@ -1157,19 +1163,27 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 						events::MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
 							for (idx, dest) in nodes.iter().enumerate() {
 								if dest.get_our_node_id() == *node_id {
-									out.locked_write(format!("Delivering revoke_and_ack to node {}.\n", idx).as_bytes());
+									out.locked_write(format!("Delivering revoke_and_ack from node {} to node {}.\n", $node, idx).as_bytes());
 									dest.handle_revoke_and_ack(nodes[$node].get_our_node_id(), msg);
 								}
 							}
 						},
 						events::MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } => {
 							for (idx, dest) in nodes.iter().enumerate() {
 								if dest.get_our_node_id() == *node_id {
-									out.locked_write(format!("Delivering channel_reestablish to node {}.\n", idx).as_bytes());
+									out.locked_write(format!("Delivering channel_reestablish from node {} to node {}.\n", $node, idx).as_bytes());
 									dest.handle_channel_reestablish(nodes[$node].get_our_node_id(), msg);
 								}
 							}
 						},
+						events::MessageSendEvent::SendStfu { ref node_id, ref msg } => {
+							for (idx, dest) in nodes.iter().enumerate() {
+								if dest.get_our_node_id() == *node_id {
+									out.locked_write(format!("Delivering stfu from node {} to node {}.\n", $node, idx).as_bytes());
+									dest.handle_stfu(nodes[$node].get_our_node_id(), msg);
+								}
+							}
+						}
 						events::MessageSendEvent::SendChannelReady { .. } => {
 							// Can be generated as a reestablish response
 						},
@@ -1222,6 +1236,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 							events::MessageSendEvent::UpdateHTLCs { .. } => {},
 							events::MessageSendEvent::SendRevokeAndACK { .. } => {},
 							events::MessageSendEvent::SendChannelReestablish { .. } => {},
+							events::MessageSendEvent::SendStfu { .. } => {},
 							events::MessageSendEvent::SendChannelReady { .. } => {},
 							events::MessageSendEvent::SendAnnouncementSignatures { .. } => {},
 							events::MessageSendEvent::SendChannelUpdate { ref msg, .. } => {
@@ -1248,6 +1263,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 							events::MessageSendEvent::UpdateHTLCs { .. } => {},
 							events::MessageSendEvent::SendRevokeAndACK { .. } => {},
 							events::MessageSendEvent::SendChannelReestablish { .. } => {},
+							events::MessageSendEvent::SendStfu { .. } => {},
 							events::MessageSendEvent::SendChannelReady { .. } => {},
 							events::MessageSendEvent::SendAnnouncementSignatures { .. } => {},
 							events::MessageSendEvent::SendChannelUpdate { ref msg, .. } => {
@@ -1691,6 +1707,19 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 				nodes[2].maybe_update_chan_fees();
 			},
 
+			0xa0 => {
+				nodes[0].maybe_propose_quiescence(&nodes[1].get_our_node_id(), &chan_a_id).unwrap()
+			},
+			0xa1 => {
+				nodes[1].maybe_propose_quiescence(&nodes[0].get_our_node_id(), &chan_a_id).unwrap()
+			},
+			0xa2 => {
+				nodes[1].maybe_propose_quiescence(&nodes[2].get_our_node_id(), &chan_b_id).unwrap()
+			},
+			0xa3 => {
+				nodes[2].maybe_propose_quiescence(&nodes[1].get_our_node_id(), &chan_b_id).unwrap()
+			},
+
 			0xf0 => complete_monitor_update(&monitor_a, &chan_1_id, &complete_first),
 			0xf1 => complete_monitor_update(&monitor_a, &chan_1_id, &complete_second),
 			0xf2 => complete_monitor_update(&monitor_a, &chan_1_id, &Vec::pop),
@@ -1756,34 +1785,49 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 					chan_b_disconnected = false;
 				}
 
-				for i in 0..std::usize::MAX {
-					if i == 100 {
-						panic!("It may take may iterations to settle the state, but it should not take forever");
-					}
-					// Then, make sure any current forwards make their way to their destination
-					if process_msg_events!(0, false, ProcessMessages::AllMessages) {
-						continue;
-					}
-					if process_msg_events!(1, false, ProcessMessages::AllMessages) {
-						continue;
-					}
-					if process_msg_events!(2, false, ProcessMessages::AllMessages) {
-						continue;
-					}
-					// ...making sure any pending PendingHTLCsForwardable events are handled and
-					// payments claimed.
-					if process_events!(0, false) {
-						continue;
-					}
-					if process_events!(1, false) {
-						continue;
-					}
-					if process_events!(2, false) {
-						continue;
-					}
-					break;
+				macro_rules! process_all_events {
+					() => {
+						for i in 0..std::usize::MAX {
+							if i == 100 {
+								panic!("It may take may iterations to settle the state, but it should not take forever");
+							}
+							// Then, make sure any current forwards make their way to their destination
+							if process_msg_events!(0, false, ProcessMessages::AllMessages) {
+								continue;
+							}
+							if process_msg_events!(1, false, ProcessMessages::AllMessages) {
+								continue;
+							}
+							if process_msg_events!(2, false, ProcessMessages::AllMessages) {
+								continue;
+							}
+							// ...making sure any pending PendingHTLCsForwardable events are handled and
+							// payments claimed.
+							if process_events!(0, false) {
+								continue;
+							}
+							if process_events!(1, false) {
+								continue;
+							}
+							if process_events!(2, false) {
+								continue;
+							}
+							break;
+						}
+					};
 				}
 
+				// At this point, we may be pending quiescence, so we'll process all messages to
+				// ensure we can complete its handshake. We'll then exit quiescence and process all
+				// messages again, to resolve any pending HTLCs (only irrevocably committed ones)
+				// before attempting to send more payments.
+				process_all_events!();
+				nodes[0].exit_quiescence(&nodes[1].get_our_node_id(), &chan_a_id).unwrap();
+				nodes[1].exit_quiescence(&nodes[0].get_our_node_id(), &chan_a_id).unwrap();
+				nodes[1].exit_quiescence(&nodes[2].get_our_node_id(), &chan_b_id).unwrap();
+				nodes[2].exit_quiescence(&nodes[1].get_our_node_id(), &chan_b_id).unwrap();
+				process_all_events!();
+
 				// Finally, make sure that at least one end of each channel can make a substantial payment
 				assert!(
 					send_payment(&nodes[0], &nodes[1], chan_a, 10_000_000, &mut p_id, &mut p_idx)

lightning-types/src/features.rs

@@ -74,6 +74,8 @@
 //!     (see [bLIP 32](https://github.com/lightning/blips/blob/master/blip-0032.md) for more information).
 //! - `ProvideStorage` - Indicates that we offer the capability to store data of our peers
 //! 	(see https://github.com/lightning/bolts/pull/1110 for more info).
+//! - `Quiescence` - protocol to quiesce a channel by indicating that "SomeThing Fundamental is Underway"
+//!     (see [BOLT-2](https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#channel-quiescence) for more information).
 //!
 //! LDK knows about the following features, but does not support them:
 //! - `AnchorsNonzeroFeeHtlcTx` - the initial version of anchor outputs, which was later found to be
@@ -152,7 +154,7 @@ mod sealed {
 			// Byte 3
 			RouteBlinding | ShutdownAnySegwit | DualFund | Taproot,
 			// Byte 4
-			OnionMessages,
+			Quiescence | OnionMessages,
 			// Byte 5
 			ProvideStorage | ChannelType | SCIDPrivacy,
 			// Byte 6
@@ -173,7 +175,7 @@ mod sealed {
 			// Byte 3
 			RouteBlinding | ShutdownAnySegwit | DualFund | Taproot,
 			// Byte 4
-			OnionMessages,
+			Quiescence | OnionMessages,
 			// Byte 5
 			ProvideStorage | ChannelType | SCIDPrivacy,
 			// Byte 6
@@ -536,6 +538,16 @@ mod sealed {
 		supports_taproot,
 		requires_taproot
 	);
+	define_feature!(
+		35,
+		Quiescence,
+		[InitContext, NodeContext],
+		"Feature flags for `option_quiesce`.",
+		set_quiescence_optional,
+		set_quiescence_required,
+		supports_quiescence,
+		requires_quiescence
+	);
 	define_feature!(
 		39,
 		OnionMessages,
@@ -1195,6 +1207,7 @@ mod tests {
 		init_features.set_channel_type_optional();
 		init_features.set_scid_privacy_optional();
 		init_features.set_zero_conf_optional();
+		init_features.set_quiescence_optional();
 
 		assert!(init_features.initial_routing_sync());
 		assert!(!init_features.supports_upfront_shutdown_script());
@@ -1215,7 +1228,7 @@ mod tests {
 			assert_eq!(node_features.flags[1], 0b01010001);
 			assert_eq!(node_features.flags[2], 0b10001010);
 			assert_eq!(node_features.flags[3], 0b00001010);
-			assert_eq!(node_features.flags[4], 0b10000000);
+			assert_eq!(node_features.flags[4], 0b10001000);
 			assert_eq!(node_features.flags[5], 0b10100000);
 			assert_eq!(node_features.flags[6], 0b00001000);
 		}

lightning/src/chain/channelmonitor.rs

@@ -34,6 +34,7 @@ use bitcoin::secp256k1::{self, SecretKey, PublicKey, Secp256k1, ecdsa::Signature
 
 use crate::ln::channel::INITIAL_COMMITMENT_NUMBER;
 use crate::ln::types::ChannelId;
+use crate::types::features::ChannelTypeFeatures;
 use crate::types::payment::{PaymentHash, PaymentPreimage};
 use crate::ln::msgs::DecodeError;
 use crate::ln::channel_keys::{DelayedPaymentKey, DelayedPaymentBasepoint, HtlcBasepoint, HtlcKey, RevocationKey, RevocationBasepoint};
@@ -1611,6 +1612,11 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 		self.inner.lock().unwrap().channel_id()
 	}
 
+	/// Gets the channel type of the corresponding channel.
+	pub fn channel_type_features(&self) -> ChannelTypeFeatures {
+		self.inner.lock().unwrap().channel_type_features()
+	}
+
 	/// Gets a list of txids, with their output scripts (in the order they appear in the
 	/// transaction), which we must learn about spends of via block_connected().
 	pub fn get_outputs_to_watch(&self) -> Vec<(Txid, Vec<(u32, ScriptBuf)>)> {
@@ -4806,6 +4812,10 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			self.onchain_events_awaiting_threshold_conf.push(entry);
 		}
 	}
+
+	fn channel_type_features(&self) -> ChannelTypeFeatures {
+		self.onchain_tx_handler.channel_type_features().clone()
+	}
 }
 
 impl<Signer: EcdsaChannelSigner, T: Deref, F: Deref, L: Deref> chain::Listen for (ChannelMonitor<Signer>, T, F, L)

lightning/src/ln/chan_utils.rs

@@ -196,15 +196,16 @@ pub(crate) fn commit_tx_fee_sat(feerate_per_kw: u32, num_htlcs: usize, channel_t
 		/ 1000
 }
 
-pub(crate) fn per_outbound_htlc_counterparty_commit_tx_fee_msat(feerate_per_kw: u32, channel_type_features: &ChannelTypeFeatures) -> u64 {
-	// Note that we need to divide before multiplying to round properly,
-	// since the lowest denomination of bitcoin on-chain is the satoshi.
-	let commitment_tx_fee = COMMITMENT_TX_WEIGHT_PER_HTLC * feerate_per_kw as u64 / 1000 * 1000;
-	if channel_type_features.supports_anchors_zero_fee_htlc_tx() {
-		commitment_tx_fee + htlc_success_tx_weight(channel_type_features) * feerate_per_kw as u64 / 1000
+pub(crate) fn commit_and_htlc_tx_fees_sat(feerate_per_kw: u32, num_accepted_htlcs: usize, num_offered_htlcs: usize, channel_type_features: &ChannelTypeFeatures) -> u64 {
+	let num_htlcs = num_accepted_htlcs + num_offered_htlcs;
+	let commit_tx_fees_sat = commit_tx_fee_sat(feerate_per_kw, num_htlcs, channel_type_features);
+	let htlc_tx_fees_sat = if !channel_type_features.supports_anchors_zero_fee_htlc_tx() {
+		num_accepted_htlcs as u64 * htlc_success_tx_weight(channel_type_features) * feerate_per_kw as u64 / 1000
+	  + num_offered_htlcs as u64 * htlc_timeout_tx_weight(channel_type_features) * feerate_per_kw as u64 / 1000
 	} else {
-		commitment_tx_fee
-	}
+		0
+	};
+	commit_tx_fees_sat + htlc_tx_fees_sat
 }
 
 // Various functions for key derivation and transaction creation for use within channels. Primarily