Build and broadcast CPFP for HolderCommitmentTx

This commit build a CPFP tx for HolderCommitmentTx and broadcast
them as a whole thus bumping package feerate. A next commit
condition CPFP on feerate fluctuation observation.

Author: Antoine Riard

lightning/src/ln/onchain_utils.rs

@@ -490,15 +490,16 @@ impl PackageTemplate {
 		};
 		bumped_tx.get_weight() + witnesses_weight
 	}
-	pub(crate) fn package_finalize<L: Deref, ChanSigner: ChannelKeys>(&self, onchain_handler: &mut OnchainTxHandler<ChanSigner>, value: u64, destination_script: Script, logger: &L) -> Option<Transaction>
+	pub(crate) fn package_finalize<L: Deref, ChanSigner: ChannelKeys, U: Deref>(&self, onchain_handler: &mut OnchainTxHandler<ChanSigner>, value: u64, destination_script: Script, logger: &L, utxo_pool: &U) -> Option<Vec<Transaction>>
 		where L::Target: Logger,
+		      U::Target: UtxoPool,
 	{
 		let mut bumped_tx = Transaction {
 			version: 2,
 			lock_time: 0,
 			input: vec![],
 			output: vec![TxOut {
-				script_pubkey: destination_script,
+				script_pubkey: destination_script.clone(),
 				value,
 			}],
 		};
@@ -535,7 +536,7 @@ impl PackageTemplate {
 					}
 				}
 				log_trace!(logger, "Going to broadcast Penalty Transaction {}...", bumped_tx.txid());
-				return Some(bumped_tx);
+				return Some(vec![bumped_tx]);
 			},
 			PackageTemplate::CounterpartyHTLCTx { ref inputs } => {
 				for outp in inputs.keys() {
@@ -566,22 +567,73 @@ impl PackageTemplate {
 					}
 				}
 				log_trace!(logger, "Going to broadcast Claim Transaction {} claiming counterparty htlc output...", bumped_tx.txid());
-				return Some(bumped_tx);
+				return Some(vec![bumped_tx]);
 			},
 			PackageTemplate::HolderHTLCTx { ref input } => {
 				let htlc_tx = onchain_handler.get_fully_signed_htlc_tx(&input.0, &input.1.preimage);
 				if let Some(htlc_tx) = htlc_tx {
 					// Timer set to $NEVER given we can't bump tx without anchor outputs
-					log_trace!(logger, "Going to broadcast Holder HTLC-{} claiming HTLC output {} from {}...", if input.1.preimage.is_some() { "Success" } else { "Timeout" }, input.0.vout, input.0.txid);
-					return Some(htlc_tx);
+					log_trace!(logger, "Going to broadcast Local HTLC-{} claiming HTLC output {} from {}...", if input.1.preimage.is_some() { "Success" } else { "Timeout" }, input.0.vout, input.0.txid);
+					return Some(vec![htlc_tx]);
 				}
 				return None;
 			},
-			PackageTemplate::HolderCommitmentTx { ref input, .. } => {
+			PackageTemplate::HolderCommitmentTx { ref input, ref utxo_input } => {
+
+				// We sign our commitment transaction
 				let signed_tx = onchain_handler.get_fully_signed_holder_tx(&input.1.funding_redeemscript).unwrap();
-				// Timer set to $NEVER given we can't bump tx without anchor outputs
+				let mut cpfp_tx = Transaction {
+					version: 2,
+					lock_time: 0,
+					input: Vec::with_capacity(2),
+					output: vec![TxOut {
+						script_pubkey: destination_script.clone(),
+						value,
+					}],
+				};
+				// TODO: make CPFP generation conditional on utxo input
+				if let Some(ref holder_tx) = onchain_handler.holder_commitment.as_ref() {
+					// We find & select our anchor output
+					let our_anchor_output_script = chan_utils::get_anchor_redeemscript(&onchain_handler.key_storage.pubkeys().funding_pubkey);
+					let mut vout = ::std::u32::MAX;
+					for (idx, outp) in holder_tx.unsigned_tx.output.iter().enumerate() {
+						if outp.script_pubkey == our_anchor_output_script.to_v0_p2wsh() {
+							vout = idx as u32;
+						}
+					}
+					if vout == ::std::u32::MAX { return None; }
+					let anchor_outpoint = BitcoinOutPoint {
+						txid: holder_tx.unsigned_tx.txid(),
+						vout,
+					};
+					// We take our bumping outpoint
+					let bumping_outpoint = utxo_input.as_ref().unwrap().0;
+					// We build our CPFP transaction
+					cpfp_tx.input.push(TxIn {
+						previous_output: anchor_outpoint,
+						script_sig: Script::new(),
+						sequence: 0xfffffffd,
+						witness: Vec::new(),
+					});
+					cpfp_tx.input.push(TxIn {
+						previous_output: bumping_outpoint,
+						script_sig: Script::new(),
+						sequence: 0xfffffffd,
+						witness: Vec::new(),
+					});
+					// We sign and witness finalize anchor input
+					if let Ok(anchor_sig) = onchain_handler.key_storage.sign_cpfp(&cpfp_tx, 0, ANCHOR_OUTPUT_VALUE, &onchain_handler.secp_ctx) {
+						cpfp_tx.input[0].witness.push(anchor_sig.serialize_der().to_vec());
+						cpfp_tx.input[0].witness[0].push(SigHashType::All as u8);
+						cpfp_tx.input[0].witness.push(our_anchor_output_script.into_bytes());
+					}
+					//// We sign and witness finalize bumping input
+					if let Ok(witness) = utxo_pool.provide_utxo_witness(&cpfp_tx, 1) {
+						cpfp_tx.input[1].witness = witness;
+					}
+				}
 				log_trace!(logger, "Going to broadcast Holder Transaction {} claiming funding output {} from {}...", signed_tx.txid(), input.0.vout, input.0.txid);
-				return Some(signed_tx);
+				return Some(vec![signed_tx, cpfp_tx]);
 			}
 		}
 	}

lightning/src/ln/onchaintx.rs

@@ -106,7 +106,7 @@ impl Writeable for Option<Vec<Option<(usize, Signature)>>> {
 /// do RBF bumping if possible.
 pub struct OnchainTxHandler<ChanSigner: ChannelKeys> {
 	destination_script: Script,
-	holder_commitment: Option<HolderCommitmentTransaction>,
+	pub(super) holder_commitment: Option<HolderCommitmentTransaction>,
 	// holder_htlc_sigs and prev_holder_htlc_sigs are in the order as they appear in the commitment
 	// transaction outputs (hence the Option<>s inside the Vec). The first usize is the index in
 	// the set of HTLCs in the HolderCommitmentTransaction (including those which do not appear in
@@ -303,7 +303,7 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 
 	/// Lightning security model (i.e being able to redeem/timeout HTLC or penalize coutnerparty onchain) lays on the assumption of claim transactions getting confirmed before timelock expiration
 	/// (CSV or CLTV following cases). In case of high-fee spikes, claim tx may stuck in the mempool, so you need to bump its feerate quickly using Replace-By-Fee or Child-Pay-For-Parent.
-	fn generate_claim_tx<F: Deref, L: Deref, U: Deref>(&mut self, height: u32, cached_request: &mut OnchainRequest, fee_estimator: F, logger: L, utxo_pool: U) -> Option<(Option<u32>, u64, Transaction)>
+	fn generate_claim_tx<F: Deref, L: Deref, U: Deref>(&mut self, height: u32, cached_request: &mut OnchainRequest, fee_estimator: F, logger: L, utxo_pool: U) -> Option<(Option<u32>, u64, Vec<Transaction>)>
 		where F::Target: FeeEstimator,
 					L::Target: Logger,
 		      U::Target: UtxoPool,
@@ -323,15 +323,17 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 		if let Some((output_value, new_feerate)) = onchain_utils::compute_output_value(predicted_weight, amt, cached_request.feerate_previous, &fee_estimator, &logger) {
 			assert!(new_feerate != 0);
 
-			let transaction = cached_request.content.package_finalize(self, output_value, self.destination_script.clone(), &logger).unwrap();
-			log_trace!(logger, "...with timer {} and feerate {}", new_timer.unwrap(), new_feerate);
-			assert!(predicted_weight >= transaction.get_weight());
-			// Temporary: disable timer for CPFP-package
-			if cached_request.bump_strategy == BumpStrategy::CPFP {
+			let txn = cached_request.content.package_finalize(self, output_value, self.destination_script.clone(), &logger, &utxo_pool).unwrap();
+			log_trace!(logger, "...with timer {} weight {} feerate {} CPFP: {}", new_timer.unwrap(), predicted_weight, new_feerate, txn.len() > 1);
+			assert!(predicted_weight >= txn[0].get_weight() + if txn.len() == 2 { txn[1].get_weight() } else { 0 });
+			//TODO: for now disable timer for CPFP-package (2nd-stage HTLC only).
+			// Enabling them is pending on refactoring first holder HTLCs construction 
+			// and signing.
+			if predicted_weight == 706 || predicted_weight == 666 {
 				new_timer = None;
 			}
 
-			return Some((new_timer, new_feerate, transaction))
+			return Some((new_timer, new_feerate, txn))
 		}
 		None
 	}
@@ -365,17 +367,19 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 		// Generate claim transactions and track them to bump if necessary at
 		// height timer expiration (i.e in how many blocks we're going to take action).
 		for mut req in preprocessed_requests {
-			if let Some((new_timer, new_feerate, tx)) = self.generate_claim_tx(height, &mut req, &*fee_estimator, &*logger, &*utxo_pool) {
+			if let Some((new_timer, new_feerate, txn)) = self.generate_claim_tx(height, &mut req, &*fee_estimator, &*logger, &*utxo_pool) {
 				req.height_timer = new_timer;
 				req.feerate_previous = new_feerate;
-				let txid = tx.txid();
+				let txid = txn[0].txid();
 				for k in req.content.outpoints() {
 					log_trace!(logger, "Registering claiming request for {}:{}", k.txid, k.vout);
 					self.claimable_outpoints.insert(k.clone(), (txid, height));
 				}
 				self.pending_claim_requests.insert(txid, req);
-				log_trace!(logger, "Broadcast onchain {}", log_tx!(tx));
-				broadcaster.broadcast_transaction(&tx);
+				for tx in txn {
+					log_trace!(logger, "Broadcast onchain {}", log_tx!(tx));
+					broadcaster.broadcast_transaction(&tx);
+				}
 			}
 		}
 
@@ -492,9 +496,11 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 		// Build, bump and rebroadcast tx accordingly
 		log_trace!(logger, "Bumping {} candidates", bump_candidates.len());
 		for (first_claim_txid, ref mut request) in bump_candidates.iter_mut() {
-			if let Some((new_timer, new_feerate, bump_tx)) = self.generate_claim_tx(height, request, &*fee_estimator, &*logger, &*utxo_pool) {
-				log_trace!(logger, "Broadcast onchain {}", log_tx!(bump_tx));
-				broadcaster.broadcast_transaction(&bump_tx);
+			if let Some((new_timer, new_feerate, txn)) = self.generate_claim_tx(height, request, &*fee_estimator, &*logger, &*utxo_pool) {
+				for tx in txn {
+					log_trace!(logger, "Broadcast onchain {}", log_tx!(tx));
+					broadcaster.broadcast_transaction(&tx);
+				}
 				if let Some(request) = self.pending_claim_requests.get_mut(first_claim_txid) {
 					request.height_timer = new_timer;
 					request.feerate_previous = new_feerate;
@@ -530,10 +536,12 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 			}
 		}
 		for (_, ref mut request) in bump_candidates.iter_mut() {
-			if let Some((new_timer, new_feerate, bump_tx)) = self.generate_claim_tx(height, request, &*fee_estimator, &*logger, &*utxo_pool) {
+			if let Some((new_timer, new_feerate, txn)) = self.generate_claim_tx(height, request, &*fee_estimator, &*logger, &*utxo_pool) {
 				request.height_timer = new_timer;
 				request.feerate_previous = new_feerate;
-				broadcaster.broadcast_transaction(&bump_tx);
+				for tx in txn {
+					broadcaster.broadcast_transaction(&tx);
+				}
 			}
 		}
 		for (ancestor_claim_txid, request) in bump_candidates.drain() {