Generate ClaimEvent for HolderFundingOutput inputs from anchor channels

wpaulino · wpaulino · commit a1eb3a692b99 · 2022-08-31T14:42:34.000-07:00
diff --git a/lightning/src/chain/onchaintx.rs b/lightning/src/chain/onchaintx.rs
@@ -23,11 +23,12 @@ use bitcoin::secp256k1;
 
 use ln::msgs::DecodeError;
 use ln::PaymentPreimage;
+use ln::chan_utils;
 use ln::chan_utils::{ChannelTransactionParameters, HolderCommitmentTransaction};
-use chain::chaininterface::{FeeEstimator, BroadcasterInterface, LowerBoundedFeeEstimator};
+use chain::chaininterface::{ConfirmationTarget, FeeEstimator, BroadcasterInterface, LowerBoundedFeeEstimator};
 use chain::channelmonitor::{ANTI_REORG_DELAY, CLTV_SHARED_CLAIM_BUFFER};
 use chain::keysinterface::{Sign, KeysInterface};
-use chain::package::PackageTemplate;
+use chain::package::{PackageSolvingData, PackageTemplate};
 use util::logger::Logger;
 use util::ser::{Readable, ReadableArgs, MaybeReadable, Writer, Writeable, VecWriter};
 use util::byte_utils;
@@ -36,6 +37,7 @@ use io;
 use prelude::*;
 use alloc::collections::BTreeMap;
 use core::cmp;
+use core::convert::TryInto;
 use core::ops::Deref;
 use core::mem::replace;
 use bitcoin::hashes::Hash;
@@ -162,8 +164,17 @@ impl Writeable for Option<Vec<Option<(usize, Signature)>>> {
 	}
 }
 
+pub(crate) enum ClaimEvent {
+	BumpCommitment {
+		target_feerate_sat_per_1000_weight: u32,
+		commitment_tx: Transaction,
+		anchor_output_idx: u32,
+	},
+}
+
 pub(crate) enum OnchainClaim {
 	Tx(Transaction),
+	Event(ClaimEvent),
 }
 
 /// OnchainTxHandler receives claiming requests, aggregates them if it's sound, broadcast and
@@ -196,6 +207,7 @@ pub struct OnchainTxHandler<ChannelSigner: Sign> {
 	pub(crate) pending_claim_requests: HashMap<Txid, PackageTemplate>,
 	#[cfg(not(test))]
 	pending_claim_requests: HashMap<Txid, PackageTemplate>,
+	pending_claim_events: HashMap<Txid, ClaimEvent>,
 
 	// Used to link outpoints claimed in a connected block to a pending claim request.
 	// Key is outpoint than monitor parsing has detected we have keys/scripts to claim
@@ -345,6 +357,7 @@ impl<'a, K: KeysInterface> ReadableArgs<&'a K> for OnchainTxHandler<K::Signer> {
 			locktimed_packages,
 			pending_claim_requests,
 			onchain_events_awaiting_threshold_conf,
+			pending_claim_events: HashMap::new(),
 			secp_ctx,
 		})
 	}
@@ -364,6 +377,7 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 			claimable_outpoints: HashMap::new(),
 			locktimed_packages: BTreeMap::new(),
 			onchain_events_awaiting_threshold_conf: Vec::new(),
+			pending_claim_events: HashMap::new(),
 
 			secp_ctx,
 		}
@@ -402,12 +416,63 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 				return Some((new_timer, new_feerate, OnchainClaim::Tx(transaction)))
 			}
 		} else {
-			// Note: Currently, amounts of holder outputs spending witnesses aren't used
-			// as we can't malleate spending package to increase their feerate. This
-			// should change with the remaining anchor output patchset.
-			if let Some(transaction) = cached_request.finalize_untractable_package(self, logger) {
-				return Some((None, 0, OnchainClaim::Tx(transaction)));
+			// Untractable packages cannot have their fees bumped through Replace-By-Fee. Some
+			// packages may support fee bumping through Child-Pays-For-Parent, indicated by those
+			// which require external funding.
+			let inputs = cached_request.inputs();
+			debug_assert_eq!(inputs.len(), 1);
+			let tx = match cached_request.finalize_untractable_package(self, logger) {
+				Some(tx) => tx,
+				None => return None,
+			};
+			if !cached_request.requires_external_funding() {
+				return Some((None, 0, OnchainClaim::Tx(tx)));
 			}
+			return inputs.iter().find_map(|input| match input.solving_data {
+				// Commitment inputs with anchors support are the only untractable inputs supported
+				// thus far that require external funding.
+				PackageSolvingData::HolderFundingOutput(..) => {
+					// We'll locate an anchor output we can spend within the commitment transaction.
+					let commitment_tx = tx.clone();
+					let anchor_script = chan_utils::get_anchor_redeemscript(
+						&self.channel_transaction_parameters.holder_pubkeys.funding_pubkey,
+					).to_v0_p2wsh();
+					match commitment_tx.output.iter().enumerate()
+						.find(|(_, txout)| txout.script_pubkey == anchor_script)
+						.map(|(idx, _)| idx as u32)
+					{
+						// An anchor output was found, so we should yield a funding event externally.
+						Some(anchor_output_idx) => {
+							let target_feerate_sat_per_1000_weight: u32 = match cached_request
+								.compute_package_child_feerate(&tx, fee_estimator, ConfirmationTarget::HighPriority)
+								.map(|f| f.try_into().ok())
+								.flatten()
+							{
+								Some(f) => f,
+								_ => return None,
+							};
+							Some((
+								new_timer,
+								target_feerate_sat_per_1000_weight as u64,
+								OnchainClaim::Event(ClaimEvent::BumpCommitment {
+									target_feerate_sat_per_1000_weight,
+									commitment_tx,
+									anchor_output_idx,
+								}),
+							))
+						},
+						// An anchor output was not found. There's nothing we can do other than
+						// attempt to broadcast the transaction with its current fee rate and hope
+						// it confirms. This is essentially the same behavior as a commitment
+						// transaction without anchor outputs.
+						None => Some((None, 0, OnchainClaim::Tx(commitment_tx))),
+					}
+				},
+				_ => {
+					debug_assert!(false, "Only HolderFundingOutput inputs should be untractable and require external funding");
+					None
+				},
+			});
 		}
 		None
 	}
@@ -481,18 +546,25 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 			if let Some((new_timer, new_feerate, claim)) = self.generate_claim(cur_height, &req, &*fee_estimator, &*logger) {
 				req.set_timer(new_timer);
 				req.set_feerate(new_feerate);
-				match claim {
+				let txid = match claim {
 					OnchainClaim::Tx(tx) => {
-						let txid = tx.txid();
-						for k in req.outpoints() {
-							log_info!(logger, "Registering claiming request for {}:{}", k.txid, k.vout);
-							self.claimable_outpoints.insert(k.clone(), (txid, conf_height));
-						}
-						self.pending_claim_requests.insert(txid, req);
 						log_info!(logger, "Broadcasting onchain {}", log_tx!(tx));
 						broadcaster.broadcast_transaction(&tx);
+						tx.txid()
+					},
+					OnchainClaim::Event(claim_event) => {
+						let txid = match claim_event {
+							ClaimEvent::BumpCommitment { ref commitment_tx, .. } => commitment_tx.txid(),
+						};
+						self.pending_claim_events.insert(txid, claim_event);
+						txid
 					},
+				};
+				for k in req.outpoints() {
+					log_info!(logger, "Registering claiming request for {}:{}", k.txid, k.vout);
+					self.claimable_outpoints.insert(k.clone(), (txid, conf_height));
 				}
+				self.pending_claim_requests.insert(txid, req);
 			}
 		}
 
@@ -584,6 +656,7 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 							for outpoint in request.outpoints() {
 								log_debug!(logger, "Removing claim tracking for {} due to maturation of claim tx {}.", outpoint, claim_request);
 								self.claimable_outpoints.remove(&outpoint);
+								self.pending_claim_events.remove(&claim_request);
 							}
 						}
 					},
@@ -616,6 +689,9 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 						log_info!(logger, "Broadcasting RBF-bumped onchain {}", log_tx!(bump_tx));
 						broadcaster.broadcast_transaction(&bump_tx);
 					},
+					OnchainClaim::Event(claim_event) => {
+						self.pending_claim_events.insert(*first_claim_txid, claim_event);
+					},
 				}
 				if let Some(request) = self.pending_claim_requests.get_mut(first_claim_txid) {
 					request.set_timer(new_timer);
@@ -678,7 +754,7 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 				self.onchain_events_awaiting_threshold_conf.push(entry);
 			}
 		}
-		for (_, request) in bump_candidates.iter_mut() {
+		for (first_claim_txid_height, request) in bump_candidates.iter_mut() {
 			if let Some((new_timer, new_feerate, bump_claim)) = self.generate_claim(height, &request, fee_estimator, &&*logger) {
 				request.set_timer(new_timer);
 				request.set_feerate(new_feerate);
@@ -687,6 +763,9 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 						log_info!(logger, "Broadcasting onchain {}", log_tx!(bump_tx));
 						broadcaster.broadcast_transaction(&bump_tx);
 					},
+					OnchainClaim::Event(claim_event) => {
+						self.pending_claim_events.insert(first_claim_txid_height.0, claim_event);
+					},
 				}
 			}
 		}
diff --git a/lightning/src/chain/package.rs b/lightning/src/chain/package.rs
@@ -316,7 +316,7 @@ impl_writeable_tlv_based_enum!(PackageSolvingData, ;
 
 #[derive(Clone, PartialEq)]
 pub(crate) struct Input {
-	solving_data: PackageSolvingData,
+	pub(crate) solving_data: PackageSolvingData,
 	opt_anchors: bool,
 }
 
@@ -557,6 +557,9 @@ impl PackageTemplate {
 	pub(crate) fn outpoints(&self) -> Vec<&BitcoinOutPoint> {
 		self.inputs.iter().map(|(o, _)| o).collect()
 	}
+	pub(crate) fn inputs(&self) -> Vec<&Input> {
+		self.inputs.iter().map(|(_, i)| i).collect()
+	}
 	pub(crate) fn split_package(&mut self, split_outp: &BitcoinOutPoint) -> Option<PackageTemplate> {
 		match self.malleability {
 			PackageMalleability::Malleable => {
@@ -620,7 +623,7 @@ impl PackageTemplate {
 	}
 	/// Gets the amount of all outptus being spent by this package, only valid for malleable
 	/// packages.
-	fn package_amount(&self) -> u64 {
+	pub(crate) fn package_amount(&self) -> u64 {
 		let mut amounts = 0;
 		for (_, outp) in self.inputs.iter() {
 			amounts += outp.amount();
@@ -733,6 +736,62 @@ impl PackageTemplate {
 		}
 		None
 	}
+
+	pub(crate) fn requires_external_funding(&self) -> bool {
+		self.inputs.iter().find(|input| match input.1.solving_data {
+			PackageSolvingData::HolderFundingOutput(..) => input.1.opt_anchors(),
+			_ => false,
+		}).is_some()
+	}
+
+	/// Computes a feerate based on the given confirmation target. If a previous feerate was used,
+	/// and the new feerate is below it, we'll use a 25% increase of the previous feerate instead of
+	/// the new one.
+	fn compute_feerate<F: Deref>(
+		previous_feerate: u64, fee_estimator: &LowerBoundedFeeEstimator<F>, conf_target: ConfirmationTarget,
+	) -> u64 where F::Target: FeeEstimator {
+		let feerate_estimate = fee_estimator.bounded_sat_per_1000_weight(conf_target);
+		if previous_feerate != 0 {
+			// If old feerate inferior to actual one given back by Fee Estimator, use it to compute new fee...
+			if feerate_estimate as u64 > previous_feerate {
+				feerate_estimate as u64
+			} else {
+				// ...else just increase the previous feerate by 25% (because that's a nice number)
+				previous_feerate + (previous_feerate / 4)
+			}
+		} else {
+			feerate_estimate as u64
+		}
+	}
+
+	/// Computes the feerate for a child transaction such that its parent transaction meets a
+	/// feerate based on the given confirmation target.
+	pub(crate) fn compute_package_child_feerate<F: Deref>(
+		&self, parent: &Transaction, fee_estimator: &LowerBoundedFeeEstimator<F>, conf_target: ConfirmationTarget,
+	) -> Option<u64> where F::Target: FeeEstimator {
+		debug_assert!(!self.is_malleable());
+		let parent_feerate = {
+			let input_amount = self.package_amount();
+			let weight = self.package_weight(
+				&parent.output.iter().map(|outp| &outp.script_pubkey).collect::<Vec<_>>(),
+			);
+			let output_amount = parent.output.iter().fold(0, |acc, outp| acc + outp.value);
+			let fee = input_amount - output_amount;
+			fee / (weight as u64 * 1000)
+		};
+		// The previous feerate tracks the previous child feerate used, so we'll need to map it back
+		// to the overall package feerate.
+		let previous_package_feerate = if self.feerate_previous != 0 {
+			(parent_feerate + self.feerate_previous) / 2
+		} else {
+			0
+		};
+		let package_feerate = Self::compute_feerate(previous_package_feerate, fee_estimator, conf_target);
+		// With the new package feerate obtained, compute the feerate the child transaction must
+		// meet such that the package feerate is met.
+		(package_feerate as u64).checked_mul(2).map(|f| f.checked_sub(parent_feerate)).flatten()
+	}
+
 	pub (crate) fn build_package(txid: Txid, vout: u32, input: Input, soonest_conf_deadline: u32, aggregable: bool, height_original: u32) -> Self {
 		let malleability = match input.solving_data {
 			PackageSolvingData::RevokedOutput(..) => PackageMalleability::Malleable,
