Support async signing for V2 channel establishment

When handling a tx_complete message, allow signers to return an error
indicating that the signer has not yet complete. This will leave the
ChannelPhase in an unfunded variant until the signer becomes unblocked.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1760,7 +1760,7 @@ pub(super) trait InteractivelyFunded<SP: Deref> where SP::Target: SignerProvider
 
 	fn funding_tx_constructed<L: Deref>(
 		&mut self, logger: &L
-	) -> Result<(msgs::CommitmentSigned, Option<Event>), ChannelError>
+	) -> Result<(Option<msgs::CommitmentSigned>, Option<Event>), ChannelError>
 	where
 		L::Target: Logger
 	{
@@ -1803,11 +1803,14 @@ 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) => {
+			Some(commitment_signed) => {
 				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) }))),
+			None => {
+				context.channel_transaction_parameters.funding_outpoint = None;
+				return Ok((None, None));
+			},
 		};
 
 		let funding_ready_for_sig_event = None;
@@ -1839,7 +1842,7 @@ pub(super) trait InteractivelyFunded<SP: Deref> where SP::Target: SignerProvider
 		// Clear the interactive transaction constructor
 		self.interactive_tx_constructor_mut().take();
 
-		Ok((commitment_signed, funding_ready_for_sig_event))
+		Ok((Some(commitment_signed), funding_ready_for_sig_event))
 	}
 }
 
@@ -4031,7 +4034,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 	fn get_initial_counterparty_commitment_signature<L: Deref>(
 		&self, logger: &L
-	) -> Result<Signature, ChannelError>
+	) -> Option<Signature>
 	where
 		SP::Target: SignerProvider,
 		L::Target: Logger
@@ -4044,19 +4047,15 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 			ChannelSignerType::Ecdsa(ref ecdsa) => {
 				ecdsa.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), Vec::new(), &self.secp_ctx)
 					.map(|(signature, _)| signature)
-					.map_err(|_| ChannelError::Close(
-						(
-							"Failed to get signatures for new commitment_signed".to_owned(),
-							ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) },
-						)))
+					.ok()
 			},
 			// TODO (taproot|arik)
 			#[cfg(taproot)]
 			_ => todo!(),
 		}
 	}
 
-	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) -> Option<msgs::CommitmentSigned>
 	where
 		SP::Target: SignerProvider,
 		L::Target: Logger
@@ -4072,32 +4071,42 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 			panic!("Should not have advanced channel commitment tx numbers prior to initial commitment_signed");
 		}
 
-		let signature = match self.get_initial_counterparty_commitment_signature(logger) {
-			Ok(res) => res,
-			Err(e) => {
-				log_error!(logger, "Got bad signatures: {:?}!", e);
-				self.channel_transaction_parameters.funding_outpoint = None;
-				return Err(e);
-			}
-		};
+		match self.get_initial_counterparty_commitment_signature(logger) {
+			Some(signature) => {
+				if self.signer_pending_funding {
+					log_trace!(logger, "Counterparty commitment signature ready for initial commitment_signed message: clearing signer_pending_funding");
+					self.signer_pending_funding = false;
+				}
 
-		log_info!(logger, "Generated commitment_signed for peer for channel {}", &self.channel_id());
+				log_info!(logger, "Generated commitment_signed for peer for channel {}", &self.channel_id);
 
-		Ok(msgs::CommitmentSigned {
-			channel_id: self.channel_id,
-			htlc_signatures: vec![],
-			signature,
-			batch: None,
-			#[cfg(taproot)]
-			partial_signature_with_nonce: None,
-		})
+				Some(msgs::CommitmentSigned {
+					channel_id: self.channel_id,
+					htlc_signatures: vec![],
+					signature,
+					batch: None,
+					#[cfg(taproot)]
+					partial_signature_with_nonce: None,
+				})
+			},
+			None => {
+				#[cfg(not(async_signing))] {
+					panic!("Failed to get signature for initial commitment_signed");
+				}
+				#[cfg(async_signing)] {
+					log_trace!(logger, "Counterparty commitment signature not available for initial commitment_signed message; setting signer_pending_funding");
+					self.signer_pending_funding = true;
+					None
+				}
+			},
+		}
 	}
 
 	#[cfg(test)]
 	pub fn get_initial_counterparty_commitment_signature_for_test<L: Deref>(
 		&mut self, logger: &L, channel_transaction_parameters: ChannelTransactionParameters,
 		counterparty_cur_commitment_point_override: PublicKey,
-	) -> Result<Signature, ChannelError>
+	) -> Option<Signature>
 	where
 		SP::Target: SignerProvider,
 		L::Target: Logger

lightning/src/ln/channelmanager.rs

@@ -8307,7 +8307,7 @@ where
 					peer_state.pending_msg_events.push(msg_send_event);
 				};
 				if let Some(signing_session) = signing_session_opt {
-					let (commitment_signed, funding_ready_for_sig_event_opt) = match chan_phase_entry.get_mut() {
+					let (commitment_signed_opt, funding_ready_for_sig_event_opt) = match chan_phase_entry.get_mut() {
 						ChannelPhase::UnfundedOutboundV2(chan) => {
 							*chan.interactive_tx_signing_session_mut() = Some(signing_session);
 							chan.funding_tx_constructed(&self.logger)
@@ -8321,6 +8321,15 @@ where
 							.into())),
 					}.map_err(|err| MsgHandleErrInternal::send_err_msg_no_close(format!("{}", err), msg.channel_id))?;
 
+					// Check if the signer returned a result.
+					//
+					// TODO: This can be removed once ChannelPhase is refactored into Channel as the phase
+					// transition will happen internally.
+					let commitment_signed = match commitment_signed_opt {
+						Some(commitment_signed) => commitment_signed,
+						None => return Ok(()),
+					};
+
 					let (channel_id, channel_phase) = chan_phase_entry.remove_entry();
 					let channel = match channel_phase {
 						ChannelPhase::UnfundedOutboundV2(chan) => chan.into_channel(),