-f Kill OnchainRequest

Author: Antoine Riard

lightning/src/chain/channelmonitor.rs

@@ -43,7 +43,7 @@ use chain::chaininterface::{BroadcasterInterface, FeeEstimator};
 use chain::transaction::{OutPoint, TransactionData};
 use chain::keysinterface::{SpendableOutputDescriptor, StaticPaymentOutputDescriptor, DelayedPaymentOutputDescriptor, Sign, KeysInterface};
 use chain::onchaintx::OnchainTxHandler;
-use chain::onchain_utils::{CounterpartyHTLCOutput, HolderFundingOutput, HolderHTLCOutput, InputDescriptors, OnchainRequest, PackageMalleability, PackageSolvingData, PackageTemplate, RevokedOutput};
+use chain::onchain_utils::{CounterpartyHTLCOutput, HolderFundingOutput, HolderHTLCOutput, InputDescriptors, PackageMalleability, PackageSolvingData, PackageTemplate, RevokedOutput};
 use chain::Filter;
 use util::logger::Logger;
 use util::ser::{Readable, ReadableArgs, MaybeReadable, Writer, Writeable, U48};
@@ -1429,7 +1429,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 	/// HTLC-Success/HTLC-Timeout transactions.
 	/// Return updates for HTLC pending in the channel and failed automatically by the broadcast of
 	/// revoked counterparty commitment tx
-	fn check_spend_counterparty_transaction<L: Deref>(&mut self, tx: &Transaction, height: u32, logger: &L) -> (Vec<OnchainRequest>, (Txid, Vec<(u32, TxOut)>)) where L::Target: Logger {
+	fn check_spend_counterparty_transaction<L: Deref>(&mut self, tx: &Transaction, height: u32, logger: &L) -> (Vec<PackageTemplate>, (Txid, Vec<(u32, TxOut)>)) where L::Target: Logger {
 		// Most secp and related errors trying to create keys means we have no hope of constructing
 		// a spend transaction...so we return no transactions to broadcast
 		let mut claimable_outpoints = Vec::new();
@@ -1463,7 +1463,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 				if outp.script_pubkey == revokeable_p2wsh {
 					let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, InputDescriptors::RevokedOutput, outp.value, None, self.counterparty_tx_cache.on_counterparty_tx_csv);
 					let justice_package = PackageTemplate::build_package(commitment_txid, idx as u32, PackageSolvingData::RevokedOutput(revk_outp), PackageMalleability::Malleable, height + self.counterparty_tx_cache.on_counterparty_tx_csv as u32, true, 0, None, height);
-					claimable_outpoints.push(OnchainRequest { content: justice_package});
+					claimable_outpoints.push(justice_package);
 				}
 			}
 
@@ -1477,7 +1477,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						}
 						let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, if htlc.offered { InputDescriptors::RevokedOfferedHTLC } else { InputDescriptors::RevokedReceivedHTLC }, htlc.amount_msat / 1000, Some(htlc.clone()), self.counterparty_tx_cache.on_counterparty_tx_csv);
 						let justice_package = PackageTemplate::build_package(commitment_txid, transaction_output_index, PackageSolvingData::RevokedOutput(revk_outp), PackageMalleability::Malleable, htlc.cltv_expiry, true, 0, None, height);
-						claimable_outpoints.push(OnchainRequest { content: justice_package});
+						claimable_outpoints.push(justice_package);
 					}
 				}
 			}
@@ -1600,7 +1600,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		(claimable_outpoints, (commitment_txid, watch_outputs))
 	}
 
-	fn get_counterparty_htlc_output_claim_reqs(&self, commitment_number: u64, commitment_txid: Txid, tx: Option<&Transaction>) -> Vec<OnchainRequest> {
+	fn get_counterparty_htlc_output_claim_reqs(&self, commitment_number: u64, commitment_txid: Txid, tx: Option<&Transaction>) -> Vec<PackageTemplate> {
 		let mut claimable_outpoints = Vec::new();
 		if let Some(htlc_outputs) = self.counterparty_claimable_outpoints.get(&commitment_txid) {
 			if let Some(revocation_points) = self.their_cur_revocation_points {
@@ -1627,7 +1627,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 							if preimage.is_some() || !htlc.offered {
 								let counterparty_htlc_outp = CounterpartyHTLCOutput::build(*revocation_point, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, preimage, htlc.clone());
 								let counterparty_package = PackageTemplate::build_package(commitment_txid, transaction_output_index, PackageSolvingData::CounterpartyHTLCOutput(counterparty_htlc_outp), PackageMalleability::Malleable, htlc.cltv_expiry, if !htlc.offered { false } else { true }, 0, None, 0);
-								claimable_outpoints.push(OnchainRequest { content: counterparty_package });
+								claimable_outpoints.push(counterparty_package);
 							}
 						}
 					}
@@ -1638,7 +1638,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 	}
 
 	/// Attempts to claim a counterparty HTLC-Success/HTLC-Timeout's outputs using the revocation key
-	fn check_spend_counterparty_htlc<L: Deref>(&mut self, tx: &Transaction, commitment_number: u64, height: u32, logger: &L) -> (Vec<OnchainRequest>, Option<(Txid, Vec<(u32, TxOut)>)>) where L::Target: Logger {
+	fn check_spend_counterparty_htlc<L: Deref>(&mut self, tx: &Transaction, commitment_number: u64, height: u32, logger: &L) -> (Vec<PackageTemplate>, Option<(Txid, Vec<(u32, TxOut)>)>) where L::Target: Logger {
 		let htlc_txid = tx.txid();
 		if tx.input.len() != 1 || tx.output.len() != 1 || tx.input[0].witness.len() != 5 {
 			return (Vec::new(), None)
@@ -1660,15 +1660,15 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		log_trace!(logger, "Counterparty HTLC broadcast {}:{}", htlc_txid, 0);
 		let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, InputDescriptors::RevokedOutput, tx.output[0].value, None, self.counterparty_tx_cache.on_counterparty_tx_csv);
 		let justice_package = PackageTemplate::build_package(htlc_txid, 0, PackageSolvingData::RevokedOutput(revk_outp), PackageMalleability::Malleable, height + self.counterparty_tx_cache.on_counterparty_tx_csv as u32, true, 0, None, height);
-		let claimable_outpoints = vec!(OnchainRequest { content: justice_package });
+		let claimable_outpoints = vec!(justice_package);
 		let outputs = vec![(0, tx.output[0].clone())];
 		(claimable_outpoints, Some((htlc_txid, outputs)))
 	}
 
-	// Returns (1) `OnchainRequest`s that can be given to the OnChainTxHandler, so that the handler can
+	// Returns (1) `PackageTemplate`s that can be given to the OnChainTxHandler, so that the handler can
 	// broadcast transactions claiming holder HTLC commitment outputs and (2) a holder revokable
 	// script so we can detect whether a holder transaction has been seen on-chain.
-	fn get_broadcasted_holder_claims(&self, holder_tx: &HolderSignedTx, height: u32) -> (Vec<OnchainRequest>, Option<(Script, PublicKey, PublicKey)>) {
+	fn get_broadcasted_holder_claims(&self, holder_tx: &HolderSignedTx, height: u32) -> (Vec<PackageTemplate>, Option<(Script, PublicKey, PublicKey)>) {
 		let mut claim_requests = Vec::with_capacity(holder_tx.htlc_outputs.len());
 
 		let redeemscript = chan_utils::get_revokeable_redeemscript(&holder_tx.revocation_key, self.on_holder_tx_csv, &holder_tx.delayed_payment_key);
@@ -1685,7 +1685,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					}
 				} else { None }, htlc.amount_msat);
 				let htlc_package = PackageTemplate::build_package(holder_tx.txid, transaction_output_index, PackageSolvingData::HolderHTLCOutput(htlc_output), PackageMalleability::Untractable, height, false, 0, None, height);
-				claim_requests.push(OnchainRequest { content: htlc_package });
+				claim_requests.push(htlc_package);
 			}
 		}
 
@@ -1706,7 +1706,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 	/// Attempts to claim any claimable HTLCs in a commitment transaction which was not (yet)
 	/// revoked using data in holder_claimable_outpoints.
 	/// Should not be used if check_spend_revoked_transaction succeeds.
-	fn check_spend_holder_transaction<L: Deref>(&mut self, tx: &Transaction, height: u32, logger: &L) -> (Vec<OnchainRequest>, (Txid, Vec<(u32, TxOut)>)) where L::Target: Logger {
+	fn check_spend_holder_transaction<L: Deref>(&mut self, tx: &Transaction, height: u32, logger: &L) -> (Vec<PackageTemplate>, (Txid, Vec<(u32, TxOut)>)) where L::Target: Logger {
 		let commitment_txid = tx.txid();
 		let mut claim_requests = Vec::new();
 		let mut watch_outputs = Vec::new();
@@ -1894,7 +1894,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		if should_broadcast {
 			let funding_outp = HolderFundingOutput::build(self.funding_redeemscript.clone());
 			let commitment_package = PackageTemplate::build_package(self.funding_info.0.txid.clone(), self.funding_info.0.index as u32, PackageSolvingData::HolderFundingOutput(funding_outp), PackageMalleability::Untractable, height, false, 0, None, height);
-			claimable_outpoints.push(OnchainRequest { content: commitment_package });
+			claimable_outpoints.push(commitment_package);
 		}
 		if should_broadcast {
 			self.pending_monitor_events.push(MonitorEvent::CommitmentTxBroadcasted(self.funding_info.0));

lightning/src/chain/onchain_utils.rs

@@ -475,6 +475,20 @@ impl Readable for PackageMalleability {
 /// the claim-settlement tx in itself has its feerate increased or Child-Pay-For-Parent, a child
 /// of the claim tx has its feerate increased. For the latter case, access to the whole package
 /// sizea and pre-committed fee is required to compute an efficient bump.
+///
+/// Metadata are related to multiple fields playing a role in package lifetime.
+/// Once issued, it may be aggregated with other package if it's judged safe
+/// and feerate opportunistic.
+/// Current LN fees model, pre-committed fees with update_fee adjustement, means
+/// that counter-signed transactions must be CPFP to be dynamically confirmed as a
+/// bumping strategy. If transactions aren't lockdown (i.e justice transactions) we
+/// may RBF them.
+/// Feerate previous will serve as a feerate floor between different bumping attempts.
+/// Height timer clocks these different bumping attempts.
+/// Absolute timelock defines the block barrier at which claiming isn't exclusive
+/// to us anymore and thus we MUST have get it solved before.
+/// Height original serves as a packet timestamps to prune out claim in case of reorg.
+/// Content embeds transactions elements to generate transaction. See PackageTemplate.
 #[derive(Clone, PartialEq)]
 pub(crate) struct PackageTemplate {
 	inputs: Vec<(BitcoinOutPoint, PackageSolvingData)>,
@@ -721,53 +735,6 @@ impl Readable for PackageTemplate {
 	}
 }
 
-/// A structure to describe a claim content and its metadatas which is generated
-/// by ChannelMonitor and used by OnchainTxHandler to generate feerate-competive
-/// transactions.
-///
-/// Metadata are related to multiple fields playing a role in packet lifetime.
-/// Once issued, it may be aggregated with other requests if it's judged safe
-/// and feerate opportunistic.
-/// Current LN fees model, pre-committed fees with update_fee adjustement, means
-/// that counter-signed transactions must be CPFP to be dynamically confirmed as a
-/// bumping strategy. If transactions aren't lockdown (i.e justice transactions) we
-/// may RBF them.
-/// Feerate previous will serve as a feerate floor between different bumping attempts.
-/// Height timer clocks these different bumping attempts.
-/// Absolute timelock defines the block barrier at which claiming isn't exclusive
-/// to us anymore and thus we MUST have get it solved before.
-/// Height original serves as a packet timestamps to prune out claim in case of reorg.
-/// Content embeds transactions elements to generate transaction. See PackageTemplate.
-#[derive(PartialEq, Clone)]
-pub struct OnchainRequest {
-	// Content of request.
-	pub(crate) content: PackageTemplate,
-}
-
-impl OnchainRequest {
-	pub(crate) fn request_merge(&mut self, req: OnchainRequest) {
-		self.content.merge_package(req.content);
-	}
-}
-
-impl Writeable for OnchainRequest {
-	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
-		self.content.write(writer)?;
-
-		Ok(())
-	}
-}
-
-impl Readable for OnchainRequest {
-	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-		let content = Readable::read(reader)?;
-
-		Ok(OnchainRequest {
-			content
-		})
-	}
-}
-
 fn subtract_high_prio_fee<F: Deref, L: Deref>(input_amounts: u64, predicted_weight: usize, fee_estimator: &F, logger: &L) -> Option<(u64, u64)>
 	where F::Target: FeeEstimator,
 	      L::Target: Logger,