Support manual signaling of channel readiness

Author: johncantrell97

lightning/src/ln/channel.rs

@@ -4968,10 +4968,11 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		self.channel_update_status = status;
 	}
 
-	fn check_get_channel_ready(&mut self, height: u32) -> Option<msgs::ChannelReady> {
+	pub fn check_get_channel_ready(&mut self, height: u32) -> Option<msgs::ChannelReady> {
 		// Called:
 		//  * always when a new block/transactions are confirmed with the new height
 		//  * when funding is signed with a height of 0
+		//  * when user calls ChannelManager::signal_channel_readiness
 		if self.funding_tx_confirmation_height == 0 && self.minimum_depth != Some(0) {
 			return None;
 		}

lightning/src/ln/channelmanager.rs

@@ -1451,20 +1451,30 @@ macro_rules! remove_channel {
 
 macro_rules! send_channel_ready {
 	($self: ident, $pending_msg_events: expr, $channel: expr, $channel_ready_msg: expr) => {{
-		$pending_msg_events.push(events::MessageSendEvent::SendChannelReady {
-			node_id: $channel.get_counterparty_node_id(),
-			msg: $channel_ready_msg,
-		});
-		// Note that we may send a `channel_ready` multiple times for a channel if we reconnect, so
-		// we allow collisions, but we shouldn't ever be updating the channel ID pointed to.
-		let mut short_to_chan_info = $self.short_to_chan_info.write().unwrap();
-		let outbound_alias_insert = short_to_chan_info.insert($channel.outbound_scid_alias(), ($channel.get_counterparty_node_id(), $channel.channel_id()));
-		assert!(outbound_alias_insert.is_none() || outbound_alias_insert.unwrap() == ($channel.get_counterparty_node_id(), $channel.channel_id()),
-			"SCIDs should never collide - ensure you weren't behind the chain tip by a full month when creating channels");
-		if let Some(real_scid) = $channel.get_short_channel_id() {
-			let scid_insert = short_to_chan_info.insert(real_scid, ($channel.get_counterparty_node_id(), $channel.channel_id()));
-			assert!(scid_insert.is_none() || scid_insert.unwrap() == ($channel.get_counterparty_node_id(), $channel.channel_id()),
+		if $self.default_configuration.manually_signal_channel_ready {
+			let mut pending_events = $self.pending_events.lock().unwrap();
+			pending_events.push(events::Event::PendingChannelReady {
+				channel_id: $channel.channel_id(),
+				user_channel_id: $channel.get_user_id(),
+				counterparty_node_id: $channel.get_counterparty_node_id(),
+				funding_txid: $channel.get_funding_txo().unwrap().txid,
+			});
+		} else {
+			$pending_msg_events.push(events::MessageSendEvent::SendChannelReady {
+				node_id: $channel.get_counterparty_node_id(),
+				msg: $channel_ready_msg,
+			});
+			// Note that we may send a `channel_ready` multiple times for a channel if we reconnect, so
+			// we allow collisions, but we shouldn't ever be updating the channel ID pointed to.
+			let mut short_to_chan_info = $self.short_to_chan_info.write().unwrap();
+			let outbound_alias_insert = short_to_chan_info.insert($channel.outbound_scid_alias(), ($channel.get_counterparty_node_id(), $channel.channel_id()));
+			assert!(outbound_alias_insert.is_none() || outbound_alias_insert.unwrap() == ($channel.get_counterparty_node_id(), $channel.channel_id()),
 				"SCIDs should never collide - ensure you weren't behind the chain tip by a full month when creating channels");
+			if let Some(real_scid) = $channel.get_short_channel_id() {
+				let scid_insert = short_to_chan_info.insert(real_scid, ($channel.get_counterparty_node_id(), $channel.channel_id()));
+				assert!(scid_insert.is_none() || scid_insert.unwrap() == ($channel.get_counterparty_node_id(), $channel.channel_id()),
+					"SCIDs should never collide - ensure you weren't behind the chain tip by a full month when creating channels");
+			}
 		}
 	}}
 }
@@ -4354,6 +4364,38 @@ where
 		Ok(())
 	}
 
+	/// Signals channel readiness after a [`Event::PendingChannelReady`].
+	///
+	/// The `channel_id` parameter indicates which channel should signal readiness,
+	/// and the `counterparty_node_id` parameter is the id of the peer the channel is with.
+	///
+	/// [`Event::PendingChannelReady`]: events::Event::PendingChannelReady
+	pub fn signal_channel_readiness(&self, channel_id: &[u8; 32], counterparty_node_id: &PublicKey) -> Result<(), APIError> {
+		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(&self.total_consistency_lock, &self.persistence_notifier);
+
+		let per_peer_state = self.per_peer_state.read().unwrap();
+		let peer_state_mutex = per_peer_state.get(counterparty_node_id)
+			.ok_or_else(|| APIError::ChannelUnavailable { err: format!("Can't find a peer matching the passed counterparty node_id {}", counterparty_node_id) })?;
+		let mut peer_state_lock = peer_state_mutex.lock().unwrap();
+		let peer_state = &mut *peer_state_lock;
+		let pending_msg_events = &mut peer_state.pending_msg_events;
+		match peer_state.channel_by_id.entry(channel_id.clone()) {
+			hash_map::Entry::Occupied(mut channel) => {
+				let best_block_height = self.best_block.read().unwrap().height();
+				let channel = channel.get_mut();
+				match channel.check_get_channel_ready(best_block_height) {
+					Some(channel_ready) => send_channel_ready!(self, pending_msg_events, channel, channel_ready),
+					None => return Err(APIError::APIMisuseError { err: "The channel isn't currently in a state where we can signal readiness.".to_owned() })
+				}				
+			}
+			hash_map::Entry::Vacant(_) => {
+				return Err(APIError::ChannelUnavailable { err: format!("Channel with id {} not found for the passed counterparty node_id {}", log_bytes!(*channel_id), counterparty_node_id) });
+			}
+		}
+
+		Ok(())
+	}
+
 	/// Gets the number of peers which match the given filter and do not have any funded, outbound,
 	/// or 0-conf channels.
 	///

lightning/src/util/config.rs

@@ -538,6 +538,17 @@ pub struct UserConfig {
 	/// [`ChannelManager::get_intercept_scid`]: crate::ln::channelmanager::ChannelManager::get_intercept_scid
 	/// [`Event::HTLCIntercepted`]: crate::util::events::Event::HTLCIntercepted
 	pub accept_intercept_htlcs: bool,
+	/// If this is set to true, the user needs to manually signal readiness for an inbound channel.
+	///
+	/// When set to true, [`Event::PendingChannelReady`] will be triggered once LDK has seen sufficient
+	/// confirmations of the funding transaction. In that case, a [`msgs::ChannelReady`] message will not be 
+	/// sent to the counterparty node unless the user explicitly chooses to signal readiness.
+	///
+	/// Default value: false.
+	///
+	/// [`Event::PendingChannelReady`]: crate::util::events::Event::PendingChannelReady
+	/// [`msgs::ChannelReady`]: crate::ln::msgs::ChannelReady
+	pub manually_signal_channel_ready: bool,
 }
 
 impl Default for UserConfig {
@@ -550,6 +561,7 @@ impl Default for UserConfig {
 			accept_inbound_channels: true,
 			manually_accept_inbound_channels: false,
 			accept_intercept_htlcs: false,
+			manually_signal_channel_ready: false,
 		}
 	}
 }

lightning/src/util/events.rs

@@ -27,7 +27,7 @@ use crate::util::errors::APIError;
 use crate::util::ser::{BigSize, FixedLengthReader, Writeable, Writer, MaybeReadable, Readable, RequiredWrapper, UpgradableRequired, WithoutLength};
 use crate::routing::router::{RouteHop, RouteParameters};
 
-use bitcoin::{PackedLockTime, Transaction};
+use bitcoin::{PackedLockTime, Transaction, Txid};
 #[cfg(anchors)]
 use bitcoin::{OutPoint, Txid, TxIn, TxOut, Witness};
 use bitcoin::blockdata::script::Script;
@@ -817,6 +817,50 @@ pub enum Event {
 		/// transaction.
 		claim_from_onchain_tx: bool,
 	},
+	/// Indicates a channel has received sufficient confirmations and LDK is ready to send [`msgs::ChannelReady`].
+	///
+	/// To signal readiness, call [`ChannelManager::signal_channel_readiness`]. To reject the
+	/// request, call [`ChannelManager::force_close_without_broadcasting_txn`].
+	///
+	/// The event is only triggered when the [`UserConfig::manually_signal_channel_ready`] 
+	/// config flag is set to true.
+	///
+	/// [`ChannelManager::signal_channel_readiness`]: crate::ln::channelmanager::ChannelManager::signal_channel_readiness
+	/// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
+	/// [`UserConfig::manually_signal_channel_ready`]: crate::util::config::UserConfig::manually_signal_channel_ready
+	/// [`msgs::ChannelReady`]: crate::ln::msgs::ChannelReady
+	PendingChannelReady {
+		/// The channel ID of the channel.
+		///
+		/// When responding to the request, the `channel_id` should be passed
+		/// back to the ChannelManager through [`ChannelManager::signal_channel_readiness`] to signal,
+		/// or through [`ChannelManager::force_close_without_broadcasting_txn`] to reject.
+		///
+		/// [`ChannelManager::signal_channel_readiness`]: crate::ln::channelmanager::ChannelManager::signal_channel_readiness
+		/// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
+		channel_id: [u8; 32],
+		/// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound
+		/// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if
+		/// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
+		/// `user_channel_id` will be randomized for an inbound channel.
+		///
+		/// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
+		/// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
+		/// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
+		user_channel_id: u128,
+		/// The node_id of the counterparty requesting to open the channel.
+		///
+		/// When responding to the request, the `counterparty_node_id` should be passed
+		/// back to the `ChannelManager` through [`ChannelManager::signal_channel_readiness`] to
+		/// signal readiness, or through [`ChannelManager::force_close_without_broadcasting_txn`] to reject the
+		/// request.
+		///
+		/// [`ChannelManager::signal_channel_readiness`]: crate::ln::channelmanager::ChannelManager::signal_channel_readiness
+		/// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
+		counterparty_node_id: PublicKey,
+		/// The txid of the funding transaction.
+		funding_txid: Txid,
+	},
 	/// Used to indicate that a channel with the given `channel_id` is ready to
 	/// be used. This event is emitted either when the funding transaction has been confirmed
 	/// on-chain, or, in case of a 0conf channel, when both parties have confirmed the channel
@@ -1136,6 +1180,15 @@ impl Writeable for Event {
 					(6, channel_type, required),
 				});
 			},
+			&Event::PendingChannelReady { ref channel_id, ref user_channel_id, ref counterparty_node_id, ref funding_txid } => {
+				31u8.write(writer)?;
+				write_tlv_fields!(writer, {
+					(0, channel_id, required),
+					(2, user_channel_id, required),
+					(4, counterparty_node_id, required),
+					(6, funding_txid, required)
+				});
+			},
 			// Note that, going forward, all new events must only write data inside of
 			// `write_tlv_fields`. Versions 0.0.101+ will ignore odd-numbered events that write
 			// data via `write_tlv_fields`.
@@ -1471,6 +1524,28 @@ impl MaybeReadable for Event {
 				};
 				f()
 			},
+			31u8 => {
+				let f = || {
+					let mut channel_id = [0; 32];
+					let mut user_channel_id: u128 = 0;
+					let mut counterparty_node_id = RequiredWrapper(None);
+					let mut funding_txid = RequiredWrapper(None);
+					read_tlv_fields!(reader, {
+						(0, channel_id, required),
+						(2, user_channel_id, required),
+						(4, counterparty_node_id, required),
+						(6, funding_txid, required),
+					});
+
+					Ok(Some(Event::PendingChannelReady {
+						channel_id,
+						user_channel_id,
+						counterparty_node_id: counterparty_node_id.0.unwrap(),
+						funding_txid: funding_txid.0.unwrap()
+					}))
+				};
+				f()
+			},
 			// Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
 			// Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt
 			// reads.