Add funding_transaction_signed, handle tx_complete

Author: optout21

Diff for: lightning/src/ln/channel.rs

@@ -24,9 +24,9 @@ use bitcoin::hash_types::{Txid, BlockHash};
 use bitcoin::secp256k1::constants::PUBLIC_KEY_SIZE;
 use bitcoin::secp256k1::{PublicKey,SecretKey};
 use bitcoin::secp256k1::{Secp256k1,ecdsa::Signature};
-use bitcoin::{secp256k1, sighash};
+use bitcoin::{secp256k1, sighash, Witness};
 #[cfg(splicing)]
-use bitcoin::{Sequence, Witness};
+use bitcoin::Sequence;
 
 use crate::ln::types::ChannelId;
 use crate::types::payment::{PaymentPreimage, PaymentHash};
@@ -1546,6 +1546,29 @@ impl<SP: Deref> Channel<SP> where
 		}
 	}
 
+	pub fn funding_transaction_signed(&mut self, witnesses: Vec<Witness>) -> Result<Option<msgs::TxSignatures>, APIError> {
+		match &mut self.phase {
+			ChannelPhase::Funded(chan) => {
+				chan.funding_transaction_signed(witnesses)
+			}
+			#[cfg(splicing)]
+			ChannelPhase::RefundingV2(chan) => {
+				if let Some(ref mut post_funded) = &mut chan.post_funded {
+					post_funded.funding_transaction_signed(witnesses)
+				} else {
+					Err(APIError::APIMisuseError {
+						err: "No negotiation in progress, called in wrong state".to_owned()
+					})
+				}
+			}
+			_ => {
+				return Err(APIError::APIMisuseError {
+					err: "Got a funding_transaction_signed call with no funding negotiation in-progress".to_owned()
+				});
+			}
+		}
+	}
+
 	pub fn force_shutdown(&mut self, should_broadcast: bool, closure_reason: ClosureReason) -> ShutdownResult {
 		let (funding, context) = self.funding_and_context_mut();
 		context.force_shutdown(funding, should_broadcast, closure_reason)
@@ -6598,6 +6621,59 @@ impl<SP: Deref> FundedChannel<SP> where
 		return Ok(self.push_ret_blockable_mon_update(monitor_update));
 	}
 
+	/// Check is a splice is currently in progress
+	/// Can be called regardless of `splicing` configuration. TODO: remove this note once `cfg(splicing)` is being removed
+	fn is_splice_pending(&self) -> bool {
+		#[cfg(splicing)]
+		return self.pending_splice_post.is_some();
+		#[cfg(not(splicing))]
+		false
+	}
+
+	pub(super) fn funding_transaction_signed(&mut self, witnesses: Vec<Witness>) -> Result<Option<msgs::TxSignatures>, APIError> {
+		self.verify_interactive_tx_signatures(&witnesses);
+		let is_splice = self.is_splice_pending();
+		if let Some(ref mut signing_session) = self.interactive_tx_signing_session {
+			// Shared signature (used in splicing): holder signature on the prev funding tx input should have been saved.
+			// include it in tlvs field
+			let tlvs = if is_splice {
+				if let Some(s) = signing_session.shared_signature {
+					Some(s)
+				} else {
+					panic!("TODO error!");
+				}
+			} else {
+				None
+			};
+			let (tx_signatures_opt, funding_tx_opt) =
+				signing_session.provide_holder_witnesses(self.context.channel_id(), witnesses, tlvs)
+				.map_err(|_| APIError::APIMisuseError {
+					err: "Internal error in funding_transaction_signed, provide_holder_witnesses".to_owned(),
+				})?;
+			if funding_tx_opt.is_some() {
+				self.funding.funding_transaction = funding_tx_opt.clone();
+				/* TODO
+				#[cfg(splicing)]
+				{
+					self.context.funding_transaction_saved = funding_tx_opt.clone();
+				}
+				*/
+			}
+			Ok(tx_signatures_opt)
+		} else {
+			Err(APIError::APIMisuseError {
+				err: format!("Channel with id {} has no pending signing session, not expecting funding signatures", self.context.channel_id())
+			})
+		}
+	}
+
+	fn verify_interactive_tx_signatures(&mut self, _witnesses: &Vec<Witness>) {
+		if let Some(ref mut _signing_session) = self.interactive_tx_signing_session {
+			// Check that sighash_all was used:
+			// TODO(dual_funding): Check sig for sighash
+		}
+	}
+
 	/// Public version of the below, checking relevant preconditions first.
 	/// If we're not in a state where freeing the holding cell makes sense, this is a no-op and
 	/// returns `(None, Vec::new())`.

Diff for: lightning/src/ln/channelmanager.rs

@@ -5532,9 +5532,36 @@ where
 	/// Do NOT broadcast the funding transaction yourself. When we have safely received our
 	/// counterparty's signature(s) the funding transaction will automatically be broadcast via the
 	/// [`BroadcasterInterface`] provided when this `ChannelManager` was constructed.
-	pub fn funding_transaction_signed(&self, _channel_id: &ChannelId, _counterparty_node_id: &PublicKey,
-		_transaction: Transaction) -> Result<(), APIError> {
-		// TODO(splicing) TODO(dual_funding)
+	pub fn funding_transaction_signed(
+		&self, channel_id: &ChannelId, counterparty_node_id: &PublicKey, transaction: Transaction)
+	-> Result<(), APIError> {
+		let per_peer_state = self.per_peer_state.read().unwrap();
+		let peer_state_mutex = per_peer_state.get(counterparty_node_id)
+			.ok_or_else(|| APIError::ChannelUnavailable {
+				err: format!("Can't find a peer matching the passed counterparty node_id {}",
+					counterparty_node_id) })?;
+
+		let witnesses: Vec<_> = transaction.input.into_iter().filter_map(|input| {
+			if input.witness.is_empty() { None } else { Some(input.witness) }
+		}).collect();
+
+		let mut peer_state_lock = peer_state_mutex.lock().unwrap();
+		let peer_state = &mut *peer_state_lock;
+
+		if let Some(channel) = peer_state.channel_by_id.get_mut(channel_id) {
+			let tx_signatures_opt = channel.funding_transaction_signed(witnesses)?;
+			if let Some(tx_signatures) = tx_signatures_opt {
+				peer_state.pending_msg_events.push(MessageSendEvent::SendTxSignatures {
+					node_id: *counterparty_node_id,
+					msg: tx_signatures,
+				});
+			}
+		} else {
+			return Err(APIError::ChannelUnavailable { err: format!(
+				"Channel with ID {} and counterparty_node_id {} not found", channel_id, counterparty_node_id
+			)});
+		}
+
 		Ok(())
 	}
 
@@ -8565,6 +8592,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 							update_fee: None,
 						},
 					});
+					// channel.set_next_funding_txid(&funding_txid);  // TODO ?
 				}
 				Ok(())
 			},

Diff for: lightning/src/ln/interactivetxs.rs

@@ -302,19 +302,8 @@ pub(crate) struct InteractiveTxSigningSession {
 impl InteractiveTxSigningSession {
 	pub fn received_commitment_signed(&mut self) -> Option<TxSignatures> {
 		self.received_commitment_signed = true;
-		if self.holder_sends_tx_signatures_first {
-			self.holder_tx_signatures.clone()
-		} else {
-			None
-		}
-	}
 
-	pub fn get_tx_signatures(&self) -> Option<TxSignatures> {
-		if self.received_commitment_signed {
-			self.holder_tx_signatures.clone()
-		} else {
-			None
-		}
+		self.get_tx_signatures()
 	}
 
 	/// Handles a `tx_signatures` message received from the counterparty.
@@ -337,22 +326,7 @@ impl InteractiveTxSigningSession {
 		self.unsigned_tx.add_remote_witnesses(tx_signatures.witnesses.clone());
 		self.counterparty_sent_tx_signatures = true;
 
-		let holder_tx_signatures = if !self.holder_sends_tx_signatures_first {
-			self.holder_tx_signatures.clone()
-		} else {
-			None
-		};
-
-		// Check if the holder has provided its signatures and if so,
-		// return the finalized funding transaction.
-		let funding_tx_opt = if self.holder_tx_signatures.is_some() {
-			Some(self.finalize_funding_tx())
-		} else {
-			// This means we're still waiting for the holder to provide their signatures.
-			None
-		};
-
-		Ok((holder_tx_signatures, funding_tx_opt))
+		Ok((self.get_tx_signatures(), self.get_finalized_funding_tx()))
 	}
 
 	/// Provides the holder witnesses for the unsigned transaction.
@@ -362,7 +336,7 @@ impl InteractiveTxSigningSession {
 	pub fn provide_holder_witnesses(
 		&mut self, channel_id: ChannelId, witnesses: Vec<Witness>,
 		shared_input_signature: Option<Signature>,
-	) -> Result<(), ()> {
+	) -> Result<(Option<TxSignatures>, Option<Transaction>), ()> {
 		if self.local_inputs_count() != witnesses.len() {
 			return Err(());
 		}
@@ -375,7 +349,35 @@ impl InteractiveTxSigningSession {
 			shared_input_signature,
 		});
 
-		Ok(())
+		Ok((self.get_tx_signatures(), self.get_finalized_funding_tx()))
+	}
+
+	/// Decide if we need to send `TxSignatures` at this stage or not
+	fn get_tx_signatures(&mut self) -> Option<TxSignatures> {
+		if self.holder_tx_signatures.is_none() {
+			return None; // no local signature yet
+		}
+		if !self.received_commitment_signed {
+			return None; // no counterparty commitment received yet
+		}
+		if (!self.holder_sends_tx_signatures_first && self.counterparty_sent_tx_signatures)
+			|| (self.holder_sends_tx_signatures_first && !self.counterparty_sent_tx_signatures)
+		{
+			self.holder_tx_signatures.clone()
+		} else {
+			None
+		}
+	}
+
+	/// Decide if we have the funding transaction signed from both parties
+	fn get_finalized_funding_tx(&mut self) -> Option<Transaction> {
+		if self.holder_tx_signatures.is_none() {
+			return None; // no local signature yet
+		}
+		if !self.counterparty_sent_tx_signatures {
+			return None; // no counterparty signature received yet
+		}
+		Some(self.finalize_funding_tx())
 	}
 
 	pub fn remote_inputs_count(&self) -> usize {

Diff for: lightning/src/ln/splicing_tests.rs

@@ -50,6 +50,8 @@ fn test_v1_splice_in() {
 	let expect_inputs_in_reverse = true;
 	let expected_pre_funding_txid =
 		"4f128bedf1a15baf465ab1bfd6e97c8f82628f4156bf86eb1cbc132cda6733ae";
+	let expected_splice_funding_txid =
+		"0a6d624a6a6ec0f72e50317856cb8169c1a2272559ba84f20fbb37838c13bf82";
 
 	// ==== Channel is now ready for normal operation
 
@@ -257,7 +259,7 @@ fn test_v1_splice_in() {
 	};
 	let (input_idx_prev_fund, input_idx_second_input) =
 		if expect_inputs_in_reverse { (0, 1) } else { (1, 0) };
-	if let Event::FundingTransactionReadyForSigning {
+	let _channel_id1 = if let Event::FundingTransactionReadyForSigning {
 		channel_id,
 		counterparty_node_id,
 		mut unsigned_transaction,
@@ -286,8 +288,44 @@ fn test_v1_splice_in() {
 			.node
 			.funding_transaction_signed(&channel_id, &counterparty_node_id, unsigned_transaction)
 			.unwrap();
+		channel_id
 	} else {
-		panic!();
+		panic!("Expected event FundingTransactionReadyForSigning");
+	};
+
+	// check new funding tx
+	assert_eq!(initiator_node.node.list_channels().len(), 1);
+	{
+		let channel = &initiator_node.node.list_channels()[0];
+		assert!(!channel.is_channel_ready);
+		assert_eq!(channel.channel_value_satoshis, post_splice_channel_value);
+		assert_eq!(channel.funding_txo.unwrap().txid.to_string(), expected_splice_funding_txid);
+		assert_eq!(channel.confirmations.unwrap(), 0);
+	}
+
+	let _res = acceptor_node
+		.node
+		.handle_tx_complete(initiator_node.node.get_our_node_id(), &tx_complete_msg);
+	let msg_events = acceptor_node.node.get_and_clear_pending_msg_events();
+	// First messsage is commitment_signed, second is tx_signatures (see below for more)
+	assert_eq!(msg_events.len(), 1);
+	let _msg_commitment_signed_from_1 = match msg_events[0] {
+		MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
+			assert_eq!(*node_id, initiator_node.node.get_our_node_id());
+			let res = updates.commitment_signed.clone();
+			res
+		},
+		_ => panic!("Unexpected event {:?}", msg_events[0]),
+	};
+
+	// check new funding tx (acceptor side)
+	assert_eq!(acceptor_node.node.list_channels().len(), 1);
+	{
+		let channel = &acceptor_node.node.list_channels()[0];
+		assert!(!channel.is_channel_ready);
+		assert_eq!(channel.channel_value_satoshis, post_splice_channel_value);
+		assert_eq!(channel.funding_txo.unwrap().txid.to_string(), expected_splice_funding_txid);
+		assert_eq!(channel.confirmations.unwrap(), 0);
 	}
 
 	// TODO(splicing): Continue with commitment flow, new tx confirmation