Implement async signing of splice shared input

We get async for free since the user already has to call back into LDK
via `funding_transaction_signed`. If the signer fails to sign, they can
simply retry the call once it is available.

Author: wpaulino

lightning/src/ln/channel.rs

@@ -7983,6 +7983,34 @@ where
 	pub fn funding_transaction_signed(
 		&mut self, funding_txid_signed: Txid, witnesses: Vec<Witness>,
 	) -> Result<(Option<msgs::TxSignatures>, Option<Transaction>), APIError> {
+		if !self.context.channel_state.is_interactive_signing() {
+			let err =
+				format!("Channel {} not expecting funding signatures", self.context.channel_id);
+			return Err(APIError::APIMisuseError { err });
+		}
+		if self.context.channel_state.is_our_tx_signatures_ready() {
+			let err =
+				format!("Channel {} already received funding signatures", self.context.channel_id);
+			return Err(APIError::APIMisuseError { err });
+		}
+		if let Some(pending_splice) = self.pending_splice.as_ref() {
+			if !pending_splice
+				.funding_negotiation
+				.as_ref()
+				.map(|funding_negotiation| {
+					matches!(funding_negotiation, FundingNegotiation::AwaitingSignatures(_))
+				})
+				.unwrap_or(false)
+			{
+				debug_assert!(false);
+				let err = format!(
+					"Channel {} with pending splice is not expecting funding signatures yet",
+					self.context.channel_id
+				);
+				return Err(APIError::APIMisuseError { err });
+			}
+		}
+
 		let (tx_signatures_opt, funding_tx_opt) = self
 			.interactive_tx_signing_session
 			.as_mut()
@@ -8000,11 +8028,34 @@ where
 					});
 				}
 
+				let shared_input_signature = if let Some(splice_input_index) =
+					signing_session.unsigned_tx().shared_input_index()
+				{
+					let sig = match &self.context.holder_signer {
+						ChannelSignerType::Ecdsa(signer) => signer
+							.sign_splicing_funding_input(
+								&self.funding.channel_transaction_parameters,
+								&tx,
+								splice_input_index as usize,
+								&self.context.secp_ctx,
+							)
+							.map_err(|_| APIError::ChannelUnavailable {
+								err: "Signer unavailable".to_string(),
+							})?,
+						#[cfg(taproot)]
+						ChannelSignerType::Taproot(_) => todo!(),
+					};
+					Some(sig)
+				} else {
+					None
+				};
+				debug_assert_eq!(self.pending_splice.is_some(), shared_input_signature.is_some());
+
 				let tx_signatures = msgs::TxSignatures {
 					channel_id: self.context.channel_id,
 					tx_hash: funding_txid_signed,
 					witnesses,
-					shared_input_signature: None,
+					shared_input_signature,
 				};
 				signing_session
 					.provide_holder_witnesses(tx_signatures, &self.context.secp_ctx)

lightning/src/ln/channelmanager.rs

@@ -9044,7 +9044,9 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 					Ok((None, _)) => {
 						debug_assert!(false, "If our tx_signatures is empty, then we should send it first!");
 					},
-					Err(err) => debug_assert!(false, "We should not error here but we got: {:?}", err),
+					Err(err) => {
+						log_warn!(logger, "Failed signing interactive funding transaction: {err:?}");
+					},
 				}
 			}
 		}

lightning/src/sign/ecdsa.rs

@@ -254,8 +254,10 @@ pub trait EcdsaChannelSigner: ChannelSigner {
 	/// `input_index`: The index of the input within the new funding transaction `tx`,
 	///    spending the previous funding transaction's output
 	///
-	/// This method is *not* asynchronous. If an `Err` is returned, the channel will be immediately
-	/// closed.
+	/// An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+	/// signature and should be retried later via [`ChannelManager::funding_transaction_signed`].
+	///
+	/// [`ChannelManager::funding_transaction_signed`]: crate::ln::channelmanager::ChannelManager::funding_transaction_signed
 	fn sign_splicing_funding_input(
 		&self, channel_parameters: &ChannelTransactionParameters, tx: &Transaction,
 		input_index: usize, secp_ctx: &Secp256k1<secp256k1::All>,