Expose signing session from InteractivelyFunded

To support async signing, the InteractiveTxSigningSession returned when
handling tx_complete needs to be saved in order to retry the
funding_tx_constructed method when the signer is unblocked. This
unfortunately means an Option as needed since the unfunded V2 channel
phase variant is left unfunded until the signer completes.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1682,6 +1682,10 @@ pub(super) trait InteractivelyFunded<SP: Deref> where SP::Target: SignerProvider
 
 	fn interactive_tx_constructor_mut(&mut self) -> &mut Option<InteractiveTxConstructor>;
 
+	fn interactive_tx_signing_session(&self) -> &Option<InteractiveTxSigningSession>;
+
+	fn interactive_tx_signing_session_mut(&mut self) -> &mut Option<InteractiveTxSigningSession>;
+
 	fn dual_funding_context(&self) -> &DualFundingChannelContext;
 
 	fn tx_add_input(&mut self, msg: &msgs::TxAddInput) -> InteractiveTxMessageSendResult {
@@ -1755,17 +1759,25 @@ pub(super) trait InteractivelyFunded<SP: Deref> where SP::Target: SignerProvider
 	}
 
 	fn funding_tx_constructed<L: Deref>(
-		&mut self, signing_session: &mut InteractiveTxSigningSession, logger: &L
+		&mut self, logger: &L
 	) -> Result<(msgs::CommitmentSigned, Option<Event>), ChannelError>
 	where
 		L::Target: Logger
 	{
 		let our_funding_satoshis = self.dual_funding_context().our_funding_satoshis;
-		let context = self.context_mut();
+		let unsigned_tx = match self.interactive_tx_signing_session() {
+			Some(signing_session) => signing_session.unsigned_tx.clone(),
+			None => return Err(ChannelError::Close(
+						(
+							"No signing session available for commitment signing".to_owned(),
+							ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) },
+						))),
+		};
 
+		let context = self.context_mut();
 		let mut output_index = None;
 		let expected_spk = context.get_funding_redeemscript().to_p2wsh();
-		for (idx, outp) in signing_session.unsigned_tx.outputs().enumerate() {
+		for (idx, outp) in unsigned_tx.outputs().enumerate() {
 			if outp.script_pubkey() == &expected_spk && outp.value() == context.get_value_satoshis() {
 				if output_index.is_some() {
 					return Err(ChannelError::Close(
@@ -1778,7 +1790,7 @@ pub(super) trait InteractivelyFunded<SP: Deref> where SP::Target: SignerProvider
 			}
 		}
 		let outpoint = if let Some(output_index) = output_index {
-			OutPoint { txid: signing_session.unsigned_tx.txid(), index: output_index }
+			OutPoint { txid: unsigned_tx.txid(), index: output_index }
 		} else {
 			return Err(ChannelError::Close(
 				(
@@ -1792,15 +1804,19 @@ pub(super) trait InteractivelyFunded<SP: Deref> where SP::Target: SignerProvider
 		let commitment_signed = context.get_initial_commitment_signed(logger);
 		let commitment_signed = match commitment_signed {
 			Ok(commitment_signed) => {
-				context.funding_transaction = Some(signing_session.unsigned_tx.clone().into_unsigned_tx());
+				context.funding_transaction = Some(unsigned_tx.into_unsigned_tx());
 				commitment_signed
 			},
 			Err(err) => return Err(ChannelError::Close((err.to_string(), ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) }))),
 		};
 
 		let funding_ready_for_sig_event = None;
 		if our_funding_satoshis == 0 {
-			signing_session.provide_holder_witnesses(context.channel_id, Vec::new());
+			let channel_id = context.channel_id;
+			self.interactive_tx_signing_session_mut()
+				.as_mut()
+				.expect("interactive_tx_signing_session_mut should be set")
+				.provide_holder_witnesses(channel_id, Vec::new());
 		} else {
 			// TODO(dual_funding): Send event for signing if we've contributed funds.
 			// Inform the user that SIGHASH_ALL must be used for all signatures when contributing
@@ -1818,7 +1834,7 @@ pub(super) trait InteractivelyFunded<SP: Deref> where SP::Target: SignerProvider
 			// </div>
 		}
 
-		context.channel_state = ChannelState::FundingNegotiated;
+		self.context_mut().channel_state = ChannelState::FundingNegotiated;
 
 		// Clear the interactive transaction constructor
 		self.interactive_tx_constructor_mut().take();
@@ -1840,6 +1856,12 @@ impl<SP: Deref> InteractivelyFunded<SP> for OutboundV2Channel<SP> where SP::Targ
 	fn interactive_tx_constructor_mut(&mut self) -> &mut Option<InteractiveTxConstructor> {
 		&mut self.interactive_tx_constructor
 	}
+	fn interactive_tx_signing_session(&self) -> &Option<InteractiveTxSigningSession> {
+		&self.signing_session
+	}
+	fn interactive_tx_signing_session_mut(&mut self) -> &mut Option<InteractiveTxSigningSession> {
+		&mut self.signing_session
+	}
 }
 
 impl<SP: Deref> InteractivelyFunded<SP> for InboundV2Channel<SP> where SP::Target: SignerProvider {
@@ -1855,6 +1877,12 @@ impl<SP: Deref> InteractivelyFunded<SP> for InboundV2Channel<SP> where SP::Targe
 	fn interactive_tx_constructor_mut(&mut self) -> &mut Option<InteractiveTxConstructor> {
 		&mut self.interactive_tx_constructor
 	}
+	fn interactive_tx_signing_session(&self) -> &Option<InteractiveTxSigningSession> {
+		&self.signing_session
+	}
+	fn interactive_tx_signing_session_mut(&mut self) -> &mut Option<InteractiveTxSigningSession> {
+		&mut self.signing_session
+	}
 }
 
 impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
@@ -4028,9 +4056,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 		}
 	}
 
-	fn get_initial_commitment_signed<L: Deref>(
-		&mut self, logger: &L
-	) -> Result<msgs::CommitmentSigned, ChannelError>
+	fn get_initial_commitment_signed<L: Deref>(&mut self, logger: &L) -> Result<msgs::CommitmentSigned, ChannelError>
 	where
 		SP::Target: SignerProvider,
 		L::Target: Logger
@@ -8719,6 +8745,7 @@ pub(super) struct OutboundV2Channel<SP: Deref> where SP::Target: SignerProvider
 	pub dual_funding_context: DualFundingChannelContext,
 	/// The current interactive transaction construction session under negotiation.
 	interactive_tx_constructor: Option<InteractiveTxConstructor>,
+	signing_session: Option<InteractiveTxSigningSession>,
 }
 
 impl<SP: Deref> OutboundV2Channel<SP> where SP::Target: SignerProvider {
@@ -8778,6 +8805,7 @@ impl<SP: Deref> OutboundV2Channel<SP> where SP::Target: SignerProvider {
 				our_funding_inputs: funding_inputs,
 			},
 			interactive_tx_constructor: None,
+			signing_session: None,
 		};
 		Ok(chan)
 	}
@@ -8845,10 +8873,11 @@ impl<SP: Deref> OutboundV2Channel<SP> where SP::Target: SignerProvider {
 		}
 	}
 
-	pub fn into_channel(self, signing_session: InteractiveTxSigningSession) -> Result<Channel<SP>, ChannelError>{
+	pub fn into_channel(self) -> Result<Channel<SP>, ChannelError>{
+		debug_assert!(self.signing_session.is_some());
 		let channel = Channel {
 			context: self.context,
-			interactive_tx_signing_session: Some(signing_session),
+			interactive_tx_signing_session: self.signing_session,
 		};
 
 		Ok(channel)
@@ -8862,6 +8891,7 @@ pub(super) struct InboundV2Channel<SP: Deref> where SP::Target: SignerProvider {
 	pub dual_funding_context: DualFundingChannelContext,
 	/// The current interactive transaction construction session under negotiation.
 	interactive_tx_constructor: Option<InteractiveTxConstructor>,
+	signing_session: Option<InteractiveTxSigningSession>,
 }
 
 impl<SP: Deref> InboundV2Channel<SP> where SP::Target: SignerProvider {
@@ -8964,6 +8994,7 @@ impl<SP: Deref> InboundV2Channel<SP> where SP::Target: SignerProvider {
 			dual_funding_context,
 			interactive_tx_constructor,
 			unfunded_context: UnfundedChannelContext { unfunded_channel_age_ticks: 0 },
+			signing_session: None,
 		})
 	}
 
@@ -9039,10 +9070,11 @@ 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_channel(self) -> Result<Channel<SP>, ChannelError>{
+		debug_assert!(self.signing_session.is_some());
 		let channel = Channel {
 			context: self.context,
-			interactive_tx_signing_session: Some(signing_session),
+			interactive_tx_signing_session: self.signing_session,
 		};
 
 		Ok(channel)

lightning/src/ln/channelmanager.rs

@@ -8306,22 +8306,25 @@ where
 				if let Some(msg_send_event) = msg_send_event_opt {
 					peer_state.pending_msg_events.push(msg_send_event);
 				};
-				if let Some(mut signing_session) = signing_session_opt {
+				if let Some(signing_session) = signing_session_opt {
 					let (commitment_signed, funding_ready_for_sig_event_opt) = match chan_phase_entry.get_mut() {
 						ChannelPhase::UnfundedOutboundV2(chan) => {
-							chan.funding_tx_constructed(&mut signing_session, &self.logger)
+							*chan.interactive_tx_signing_session_mut() = Some(signing_session);
+							chan.funding_tx_constructed(&self.logger)
 						},
 						ChannelPhase::UnfundedInboundV2(chan) => {
-							chan.funding_tx_constructed(&mut signing_session, &self.logger)
+							*chan.interactive_tx_signing_session_mut() = Some(signing_session);
+							chan.funding_tx_constructed(&self.logger)
 						},
 						_ => Err(ChannelError::Warn(
 							"Got a tx_complete message with no interactive transaction construction expected or in-progress"
 							.into())),
 					}.map_err(|err| MsgHandleErrInternal::send_err_msg_no_close(format!("{}", err), msg.channel_id))?;
+
 					let (channel_id, channel_phase) = chan_phase_entry.remove_entry();
 					let channel = match channel_phase {
-						ChannelPhase::UnfundedOutboundV2(chan) => chan.into_channel(signing_session),
-						ChannelPhase::UnfundedInboundV2(chan) => chan.into_channel(signing_session),
+						ChannelPhase::UnfundedOutboundV2(chan) => chan.into_channel(),
+						ChannelPhase::UnfundedInboundV2(chan) => chan.into_channel(),
 						_ => {
 							debug_assert!(false); // It cannot be another variant as we are in the `Ok` branch of the above match.
 							Err(ChannelError::Warn(