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

@@ -1676,8 +1676,35 @@ where
 					}
 				}
 			},
-			LdkEvent::FundingTransactionReadyForSigning { .. } => {
-				debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");
+			// TODO(splicing): Revisit error handling once splicing API is settled in LDK 0.3
+			LdkEvent::FundingTransactionReadyForSigning {
+				channel_id,
+				counterparty_node_id,
+				unsigned_transaction,
+				..
+			} => match self.wallet.sign_owned_inputs(unsigned_transaction) {
+				Ok(partially_signed_tx) => {
+					match self.channel_manager.funding_transaction_signed(
+						&channel_id,
+						&counterparty_node_id,
+						partially_signed_tx,
+					) {
+						Ok(()) => {
+							log_info!(
+								self.logger,
+								"Signed funding transaction for channel {} with counterparty {}",
+								channel_id,
+								counterparty_node_id
+							);
+						},
+						Err(e) => {
+							// TODO(splicing): Abort splice once supported in LDK 0.3
+							debug_assert!(false, "Failed signing funding transaction: {:?}", e);
+							log_error!(self.logger, "Failed signing funding transaction: {:?}", e);
+						},
+					}
+				},
+				Err(()) => log_error!(self.logger, "Failed signing funding transaction"),
 			},
 			LdkEvent::SplicePending {
 				channel_id,

src/wallet/mod.rs

@@ -664,6 +664,43 @@ 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) {
+				debug_assert!(!utxo.is_spent);
+				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(());
+			},
+		}
+
+		match psbt.extract_tx() {
+			Ok(tx) => Ok(tx),
+			Err(bitcoin::psbt::ExtractTxError::MissingInputValue { tx }) => Ok(tx),
+			Err(e) => {
+				log_error!(self.logger, "Failed to extract transaction: {}", e);
+				Err(())
+			},
+		}
+	}
+
 	#[allow(deprecated)]
 	fn sign_psbt_inner(&self, mut psbt: Psbt) -> Result<Transaction, ()> {
 		let locked_wallet = self.inner.lock().unwrap();