Rename ChannelPhase to Channel

In preparation for hiding ChannelPhase inside a Channel type, rename
ChannelPhase to Channel.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1124,44 +1124,44 @@ impl_writeable_tlv_based!(PendingChannelMonitorUpdate, {
 	(0, update, required),
 });
 
-/// The `ChannelPhase` enum describes the current phase in life of a lightning channel with each of
+/// The `Channel` enum describes the current phase in life of a lightning channel with each of
 /// its variants containing an appropriate channel struct.
-pub(super) enum ChannelPhase<SP: Deref> where SP::Target: SignerProvider {
+pub(super) enum Channel<SP: Deref> where SP::Target: SignerProvider {
 	UnfundedOutboundV1(OutboundV1Channel<SP>),
 	UnfundedInboundV1(InboundV1Channel<SP>),
 	#[allow(dead_code)] // TODO(dual_funding): Remove once creating V2 channels is enabled.
 	UnfundedV2(PendingV2Channel<SP>),
 	Funded(FundedChannel<SP>),
 }
 
-impl<'a, SP: Deref> ChannelPhase<SP> where
+impl<'a, SP: Deref> Channel<SP> where
 	SP::Target: SignerProvider,
 	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
 {
 	pub fn context(&'a self) -> &'a ChannelContext<SP> {
 		match self {
-			ChannelPhase::Funded(chan) => &chan.context,
-			ChannelPhase::UnfundedOutboundV1(chan) => &chan.context,
-			ChannelPhase::UnfundedInboundV1(chan) => &chan.context,
-			ChannelPhase::UnfundedV2(chan) => &chan.context,
+			Channel::Funded(chan) => &chan.context,
+			Channel::UnfundedOutboundV1(chan) => &chan.context,
+			Channel::UnfundedInboundV1(chan) => &chan.context,
+			Channel::UnfundedV2(chan) => &chan.context,
 		}
 	}
 
 	pub fn context_mut(&'a mut self) -> &'a mut ChannelContext<SP> {
 		match self {
-			ChannelPhase::Funded(ref mut chan) => &mut chan.context,
-			ChannelPhase::UnfundedOutboundV1(ref mut chan) => &mut chan.context,
-			ChannelPhase::UnfundedInboundV1(ref mut chan) => &mut chan.context,
-			ChannelPhase::UnfundedV2(ref mut chan) => &mut chan.context,
+			Channel::Funded(ref mut chan) => &mut chan.context,
+			Channel::UnfundedOutboundV1(ref mut chan) => &mut chan.context,
+			Channel::UnfundedInboundV1(ref mut chan) => &mut chan.context,
+			Channel::UnfundedV2(ref mut chan) => &mut chan.context,
 		}
 	}
 
 	pub fn unfunded_context_mut(&mut self) -> Option<&mut UnfundedChannelContext> {
 		match self {
-			ChannelPhase::Funded(_) => { debug_assert!(false); None },
-			ChannelPhase::UnfundedOutboundV1(chan) => Some(&mut chan.unfunded_context),
-			ChannelPhase::UnfundedInboundV1(chan) => Some(&mut chan.unfunded_context),
-			ChannelPhase::UnfundedV2(chan) => Some(&mut chan.unfunded_context),
+			Channel::Funded(_) => { debug_assert!(false); None },
+			Channel::UnfundedOutboundV1(chan) => Some(&mut chan.unfunded_context),
+			Channel::UnfundedInboundV1(chan) => Some(&mut chan.unfunded_context),
+			Channel::UnfundedV2(chan) => Some(&mut chan.unfunded_context),
 		}
 	}
 
@@ -1170,67 +1170,67 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 	}
 
 	pub fn as_funded(&self) -> Option<&FundedChannel<SP>> {
-		if let ChannelPhase::Funded(channel) = self {
+		if let Channel::Funded(channel) = self {
 			Some(channel)
 		} else {
 			None
 		}
 	}
 
 	pub fn as_funded_mut(&mut self) -> Option<&mut FundedChannel<SP>> {
-		if let ChannelPhase::Funded(channel) = self {
+		if let Channel::Funded(channel) = self {
 			Some(channel)
 		} else {
 			None
 		}
 	}
 
 	pub fn as_unfunded_outbound_v1_mut(&mut self) -> Option<&mut OutboundV1Channel<SP>> {
-		if let ChannelPhase::UnfundedOutboundV1(channel) = self {
+		if let Channel::UnfundedOutboundV1(channel) = self {
 			Some(channel)
 		} else {
 			None
 		}
 	}
 
 	pub fn is_unfunded_outbound_v1(&self) -> bool {
-		matches!(self, ChannelPhase::UnfundedOutboundV1(_))
+		matches!(self, Channel::UnfundedOutboundV1(_))
 	}
 
 	pub fn into_unfunded_outbound_v1(self) -> Result<OutboundV1Channel<SP>, Self> {
-		if let ChannelPhase::UnfundedOutboundV1(channel) = self {
+		if let Channel::UnfundedOutboundV1(channel) = self {
 			Ok(channel)
 		} else {
 			Err(self)
 		}
 	}
 
 	pub fn into_unfunded_inbound_v1(self) -> Result<InboundV1Channel<SP>, Self> {
-		if let ChannelPhase::UnfundedInboundV1(channel) = self {
+		if let Channel::UnfundedInboundV1(channel) = self {
 			Ok(channel)
 		} else {
 			Err(self)
 		}
 	}
 
 	pub fn as_unfunded_v2(&self) -> Option<&PendingV2Channel<SP>> {
-		if let ChannelPhase::UnfundedV2(channel) = self {
+		if let Channel::UnfundedV2(channel) = self {
 			Some(channel)
 		} else {
 			None
 		}
 	}
 
 	pub fn as_unfunded_v2_mut(&mut self) -> Option<&mut PendingV2Channel<SP>> {
-		if let ChannelPhase::UnfundedV2(channel) = self {
+		if let Channel::UnfundedV2(channel) = self {
 			Some(channel)
 		} else {
 			None
 		}
 	}
 
 	pub fn into_unfunded_v2(self) -> Option<PendingV2Channel<SP>> {
-		if let ChannelPhase::UnfundedV2(channel) = self {
+		if let Channel::UnfundedV2(channel) = self {
 			Some(channel)
 		} else {
 			None
@@ -1241,8 +1241,8 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 		&mut self, chain_hash: ChainHash, logger: &L,
 	) -> Option<SignerResumeUpdates> where L::Target: Logger {
 		match self {
-			ChannelPhase::Funded(chan) => Some(chan.signer_maybe_unblocked(logger)),
-			ChannelPhase::UnfundedOutboundV1(chan) => {
+			Channel::Funded(chan) => Some(chan.signer_maybe_unblocked(logger)),
+			Channel::UnfundedOutboundV1(chan) => {
 				let (open_channel, funding_created) = chan.signer_maybe_unblocked(chain_hash, logger);
 				Some(SignerResumeUpdates {
 					commitment_update: None,
@@ -1258,7 +1258,7 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 					shutdown_result: None,
 				})
 			},
-			ChannelPhase::UnfundedInboundV1(chan) => {
+			Channel::UnfundedInboundV1(chan) => {
 				let logger = WithChannelContext::from(logger, &chan.context, None);
 				let accept_channel = chan.signer_maybe_unblocked(&&logger);
 				Some(SignerResumeUpdates {
@@ -1275,38 +1275,38 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 					shutdown_result: None,
 				})
 			},
-			ChannelPhase::UnfundedV2(_) => None,
+			Channel::UnfundedV2(_) => None,
 		}
 	}
 
 	pub fn is_resumable(&self) -> bool {
 		match self {
-			ChannelPhase::Funded(_) => false,
-			ChannelPhase::UnfundedOutboundV1(chan) => chan.is_resumable(),
-			ChannelPhase::UnfundedInboundV1(_) => false,
-			ChannelPhase::UnfundedV2(_) => false,
+			Channel::Funded(_) => false,
+			Channel::UnfundedOutboundV1(chan) => chan.is_resumable(),
+			Channel::UnfundedInboundV1(_) => false,
+			Channel::UnfundedV2(_) => false,
 		}
 	}
 
 	pub fn maybe_get_open_channel<L: Deref>(
 		&mut self, chain_hash: ChainHash, logger: &L,
 	) -> Option<OpenChannelMessage> where L::Target: Logger {
 		match self {
-			ChannelPhase::Funded(_) => None,
-			ChannelPhase::UnfundedOutboundV1(chan) => {
+			Channel::Funded(_) => None,
+			Channel::UnfundedOutboundV1(chan) => {
 				let logger = WithChannelContext::from(logger, &chan.context, None);
 				chan.get_open_channel(chain_hash, &&logger)
 					.map(|msg| OpenChannelMessage::V1(msg))
 			},
-			ChannelPhase::UnfundedInboundV1(_) => {
+			Channel::UnfundedInboundV1(_) => {
 				// Since unfunded inbound channel maps are cleared upon disconnecting a peer,
 				// they are not persisted and won't be recovered after a crash.
 				// Therefore, they shouldn't exist at this point.
 				debug_assert!(false);
 				None
 			},
 			#[cfg(dual_funding)]
-			ChannelPhase::UnfundedV2(chan) => {
+			Channel::UnfundedV2(chan) => {
 				if chan.context.is_outbound() {
 					Some(OpenChannelMessage::V2(chan.get_open_channel_v2(chain_hash)))
 				} else {
@@ -1318,7 +1318,7 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 				}
 			},
 			#[cfg(not(dual_funding))]
-			ChannelPhase::UnfundedV2(_) => {
+			Channel::UnfundedV2(_) => {
 				debug_assert!(false);
 				None
 			},
@@ -1333,15 +1333,15 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 		L::Target: Logger,
 	{
 		match self {
-			ChannelPhase::Funded(_) => Ok(None),
-			ChannelPhase::UnfundedOutboundV1(chan) => {
+			Channel::Funded(_) => Ok(None),
+			Channel::UnfundedOutboundV1(chan) => {
 				let logger = WithChannelContext::from(logger, &chan.context, None);
 				chan.maybe_handle_error_without_close(chain_hash, fee_estimator, &&logger)
 					.map(|msg| Some(OpenChannelMessage::V1(msg)))
 			},
-			ChannelPhase::UnfundedInboundV1(_) => Ok(None),
+			Channel::UnfundedInboundV1(_) => Ok(None),
 			#[cfg(dual_funding)]
-			ChannelPhase::UnfundedV2(chan) => {
+			Channel::UnfundedV2(chan) => {
 				if chan.context.is_outbound() {
 					chan.maybe_handle_error_without_close(chain_hash, fee_estimator)
 						.map(|msg| Some(OpenChannelMessage::V2(msg)))
@@ -1350,51 +1350,51 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 				}
 			},
 			#[cfg(not(dual_funding))]
-			ChannelPhase::UnfundedV2(_) => {
+			Channel::UnfundedV2(_) => {
 				debug_assert!(false);
 				Ok(None)
 			},
 		}
 	}
 }
 
-impl<SP: Deref> From<OutboundV1Channel<SP>> for ChannelPhase<SP>
+impl<SP: Deref> From<OutboundV1Channel<SP>> for Channel<SP>
 where
 	SP::Target: SignerProvider,
 	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
 {
 	fn from(channel: OutboundV1Channel<SP>) -> Self {
-		ChannelPhase::UnfundedOutboundV1(channel)
+		Channel::UnfundedOutboundV1(channel)
 	}
 }
 
-impl<SP: Deref> From<InboundV1Channel<SP>> for ChannelPhase<SP>
+impl<SP: Deref> From<InboundV1Channel<SP>> for Channel<SP>
 where
 	SP::Target: SignerProvider,
 	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
 {
 	fn from(channel: InboundV1Channel<SP>) -> Self {
-		ChannelPhase::UnfundedInboundV1(channel)
+		Channel::UnfundedInboundV1(channel)
 	}
 }
 
-impl<SP: Deref> From<PendingV2Channel<SP>> for ChannelPhase<SP>
+impl<SP: Deref> From<PendingV2Channel<SP>> for Channel<SP>
 where
 	SP::Target: SignerProvider,
 	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
 {
 	fn from(channel: PendingV2Channel<SP>) -> Self {
-		ChannelPhase::UnfundedV2(channel)
+		Channel::UnfundedV2(channel)
 	}
 }
 
-impl<SP: Deref> From<FundedChannel<SP>> for ChannelPhase<SP>
+impl<SP: Deref> From<FundedChannel<SP>> for Channel<SP>
 where
 	SP::Target: SignerProvider,
 	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
 {
 	fn from(channel: FundedChannel<SP>) -> Self {
-		ChannelPhase::Funded(channel)
+		Channel::Funded(channel)
 	}
 }