Split out remaining uses of is_pre_funded_state and rename it

`Channel::is_pre_funded_state` is used to mean several different
things. In the past few commits we stopped using it for a few
conflicting uses, but here we break out the remaining uses and
rename the remnants for clarity.

`is_funding_broadcast` was using `is_pre_funded_state` and was then
later used to decide if the `Channel` could be written to disk
(because it can be resumed on restart), if we should broadcast a
force-close transaction, and when to emit a `ChannelPending` event.

These were also somewhat divergent - we shouldn't generate a
`ChannelReady` event or broadcast a force-closing transaction until
we've actually broadcasted but want to write the `Channel` to disk
once we enter funding signature exchange for dual-funded open.

Thus, the ability to write a `Channel` to disk is provided by a new
`can_resume_on_restart` method. Then, `is_funding_broadcast`  is
updated to only consider funding broadcasted after we provide our
funding signatures (i.e. the funding *could* have been
broadcasted). This is still a bit early to generate a
`ChannelPending` event (as the funding may not actually have been
broadcasted yet), but its better than it was.

Finally, the remaining `is_pre_funded_state` is renamed
`can_resume_on_reconnect`, which has slightly different semantics
than on-restart channels in batch opens.

Author: TheBlueMatt

lightning/src/ln/channel.rs

@@ -806,11 +806,11 @@ impl ChannelState {
 		}
 	}
 
-	fn is_pre_funded_state(&self) -> bool {
+	fn can_resume_on_reconnect(&self) -> bool {
 		match self {
-			ChannelState::NegotiatingFunding(_) => true,
-			ChannelState::FundingNegotiated(flags) => !flags.is_interactive_signing(),
-			_ => false,
+			ChannelState::NegotiatingFunding(_) => false,
+			ChannelState::FundingNegotiated(flags) => flags.is_interactive_signing(),
+			_ => true,
 		}
 	}
 
@@ -4001,7 +4001,7 @@ where
 
 	// Checks whether we should emit a `ChannelPending` event.
 	pub(crate) fn should_emit_channel_pending_event(&mut self) -> bool {
-		self.is_funding_broadcast() && !self.channel_pending_event_emitted
+		self.is_funding_broadcastable() && !self.channel_pending_event_emitted
 	}
 
 	// Returns whether we already emitted a `ChannelPending` event.
@@ -4082,11 +4082,28 @@ where
 		self.is_manual_broadcast = true;
 	}
 
+	/// Returns true if this channel can be resume after a restart, implying its past the initial
+	/// funding negotiation stages (and any assocated batch channels are similarly past initial
+	/// funding negotiation).
+	///
+	/// This is equivalent to saying the channel can be persisted to disk.
+	pub fn can_resume_on_restart(&self) -> bool {
+		self.channel_state.can_resume_on_reconnect()
+			&& match self.channel_state {
+				ChannelState::AwaitingChannelReady(flags) => !flags.is_waiting_for_batch(),
+				_ => true,
+			}
+	}
+
 	/// Returns true if funding_signed was sent/received and the
 	/// funding transaction has been broadcast if necessary.
-	pub fn is_funding_broadcast(&self) -> bool {
-		!self.channel_state.is_pre_funded_state()
-			&& !matches!(self.channel_state, ChannelState::AwaitingChannelReady(flags) if flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH))
+	fn is_funding_broadcastable(&self) -> bool {
+		match self.channel_state {
+			ChannelState::NegotiatingFunding(_) => false,
+			ChannelState::FundingNegotiated(flags) => !flags.is_our_tx_signatures_ready(),
+			ChannelState::AwaitingChannelReady(flags) => !flags.is_waiting_for_batch(),
+			_ => true,
+		}
 	}
 
 	#[rustfmt::skip]
@@ -5432,7 +5449,7 @@ where
 		// be delayed in being processed! See the docs for `ChannelManagerReadArgs` for more.
 		assert!(!matches!(self.channel_state, ChannelState::ShutdownComplete));
 
-		let broadcast = self.is_funding_broadcast();
+		let broadcast = self.is_funding_broadcastable();
 
 		// We go ahead and "free" any holding cell HTLCs or HTLCs we haven't yet committed to and
 		// return them to fail the payment.
@@ -8306,12 +8323,12 @@ where
 	#[rustfmt::skip]
 	fn remove_uncommitted_htlcs_and_mark_paused<L: Deref>(&mut self, logger: &L) -> Result<(), ()> where L::Target: Logger {
 		assert!(!matches!(self.context.channel_state, ChannelState::ShutdownComplete));
-		if self.context.channel_state.is_pre_funded_state() {
+		if !self.context.channel_state.can_resume_on_reconnect() {
 			return Err(())
 		}
 
 		// We only clear `peer_disconnected` if we were able to reestablish the channel. We always
- 		// reset our awaiting response in case we failed reestablishment and are disconnecting.
+		// reset our awaiting response in case we failed reestablishment and are disconnecting.
 		self.context.sent_message_awaiting_response = None;
 
 		if self.context.channel_state.is_peer_disconnected() {

lightning/src/ln/channelmanager.rs

@@ -15242,7 +15242,7 @@ where
 				number_of_funded_channels += peer_state.channel_by_id
 					.values()
 					.filter_map(Channel::as_funded)
-					.filter(|chan| chan.context.is_funding_broadcast())
+					.filter(|chan| chan.context.can_resume_on_restart())
 					.count();
 			}
 
@@ -15254,7 +15254,7 @@ where
 				for channel in peer_state.channel_by_id
 					.values()
 					.filter_map(Channel::as_funded)
-					.filter(|channel| channel.context.is_funding_broadcast())
+					.filter(|channel| channel.context.can_resume_on_restart())
 				{
 					channel.write(writer)?;
 				}