Channel phase refactor, wrap channel phase, store wrapped phase in map

lightning/src/ln/channel.rs

@@ -1139,7 +1139,8 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 	SP::Target: SignerProvider,
 	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
 {
-	pub fn context(&'a self) -> &'a ChannelContext<SP> {
+	#[inline]
+	pub fn context(&self) -> &ChannelContext<SP> {
 		match self {
 			ChannelPhase::Funded(chan) => &chan.context,
 			ChannelPhase::UnfundedOutboundV1(chan) => &chan.context,
@@ -1149,7 +1150,8 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 		}
 	}
 
-	pub fn context_mut(&'a mut self) -> &'a mut ChannelContext<SP> {
+	#[inline]
+	pub fn context_mut(&mut self) -> &mut ChannelContext<SP> {
 		match self {
 			ChannelPhase::Funded(ref mut chan) => &mut chan.context,
 			ChannelPhase::UnfundedOutboundV1(ref mut chan) => &mut chan.context,
@@ -1160,6 +1162,77 @@ impl<'a, SP: Deref> ChannelPhase<SP> where
 	}
 }
 
+/// A top-level channel struct, containing a channel phase
+pub(super) struct ChannelWrapper<SP: Deref> where SP::Target: SignerProvider {
+	/// The inner channel phase
+	/// Option is used to facilitate in-place replacement (see e.g. move_v2_to_funded),
+	/// but it is never None, ensured in new() and set_phase()
+	phase: Option<ChannelPhase<SP>>,
+}
+
+impl<'a, SP: Deref> ChannelWrapper<SP> where SP::Target: SignerProvider {
+	pub fn new(phase: ChannelPhase<SP>) -> Self {
+		Self {
+			phase: Some(phase),
+		}
+	}
+
+	#[inline]
+	pub fn phase(&self) -> &ChannelPhase<SP> {
+		self.phase.as_ref().unwrap()
+	}
+
+	#[inline]
+	pub fn phase_mut(&mut self) -> &mut ChannelPhase<SP> {
+		self.phase.as_mut().unwrap()
+	}
+
+	pub fn phase_take(self) -> ChannelPhase<SP> {
+		match self.phase {
+			Some(phase) => phase,
+			None => panic!("None phase"),
+		}
+	}
+
+	pub fn funded_channel(&self) -> Option<&Channel<SP>> {
+		if let ChannelPhase::Funded(chan) = &self.phase.as_ref().unwrap() {
+			Some(chan)
+		} else {
+			None
+		}
+	}
+
+	/// Change the internal phase
+	#[inline]
+	pub fn set_phase(&mut self, new_phase: ChannelPhase<SP>) {
+		self.phase = Some(new_phase);
+	}
+
+	pub fn move_v2_to_funded(&mut self, signing_session: InteractiveTxSigningSession) -> Result<(), ChannelError> {
+		// We need a borrow to the phase field, but self is only a mut ref
+		let phase_inline = self.phase.take().unwrap();
+		let new_phase = match phase_inline {
+			ChannelPhase::UnfundedOutboundV2(chan) =>
+				ChannelPhase::Funded(chan.into_funded_channel(signing_session)?),
+			ChannelPhase::UnfundedInboundV2(chan) =>
+				ChannelPhase::Funded(chan.into_funded_channel(signing_session)?),
+			_ => phase_inline,
+		};
+		self.set_phase(new_phase);
+		Ok(())
+	}
+
+	#[inline]
+	pub fn context(&self) -> &ChannelContext<SP> {
+		self.phase().context()
+	}
+
+	#[inline]
+	pub fn context_mut(&mut self) -> &mut ChannelContext<SP> {
+		self.phase_mut().context_mut()
+	}
+}
+
 /// Contains all state common to unfunded inbound/outbound channels.
 pub(super) struct UnfundedChannelContext {
 	/// A counter tracking how many ticks have elapsed since this unfunded channel was
@@ -8849,7 +8922,7 @@ impl<SP: Deref> OutboundV2Channel<SP> where SP::Target: SignerProvider {
 		}
 	}
 
-	pub fn into_channel(self, signing_session: InteractiveTxSigningSession) -> Result<Channel<SP>, ChannelError>{
+	pub fn into_funded_channel(self, signing_session: InteractiveTxSigningSession) -> Result<Channel<SP>, ChannelError>{
 		let channel = Channel {
 			context: self.context,
 			interactive_tx_signing_session: Some(signing_session),
@@ -9043,7 +9116,7 @@ impl<SP: Deref> InboundV2Channel<SP> where SP::Target: SignerProvider {
 		self.generate_accept_channel_v2_message()
 	}
 
-	pub fn into_channel(self, signing_session: InteractiveTxSigningSession) -> Result<Channel<SP>, ChannelError>{
+	pub fn into_funded_channel(self, signing_session: InteractiveTxSigningSession) -> Result<Channel<SP>, ChannelError>{
 		let channel = Channel {
 			context: self.context,
 			interactive_tx_signing_session: Some(signing_session),