WIP: Check all funding transactions

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1864,6 +1864,7 @@ impl FundingScope {
 #[cfg(splicing)]
 struct PendingSplice {
 	pub our_funding_contribution: i64,
+	confirmed_funding_txid: Option<Txid>,
 }
 
 /// Contains everything about the channel including state, and various flags.
@@ -4967,6 +4968,13 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 			_ => todo!()
 		}
 	}
+
+	#[cfg(splicing)]
+	fn check_get_splice_locked<L: Deref>(&mut self, funding: &FundingScope, height: u32, logger: &L) -> Option<msgs::SpliceLocked>
+		where L::Target: Logger
+	{
+		None
+	}
 }
 
 // Internal utility functions for channels
@@ -8287,20 +8295,29 @@ impl<SP: Deref> FundedChannel<SP> where
 		L::Target: Logger
 	{
 		struct ConfirmedFunding<'a> {
+			funding: &'a mut FundingScope,
 			funding_tx: &'a Transaction,
 		}
 
 		let mut confirmed_funding = None;
-		if let Some(funding_txo) = self.funding.get_funding_txo() {
+		let mut confirmed_funding_tx = None;
+		let current_funding_txo = self.funding.get_funding_txo();
+		let funding_iter = core::iter::once(&mut self.funding).chain(self.pending_funding.iter_mut());
+		for (funding, funding_txo) in funding_iter.filter_map(|funding| funding.get_funding_txo().map(|txo| (funding, txo))) {
 			for &(index_in_block, tx) in txdata.iter() {
 				// Check if the transaction is the expected funding transaction, and if it is,
 				// check that it pays the right amount to the right script.
-				if self.funding.funding_tx_confirmation_height == 0 {
+				if funding.funding_tx_confirmation_height == 0 {
 					if tx.compute_txid() == funding_txo.txid {
+						if confirmed_funding_tx.is_some() {
+							let err_reason = "funding tx of another pending funding already confirmed";
+							return Err(ClosureReason::ProcessingError { err: err_reason.to_owned() });
+						}
+
 						let txo_idx = funding_txo.index as usize;
-						if txo_idx >= tx.output.len() || tx.output[txo_idx].script_pubkey != self.funding.get_funding_redeemscript().to_p2wsh() ||
-								tx.output[txo_idx].value.to_sat() != self.funding.get_value_satoshis() {
-							if self.funding.is_outbound() {
+						if txo_idx >= tx.output.len() || tx.output[txo_idx].script_pubkey != funding.get_funding_redeemscript().to_p2wsh() ||
+								tx.output[txo_idx].value.to_sat() != funding.get_value_satoshis() {
+							if funding.is_outbound() {
 								// If we generated the funding transaction and it doesn't match what it
 								// should, the client is really broken and we should just panic and
 								// tell them off. That said, because hash collisions happen with high
@@ -8313,7 +8330,7 @@ impl<SP: Deref> FundedChannel<SP> where
 							let err_reason = "funding tx had wrong script/value or output index";
 							return Err(ClosureReason::ProcessingError { err: err_reason.to_owned() });
 						} else {
-							if self.funding.is_outbound() {
+							if funding.is_outbound() {
 								if !tx.is_coinbase() {
 									for input in tx.input.iter() {
 										if input.witness.is_empty() {
@@ -8326,15 +8343,15 @@ impl<SP: Deref> FundedChannel<SP> where
 								}
 							}
 
-							self.funding.funding_tx_confirmation_height = height;
-							self.funding.funding_tx_confirmed_in = Some(*block_hash);
-							self.funding.short_channel_id = match scid_from_parts(height as u64, index_in_block as u64, txo_idx as u64) {
+							funding.funding_tx_confirmation_height = height;
+							funding.funding_tx_confirmed_in = Some(*block_hash);
+							funding.short_channel_id = match scid_from_parts(height as u64, index_in_block as u64, txo_idx as u64) {
 								Ok(scid) => Some(scid),
 								Err(_) => panic!("Block was bogus - either height was > 16 million, had > 16 million transactions, or had > 65k outputs"),
 							};
 						}
 
-						confirmed_funding = Some(ConfirmedFunding { funding_tx: &tx });
+						confirmed_funding_tx = Some(tx);
 					}
 				}
 				for inp in tx.input.iter() {
@@ -8344,24 +8361,45 @@ impl<SP: Deref> FundedChannel<SP> where
 					}
 				}
 			}
-		}
 
-		if let Some(ConfirmedFunding { funding_tx }) = confirmed_funding {
-			// If this is a coinbase transaction and not a 0-conf channel
-			// we should update our min_depth to 100 to handle coinbase maturity
-			if funding_tx.is_coinbase() &&
-				self.funding.minimum_depth.unwrap_or(0) > 0 &&
-				self.funding.minimum_depth.unwrap_or(0) < COINBASE_MATURITY {
-				self.funding.minimum_depth = Some(COINBASE_MATURITY);
+			if let Some(funding_tx) = confirmed_funding_tx {
+				confirmed_funding = Some(ConfirmedFunding { funding, funding_tx });
 			}
+		}
 
-			// If we allow 1-conf funding, we may need to check for channel_ready here and
-			// send it immediately instead of waiting for a best_block_updated call (which
-			// may have already happened for this block).
-			if let Some(channel_ready) = self.check_get_channel_ready(height, logger) {
-				log_info!(logger, "Sending a channel_ready to our peer for channel {}", &self.context.channel_id);
-				let announcement_sigs = self.get_announcement_sigs(node_signer, chain_hash, user_config, height, logger);
-				return Ok((Some(FundingConfirmedMessage::Establishment(channel_ready)), announcement_sigs));
+		// If we allow 1-conf funding, we may need to check for channel_ready or splice_locked here
+		// and send it immediately instead of waiting for a best_block_updated call (which may have
+		// already happened for this block).
+		if let Some(ConfirmedFunding { funding, funding_tx }) = confirmed_funding {
+			let confirmed_funding_txo = funding.get_funding_txo();
+			if confirmed_funding_txo == current_funding_txo {
+				// If this is a coinbase transaction and not a 0-conf channel
+				// we should update our min_depth to 100 to handle coinbase maturity
+				if funding_tx.is_coinbase() &&
+					funding.minimum_depth.unwrap_or(0) > 0 &&
+					funding.minimum_depth.unwrap_or(0) < COINBASE_MATURITY {
+					funding.minimum_depth = Some(COINBASE_MATURITY);
+				}
+
+				if let Some(channel_ready) = self.check_get_channel_ready(height, logger) {
+					log_info!(logger, "Sending a channel_ready to our peer for channel {}", &self.context.channel_id);
+					let announcement_sigs = self.get_announcement_sigs(node_signer, chain_hash, user_config, height, logger);
+					return Ok((Some(FundingConfirmedMessage::Establishment(channel_ready)), announcement_sigs));
+				}
+			} else {
+			#[cfg(splicing)] {
+				if let Some(pending_splice) = &mut self.pending_splice {
+					pending_splice.confirmed_funding_txid = confirmed_funding_txo.map(|txo| txo.txid);
+					debug_assert!(pending_splice.confirmed_funding_txid.is_some());
+				} else {
+					debug_assert!(false);
+				}
+				if let Some(splice_locked) = self.context.check_get_splice_locked(funding, height, logger) {
+					log_info!(logger, "Sending a splice_locked to our peer for channel {}", &self.context.channel_id);
+					let announcement_sigs = self.context.get_announcement_sigs(funding, node_signer, chain_hash, user_config, height, logger);
+					return Ok((Some(FundingConfirmedMessage::Splice(splice_locked)), announcement_sigs));
+				}
+			}
 			}
 		}
 
@@ -8458,6 +8496,27 @@ impl<SP: Deref> FundedChannel<SP> where
 			return Err(ClosureReason::FundingTimedOut);
 		}
 
+		if let Some(confirmed_funding_txid) = self.pending_splice
+			.as_ref()
+			.and_then(|pending_splice| pending_splice.confirmed_funding_txid)
+		{
+			if let Some((funding, _)) = self.pending_funding
+				.iter()
+				.filter_map(|funding| funding.get_funding_txo().map(|txo| (funding, txo.txid)))
+				.find(|(_, funding_txid)| *funding_txid == confirmed_funding_txid)
+			{
+				if let Some(splice_locked) = self.context.check_get_splice_locked(funding, height, logger) {
+					let announcement_sigs = if let Some((chain_hash, node_signer, user_config)) = chain_node_signer {
+						self.context.get_announcement_sigs(funding, node_signer, chain_hash, user_config, height, logger)
+					} else {
+						None
+					};
+					log_info!(logger, "Sending a splice_locked to our peer for channel {}", &self.context.channel_id);
+					return Ok((Some(FundingConfirmedMessage::Splice(splice_locked)), timed_out_htlcs, announcement_sigs));
+				}
+			}
+		}
+
 		let announcement_sigs = if let Some((chain_hash, node_signer, user_config)) = chain_node_signer {
 			self.get_announcement_sigs(node_signer, chain_hash, user_config, height, logger)
 		} else { None };
@@ -8704,6 +8763,7 @@ impl<SP: Deref> FundedChannel<SP> where
 
 		self.pending_splice = Some(PendingSplice {
 			our_funding_contribution: our_funding_contribution_satoshis,
+			confirmed_funding_txid: None,
 		});
 
 		let msg = self.get_splice_init(our_funding_contribution_satoshis, funding_feerate_per_kw, locktime);

lightning/src/ln/channelmanager.rs

@@ -11664,6 +11664,8 @@ where
 
 pub(super) enum FundingConfirmedMessage {
 	Establishment(msgs::ChannelReady),
+	#[cfg(splicing)]
+	Splice(msgs::SpliceLocked),
 }
 
 impl<M: Deref, T: Deref, ES: Deref, NS: Deref, SP: Deref, F: Deref, R: Deref, MR: Deref, L: Deref> ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
@@ -11725,6 +11727,8 @@ where
 											log_trace!(logger, "Sending channel_ready WITHOUT channel_update for {}", funded_channel.context.channel_id());
 										}
 									},
+									#[cfg(splicing)]
+									Some(FundingConfirmedMessage::Splice(splice_locked)) => {},
 									None => {}
 								}