X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fchain%2Fchannelmonitor.rs;h=28f3b59996c904c202b2bba0a62e476777005529;hb=6ae6d362bb4ba43fe780db90525ed9b554a7eaf8;hp=4225bdee6325b3af5e6ae15b11d5ad28586623fc;hpb=36e9725d9a9e9f71b31f8193daccfc96bb94090a;p=rust-lightning

diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs
index 4225bdee..28f3b599 100644
--- a/lightning/src/chain/channelmonitor.rs
+++ b/lightning/src/chain/channelmonitor.rs
@@ -22,6 +22,7 @@
 
 use bitcoin::blockdata::block::BlockHeader;
 use bitcoin::blockdata::transaction::{TxOut,Transaction};
+use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint;
 use bitcoin::blockdata::script::{Script, Builder};
 use bitcoin::blockdata::opcodes;
 
@@ -36,7 +37,7 @@ use bitcoin::secp256k1;
 use ln::{PaymentHash, PaymentPreimage};
 use ln::msgs::DecodeError;
 use ln::chan_utils;
-use ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCType, ChannelTransactionParameters, HolderCommitmentTransaction};
+use ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction};
 use ln::channelmanager::HTLCSource;
 use chain;
 use chain::{BestBlock, WatchedOutput};
@@ -54,6 +55,7 @@ use util::events::Event;
 use prelude::*;
 use core::{cmp, mem};
 use io::{self, Error};
+use core::convert::TryInto;
 use core::ops::Deref;
 use sync::Mutex;
 
@@ -320,6 +322,7 @@ struct OnchainEventEntry {
 	txid: Txid,
 	height: u32,
 	event: OnchainEvent,
+	transaction: Option<Transaction>, // Added as optional, but always filled in, in LDK 0.0.110
 }
 
 impl OnchainEventEntry {
@@ -349,6 +352,11 @@ impl OnchainEventEntry {
 	}
 }
 
+/// The (output index, sats value) for the counterparty's output in a commitment transaction.
+///
+/// This was added as an `Option` in 0.0.110.
+type CommitmentTxCounterpartyOutputInfo = Option<(u32, u64)>;
+
 /// Upon discovering of some classes of onchain tx by ChannelMonitor, we may have to take actions on it
 /// once they mature to enough confirmations (ANTI_REORG_DELAY)
 #[derive(PartialEq)]
@@ -367,6 +375,8 @@ enum OnchainEvent {
 		/// transaction which appeared on chain.
 		commitment_tx_output_idx: Option<u32>,
 	},
+	/// An output waiting on [`ANTI_REORG_DELAY`] confirmations before we hand the user the
+	/// [`SpendableOutputDescriptor`].
 	MaturingOutput {
 		descriptor: SpendableOutputDescriptor,
 	},
@@ -376,6 +386,12 @@ enum OnchainEvent {
 		/// The CSV delay for the output of the funding spend transaction (implying it is a local
 		/// commitment transaction, and this is the delay on the to_self output).
 		on_local_output_csv: Option<u16>,
+		/// If the funding spend transaction was a known remote commitment transaction, we track
+		/// the output index and amount of the counterparty's `to_self` output here.
+		///
+		/// This allows us to generate a [`Balance::CounterpartyRevokedOutputClaimable`] for the
+		/// counterparty output.
+		commitment_tx_to_counterparty_output: CommitmentTxCounterpartyOutputInfo,
 	},
 	/// A spend of a commitment transaction HTLC output, set in the cases where *no* `HTLCUpdate`
 	/// is constructed. This is used when
@@ -385,6 +401,9 @@ enum OnchainEvent {
 	///  * an inbound HTLC is claimed by us (with a preimage).
 	///  * a revoked-state HTLC transaction was broadcasted, which was claimed by the revocation
 	///    signature.
+	///  * a revoked-state HTLC transaction was broadcasted, which was claimed by an
+	///    HTLC-Success/HTLC-Failure transaction (and is still claimable with a revocation
+	///    signature).
 	HTLCSpendConfirmation {
 		commitment_tx_output_idx: u32,
 		/// If the claim was made by either party with a preimage, this is filled in
@@ -400,6 +419,7 @@ impl Writeable for OnchainEventEntry {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 		write_tlv_fields!(writer, {
 			(0, self.txid, required),
+			(1, self.transaction, option),
 			(2, self.height, required),
 			(4, self.event, required),
 		});
@@ -409,16 +429,18 @@ impl Writeable for OnchainEventEntry {
 
 impl MaybeReadable for OnchainEventEntry {
 	fn read<R: io::Read>(reader: &mut R) -> Result<Option<Self>, DecodeError> {
-		let mut txid = Default::default();
+		let mut txid = Txid::all_zeros();
+		let mut transaction = None;
 		let mut height = 0;
 		let mut event = None;
 		read_tlv_fields!(reader, {
 			(0, txid, required),
+			(1, transaction, option),
 			(2, height, required),
 			(4, event, ignorable),
 		});
 		if let Some(ev) = event {
-			Ok(Some(Self { txid, height, event: ev }))
+			Ok(Some(Self { txid, transaction, height, event: ev }))
 		} else {
 			Ok(None)
 		}
@@ -437,6 +459,7 @@ impl_writeable_tlv_based_enum_upgradable!(OnchainEvent,
 	},
 	(3, FundingSpendConfirmation) => {
 		(0, on_local_output_csv, option),
+		(1, commitment_tx_to_counterparty_output, option),
 	},
 	(5, HTLCSpendConfirmation) => {
 		(0, commitment_tx_output_idx, required),
@@ -560,28 +583,84 @@ pub enum Balance {
 	/// HTLCs which we sent to our counterparty which are claimable after a timeout (less on-chain
 	/// fees) if the counterparty does not know the preimage for the HTLCs. These are somewhat
 	/// likely to be claimed by our counterparty before we do.
-	MaybeClaimableHTLCAwaitingTimeout {
-		/// The amount available to claim, in satoshis, excluding the on-chain fees which will be
-		/// required to do so.
+	MaybeTimeoutClaimableHTLC {
+		/// The amount potentially available to claim, in satoshis, excluding the on-chain fees
+		/// which will be required to do so.
 		claimable_amount_satoshis: u64,
 		/// The height at which we will be able to claim the balance if our counterparty has not
 		/// done so.
 		claimable_height: u32,
 	},
+	/// HTLCs which we received from our counterparty which are claimable with a preimage which we
+	/// do not currently have. This will only be claimable if we receive the preimage from the node
+	/// to which we forwarded this HTLC before the timeout.
+	MaybePreimageClaimableHTLC {
+		/// The amount potentially available to claim, in satoshis, excluding the on-chain fees
+		/// which will be required to do so.
+		claimable_amount_satoshis: u64,
+		/// The height at which our counterparty will be able to claim the balance if we have not
+		/// yet received the preimage and claimed it ourselves.
+		expiry_height: u32,
+	},
+	/// The channel has been closed, and our counterparty broadcasted a revoked commitment
+	/// transaction.
+	///
+	/// Thus, we're able to claim all outputs in the commitment transaction, one of which has the
+	/// following amount.
+	CounterpartyRevokedOutputClaimable {
+		/// The amount, in satoshis, of the output which we can claim.
+		///
+		/// Note that for outputs from HTLC balances this may be excluding some on-chain fees that
+		/// were already spent.
+		claimable_amount_satoshis: u64,
+	},
 }
 
 /// An HTLC which has been irrevocably resolved on-chain, and has reached ANTI_REORG_DELAY.
 #[derive(PartialEq)]
 struct IrrevocablyResolvedHTLC {
-	commitment_tx_output_idx: u32,
+	commitment_tx_output_idx: Option<u32>,
+	/// The txid of the transaction which resolved the HTLC, this may be a commitment (if the HTLC
+	/// was not present in the confirmed commitment transaction), HTLC-Success, or HTLC-Timeout
+	/// transaction.
+	resolving_txid: Option<Txid>, // Added as optional, but always filled in, in 0.0.110
 	/// Only set if the HTLC claim was ours using a payment preimage
 	payment_preimage: Option<PaymentPreimage>,
 }
 
-impl_writeable_tlv_based!(IrrevocablyResolvedHTLC, {
-	(0, commitment_tx_output_idx, required),
-	(2, payment_preimage, option),
-});
+// In LDK versions prior to 0.0.111 commitment_tx_output_idx was not Option-al and
+// IrrevocablyResolvedHTLC objects only existed for non-dust HTLCs. This was a bug, but to maintain
+// backwards compatibility we must ensure we always write out a commitment_tx_output_idx field,
+// using `u32::max_value()` as a sentinal to indicate the HTLC was dust.
+impl Writeable for IrrevocablyResolvedHTLC {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+		let mapped_commitment_tx_output_idx = self.commitment_tx_output_idx.unwrap_or(u32::max_value());
+		write_tlv_fields!(writer, {
+			(0, mapped_commitment_tx_output_idx, required),
+			(1, self.resolving_txid, option),
+			(2, self.payment_preimage, option),
+		});
+		Ok(())
+	}
+}
+
+impl Readable for IrrevocablyResolvedHTLC {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+		let mut mapped_commitment_tx_output_idx = 0;
+		let mut resolving_txid = None;
+		let mut payment_preimage = None;
+		read_tlv_fields!(reader, {
+			(0, mapped_commitment_tx_output_idx, required),
+			(1, resolving_txid, option),
+			(2, payment_preimage, option),
+		});
+		Ok(Self {
+			commitment_tx_output_idx: if mapped_commitment_tx_output_idx == u32::max_value() { None } else { Some(mapped_commitment_tx_output_idx) },
+			resolving_txid,
+			payment_preimage,
+		})
+	}
+}
 
 /// A ChannelMonitor handles chain events (blocks connected and disconnected) and generates
 /// on-chain transactions to ensure no loss of funds occurs.
@@ -714,7 +793,11 @@ pub(crate) struct ChannelMonitorImpl<Signer: Sign> {
 	// of block connection between ChannelMonitors and the ChannelManager.
 	funding_spend_seen: bool,
 
+	/// Set to `Some` of the confirmed transaction spending the funding input of the channel after
+	/// reaching `ANTI_REORG_DELAY` confirmations.
 	funding_spend_confirmed: Option<Txid>,
+
+	confirmed_commitment_tx_counterparty_output: CommitmentTxCounterpartyOutputInfo,
 	/// The set of HTLCs which have been either claimed or failed on chain and have reached
 	/// the requisite confirmations on the claim/fail transaction (either ANTI_REORG_DELAY or the
 	/// spending CSV for revocable outputs).
@@ -784,6 +867,7 @@ impl<Signer: Sign> PartialEq for ChannelMonitorImpl<Signer> {
 			self.holder_tx_signed != other.holder_tx_signed ||
 			self.funding_spend_seen != other.funding_spend_seen ||
 			self.funding_spend_confirmed != other.funding_spend_confirmed ||
+			self.confirmed_commitment_tx_counterparty_output != other.confirmed_commitment_tx_counterparty_output ||
 			self.htlcs_resolved_on_chain != other.htlcs_resolved_on_chain
 		{
 			false
@@ -963,6 +1047,7 @@ impl<Signer: Sign> Writeable for ChannelMonitorImpl<Signer> {
 			(5, self.pending_monitor_events, vec_type),
 			(7, self.funding_spend_seen, required),
 			(9, self.counterparty_node_id, option),
+			(11, self.confirmed_commitment_tx_counterparty_output, option),
 		});
 
 		Ok(())
@@ -1069,6 +1154,7 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 			holder_tx_signed: false,
 			funding_spend_seen: false,
 			funding_spend_confirmed: None,
+			confirmed_commitment_tx_counterparty_output: None,
 			htlcs_resolved_on_chain: Vec::new(),
 
 			best_block,
@@ -1388,7 +1474,155 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 	pub fn current_best_block(&self) -> BestBlock {
 		self.inner.lock().unwrap().best_block.clone()
 	}
+}
+
+impl<Signer: Sign> ChannelMonitorImpl<Signer> {
+	/// Helper for get_claimable_balances which does the work for an individual HTLC, generating up
+	/// to one `Balance` for the HTLC.
+	fn get_htlc_balance(&self, htlc: &HTLCOutputInCommitment, holder_commitment: bool,
+		counterparty_revoked_commitment: bool, confirmed_txid: Option<Txid>)
+	-> Option<Balance> {
+		let htlc_commitment_tx_output_idx =
+			if let Some(v) = htlc.transaction_output_index { v } else { return None; };
+
+		let mut htlc_spend_txid_opt = None;
+		let mut holder_timeout_spend_pending = None;
+		let mut htlc_spend_pending = None;
+		let mut holder_delayed_output_pending = None;
+		for event in self.onchain_events_awaiting_threshold_conf.iter() {
+			match event.event {
+				OnchainEvent::HTLCUpdate { commitment_tx_output_idx, htlc_value_satoshis, .. }
+				if commitment_tx_output_idx == Some(htlc_commitment_tx_output_idx) => {
+					debug_assert!(htlc_spend_txid_opt.is_none());
+					htlc_spend_txid_opt = event.transaction.as_ref().map(|tx| tx.txid());
+					debug_assert!(holder_timeout_spend_pending.is_none());
+					debug_assert_eq!(htlc_value_satoshis.unwrap(), htlc.amount_msat / 1000);
+					holder_timeout_spend_pending = Some(event.confirmation_threshold());
+				},
+				OnchainEvent::HTLCSpendConfirmation { commitment_tx_output_idx, preimage, .. }
+				if commitment_tx_output_idx == htlc_commitment_tx_output_idx => {
+					debug_assert!(htlc_spend_txid_opt.is_none());
+					htlc_spend_txid_opt = event.transaction.as_ref().map(|tx| tx.txid());
+					debug_assert!(htlc_spend_pending.is_none());
+					htlc_spend_pending = Some((event.confirmation_threshold(), preimage.is_some()));
+				},
+				OnchainEvent::MaturingOutput {
+					descriptor: SpendableOutputDescriptor::DelayedPaymentOutput(ref descriptor) }
+				if descriptor.outpoint.index as u32 == htlc_commitment_tx_output_idx => {
+					debug_assert!(holder_delayed_output_pending.is_none());
+					holder_delayed_output_pending = Some(event.confirmation_threshold());
+				},
+				_ => {},
+			}
+		}
+		let htlc_resolved = self.htlcs_resolved_on_chain.iter()
+			.find(|v| if v.commitment_tx_output_idx == Some(htlc_commitment_tx_output_idx) {
+				debug_assert!(htlc_spend_txid_opt.is_none());
+				htlc_spend_txid_opt = v.resolving_txid;
+				true
+			} else { false });
+		debug_assert!(holder_timeout_spend_pending.is_some() as u8 + htlc_spend_pending.is_some() as u8 + htlc_resolved.is_some() as u8 <= 1);
+
+		let htlc_output_to_spend =
+			if let Some(txid) = htlc_spend_txid_opt {
+				debug_assert!(
+					self.onchain_tx_handler.channel_transaction_parameters.opt_anchors.is_none(),
+					"This code needs updating for anchors");
+				BitcoinOutPoint::new(txid, 0)
+			} else {
+				BitcoinOutPoint::new(confirmed_txid.unwrap(), htlc_commitment_tx_output_idx)
+			};
+		let htlc_output_spend_pending = self.onchain_tx_handler.is_output_spend_pending(&htlc_output_to_spend);
+
+		if let Some(conf_thresh) = holder_delayed_output_pending {
+			debug_assert!(holder_commitment);
+			return Some(Balance::ClaimableAwaitingConfirmations {
+				claimable_amount_satoshis: htlc.amount_msat / 1000,
+				confirmation_height: conf_thresh,
+			});
+		} else if htlc_resolved.is_some() && !htlc_output_spend_pending {
+			// Funding transaction spends should be fully confirmed by the time any
+			// HTLC transactions are resolved, unless we're talking about a holder
+			// commitment tx, whose resolution is delayed until the CSV timeout is
+			// reached, even though HTLCs may be resolved after only
+			// ANTI_REORG_DELAY confirmations.
+			debug_assert!(holder_commitment || self.funding_spend_confirmed.is_some());
+		} else if counterparty_revoked_commitment {
+			let htlc_output_claim_pending = self.onchain_events_awaiting_threshold_conf.iter().find_map(|event| {
+				if let OnchainEvent::MaturingOutput {
+					descriptor: SpendableOutputDescriptor::StaticOutput { .. }
+				} = &event.event {
+					if event.transaction.as_ref().map(|tx| tx.input.iter().any(|inp| {
+						if let Some(htlc_spend_txid) = htlc_spend_txid_opt {
+							Some(tx.txid()) == htlc_spend_txid_opt ||
+								inp.previous_output.txid == htlc_spend_txid
+						} else {
+							Some(inp.previous_output.txid) == confirmed_txid &&
+								inp.previous_output.vout == htlc_commitment_tx_output_idx
+						}
+					})).unwrap_or(false) {
+						Some(())
+					} else { None }
+				} else { None }
+			});
+			if htlc_output_claim_pending.is_some() {
+				// We already push `Balance`s onto the `res` list for every
+				// `StaticOutput` in a `MaturingOutput` in the revoked
+				// counterparty commitment transaction case generally, so don't
+				// need to do so again here.
+			} else {
+				debug_assert!(holder_timeout_spend_pending.is_none(),
+					"HTLCUpdate OnchainEvents should never appear for preimage claims");
+				debug_assert!(!htlc.offered || htlc_spend_pending.is_none() || !htlc_spend_pending.unwrap().1,
+					"We don't (currently) generate preimage claims against revoked outputs, where did you get one?!");
+				return Some(Balance::CounterpartyRevokedOutputClaimable {
+					claimable_amount_satoshis: htlc.amount_msat / 1000,
+				});
+			}
+		} else if htlc.offered == holder_commitment {
+			// If the payment was outbound, check if there's an HTLCUpdate
+			// indicating we have spent this HTLC with a timeout, claiming it back
+			// and awaiting confirmations on it.
+			if let Some(conf_thresh) = holder_timeout_spend_pending {
+				return Some(Balance::ClaimableAwaitingConfirmations {
+					claimable_amount_satoshis: htlc.amount_msat / 1000,
+					confirmation_height: conf_thresh,
+				});
+			} else {
+				return Some(Balance::MaybeTimeoutClaimableHTLC {
+					claimable_amount_satoshis: htlc.amount_msat / 1000,
+					claimable_height: htlc.cltv_expiry,
+				});
+			}
+		} else if self.payment_preimages.get(&htlc.payment_hash).is_some() {
+			// Otherwise (the payment was inbound), only expose it as claimable if
+			// we know the preimage.
+			// Note that if there is a pending claim, but it did not use the
+			// preimage, we lost funds to our counterparty! We will then continue
+			// to show it as ContentiousClaimable until ANTI_REORG_DELAY.
+			debug_assert!(holder_timeout_spend_pending.is_none());
+			if let Some((conf_thresh, true)) = htlc_spend_pending {
+				return Some(Balance::ClaimableAwaitingConfirmations {
+					claimable_amount_satoshis: htlc.amount_msat / 1000,
+					confirmation_height: conf_thresh,
+				});
+			} else {
+				return Some(Balance::ContentiousClaimable {
+					claimable_amount_satoshis: htlc.amount_msat / 1000,
+					timeout_height: htlc.cltv_expiry,
+				});
+			}
+		} else if htlc_resolved.is_none() {
+			return Some(Balance::MaybePreimageClaimableHTLC {
+				claimable_amount_satoshis: htlc.amount_msat / 1000,
+				expiry_height: htlc.cltv_expiry,
+			});
+		}
+		None
+	}
+}
 
+impl<Signer: Sign> ChannelMonitor<Signer> {
 	/// Gets the balances in this channel which are either claimable by us if we were to
 	/// force-close the channel now or which are claimable on-chain (possibly awaiting
 	/// confirmation).
@@ -1398,9 +1632,9 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 	/// balance, or until our counterparty has claimed the balance and accrued several
 	/// confirmations on the claim transaction.
 	///
-	/// Note that the balances available when you or your counterparty have broadcasted revoked
-	/// state(s) may not be fully captured here.
-	// TODO, fix that ^
+	/// Note that for `ChannelMonitors` which track a channel which went on-chain with versions of
+	/// LDK prior to 0.0.111, balances may not be fully captured if our counterparty broadcasted
+	/// a revoked state.
 	///
 	/// See [`Balance`] for additional details on the types of claimable balances which
 	/// may be returned here and their meanings.
@@ -1409,9 +1643,13 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		let us = self.inner.lock().unwrap();
 
 		let mut confirmed_txid = us.funding_spend_confirmed;
+		let mut confirmed_counterparty_output = us.confirmed_commitment_tx_counterparty_output;
 		let mut pending_commitment_tx_conf_thresh = None;
 		let funding_spend_pending = us.onchain_events_awaiting_threshold_conf.iter().find_map(|event| {
-			if let OnchainEvent::FundingSpendConfirmation { .. } = event.event {
+			if let OnchainEvent::FundingSpendConfirmation { commitment_tx_to_counterparty_output, .. } =
+				event.event
+			{
+				confirmed_counterparty_output = commitment_tx_to_counterparty_output;
 				Some((event.txid, event.confirmation_threshold()))
 			} else { None }
 		});
@@ -1423,71 +1661,12 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		}
 
 		macro_rules! walk_htlcs {
-			($holder_commitment: expr, $htlc_iter: expr) => {
+			($holder_commitment: expr, $counterparty_revoked_commitment: expr, $htlc_iter: expr) => {
 				for htlc in $htlc_iter {
-					if let Some(htlc_commitment_tx_output_idx) = htlc.transaction_output_index {
-						if let Some(conf_thresh) = us.onchain_events_awaiting_threshold_conf.iter().find_map(|event| {
-							if let OnchainEvent::MaturingOutput { descriptor: SpendableOutputDescriptor::DelayedPaymentOutput(descriptor) } = &event.event {
-								if descriptor.outpoint.index as u32 == htlc_commitment_tx_output_idx { Some(event.confirmation_threshold()) } else { None }
-							} else { None }
-						}) {
-							debug_assert!($holder_commitment);
-							res.push(Balance::ClaimableAwaitingConfirmations {
-								claimable_amount_satoshis: htlc.amount_msat / 1000,
-								confirmation_height: conf_thresh,
-							});
-						} else if us.htlcs_resolved_on_chain.iter().any(|v| v.commitment_tx_output_idx == htlc_commitment_tx_output_idx) {
-							// Funding transaction spends should be fully confirmed by the time any
-							// HTLC transactions are resolved, unless we're talking about a holder
-							// commitment tx, whose resolution is delayed until the CSV timeout is
-							// reached, even though HTLCs may be resolved after only
-							// ANTI_REORG_DELAY confirmations.
-							debug_assert!($holder_commitment || us.funding_spend_confirmed.is_some());
-						} else if htlc.offered == $holder_commitment {
-							// If the payment was outbound, check if there's an HTLCUpdate
-							// indicating we have spent this HTLC with a timeout, claiming it back
-							// and awaiting confirmations on it.
-							let htlc_update_pending = us.onchain_events_awaiting_threshold_conf.iter().find_map(|event| {
-								if let OnchainEvent::HTLCUpdate { commitment_tx_output_idx: Some(commitment_tx_output_idx), .. } = event.event {
-									if commitment_tx_output_idx == htlc_commitment_tx_output_idx {
-										Some(event.confirmation_threshold()) } else { None }
-								} else { None }
-							});
-							if let Some(conf_thresh) = htlc_update_pending {
-								res.push(Balance::ClaimableAwaitingConfirmations {
-									claimable_amount_satoshis: htlc.amount_msat / 1000,
-									confirmation_height: conf_thresh,
-								});
-							} else {
-								res.push(Balance::MaybeClaimableHTLCAwaitingTimeout {
-									claimable_amount_satoshis: htlc.amount_msat / 1000,
-									claimable_height: htlc.cltv_expiry,
-								});
-							}
-						} else if us.payment_preimages.get(&htlc.payment_hash).is_some() {
-							// Otherwise (the payment was inbound), only expose it as claimable if
-							// we know the preimage.
-							// Note that if there is a pending claim, but it did not use the
-							// preimage, we lost funds to our counterparty! We will then continue
-							// to show it as ContentiousClaimable until ANTI_REORG_DELAY.
-							let htlc_spend_pending = us.onchain_events_awaiting_threshold_conf.iter().find_map(|event| {
-								if let OnchainEvent::HTLCSpendConfirmation { commitment_tx_output_idx, preimage, .. } = event.event {
-									if commitment_tx_output_idx == htlc_commitment_tx_output_idx {
-										Some((event.confirmation_threshold(), preimage.is_some()))
-									} else { None }
-								} else { None }
-							});
-							if let Some((conf_thresh, true)) = htlc_spend_pending {
-								res.push(Balance::ClaimableAwaitingConfirmations {
-									claimable_amount_satoshis: htlc.amount_msat / 1000,
-									confirmation_height: conf_thresh,
-								});
-							} else {
-								res.push(Balance::ContentiousClaimable {
-									claimable_amount_satoshis: htlc.amount_msat / 1000,
-									timeout_height: htlc.cltv_expiry,
-								});
-							}
+					if htlc.transaction_output_index.is_some() {
+
+						if let Some(bal) = us.get_htlc_balance(htlc, $holder_commitment, $counterparty_revoked_commitment, confirmed_txid) {
+							res.push(bal);
 						}
 					}
 				}
@@ -1496,8 +1675,8 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 
 		if let Some(txid) = confirmed_txid {
 			let mut found_commitment_tx = false;
-			if Some(txid) == us.current_counterparty_commitment_txid || Some(txid) == us.prev_counterparty_commitment_txid {
-				walk_htlcs!(false, us.counterparty_claimable_outpoints.get(&txid).unwrap().iter().map(|(a, _)| a));
+			if let Some(counterparty_tx_htlcs) = us.counterparty_claimable_outpoints.get(&txid) {
+				// First look for the to_remote output back to us.
 				if let Some(conf_thresh) = pending_commitment_tx_conf_thresh {
 					if let Some(value) = us.onchain_events_awaiting_threshold_conf.iter().find_map(|event| {
 						if let OnchainEvent::MaturingOutput {
@@ -1516,9 +1695,50 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 						// confirmation with the same height or have never met our dust amount.
 					}
 				}
+				if Some(txid) == us.current_counterparty_commitment_txid || Some(txid) == us.prev_counterparty_commitment_txid {
+					walk_htlcs!(false, false, counterparty_tx_htlcs.iter().map(|(a, _)| a));
+				} else {
+					walk_htlcs!(false, true, counterparty_tx_htlcs.iter().map(|(a, _)| a));
+					// The counterparty broadcasted a revoked state!
+					// Look for any StaticOutputs first, generating claimable balances for those.
+					// If any match the confirmed counterparty revoked to_self output, skip
+					// generating a CounterpartyRevokedOutputClaimable.
+					let mut spent_counterparty_output = false;
+					for event in us.onchain_events_awaiting_threshold_conf.iter() {
+						if let OnchainEvent::MaturingOutput {
+							descriptor: SpendableOutputDescriptor::StaticOutput { output, .. }
+						} = &event.event {
+							res.push(Balance::ClaimableAwaitingConfirmations {
+								claimable_amount_satoshis: output.value,
+								confirmation_height: event.confirmation_threshold(),
+							});
+							if let Some(confirmed_to_self_idx) = confirmed_counterparty_output.map(|(idx, _)| idx) {
+								if event.transaction.as_ref().map(|tx|
+									tx.input.iter().any(|inp| inp.previous_output.vout == confirmed_to_self_idx)
+								).unwrap_or(false) {
+									spent_counterparty_output = true;
+								}
+							}
+						}
+					}
+
+					if spent_counterparty_output {
+					} else if let Some((confirmed_to_self_idx, amt)) = confirmed_counterparty_output {
+						let output_spendable = us.onchain_tx_handler
+							.is_output_spend_pending(&BitcoinOutPoint::new(txid, confirmed_to_self_idx));
+						if output_spendable {
+							res.push(Balance::CounterpartyRevokedOutputClaimable {
+								claimable_amount_satoshis: amt,
+							});
+						}
+					} else {
+						// Counterparty output is missing, either it was broadcasted on a
+						// previous version of LDK or the counterparty hadn't met dust.
+					}
+				}
 				found_commitment_tx = true;
 			} else if txid == us.current_holder_commitment_tx.txid {
-				walk_htlcs!(true, us.current_holder_commitment_tx.htlc_outputs.iter().map(|(a, _, _)| a));
+				walk_htlcs!(true, false, us.current_holder_commitment_tx.htlc_outputs.iter().map(|(a, _, _)| a));
 				if let Some(conf_thresh) = pending_commitment_tx_conf_thresh {
 					res.push(Balance::ClaimableAwaitingConfirmations {
 						claimable_amount_satoshis: us.current_holder_commitment_tx.to_self_value_sat,
@@ -1528,7 +1748,7 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 				found_commitment_tx = true;
 			} else if let Some(prev_commitment) = &us.prev_holder_signed_commitment_tx {
 				if txid == prev_commitment.txid {
-					walk_htlcs!(true, prev_commitment.htlc_outputs.iter().map(|(a, _, _)| a));
+					walk_htlcs!(true, false, prev_commitment.htlc_outputs.iter().map(|(a, _, _)| a));
 					if let Some(conf_thresh) = pending_commitment_tx_conf_thresh {
 						res.push(Balance::ClaimableAwaitingConfirmations {
 							claimable_amount_satoshis: prev_commitment.to_self_value_sat,
@@ -1549,19 +1769,24 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 					});
 				}
 			}
-			// TODO: Add logic to provide claimable balances for counterparty broadcasting revoked
-			// outputs.
 		} else {
 			let mut claimable_inbound_htlc_value_sat = 0;
 			for (htlc, _, _) in us.current_holder_commitment_tx.htlc_outputs.iter() {
 				if htlc.transaction_output_index.is_none() { continue; }
 				if htlc.offered {
-					res.push(Balance::MaybeClaimableHTLCAwaitingTimeout {
+					res.push(Balance::MaybeTimeoutClaimableHTLC {
 						claimable_amount_satoshis: htlc.amount_msat / 1000,
 						claimable_height: htlc.cltv_expiry,
 					});
 				} else if us.payment_preimages.get(&htlc.payment_hash).is_some() {
 					claimable_inbound_htlc_value_sat += htlc.amount_msat / 1000;
+				} else {
+					// As long as the HTLC is still in our latest commitment state, treat
+					// it as potentially claimable, even if it has long-since expired.
+					res.push(Balance::MaybePreimageClaimableHTLC {
+						claimable_amount_satoshis: htlc.amount_msat / 1000,
+						expiry_height: htlc.cltv_expiry,
+					});
 				}
 			}
 			res.push(Balance::ClaimableOnChannelClose {
@@ -1581,7 +1806,7 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		macro_rules! walk_htlcs {
 			($holder_commitment: expr, $htlc_iter: expr) => {
 				for (htlc, source) in $htlc_iter {
-					if us.htlcs_resolved_on_chain.iter().any(|v| Some(v.commitment_tx_output_idx) == htlc.transaction_output_index) {
+					if us.htlcs_resolved_on_chain.iter().any(|v| v.commitment_tx_output_idx == htlc.transaction_output_index) {
 						// We should assert that funding_spend_confirmed is_some() here, but we
 						// have some unit tests which violate HTLC transaction CSVs entirely and
 						// would fail.
@@ -1688,8 +1913,10 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 /// as long as we examine both the current counterparty commitment transaction and, if it hasn't
 /// been revoked yet, the previous one, we we will never "forget" to resolve an HTLC.
 macro_rules! fail_unbroadcast_htlcs {
-	($self: expr, $commitment_tx_type: expr, $commitment_txid_confirmed: expr,
+	($self: expr, $commitment_tx_type: expr, $commitment_txid_confirmed: expr, $commitment_tx_confirmed: expr,
 	 $commitment_tx_conf_height: expr, $confirmed_htlcs_list: expr, $logger: expr) => { {
+		debug_assert_eq!($commitment_tx_confirmed.txid(), $commitment_txid_confirmed);
+
 		macro_rules! check_htlc_fails {
 			($txid: expr, $commitment_tx: expr) => {
 				if let Some(ref latest_outpoints) = $self.counterparty_claimable_outpoints.get($txid) {
@@ -1729,6 +1956,7 @@ macro_rules! fail_unbroadcast_htlcs {
 							});
 							let entry = OnchainEventEntry {
 								txid: $commitment_txid_confirmed,
+								transaction: Some($commitment_tx_confirmed.clone()),
 								height: $commitment_tx_conf_height,
 								event: OnchainEvent::HTLCUpdate {
 									source: (**source).clone(),
@@ -1761,12 +1989,12 @@ macro_rules! fail_unbroadcast_htlcs {
 
 #[cfg(test)]
 pub fn deliberately_bogus_accepted_htlc_witness_program() -> Vec<u8> {
-	let mut ret = [opcodes::all::OP_NOP.into_u8(); 136];
-	ret[131] = opcodes::all::OP_DROP.into_u8();
-	ret[132] = opcodes::all::OP_DROP.into_u8();
-	ret[133] = opcodes::all::OP_DROP.into_u8();
-	ret[134] = opcodes::all::OP_DROP.into_u8();
-	ret[135] = opcodes::OP_TRUE.into_u8();
+	let mut ret = [opcodes::all::OP_NOP.to_u8(); 136];
+	ret[131] = opcodes::all::OP_DROP.to_u8();
+	ret[132] = opcodes::all::OP_DROP.to_u8();
+	ret[133] = opcodes::all::OP_DROP.to_u8();
+	ret[134] = opcodes::all::OP_DROP.to_u8();
+	ret[135] = opcodes::OP_TRUE.to_u8();
 	Vec::from(&ret[..])
 }
 
@@ -1916,7 +2144,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		// First check if a counterparty commitment transaction has been broadcasted:
 		macro_rules! claim_htlcs {
 			($commitment_number: expr, $txid: expr) => {
-				let htlc_claim_reqs = self.get_counterparty_htlc_output_claim_reqs($commitment_number, $txid, None);
+				let (htlc_claim_reqs, _) = self.get_counterparty_output_claim_info($commitment_number, $txid, None);
 				self.onchain_tx_handler.update_claims_view(&Vec::new(), htlc_claim_reqs, self.best_block.height(), self.best_block.height(), broadcaster, fee_estimator, logger);
 			}
 		}
@@ -2095,13 +2323,18 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 	/// data in counterparty_claimable_outpoints. Will directly claim any HTLC outputs which expire at a
 	/// height > height + CLTV_SHARED_CLAIM_BUFFER. In any case, will install monitoring for
 	/// 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<PackageTemplate>, TransactionOutputs) where L::Target: Logger {
+	///
+	/// Returns packages to claim the revoked output(s), as well as additional outputs to watch and
+	/// general information about the output that is to the counterparty in the commitment
+	/// transaction.
+	fn check_spend_counterparty_transaction<L: Deref>(&mut self, tx: &Transaction, height: u32, logger: &L)
+		-> (Vec<PackageTemplate>, TransactionOutputs, CommitmentTxCounterpartyOutputInfo)
+	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();
 		let mut watch_outputs = Vec::new();
+		let mut to_counterparty_output_info = None;
 
 		let commitment_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers!
 		let per_commitment_option = self.counterparty_claimable_outpoints.get(&commitment_txid);
@@ -2110,12 +2343,12 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			( $thing : expr ) => {
 				match $thing {
 					Ok(a) => a,
-					Err(_) => return (claimable_outpoints, (commitment_txid, watch_outputs))
+					Err(_) => return (claimable_outpoints, (commitment_txid, watch_outputs), to_counterparty_output_info)
 				}
 			};
 		}
 
-		let commitment_number = 0xffffffffffff - ((((tx.input[0].sequence as u64 & 0xffffff) << 3*8) | (tx.lock_time as u64 & 0xffffff)) ^ self.commitment_transaction_number_obscure_factor);
+		let commitment_number = 0xffffffffffff - ((((tx.input[0].sequence.0 as u64 & 0xffffff) << 3*8) | (tx.lock_time.0 as u64 & 0xffffff)) ^ self.commitment_transaction_number_obscure_factor);
 		if commitment_number >= self.get_min_seen_secret() {
 			let secret = self.get_secret(commitment_number).unwrap();
 			let per_commitment_key = ignore_error!(SecretKey::from_slice(&secret));
@@ -2132,6 +2365,8 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					let revk_outp = RevokedOutput::build(per_commitment_point, self.counterparty_commitment_params.counterparty_delayed_payment_base_key, self.counterparty_commitment_params.counterparty_htlc_base_key, per_commitment_key, outp.value, self.counterparty_commitment_params.on_counterparty_tx_csv);
 					let justice_package = PackageTemplate::build_package(commitment_txid, idx as u32, PackageSolvingData::RevokedOutput(revk_outp), height + self.counterparty_commitment_params.on_counterparty_tx_csv as u32, true, height);
 					claimable_outpoints.push(justice_package);
+					to_counterparty_output_info =
+						Some((idx.try_into().expect("Txn can't have more than 2^32 outputs"), outp.value));
 				}
 			}
 
@@ -2141,7 +2376,9 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					if let Some(transaction_output_index) = htlc.transaction_output_index {
 						if transaction_output_index as usize >= tx.output.len() ||
 								tx.output[transaction_output_index as usize].value != htlc.amount_msat / 1000 {
-							return (claimable_outpoints, (commitment_txid, watch_outputs)); // Corrupted per_commitment_data, fuck this user
+							// per_commitment_data is corrupt or our commitment signing key leaked!
+							return (claimable_outpoints, (commitment_txid, watch_outputs),
+								to_counterparty_output_info);
 						}
 						let revk_htlc_outp = RevokedHTLCOutput::build(per_commitment_point, self.counterparty_commitment_params.counterparty_delayed_payment_base_key, self.counterparty_commitment_params.counterparty_htlc_base_key, per_commitment_key, htlc.amount_msat / 1000, htlc.clone(), self.onchain_tx_handler.channel_transaction_parameters.opt_anchors.is_some());
 						let justice_package = PackageTemplate::build_package(commitment_txid, transaction_output_index, PackageSolvingData::RevokedHTLCOutput(revk_htlc_outp), htlc.cltv_expiry, true, height);
@@ -2160,13 +2397,13 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 				self.counterparty_commitment_txn_on_chain.insert(commitment_txid, commitment_number);
 
 				if let Some(per_commitment_data) = per_commitment_option {
-					fail_unbroadcast_htlcs!(self, "revoked_counterparty", commitment_txid, height,
+					fail_unbroadcast_htlcs!(self, "revoked_counterparty", commitment_txid, tx, height,
 						per_commitment_data.iter().map(|(htlc, htlc_source)|
 							(htlc, htlc_source.as_ref().map(|htlc_source| htlc_source.as_ref()))
 						), logger);
 				} else {
 					debug_assert!(false, "We should have per-commitment option for any recognized old commitment txn");
-					fail_unbroadcast_htlcs!(self, "revoked counterparty", commitment_txid, height,
+					fail_unbroadcast_htlcs!(self, "revoked counterparty", commitment_txid, tx, height,
 						[].iter().map(|reference| *reference), logger);
 				}
 			}
@@ -2184,68 +2421,112 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			self.counterparty_commitment_txn_on_chain.insert(commitment_txid, commitment_number);
 
 			log_info!(logger, "Got broadcast of non-revoked counterparty commitment transaction {}", commitment_txid);
-			fail_unbroadcast_htlcs!(self, "counterparty", commitment_txid, height,
+			fail_unbroadcast_htlcs!(self, "counterparty", commitment_txid, tx, height,
 				per_commitment_data.iter().map(|(htlc, htlc_source)|
 					(htlc, htlc_source.as_ref().map(|htlc_source| htlc_source.as_ref()))
 				), logger);
 
-			let htlc_claim_reqs = self.get_counterparty_htlc_output_claim_reqs(commitment_number, commitment_txid, Some(tx));
+			let (htlc_claim_reqs, counterparty_output_info) =
+				self.get_counterparty_output_claim_info(commitment_number, commitment_txid, Some(tx));
+			to_counterparty_output_info = counterparty_output_info;
 			for req in htlc_claim_reqs {
 				claimable_outpoints.push(req);
 			}
 
 		}
-		(claimable_outpoints, (commitment_txid, watch_outputs))
+		(claimable_outpoints, (commitment_txid, watch_outputs), to_counterparty_output_info)
 	}
 
-	fn get_counterparty_htlc_output_claim_reqs(&self, commitment_number: u64, commitment_txid: Txid, tx: Option<&Transaction>) -> Vec<PackageTemplate> {
+	/// Returns the HTLC claim package templates and the counterparty output info
+	fn get_counterparty_output_claim_info(&self, commitment_number: u64, commitment_txid: Txid, tx: Option<&Transaction>)
+	-> (Vec<PackageTemplate>, CommitmentTxCounterpartyOutputInfo) {
 		let mut claimable_outpoints = Vec::new();
-		if let Some(htlc_outputs) = self.counterparty_claimable_outpoints.get(&commitment_txid) {
-			if let Some(per_commitment_points) = self.their_cur_per_commitment_points {
-				let per_commitment_point_option =
-					// If the counterparty commitment tx is the latest valid state, use their latest
-					// per-commitment point
-					if per_commitment_points.0 == commitment_number { Some(&per_commitment_points.1) }
-					else if let Some(point) = per_commitment_points.2.as_ref() {
-						// If counterparty commitment tx is the state previous to the latest valid state, use
-						// their previous per-commitment point (non-atomicity of revocation means it's valid for
-						// them to temporarily have two valid commitment txns from our viewpoint)
-						if per_commitment_points.0 == commitment_number + 1 { Some(point) } else { None }
-					} else { None };
-				if let Some(per_commitment_point) = per_commitment_point_option {
-					for (_, &(ref htlc, _)) in htlc_outputs.iter().enumerate() {
-						if let Some(transaction_output_index) = htlc.transaction_output_index {
-							if let Some(transaction) = tx {
-								if transaction_output_index as usize >= transaction.output.len() ||
-									transaction.output[transaction_output_index as usize].value != htlc.amount_msat / 1000 {
-										return claimable_outpoints; // Corrupted per_commitment_data, fuck this user
-									}
-							}
-							let preimage = if htlc.offered { if let Some(p) = self.payment_preimages.get(&htlc.payment_hash) { Some(*p) } else { None } } else { None };
-							if preimage.is_some() || !htlc.offered {
-								let counterparty_htlc_outp = if htlc.offered {
-									PackageSolvingData::CounterpartyOfferedHTLCOutput(
-										CounterpartyOfferedHTLCOutput::build(*per_commitment_point,
-											self.counterparty_commitment_params.counterparty_delayed_payment_base_key,
-											self.counterparty_commitment_params.counterparty_htlc_base_key,
-											preimage.unwrap(), htlc.clone()))
-								} else {
-									PackageSolvingData::CounterpartyReceivedHTLCOutput(
-										CounterpartyReceivedHTLCOutput::build(*per_commitment_point,
-											self.counterparty_commitment_params.counterparty_delayed_payment_base_key,
-											self.counterparty_commitment_params.counterparty_htlc_base_key,
-											htlc.clone()))
-								};
-								let aggregation = if !htlc.offered { false } else { true };
-								let counterparty_package = PackageTemplate::build_package(commitment_txid, transaction_output_index, counterparty_htlc_outp, htlc.cltv_expiry,aggregation, 0);
-								claimable_outpoints.push(counterparty_package);
-							}
-						}
+		let mut to_counterparty_output_info: CommitmentTxCounterpartyOutputInfo = None;
+
+		let htlc_outputs = match self.counterparty_claimable_outpoints.get(&commitment_txid) {
+			Some(outputs) => outputs,
+			None => return (claimable_outpoints, to_counterparty_output_info),
+		};
+		let per_commitment_points = match self.their_cur_per_commitment_points {
+			Some(points) => points,
+			None => return (claimable_outpoints, to_counterparty_output_info),
+		};
+
+		let per_commitment_point =
+			// If the counterparty commitment tx is the latest valid state, use their latest
+			// per-commitment point
+			if per_commitment_points.0 == commitment_number { &per_commitment_points.1 }
+			else if let Some(point) = per_commitment_points.2.as_ref() {
+				// If counterparty commitment tx is the state previous to the latest valid state, use
+				// their previous per-commitment point (non-atomicity of revocation means it's valid for
+				// them to temporarily have two valid commitment txns from our viewpoint)
+				if per_commitment_points.0 == commitment_number + 1 {
+					point
+				} else { return (claimable_outpoints, to_counterparty_output_info); }
+			} else { return (claimable_outpoints, to_counterparty_output_info); };
+
+		if let Some(transaction) = tx {
+			let revokeable_p2wsh_opt =
+				if let Ok(revocation_pubkey) = chan_utils::derive_public_revocation_key(
+					&self.secp_ctx, &per_commitment_point, &self.holder_revocation_basepoint)
+				{
+					if let Ok(delayed_key) = chan_utils::derive_public_key(&self.secp_ctx,
+						&per_commitment_point,
+						&self.counterparty_commitment_params.counterparty_delayed_payment_base_key)
+					{
+						Some(chan_utils::get_revokeable_redeemscript(&revocation_pubkey,
+							self.counterparty_commitment_params.on_counterparty_tx_csv,
+							&delayed_key).to_v0_p2wsh())
+					} else {
+						debug_assert!(false, "Failed to derive a delayed payment key for a commitment state we accepted");
+						None
+					}
+				} else {
+					debug_assert!(false, "Failed to derive a revocation pubkey key for a commitment state we accepted");
+					None
+				};
+			if let Some(revokeable_p2wsh) = revokeable_p2wsh_opt {
+				for (idx, outp) in transaction.output.iter().enumerate() {
+					if outp.script_pubkey == revokeable_p2wsh {
+						to_counterparty_output_info =
+							Some((idx.try_into().expect("Can't have > 2^32 outputs"), outp.value));
 					}
 				}
 			}
 		}
-		claimable_outpoints
+
+		for (_, &(ref htlc, _)) in htlc_outputs.iter().enumerate() {
+			if let Some(transaction_output_index) = htlc.transaction_output_index {
+				if let Some(transaction) = tx {
+					if transaction_output_index as usize >= transaction.output.len() ||
+						transaction.output[transaction_output_index as usize].value != htlc.amount_msat / 1000 {
+							// per_commitment_data is corrupt or our commitment signing key leaked!
+							return (claimable_outpoints, to_counterparty_output_info);
+						}
+				}
+				let preimage = if htlc.offered { if let Some(p) = self.payment_preimages.get(&htlc.payment_hash) { Some(*p) } else { None } } else { None };
+				if preimage.is_some() || !htlc.offered {
+					let counterparty_htlc_outp = if htlc.offered {
+						PackageSolvingData::CounterpartyOfferedHTLCOutput(
+							CounterpartyOfferedHTLCOutput::build(*per_commitment_point,
+								self.counterparty_commitment_params.counterparty_delayed_payment_base_key,
+								self.counterparty_commitment_params.counterparty_htlc_base_key,
+								preimage.unwrap(), htlc.clone()))
+					} else {
+						PackageSolvingData::CounterpartyReceivedHTLCOutput(
+							CounterpartyReceivedHTLCOutput::build(*per_commitment_point,
+								self.counterparty_commitment_params.counterparty_delayed_payment_base_key,
+								self.counterparty_commitment_params.counterparty_htlc_base_key,
+								htlc.clone()))
+					};
+					let aggregation = if !htlc.offered { false } else { true };
+					let counterparty_package = PackageTemplate::build_package(commitment_txid, transaction_output_index, counterparty_htlc_outp, htlc.cltv_expiry,aggregation, 0);
+					claimable_outpoints.push(counterparty_package);
+				}
+			}
+		}
+
+		(claimable_outpoints, to_counterparty_output_info)
 	}
 
 	/// Attempts to claim a counterparty HTLC-Success/HTLC-Timeout's outputs using the revocation key
@@ -2343,7 +2624,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			let res = self.get_broadcasted_holder_claims(&self.current_holder_commitment_tx, height);
 			let mut to_watch = self.get_broadcasted_holder_watch_outputs(&self.current_holder_commitment_tx, tx);
 			append_onchain_update!(res, to_watch);
-			fail_unbroadcast_htlcs!(self, "latest holder", commitment_txid, height,
+			fail_unbroadcast_htlcs!(self, "latest holder", commitment_txid, tx, height,
 				self.current_holder_commitment_tx.htlc_outputs.iter()
 				.map(|(htlc, _, htlc_source)| (htlc, htlc_source.as_ref())), logger);
 		} else if let &Some(ref holder_tx) = &self.prev_holder_signed_commitment_tx {
@@ -2353,7 +2634,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 				let res = self.get_broadcasted_holder_claims(holder_tx, height);
 				let mut to_watch = self.get_broadcasted_holder_watch_outputs(holder_tx, tx);
 				append_onchain_update!(res, to_watch);
-				fail_unbroadcast_htlcs!(self, "previous holder", commitment_txid, height,
+				fail_unbroadcast_htlcs!(self, "previous holder", commitment_txid, tx, height,
 					holder_tx.htlc_outputs.iter().map(|(htlc, _, htlc_source)| (htlc, htlc_source.as_ref())),
 					logger);
 			}
@@ -2372,6 +2653,11 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		let commitment_tx = self.onchain_tx_handler.get_fully_signed_holder_tx(&self.funding_redeemscript);
 		let txid = commitment_tx.txid();
 		let mut holder_transactions = vec![commitment_tx];
+		// When anchor outputs are present, the HTLC transactions are only valid once the commitment
+		// transaction confirms.
+		if self.onchain_tx_handler.opt_anchors() {
+			return holder_transactions;
+		}
 		for htlc in self.current_holder_commitment_tx.htlc_outputs.iter() {
 			if let Some(vout) = htlc.0.transaction_output_index {
 				let preimage = if !htlc.0.offered {
@@ -2405,6 +2691,11 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		let commitment_tx = self.onchain_tx_handler.get_fully_signed_copy_holder_tx(&self.funding_redeemscript);
 		let txid = commitment_tx.txid();
 		let mut holder_transactions = vec![commitment_tx];
+		// When anchor outputs are present, the HTLC transactions are only final once the commitment
+		// transaction confirms due to the CSV 1 encumberance.
+		if self.onchain_tx_handler.opt_anchors() {
+			return holder_transactions;
+		}
 		for htlc in self.current_holder_commitment_tx.htlc_outputs.iter() {
 			if let Some(vout) = htlc.0.transaction_output_index {
 				let preimage = if !htlc.0.offered {
@@ -2500,14 +2791,19 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					log_info!(logger, "Channel {} closed by funding output spend in txid {}.",
 						log_bytes!(self.funding_info.0.to_channel_id()), tx.txid());
 					self.funding_spend_seen = true;
-					if (tx.input[0].sequence >> 8*3) as u8 == 0x80 && (tx.lock_time >> 8*3) as u8 == 0x20 {
-						let (mut new_outpoints, new_outputs) = self.check_spend_counterparty_transaction(&tx, height, &logger);
+					let mut commitment_tx_to_counterparty_output = None;
+					if (tx.input[0].sequence.0 >> 8*3) as u8 == 0x80 && (tx.lock_time.0 >> 8*3) as u8 == 0x20 {
+						let (mut new_outpoints, new_outputs, counterparty_output_idx_sats) =
+							self.check_spend_counterparty_transaction(&tx, height, &logger);
+						commitment_tx_to_counterparty_output = counterparty_output_idx_sats;
 						if !new_outputs.1.is_empty() {
 							watch_outputs.push(new_outputs);
 						}
 						claimable_outpoints.append(&mut new_outpoints);
 						if new_outpoints.is_empty() {
 							if let Some((mut new_outpoints, new_outputs)) = self.check_spend_holder_transaction(&tx, height, &logger) {
+								debug_assert!(commitment_tx_to_counterparty_output.is_none(),
+									"A commitment transaction matched as both a counterparty and local commitment tx?");
 								if !new_outputs.1.is_empty() {
 									watch_outputs.push(new_outputs);
 								}
@@ -2519,9 +2815,11 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					let txid = tx.txid();
 					self.onchain_events_awaiting_threshold_conf.push(OnchainEventEntry {
 						txid,
+						transaction: Some((*tx).clone()),
 						height: height,
 						event: OnchainEvent::FundingSpendConfirmation {
 							on_local_output_csv: balance_spendable_csv,
+							commitment_tx_to_counterparty_output,
 						},
 					});
 				} else {
@@ -2645,9 +2943,10 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						source: source.clone(),
 						htlc_value_satoshis,
 					}));
-					if let Some(idx) = commitment_tx_output_idx {
-						self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC { commitment_tx_output_idx: idx, payment_preimage: None });
-					}
+					self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC {
+						commitment_tx_output_idx, resolving_txid: Some(entry.txid),
+						payment_preimage: None,
+					});
 				},
 				OnchainEvent::MaturingOutput { descriptor } => {
 					log_debug!(logger, "Descriptor {} has got enough confirmations to be passed upstream", log_spendable!(descriptor));
@@ -2656,10 +2955,14 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					});
 				},
 				OnchainEvent::HTLCSpendConfirmation { commitment_tx_output_idx, preimage, .. } => {
-					self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC { commitment_tx_output_idx, payment_preimage: preimage });
+					self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC {
+						commitment_tx_output_idx: Some(commitment_tx_output_idx), resolving_txid: Some(entry.txid),
+						payment_preimage: preimage,
+					});
 				},
-				OnchainEvent::FundingSpendConfirmation { .. } => {
+				OnchainEvent::FundingSpendConfirmation { commitment_tx_to_counterparty_output, .. } => {
 					self.funding_spend_confirmed = Some(entry.txid);
+					self.confirmed_commitment_tx_counterparty_output = commitment_tx_to_counterparty_output;
 				},
 			}
 		}
@@ -2778,6 +3081,16 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 	}
 
 	fn should_broadcast_holder_commitment_txn<L: Deref>(&self, logger: &L) -> bool where L::Target: Logger {
+		// There's no need to broadcast our commitment transaction if we've seen one confirmed (even
+		// with 1 confirmation) as it'll be rejected as duplicate/conflicting.
+		if self.funding_spend_confirmed.is_some() ||
+			self.onchain_events_awaiting_threshold_conf.iter().find(|event| match event.event {
+				OnchainEvent::FundingSpendConfirmation { .. } => true,
+				_ => false,
+			}).is_some()
+		{
+			return false;
+		}
 		// We need to consider all HTLCs which are:
 		//  * in any unrevoked counterparty commitment transaction, as they could broadcast said
 		//    transactions and we'd end up in a race, or
@@ -2846,25 +3159,17 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 	fn is_resolving_htlc_output<L: Deref>(&mut self, tx: &Transaction, height: u32, logger: &L) where L::Target: Logger {
 		'outer_loop: for input in &tx.input {
 			let mut payment_data = None;
-			let witness_items = input.witness.len();
-			let htlctype = input.witness.last().map(|w| w.len()).and_then(HTLCType::scriptlen_to_htlctype);
-			let prev_last_witness_len = input.witness.second_to_last().map(|w| w.len()).unwrap_or(0);
-			let revocation_sig_claim = (witness_items == 3 && htlctype == Some(HTLCType::OfferedHTLC) && prev_last_witness_len == 33)
-				|| (witness_items == 3 && htlctype == Some(HTLCType::AcceptedHTLC) && prev_last_witness_len == 33);
-			let accepted_preimage_claim = witness_items == 5 && htlctype == Some(HTLCType::AcceptedHTLC)
-				&& input.witness.second_to_last().unwrap().len() == 32;
+			let htlc_claim = HTLCClaim::from_witness(&input.witness);
+			let revocation_sig_claim = htlc_claim == Some(HTLCClaim::Revocation);
+			let accepted_preimage_claim = htlc_claim == Some(HTLCClaim::AcceptedPreimage);
 			#[cfg(not(fuzzing))]
-			let accepted_timeout_claim = witness_items == 3 && htlctype == Some(HTLCType::AcceptedHTLC) && !revocation_sig_claim;
-			let offered_preimage_claim = witness_items == 3 && htlctype == Some(HTLCType::OfferedHTLC) &&
-				!revocation_sig_claim && input.witness.second_to_last().unwrap().len() == 32;
-
+			let accepted_timeout_claim = htlc_claim == Some(HTLCClaim::AcceptedTimeout);
+			let offered_preimage_claim = htlc_claim == Some(HTLCClaim::OfferedPreimage);
 			#[cfg(not(fuzzing))]
-			let offered_timeout_claim = witness_items == 5 && htlctype == Some(HTLCType::OfferedHTLC);
+			let offered_timeout_claim = htlc_claim == Some(HTLCClaim::OfferedTimeout);
 
 			let mut payment_preimage = PaymentPreimage([0; 32]);
-			if accepted_preimage_claim {
-				payment_preimage.0.copy_from_slice(input.witness.second_to_last().unwrap());
-			} else if offered_preimage_claim {
+			if offered_preimage_claim || accepted_preimage_claim {
 				payment_preimage.0.copy_from_slice(input.witness.second_to_last().unwrap());
 			}
 
@@ -2888,7 +3193,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						log_error!(logger, "Input spending {} ({}:{}) in {} resolves {} HTLC with payment hash {} with {}!",
 							$tx_info, input.previous_output.txid, input.previous_output.vout, tx.txid(),
 							if outbound_htlc { "outbound" } else { "inbound" }, log_bytes!($htlc.payment_hash.0),
-							if revocation_sig_claim { "revocation sig" } else { "preimage claim after we'd passed the HTLC resolution back" });
+							if revocation_sig_claim { "revocation sig" } else { "preimage claim after we'd passed the HTLC resolution back. We can likely claim the HTLC output with a revocation claim" });
 					} else {
 						log_info!(logger, "Input spending {} ({}:{}) in {} resolves {} HTLC with payment hash {} with {}",
 							$tx_info, input.previous_output.txid, input.previous_output.vout, tx.txid(),
@@ -2935,29 +3240,20 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 							if payment_data.is_none() {
 								log_claim!($tx_info, $holder_tx, htlc_output, false);
 								let outbound_htlc = $holder_tx == htlc_output.offered;
-								if !outbound_htlc || revocation_sig_claim {
-									self.onchain_events_awaiting_threshold_conf.push(OnchainEventEntry {
-										txid: tx.txid(), height,
-										event: OnchainEvent::HTLCSpendConfirmation {
-											commitment_tx_output_idx: input.previous_output.vout,
-											preimage: if accepted_preimage_claim || offered_preimage_claim {
-												Some(payment_preimage) } else { None },
-											// If this is a payment to us (!outbound_htlc, above),
-											// wait for the CSV delay before dropping the HTLC from
-											// claimable balance if the claim was an HTLC-Success
-											// transaction.
-											on_to_local_output_csv: if accepted_preimage_claim {
-												Some(self.on_holder_tx_csv) } else { None },
-										},
-									});
-								} else {
-									// Outbound claims should always have payment_data, unless
-									// we've already failed the HTLC as the commitment transaction
-									// which was broadcasted was revoked. In that case, we should
-									// spend the HTLC output here immediately, and expose that fact
-									// as a Balance, something which we do not yet do.
-									// TODO: Track the above as claimable!
-								}
+								self.onchain_events_awaiting_threshold_conf.push(OnchainEventEntry {
+									txid: tx.txid(), height, transaction: Some(tx.clone()),
+									event: OnchainEvent::HTLCSpendConfirmation {
+										commitment_tx_output_idx: input.previous_output.vout,
+										preimage: if accepted_preimage_claim || offered_preimage_claim {
+											Some(payment_preimage) } else { None },
+										// If this is a payment to us (ie !outbound_htlc), wait for
+										// the CSV delay before dropping the HTLC from claimable
+										// balance if the claim was an HTLC-Success transaction (ie
+										// accepted_preimage_claim).
+										on_to_local_output_csv: if accepted_preimage_claim && !outbound_htlc {
+											Some(self.on_holder_tx_csv) } else { None },
+									},
+								});
 								continue 'outer_loop;
 							}
 						}
@@ -2989,6 +3285,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						self.onchain_events_awaiting_threshold_conf.push(OnchainEventEntry {
 							txid: tx.txid(),
 							height,
+							transaction: Some(tx.clone()),
 							event: OnchainEvent::HTLCSpendConfirmation {
 								commitment_tx_output_idx: input.previous_output.vout,
 								preimage: Some(payment_preimage),
@@ -3009,6 +3306,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						} else { false }) {
 						self.onchain_events_awaiting_threshold_conf.push(OnchainEventEntry {
 							txid: tx.txid(),
+							transaction: Some(tx.clone()),
 							height,
 							event: OnchainEvent::HTLCSpendConfirmation {
 								commitment_tx_output_idx: input.previous_output.vout,
@@ -3035,6 +3333,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					});
 					let entry = OnchainEventEntry {
 						txid: tx.txid(),
+						transaction: Some(tx.clone()),
 						height,
 						event: OnchainEvent::HTLCUpdate {
 							source, payment_hash,
@@ -3108,6 +3407,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		if let Some(spendable_output) = spendable_output {
 			let entry = OnchainEventEntry {
 				txid: tx.txid(),
+				transaction: Some(tx.clone()),
 				height: height,
 				event: OnchainEvent::MaturingOutput { descriptor: spendable_output.clone() },
 			};
@@ -3368,12 +3668,14 @@ impl<'a, Signer: Sign, K: KeysInterface<Signer = Signer>> ReadableArgs<&'a K>
 		let mut htlcs_resolved_on_chain = Some(Vec::new());
 		let mut funding_spend_seen = Some(false);
 		let mut counterparty_node_id = None;
+		let mut confirmed_commitment_tx_counterparty_output = None;
 		read_tlv_fields!(reader, {
 			(1, funding_spend_confirmed, option),
 			(3, htlcs_resolved_on_chain, vec_type),
 			(5, pending_monitor_events, vec_type),
 			(7, funding_spend_seen, option),
 			(9, counterparty_node_id, option),
+			(11, confirmed_commitment_tx_counterparty_output, option),
 		});
 
 		let mut secp_ctx = Secp256k1::new();
@@ -3424,6 +3726,7 @@ impl<'a, Signer: Sign, K: KeysInterface<Signer = Signer>> ReadableArgs<&'a K>
 			holder_tx_signed,
 			funding_spend_seen: funding_spend_seen.unwrap(),
 			funding_spend_confirmed,
+			confirmed_commitment_tx_counterparty_output,
 			htlcs_resolved_on_chain: htlcs_resolved_on_chain.unwrap(),
 
 			best_block,
@@ -3474,7 +3777,7 @@ mod tests {
 	use util::ser::{ReadableArgs, Writeable};
 	use sync::{Arc, Mutex};
 	use io;
-	use bitcoin::Witness;
+	use bitcoin::{PackedLockTime, Sequence, TxMerkleNode, Witness};
 	use prelude::*;
 
 	fn do_test_funding_spend_refuses_updates(use_local_txn: bool) {
@@ -3518,7 +3821,7 @@ mod tests {
 		let new_header = BlockHeader {
 			version: 2, time: 0, bits: 0, nonce: 0,
 			prev_blockhash: nodes[0].best_block_info().0,
-			merkle_root: Default::default() };
+			merkle_root: TxMerkleNode::all_zeros() };
 		let conf_height = nodes[0].best_block_info().1 + 1;
 		nodes[1].chain_monitor.chain_monitor.transactions_confirmed(&new_header,
 			&[(0, broadcast_tx)], conf_height);
@@ -3578,7 +3881,7 @@ mod tests {
 		let fee_estimator = TestFeeEstimator { sat_per_kw: Mutex::new(253) };
 
 		let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
-		let dummy_tx = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
+		let dummy_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };
 
 		let mut preimages = Vec::new();
 		{
@@ -3644,7 +3947,7 @@ mod tests {
 			delayed_payment_basepoint: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[47; 32]).unwrap()),
 			htlc_basepoint: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[48; 32]).unwrap())
 		};
-		let funding_outpoint = OutPoint { txid: Default::default(), index: u16::max_value() };
+		let funding_outpoint = OutPoint { txid: Txid::all_zeros(), index: u16::max_value() };
 		let channel_parameters = ChannelTransactionParameters {
 			holder_pubkeys: keys.holder_channel_pubkeys.clone(),
 			holder_selected_contest_delay: 66,
@@ -3758,7 +4061,7 @@ mod tests {
 
 		// Justice tx with 1 to_holder, 2 revoked offered HTLCs, 1 revoked received HTLCs
 		for &opt_anchors in [false, true].iter() {
-			let mut claim_tx = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
+			let mut claim_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };
 			let mut sum_actual_sigs = 0;
 			for i in 0..4 {
 				claim_tx.input.push(TxIn {
@@ -3767,7 +4070,7 @@ mod tests {
 						vout: i,
 					},
 					script_sig: Script::new(),
-					sequence: 0xfffffffd,
+					sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
 					witness: Witness::new(),
 				});
 			}
@@ -3790,7 +4093,7 @@ mod tests {
 
 		// Claim tx with 1 offered HTLCs, 3 received HTLCs
 		for &opt_anchors in [false, true].iter() {
-			let mut claim_tx = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
+			let mut claim_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };
 			let mut sum_actual_sigs = 0;
 			for i in 0..4 {
 				claim_tx.input.push(TxIn {
@@ -3799,7 +4102,7 @@ mod tests {
 						vout: i,
 					},
 					script_sig: Script::new(),
-					sequence: 0xfffffffd,
+					sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
 					witness: Witness::new(),
 				});
 			}
@@ -3822,7 +4125,7 @@ mod tests {
 
 		// Justice tx with 1 revoked HTLC-Success tx output
 		for &opt_anchors in [false, true].iter() {
-			let mut claim_tx = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
+			let mut claim_tx = Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };
 			let mut sum_actual_sigs = 0;
 			claim_tx.input.push(TxIn {
 				previous_output: BitcoinOutPoint {
@@ -3830,7 +4133,7 @@ mod tests {
 					vout: 0,
 				},
 				script_sig: Script::new(),
-				sequence: 0xfffffffd,
+				sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
 				witness: Witness::new(),
 			});
 			claim_tx.output.push(TxOut {