Use outpoint creation height when restoring locktimed packages

When we have an outpoint to claim which is lock-timed and the
locktime is reached, we add it to
`OnchainTxHandler::claimable_outpoints` to indicate the outpoint is
now being claimed. However, `claimable_outpoints` is supposed to
track when the outpoint first appeared on chain so that we can
remove the claim if the outpoint is reorged out.

Sadly, in the handling for lock-timed packages, we incorrectly
stored the current height in `claimable_outpoints`, causing such
claims to be removed in case of a reorg right after they were
generated, even if the output we intend to claim isn't removed at
all.

Here we use the creation-height tracking added in the previous
commit to actually address the issue, using the tracked height when
adding a claim to `OnchainTxHandler::claimable_outpoints`.

In cases where we have no information, we continue to use the
current height, retaining the issue for locktimed packages on
upgrades, but this simplifies cases where we actually don't have
the information available anyway.

Trivial conflicts resolved in:
 * lightning/src/chain/package.rs

Author: TheBlueMatt

lightning/src/chain/onchaintx.rs

@@ -865,9 +865,10 @@ impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 				// Because fuzzing can cause hash collisions, we can end up with conflicting claim
 				// ids here, so we only assert when not fuzzing.
 				debug_assert!(cfg!(fuzzing) || self.pending_claim_requests.get(&claim_id).is_none());
-				for k in req.outpoints() {
-					log_info!(logger, "Registering claiming request for {}:{}", k.txid, k.vout);
-					self.claimable_outpoints.insert(k.clone(), (claim_id, conf_height));
+				for (k, outpoint_confirmation_height) in req.outpoints_and_creation_heights() {
+					let creation_height = outpoint_confirmation_height.unwrap_or(conf_height);
+					log_info!(logger, "Registering claiming request for {}:{}, which exists as of height {creation_height}", k.txid, k.vout);
+					self.claimable_outpoints.insert(k.clone(), (claim_id, creation_height));
 				}
 				self.pending_claim_requests.insert(claim_id, req);
 			}

lightning/src/chain/package.rs

@@ -603,6 +603,35 @@ impl PackageSolvingData {
 		}
 	}
 
+	fn input_confirmation_height(&self) -> Option<u32> {
+		match self {
+			PackageSolvingData::RevokedOutput(RevokedOutput {
+				outpoint_confirmation_height,
+				..
+			})
+			| PackageSolvingData::RevokedHTLCOutput(RevokedHTLCOutput {
+				outpoint_confirmation_height,
+				..
+			})
+			| PackageSolvingData::CounterpartyOfferedHTLCOutput(CounterpartyOfferedHTLCOutput {
+				outpoint_confirmation_height,
+				..
+			})
+			| PackageSolvingData::CounterpartyReceivedHTLCOutput(
+				CounterpartyReceivedHTLCOutput { outpoint_confirmation_height, .. },
+			)
+			| PackageSolvingData::HolderHTLCOutput(HolderHTLCOutput {
+				outpoint_confirmation_height,
+				..
+			}) => *outpoint_confirmation_height,
+			// We don't bother to track `HolderFundingOutput`'s creation height as its the funding
+			// transaction itself and we build `HolderFundingOutput`s before we actually get the
+			// commitment transaction confirmed.
+			PackageSolvingData::HolderFundingOutput(_) => None,
+		}
+	}
+
+	#[rustfmt::skip]
 	fn as_tx_input(&self, previous_output: BitcoinOutPoint) -> TxIn {
 		let sequence = match self {
 			PackageSolvingData::RevokedOutput(_) => Sequence::ENABLE_RBF_NO_LOCKTIME,
@@ -905,6 +934,12 @@ impl PackageTemplate {
 	pub(crate) fn outpoints(&self) -> Vec<&BitcoinOutPoint> {
 		self.inputs.iter().map(|(o, _)| o).collect()
 	}
+	pub(crate) fn outpoints_and_creation_heights(
+		&self,
+	) -> impl Iterator<Item = (&BitcoinOutPoint, Option<u32>)> {
+		self.inputs.iter().map(|(o, p)| (o, p.input_confirmation_height()))
+	}
+
 	pub(crate) fn inputs(&self) -> impl ExactSizeIterator<Item = &PackageSolvingData> {
 		self.inputs.iter().map(|(_, i)| i)
 	}