track PendingChannelReady emission and surface readiness

Author: johncantrell97

lightning/src/ln/channel.rs

@@ -78,7 +78,8 @@ pub struct AvailableBalances {
 pub(crate) struct ChainActionUpdates {
 	pub(crate) channel_ready_msg: Option<msgs::ChannelReady>, 
 	pub(crate) timed_out_htlcs: Vec<(HTLCSource, PaymentHash)>,
-	pub(crate) announcement_sigs: Option<msgs::AnnouncementSignatures>
+	pub(crate) announcement_sigs: Option<msgs::AnnouncementSignatures>,
+	pub(crate) pending_channel_ready: bool
 }
 
 impl ChainActionUpdates {
@@ -87,6 +88,7 @@ impl ChainActionUpdates {
 			channel_ready_msg: None,
 			timed_out_htlcs: Vec::new(),
 			announcement_sigs: None,
+			pending_channel_ready: false,
 		}
 	}
 }
@@ -755,6 +757,8 @@ pub(super) struct Channel<Signer: ChannelSigner> {
 
 	// We track whether we already emitted a `ChannelReady` event.
 	channel_ready_event_emitted: bool,
+	// We track whether we already emitted a `PendingChannelReady` event.
+	pending_channel_ready_event_emitted: bool,
 
 	/// The unique identifier used to re-derive the private key material for the channel through
 	/// [`SignerProvider::derive_channel_signer`].
@@ -1129,6 +1133,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			outbound_scid_alias,
 
 			channel_ready_event_emitted: false,
+			pending_channel_ready_event_emitted: false,
 
 			#[cfg(any(test, fuzzing))]
 			historical_inbound_htlc_fulfills: HashSet::new(),
@@ -1478,6 +1483,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			outbound_scid_alias,
 
 			channel_ready_event_emitted: false,
+			pending_channel_ready_event_emitted: false,
 
 			#[cfg(any(test, fuzzing))]
 			historical_inbound_htlc_fulfills: HashSet::new(),
@@ -2373,7 +2379,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 		log_info!(logger, "Generated funding_signed for peer for channel {}", log_bytes!(self.channel_id()));
 
-		let need_channel_ready = self.check_get_channel_ready(0).is_some();
+		let need_channel_ready = self.check_get_channel_ready(0).0.is_some();
 		self.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
 
 		Ok((msgs::FundingSigned {
@@ -2461,7 +2467,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 		log_info!(logger, "Received funding_signed from peer for channel {}", log_bytes!(self.channel_id()));
 
-		let need_channel_ready = self.check_get_channel_ready(0).is_some();
+		let need_channel_ready = self.check_get_channel_ready(0).0.is_some();
 		self.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
 		Ok(channel_monitor)
 	}
@@ -4730,6 +4736,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		self.channel_ready_event_emitted = true;
 	}
 
+	// Checks whether we should emit a `PendingChannelReady` event.
+	pub(crate) fn should_emit_pending_channel_ready_event(&self) -> bool {
+		self.requires_manual_readiness_signal && !self.pending_channel_ready_event_emitted
+	}
+
+	// Remembers that we already emitted a `PendingChannelReady` event.
+	pub(crate) fn set_pending_channel_ready_event_emitted(&mut self) {
+		self.pending_channel_ready_event_emitted = true;
+	}
+
 	/// Tracks the number of ticks elapsed since the previous [`ChannelConfig`] was updated. Once
 	/// [`EXPIRE_PREV_CONFIG_TICKS`] is reached, the previous config is considered expired and will
 	/// no longer be considered when forwarding HTLCs.
@@ -4994,12 +5010,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		self.channel_update_status = status;
 	}
 
-	fn check_get_channel_ready(&mut self, height: u32) -> Option<msgs::ChannelReady> {
+	fn check_get_channel_ready(&mut self, height: u32) -> (Option<msgs::ChannelReady>, bool) {
 		// Called:
 		//  * always when a new block/transactions are confirmed with the new height
 		//  * when funding is signed with a height of 0
 		if self.funding_tx_confirmation_height == 0 && self.minimum_depth != Some(0) {
-			return None;
+			return (None, false);
 		}
 
 		let funding_tx_confirmations = height as i64 - self.funding_tx_confirmation_height as i64 + 1;
@@ -5008,7 +5024,11 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		}
 
 		if funding_tx_confirmations < self.minimum_depth.unwrap_or(0) as i64 {
-			return None;
+			return (None, false);
+		}
+
+		if self.should_emit_pending_channel_ready_event() {
+			return (None, true);
 		}
 
 		let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
@@ -5042,17 +5062,17 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 				if self.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
 					let next_per_commitment_point =
 						self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.secp_ctx);
-					return Some(msgs::ChannelReady {
+					return (Some(msgs::ChannelReady {
 						channel_id: self.channel_id,
 						next_per_commitment_point,
 						short_channel_id_alias: Some(self.outbound_scid_alias),
-					});
+					}), false);
 				}
 			} else {
 				self.monitor_pending_channel_ready = true;
 			}
 		}
-		None
+		(None, false)
 	}
 
 	/// When a transaction is confirmed, we check whether it is or spends the funding transaction
@@ -5109,13 +5129,23 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 					// If we allow 1-conf funding, we may need to check for channel_ready here and
 					// send it immediately instead of waiting for a best_block_updated call (which
 					// may have already happened for this block).
-					if let Some(channel_ready) = self.check_get_channel_ready(height) {
+					let (channel_ready_opt, generate_pending_channel_ready) = self.check_get_channel_ready(height);
+
+					if let Some(channel_ready) = channel_ready_opt {
 						log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.channel_id));
 						let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger);
 						return Ok(ChainActionUpdates {
 							channel_ready_msg: Some(channel_ready), 
 							announcement_sigs,
-							timed_out_htlcs: vec![]
+							timed_out_htlcs: vec![],
+							pending_channel_ready: false
+						});
+					} else if generate_pending_channel_ready {
+						return Ok(ChainActionUpdates {
+							channel_ready_msg: None,
+							announcement_sigs: None,
+							timed_out_htlcs: vec![],
+							pending_channel_ready: true
 						});
 					}
 				}
@@ -5127,11 +5157,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 				}
 			}
 		}
-		Ok(ChainActionUpdates {
-			channel_ready_msg: None,
-			announcement_sigs: None,
-			timed_out_htlcs: vec![]
-		})
+		Ok(ChainActionUpdates::no_updates())
 	}
 
 	/// When a new block is connected, we check the height of the block against outbound holding
@@ -5183,15 +5209,17 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 		self.update_time_counter = cmp::max(self.update_time_counter, highest_header_time);
 
-		if let Some(channel_ready) = self.check_get_channel_ready(height) {
+		let (channel_ready_opt, generate_pending_channel_ready) = self.check_get_channel_ready(height);
+		if let Some(channel_ready) = channel_ready_opt {
 			let announcement_sigs = if let Some((genesis_block_hash, node_signer, user_config)) = genesis_node_signer {
 				self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger)
 			} else { None };
 			log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.channel_id));
 			return Ok(ChainActionUpdates {
 				channel_ready_msg: Some(channel_ready), 
 				timed_out_htlcs, 
-				announcement_sigs
+				announcement_sigs,
+				pending_channel_ready: false
 			});
 		}
 
@@ -5235,7 +5263,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		Ok(ChainActionUpdates {
 			channel_ready_msg: None, 
 			timed_out_htlcs, 
-			announcement_sigs
+			announcement_sigs,
+			pending_channel_ready: generate_pending_channel_ready
 		})
 	}
 
@@ -6467,6 +6496,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
 			{ Some(self.holder_max_htlc_value_in_flight_msat) } else { None };
 
 		let channel_ready_event_emitted = Some(self.channel_ready_event_emitted);
+		let pending_channel_ready_event_emitted = Some(self.pending_channel_ready_event_emitted);
 
 		// `user_id` used to be a single u64 value. In order to remain backwards compatible with
 		// versions prior to 0.0.113, the u128 is serialized as two separate u64 values. Therefore,
@@ -6500,7 +6530,8 @@ 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),
-			(29, requires_manual_readiness_signal, option)
+			(29, requires_manual_readiness_signal, option),
+			(31, pending_channel_ready_event_emitted, option),
 		});
 
 		Ok(())
@@ -6773,6 +6804,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 		let mut user_id_high_opt: Option<u64> = None;
 		let mut channel_keys_id: Option<[u8; 32]> = None;
 		let mut requires_manual_readiness_signal: Option<bool> = Some(false);
+		let mut pending_channel_ready_event_emitted = None;
 
 		read_tlv_fields!(reader, {
 			(0, announcement_sigs, option),
@@ -6794,6 +6826,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 			(25, user_id_high_opt, option),
 			(27, channel_keys_id, option),
 			(29, requires_manual_readiness_signal, option),
+			(31, pending_channel_ready_event_emitted, option),
 		});
 
 		let (channel_keys_id, holder_signer) = if let Some(channel_keys_id) = channel_keys_id {
@@ -6952,6 +6985,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 			outbound_scid_alias: outbound_scid_alias.unwrap_or(0),
 
 			channel_ready_event_emitted: channel_ready_event_emitted.unwrap_or(true),
+			pending_channel_ready_event_emitted: pending_channel_ready_event_emitted.unwrap_or(true),
 
 			#[cfg(any(test, fuzzing))]
 			historical_inbound_htlc_fulfills,

lightning/src/ln/channelmanager.rs

@@ -1504,6 +1504,23 @@ macro_rules! emit_channel_ready_event {
 	}
 }
 
+macro_rules! emit_pending_channel_ready_event {
+	($self: expr, $channel: expr) => {
+		if $channel.should_emit_channel_ready_event() {
+			{
+				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_outpoint: $channel.get_funding_txo().unwrap(),
+				});
+			}
+			$channel.set_pending_channel_ready_event_emitted();
+		}
+	}
+}
+
 macro_rules! handle_monitor_update_completion {
 	($self: ident, $update_id: expr, $peer_state_lock: expr, $peer_state: expr, $per_peer_state_lock: expr, $chan: expr) => { {
 		let mut updates = $chan.monitor_updating_restored(&$self.logger,
@@ -6001,6 +6018,10 @@ where
 							}
 						}
 
+						if chain_action_updates.pending_channel_ready {
+							emit_pending_channel_ready_event!(self, channel);
+						}
+
 						emit_channel_ready_event!(self, channel);
 
 						if let Some(announcement_sigs) = chain_action_updates.announcement_sigs {