Allocate UTXO for CPFP-strategy transactions

Pre-committed feerates transactions (commitment, HTLC input-ouput pair)
need the adjunction of an unspent transaction output. This will serve
as a potential bumping input for a CPFP spending also a commitment
transaction anchor output, thus increasing package feerate.

Bumping utxo are only committed when the channel transactions goes
onchain.

Author: Antoine Riard

lightning/src/ln/onchain_utils.rs

@@ -15,6 +15,7 @@ use ln::msgs::DecodeError;
 use ln::onchaintx::OnchainTxHandler;
 use chain::chaininterface::{FeeEstimator, ConfirmationTarget, MIN_RELAY_FEE_SAT_PER_1000_WEIGHT};
 use chain::keysinterface::ChannelKeys;
+use chain::utxointerface::UtxoPool;
 use util::byte_utils;
 use util::logger::Logger;
 use util::ser::{Readable, Writer, Writeable};
@@ -308,6 +309,7 @@ pub(crate) enum PackageTemplate {
 	},
 	HolderCommitmentTx {
 		input: (BitcoinOutPoint, HolderFundingOutput),
+		utxo_input: Option<(BitcoinOutPoint, BumpingOutput)>
 	}
 }
 
@@ -325,7 +327,7 @@ impl PackageTemplate {
 				outpoints.push(&input.0);
 				return outpoints;
 			},
-			PackageTemplate::HolderCommitmentTx { ref input } => {
+			PackageTemplate::HolderCommitmentTx { ref input, ..  } => {
 				let mut outpoints = Vec::with_capacity(1);
 				outpoints.push(&input.0);
 				return outpoints;
@@ -541,14 +543,28 @@ impl PackageTemplate {
 				}
 				return None;
 			},
-			PackageTemplate::HolderCommitmentTx { ref input } => {
+			PackageTemplate::HolderCommitmentTx { ref input, .. } => {
 				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
 				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);
 			}
 		}
 	}
+	pub(crate) fn package_cpfp<U: Deref>(&mut self, utxo_pool: &U)
+		where U::Target: UtxoPool,
+	{
+		match self {
+			PackageTemplate::HolderCommitmentTx { ref mut utxo_input, .. } => {
+				if utxo_input.is_some() { return; }
+				*utxo_input = utxo_pool.allocate_utxo(0);
+			},
+			PackageTemplate::HolderHTLCTx { .. } => {
+				return; //TODO: Should we anchor output HTLC-txn?
+			},
+			_  => panic!("Package template should be bumped through RBF")
+		}
+	}
 	pub(crate) fn build_malleable_justice_tx(per_commitment_point: PublicKey, per_commitment_key: SecretKey, counterparty_delayed_payment_base_key: PublicKey, counterparty_htlc_base_key: PublicKey, input_descriptor: InputDescriptors, txid: Txid, vout: u32, amount: u64, htlc: Option<HTLCOutputInCommitment>, on_counterparty_tx_csv: u16) -> Self {
 		let revk_outp = RevokedOutput {
 			per_commitment_point,
@@ -594,7 +610,8 @@ impl PackageTemplate {
 			funding_redeemscript,
 		};
 		PackageTemplate::HolderCommitmentTx {
-			input: (BitcoinOutPoint { txid, vout }, funding_outp)
+			input: (BitcoinOutPoint { txid, vout }, funding_outp),
+			utxo_input: None,
 		}
 	}
 }
@@ -631,10 +648,11 @@ impl Writeable for PackageTemplate {
 				input.0.write(writer)?;
 				input.1.write(writer)?;
 			},
-			&PackageTemplate::HolderCommitmentTx { ref input } => {
+			&PackageTemplate::HolderCommitmentTx { ref input, ref utxo_input } => {
 				writer.write_all(&[3; 1])?;
 				input.0.write(writer)?;
 				input.1.write(writer)?;
+				utxo_input.write(writer)?;
 			}
 		}
 		Ok(())
@@ -678,8 +696,10 @@ impl Readable for PackageTemplate {
 			3 => {
 				let outpoint = Readable::read(reader)?;
 				let funding_outp = Readable::read(reader)?;
+				let utxo_input = Readable::read(reader)?;
 				PackageTemplate::HolderCommitmentTx {
-					input: (outpoint, funding_outp)
+					input: (outpoint, funding_outp),
+					utxo_input,
 				}
 			},
 			_ => return Err(DecodeError::InvalidValue),

lightning/src/ln/onchaintx.rs

@@ -303,13 +303,17 @@ 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: &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, Transaction)>
 		where F::Target: FeeEstimator,
 					L::Target: Logger,
 		      U::Target: UtxoPool,
 	{
 		if cached_request.content.outpoints().len() == 0 { return None } // But don't prune pending claiming request yet, we may have to resurrect HTLCs
 
+		if cached_request.bump_strategy == BumpStrategy::CPFP {
+			cached_request.content.package_cpfp(&utxo_pool);
+		}
+
 		// Compute new height timer to decide when we need to regenerate a new bumped version of the claim tx (if we
 		// didn't receive confirmation of it before, or not enough reorg-safe depth on top of it).
 		let new_timer = Some(Self::get_height_timer(height, cached_request.absolute_timelock));
@@ -361,7 +365,7 @@ 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, &req, &*fee_estimator, &*logger, &*utxo_pool) {
+			if let Some((new_timer, new_feerate, tx)) = 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();
@@ -487,8 +491,8 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 
 		// Build, bump and rebroadcast tx accordingly
 		log_trace!(logger, "Bumping {} candidates", bump_candidates.len());
-		for (first_claim_txid, request) in bump_candidates.iter() {
-			if let Some((new_timer, new_feerate, bump_tx)) = self.generate_claim_tx(height, &request, &*fee_estimator, &*logger, &*utxo_pool) {
+		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(request) = self.pending_claim_requests.get_mut(first_claim_txid) {
@@ -525,8 +529,8 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 				}
 			}
 		}
-		for (_, 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) {
+		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) {
 				request.height_timer = new_timer;
 				request.feerate_previous = new_feerate;
 				broadcaster.broadcast_transaction(&bump_tx);