Sign splice shared input when producing holder tx_signatures

We also remove the `Result` to make it clear that this method does not
support async operations yet and rename the method to clarify that it is
only intended to be used for the shared input of a splice.

Author: wpaulino

lightning/src/ln/channel.rs

@@ -7984,6 +7984,35 @@ 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 });
+		}
+		#[cfg(splicing)]
+		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()
@@ -8001,11 +8030,31 @@ 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_splice_shared_input(
+							&self.funding.channel_transaction_parameters,
+							&tx,
+							splice_input_index as usize,
+							&self.context.secp_ctx,
+						),
+						#[cfg(taproot)]
+						ChannelSignerType::Taproot(_) => todo!(),
+					};
+					Some(sig)
+				} else {
+					None
+				};
+				#[cfg(splicing)]
+				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

@@ -242,7 +242,7 @@ pub trait EcdsaChannelSigner: ChannelSigner {
 		msg: &UnsignedChannelAnnouncement, secp_ctx: &Secp256k1<secp256k1::All>,
 	) -> Result<Signature, ()>;
 
-	/// Signs the input of a splicing funding transaction with our funding key.
+	/// Signs the shared input of a splice transaction with our funding key.
 	///
 	/// In splicing, the previous funding transaction output is spent as the input of
 	/// the new funding transaction, and is a 2-of-2 multisig.
@@ -253,11 +253,8 @@ 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.
-	fn sign_splicing_funding_input(
+	fn sign_splice_shared_input(
 		&self, channel_parameters: &ChannelTransactionParameters, tx: &Transaction,
 		input_index: usize, secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> Result<Signature, ()>;
+	) -> Signature;
 }

lightning/src/sign/mod.rs

@@ -1753,10 +1753,10 @@ impl EcdsaChannelSigner for InMemorySigner {
 		Ok(secp_ctx.sign_ecdsa(&msghash, &funding_key))
 	}
 
-	fn sign_splicing_funding_input(
+	fn sign_splice_shared_input(
 		&self, channel_parameters: &ChannelTransactionParameters, tx: &Transaction,
 		input_index: usize, secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> Result<Signature, ()> {
+	) -> Signature {
 		assert!(channel_parameters.is_populated(), "Channel parameters must be fully populated");
 		assert_eq!(
 			tx.input[input_index].previous_output,
@@ -1782,7 +1782,7 @@ impl EcdsaChannelSigner for InMemorySigner {
 			)
 			.unwrap()[..];
 		let msg = hash_to_message!(sighash);
-		Ok(sign(secp_ctx, &msg, &funding_key))
+		sign(secp_ctx, &msg, &funding_key)
 	}
 }
 

lightning/src/util/dyn_signer.rs

@@ -159,8 +159,8 @@ delegate!(DynSigner, EcdsaChannelSigner, inner,
 		secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()>,
 	fn sign_holder_htlc_transaction(, htlc_tx: &Transaction, input: usize,
 		htlc_descriptor: &HTLCDescriptor, secp_ctx: &Secp256k1<All>) -> Result<Signature, ()>,
-	fn sign_splicing_funding_input(, channel_parameters: &ChannelTransactionParameters,
-		tx: &Transaction, input_index: usize, secp_ctx: &Secp256k1<All>) -> Result<Signature, ()>
+	fn sign_splice_shared_input(, channel_parameters: &ChannelTransactionParameters,
+		tx: &Transaction, input_index: usize, secp_ctx: &Secp256k1<All>) -> Signature
 );
 
 delegate!(DynSigner, ChannelSigner,

lightning/src/util/test_channel_signer.rs

@@ -484,11 +484,11 @@ impl EcdsaChannelSigner for TestChannelSigner {
 		self.inner.sign_channel_announcement_with_funding_key(channel_parameters, msg, secp_ctx)
 	}
 
-	fn sign_splicing_funding_input(
+	fn sign_splice_shared_input(
 		&self, channel_parameters: &ChannelTransactionParameters, tx: &Transaction,
 		input_index: usize, secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> Result<Signature, ()> {
-		self.inner.sign_splicing_funding_input(channel_parameters, tx, input_index, secp_ctx)
+	) -> Signature {
+		self.inner.sign_splice_shared_input(channel_parameters, tx, input_index, secp_ctx)
 	}
 }