Handle LdkEvent::FundingTransactionReadyForSigning

When the interactive-tx construction protocol completes in LDK during
splicing (and in the future dual-funding), LDK Node must provide
signatures for any non-shared inputs belonging to its on-chain wallet.
This commit implements this when handling the corresponding
FundingTransactionReadyForSigning event.

Author: jkczyz

src/event.rs

@@ -1660,8 +1660,35 @@ where
 					}
 				}
 			},
-			LdkEvent::FundingTransactionReadyForSigning { .. } => {
-				debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+			LdkEvent::FundingTransactionReadyForSigning {
+				channel_id,
+				counterparty_node_id,
+				unsigned_transaction,
+				..
+			} => {
+				let partially_signed_tx =
+					self.wallet.sign_owned_inputs(unsigned_transaction).map_err(|()| {
+						log_error!(self.logger, "Failed signing funding transaction");
+						ReplayEvent()
+					})?;
+
+				self.channel_manager
+					.funding_transaction_signed(
+						&channel_id,
+						&counterparty_node_id,
+						partially_signed_tx,
+					)
+					.map_err(|e| {
+						log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+						ReplayEvent()
+					})?;
+
+				log_info!(
+					self.logger,
+					"Signed funding transaction for channel {} with counterparty {}",
+					channel_id,
+					counterparty_node_id
+				);
 			},
 			LdkEvent::SplicePending {
 				channel_id,

src/wallet/mod.rs

@@ -664,6 +664,40 @@ impl Wallet {
 		Ok(address_info.address.script_pubkey())
 	}
 
+	#[allow(deprecated)]
+	pub(crate) fn sign_owned_inputs(&self, unsigned_tx: Transaction) -> Result<Transaction, ()> {
+		let locked_wallet = self.inner.lock().unwrap();
+
+		let mut psbt = Psbt::from_unsigned_tx(unsigned_tx).map_err(|e| {
+			log_error!(self.logger, "Failed to construct PSBT: {}", e);
+		})?;
+		for (i, txin) in psbt.unsigned_tx.input.iter().enumerate() {
+			if let Some(utxo) = locked_wallet.get_utxo(txin.previous_output) {
+				psbt.inputs[i] = locked_wallet.get_psbt_input(utxo, None, true).map_err(|e| {
+					log_error!(self.logger, "Failed to construct PSBT input: {}", e);
+				})?;
+			}
+		}
+
+		let mut sign_options = SignOptions::default();
+		sign_options.trust_witness_utxo = true;
+
+		match locked_wallet.sign(&mut psbt, sign_options) {
+			Ok(finalized) => debug_assert!(!finalized),
+			Err(e) => {
+				log_error!(self.logger, "Failed to sign owned inputs: {}", e);
+				return Err(());
+			},
+		}
+
+		let mut tx = psbt.unsigned_tx;
+		for (txin, input) in tx.input.iter_mut().zip(psbt.inputs.into_iter()) {
+			txin.witness = input.final_script_witness.unwrap_or_default();
+		}
+
+		Ok(tx)
+	}
+
 	#[allow(deprecated)]
 	fn sign_psbt_inner(&self, mut psbt: Psbt) -> Result<Transaction, ()> {
 		let locked_wallet = self.inner.lock().unwrap();