X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fchain%2Fchannelmonitor.rs;h=4d109294cf061e4a5a5f296ca839b1d5c778e716;hb=66ced68ec652ff84b654bd50919a70f866418089;hp=5128600163a42854f0be6c2bb5f27f79608050e6;hpb=a534a5e7af4923122a359005a99f01cfb33b451c;p=rust-lightning

diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs
index 51286001..4d109294 100644
--- a/lightning/src/chain/channelmonitor.rs
+++ b/lightning/src/chain/channelmonitor.rs
@@ -40,7 +40,7 @@ use ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLC
 use ln::channelmanager::HTLCSource;
 use chain;
 use chain::{BestBlock, WatchedOutput};
-use chain::chaininterface::{BroadcasterInterface, FeeEstimator};
+use chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
 use chain::transaction::{OutPoint, TransactionData};
 use chain::keysinterface::{SpendableOutputDescriptor, StaticPaymentOutputDescriptor, DelayedPaymentOutputDescriptor, Sign, KeysInterface};
 use chain::onchaintx::OnchainTxHandler;
@@ -54,6 +54,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;
 
@@ -315,6 +316,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 {
@@ -344,6 +346,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)]
@@ -371,6 +378,9 @@ 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.
+		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
@@ -395,6 +405,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),
 		});
@@ -404,16 +415,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)
 		}
@@ -432,6 +445,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),
@@ -710,6 +724,7 @@ pub(crate) struct ChannelMonitorImpl<Signer: Sign> {
 	funding_spend_seen: bool,
 
 	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).
@@ -722,6 +737,9 @@ pub(crate) struct ChannelMonitorImpl<Signer: Sign> {
 	// the full block_connected).
 	best_block: BestBlock,
 
+	/// The node_id of our counterparty
+	counterparty_node_id: Option<PublicKey>,
+
 	secp_ctx: Secp256k1<secp256k1::All>, //TODO: dedup this a bit...
 }
 
@@ -776,6 +794,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
@@ -869,6 +888,9 @@ impl<Signer: Sign> Writeable for ChannelMonitorImpl<Signer> {
 			writer.write_all(&txid[..])?;
 			writer.write_all(&byte_utils::be64_to_array(htlc_infos.len() as u64))?;
 			for &(ref htlc_output, ref htlc_source) in htlc_infos.iter() {
+				debug_assert!(htlc_source.is_none() || Some(**txid) == self.current_counterparty_commitment_txid
+						|| Some(**txid) == self.prev_counterparty_commitment_txid,
+					"HTLC Sources for all revoked commitment transactions should be none!");
 				serialize_htlc_in_commitment!(htlc_output);
 				htlc_source.as_ref().map(|b| b.as_ref()).write(writer)?;
 			}
@@ -951,6 +973,8 @@ impl<Signer: Sign> Writeable for ChannelMonitorImpl<Signer> {
 			(3, self.htlcs_resolved_on_chain, vec_type),
 			(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(())
@@ -958,13 +982,20 @@ impl<Signer: Sign> Writeable for ChannelMonitorImpl<Signer> {
 }
 
 impl<Signer: Sign> ChannelMonitor<Signer> {
+	/// For lockorder enforcement purposes, we need to have a single site which constructs the
+	/// `inner` mutex, otherwise cases where we lock two monitors at the same time (eg in our
+	/// PartialEq implementation) we may decide a lockorder violation has occurred.
+	fn from_impl(imp: ChannelMonitorImpl<Signer>) -> Self {
+		ChannelMonitor { inner: Mutex::new(imp) }
+	}
+
 	pub(crate) fn new(secp_ctx: Secp256k1<secp256k1::All>, keys: Signer, shutdown_script: Option<Script>,
 	                  on_counterparty_tx_csv: u16, destination_script: &Script, funding_info: (OutPoint, Script),
 	                  channel_parameters: &ChannelTransactionParameters,
 	                  funding_redeemscript: Script, channel_value_satoshis: u64,
 	                  commitment_transaction_number_obscure_factor: u64,
 	                  initial_holder_commitment_tx: HolderCommitmentTransaction,
-	                  best_block: BestBlock) -> ChannelMonitor<Signer> {
+	                  best_block: BestBlock, counterparty_node_id: PublicKey) -> ChannelMonitor<Signer> {
 
 		assert!(commitment_transaction_number_obscure_factor <= (1 << 48));
 		let payment_key_hash = WPubkeyHash::hash(&keys.pubkeys().payment_point.serialize());
@@ -1005,59 +1036,59 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		let mut outputs_to_watch = HashMap::new();
 		outputs_to_watch.insert(funding_info.0.txid, vec![(funding_info.0.index as u32, funding_info.1.clone())]);
 
-		ChannelMonitor {
-			inner: Mutex::new(ChannelMonitorImpl {
-				latest_update_id: 0,
-				commitment_transaction_number_obscure_factor,
+		Self::from_impl(ChannelMonitorImpl {
+			latest_update_id: 0,
+			commitment_transaction_number_obscure_factor,
 
-				destination_script: destination_script.clone(),
-				broadcasted_holder_revokable_script: None,
-				counterparty_payment_script,
-				shutdown_script,
+			destination_script: destination_script.clone(),
+			broadcasted_holder_revokable_script: None,
+			counterparty_payment_script,
+			shutdown_script,
 
-				channel_keys_id,
-				holder_revocation_basepoint,
-				funding_info,
-				current_counterparty_commitment_txid: None,
-				prev_counterparty_commitment_txid: None,
+			channel_keys_id,
+			holder_revocation_basepoint,
+			funding_info,
+			current_counterparty_commitment_txid: None,
+			prev_counterparty_commitment_txid: None,
 
-				counterparty_commitment_params,
-				funding_redeemscript,
-				channel_value_satoshis,
-				their_cur_per_commitment_points: None,
+			counterparty_commitment_params,
+			funding_redeemscript,
+			channel_value_satoshis,
+			their_cur_per_commitment_points: None,
 
-				on_holder_tx_csv: counterparty_channel_parameters.selected_contest_delay,
+			on_holder_tx_csv: counterparty_channel_parameters.selected_contest_delay,
 
-				commitment_secrets: CounterpartyCommitmentSecrets::new(),
-				counterparty_claimable_outpoints: HashMap::new(),
-				counterparty_commitment_txn_on_chain: HashMap::new(),
-				counterparty_hash_commitment_number: HashMap::new(),
+			commitment_secrets: CounterpartyCommitmentSecrets::new(),
+			counterparty_claimable_outpoints: HashMap::new(),
+			counterparty_commitment_txn_on_chain: HashMap::new(),
+			counterparty_hash_commitment_number: HashMap::new(),
 
-				prev_holder_signed_commitment_tx: None,
-				current_holder_commitment_tx: holder_commitment_tx,
-				current_counterparty_commitment_number: 1 << 48,
-				current_holder_commitment_number,
+			prev_holder_signed_commitment_tx: None,
+			current_holder_commitment_tx: holder_commitment_tx,
+			current_counterparty_commitment_number: 1 << 48,
+			current_holder_commitment_number,
 
-				payment_preimages: HashMap::new(),
-				pending_monitor_events: Vec::new(),
-				pending_events: Vec::new(),
+			payment_preimages: HashMap::new(),
+			pending_monitor_events: Vec::new(),
+			pending_events: Vec::new(),
 
-				onchain_events_awaiting_threshold_conf: Vec::new(),
-				outputs_to_watch,
+			onchain_events_awaiting_threshold_conf: Vec::new(),
+			outputs_to_watch,
 
-				onchain_tx_handler,
+			onchain_tx_handler,
 
-				lockdown_from_offchain: false,
-				holder_tx_signed: false,
-				funding_spend_seen: false,
-				funding_spend_confirmed: None,
-				htlcs_resolved_on_chain: Vec::new(),
+			lockdown_from_offchain: false,
+			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,
+			best_block,
+			counterparty_node_id: Some(counterparty_node_id),
 
-				secp_ctx,
-			}),
-		}
+			secp_ctx,
+		})
 	}
 
 	#[cfg(test)]
@@ -1096,7 +1127,7 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		payment_hash: &PaymentHash,
 		payment_preimage: &PaymentPreimage,
 		broadcaster: &B,
-		fee_estimator: &F,
+		fee_estimator: &LowerBoundedFeeEstimator<F>,
 		logger: &L,
 	) where
 		B::Target: BroadcasterInterface,
@@ -1126,7 +1157,7 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		&self,
 		updates: &ChannelMonitorUpdate,
 		broadcaster: &B,
-		fee_estimator: &F,
+		fee_estimator: F,
 		logger: &L,
 	) -> Result<(), ()>
 	where
@@ -1201,6 +1232,14 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		self.inner.lock().unwrap().get_cur_holder_commitment_number()
 	}
 
+	/// Gets the `node_id` of the counterparty for this channel.
+	///
+	/// Will be `None` for channels constructed on LDK versions prior to 0.0.110 and always `Some`
+	/// otherwise.
+	pub fn get_counterparty_node_id(&self) -> Option<PublicKey> {
+		self.inner.lock().unwrap().counterparty_node_id
+	}
+
 	/// Used by ChannelManager deserialization to broadcast the latest holder state if its copy of
 	/// the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of
 	/// fallen-behind, i.e when receiving a channel_reestablish with a proof that our counterparty side knows
@@ -1292,8 +1331,9 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		F::Target: FeeEstimator,
 		L::Target: Logger,
 	{
+		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
 		self.inner.lock().unwrap().transactions_confirmed(
-			header, txdata, height, broadcaster, fee_estimator, logger)
+			header, txdata, height, broadcaster, &bounded_fee_estimator, logger)
 	}
 
 	/// Processes a transaction that was reorganized out of the chain.
@@ -1313,8 +1353,9 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		F::Target: FeeEstimator,
 		L::Target: Logger,
 	{
+		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
 		self.inner.lock().unwrap().transaction_unconfirmed(
-			txid, broadcaster, fee_estimator, logger);
+			txid, broadcaster, &bounded_fee_estimator, logger);
 	}
 
 	/// Updates the monitor with the current best chain tip, returning new outputs to watch. See
@@ -1337,8 +1378,9 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		F::Target: FeeEstimator,
 		L::Target: Logger,
 	{
+		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
 		self.inner.lock().unwrap().best_block_updated(
-			header, height, broadcaster, fee_estimator, logger)
+			header, height, broadcaster, &bounded_fee_estimator, logger)
 	}
 
 	/// Returns the set of txids that should be monitored for re-organization out of the chain.
@@ -1659,7 +1701,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_tx_conf_height: expr, $confirmed_htlcs_list: expr, $logger: 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) {
@@ -1675,9 +1720,14 @@ macro_rules! fail_unbroadcast_htlcs {
 							// cannot currently change after channel initialization, so we don't
 							// need to here.
 							let confirmed_htlcs_iter: &mut Iterator<Item = (&HTLCOutputInCommitment, Option<&HTLCSource>)> = &mut $confirmed_htlcs_list;
+
 							let mut matched_htlc = false;
 							for (ref broadcast_htlc, ref broadcast_source) in confirmed_htlcs_iter {
-								if broadcast_htlc.transaction_output_index.is_some() && Some(&**source) == *broadcast_source {
+								if broadcast_htlc.transaction_output_index.is_some() &&
+									(Some(&**source) == *broadcast_source ||
+									 (broadcast_source.is_none() &&
+									  broadcast_htlc.payment_hash == htlc.payment_hash &&
+									  broadcast_htlc.amount_msat == htlc.amount_msat)) {
 									matched_htlc = true;
 									break;
 								}
@@ -1693,7 +1743,8 @@ macro_rules! fail_unbroadcast_htlcs {
 								}
 							});
 							let entry = OnchainEventEntry {
-								txid: *$txid,
+								txid: $commitment_txid_confirmed,
+								transaction: Some($commitment_tx_confirmed.clone()),
 								height: $commitment_tx_conf_height,
 								event: OnchainEvent::HTLCUpdate {
 									source: (**source).clone(),
@@ -1702,8 +1753,9 @@ macro_rules! fail_unbroadcast_htlcs {
 									commitment_tx_output_idx: None,
 								},
 							};
-							log_trace!($logger, "Failing HTLC with payment_hash {} from {} counterparty commitment tx due to broadcast of {} commitment transaction, waiting for confirmation (at height {})",
-								log_bytes!(htlc.payment_hash.0), $commitment_tx, $commitment_tx_type, entry.confirmation_threshold());
+							log_trace!($logger, "Failing HTLC with payment_hash {} from {} counterparty commitment tx due to broadcast of {} commitment transaction {}, waiting for confirmation (at height {})",
+								log_bytes!(htlc.payment_hash.0), $commitment_tx, $commitment_tx_type,
+								$commitment_txid_confirmed, entry.confirmation_threshold());
 							$self.onchain_events_awaiting_threshold_conf.push(entry);
 						}
 					}
@@ -1719,6 +1771,26 @@ macro_rules! fail_unbroadcast_htlcs {
 	} }
 }
 
+// In the `test_invalid_funding_tx` test, we need a bogus script which matches the HTLC-Accepted
+// witness length match (ie is 136 bytes long). We generate one here which we also use in some
+// in-line tests later.
+
+#[cfg(test)]
+pub fn deliberately_bogus_accepted_htlc_witness_program() -> Vec<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[..])
+}
+
+#[cfg(test)]
+pub fn deliberately_bogus_accepted_htlc_witness() -> Vec<Vec<u8>> {
+	vec![Vec::new(), Vec::new(), Vec::new(), Vec::new(), deliberately_bogus_accepted_htlc_witness_program().into()].into()
+}
+
 impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 	/// Inserts a revocation secret into this channel monitor. Prunes old preimages if neither
 	/// needed by holder commitment transactions HTCLs nor by counterparty ones. Unless we haven't already seen
@@ -1847,7 +1919,9 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 
 	/// Provides a payment_hash->payment_preimage mapping. Will be automatically pruned when all
 	/// commitment_tx_infos which contain the payment hash have been revoked.
-	fn provide_payment_preimage<B: Deref, F: Deref, L: Deref>(&mut self, payment_hash: &PaymentHash, payment_preimage: &PaymentPreimage, broadcaster: &B, fee_estimator: &F, logger: &L)
+	fn provide_payment_preimage<B: Deref, F: Deref, L: Deref>(
+		&mut self, payment_hash: &PaymentHash, payment_preimage: &PaymentPreimage, broadcaster: &B,
+		fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L)
 	where B::Target: BroadcasterInterface,
 		    F::Target: FeeEstimator,
 		    L::Target: Logger,
@@ -1858,7 +1932,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);
 			}
 		}
@@ -1904,10 +1978,10 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		self.pending_monitor_events.push(MonitorEvent::CommitmentTxConfirmed(self.funding_info.0));
 	}
 
-	pub fn update_monitor<B: Deref, F: Deref, L: Deref>(&mut self, updates: &ChannelMonitorUpdate, broadcaster: &B, fee_estimator: &F, logger: &L) -> Result<(), ()>
+	pub fn update_monitor<B: Deref, F: Deref, L: Deref>(&mut self, updates: &ChannelMonitorUpdate, broadcaster: &B, fee_estimator: F, logger: &L) -> Result<(), ()>
 	where B::Target: BroadcasterInterface,
-		    F::Target: FeeEstimator,
-		    L::Target: Logger,
+		F::Target: FeeEstimator,
+		L::Target: Logger,
 	{
 		log_info!(logger, "Applying update to monitor {}, bringing update_id from {} to {} with {} changes.",
 			log_funding_info!(self), self.latest_update_id, updates.update_id, updates.updates.len());
@@ -1945,7 +2019,8 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 				},
 				ChannelMonitorUpdateStep::PaymentPreimage { payment_preimage } => {
 					log_trace!(logger, "Updating ChannelMonitor with payment preimage");
-					self.provide_payment_preimage(&PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner()), &payment_preimage, broadcaster, fee_estimator, logger)
+					let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
+					self.provide_payment_preimage(&PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner()), &payment_preimage, broadcaster, &bounded_fee_estimator, logger)
 				},
 				ChannelMonitorUpdateStep::CommitmentSecret { idx, secret } => {
 					log_trace!(logger, "Updating ChannelMonitor with commitment secret");
@@ -2036,13 +2111,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);
@@ -2051,12 +2131,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));
@@ -2073,6 +2153,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));
 				}
 			}
 
@@ -2082,7 +2164,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);
@@ -2100,7 +2184,16 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 				}
 				self.counterparty_commitment_txn_on_chain.insert(commitment_txid, commitment_number);
 
-				fail_unbroadcast_htlcs!(self, "revoked counterparty", height, [].iter().map(|a| *a), logger);
+				if let Some(per_commitment_data) = per_commitment_option {
+					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, tx, height,
+						[].iter().map(|reference| *reference), logger);
+				}
 			}
 		} else if let Some(per_commitment_data) = per_commitment_option {
 			// While this isn't useful yet, there is a potential race where if a counterparty
@@ -2116,65 +2209,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", height, per_commitment_data.iter().map(|(a, b)| (a, b.as_ref().map(|b| b.as_ref()))), logger);
-
-			let htlc_claim_reqs = self.get_counterparty_htlc_output_claim_reqs(commitment_number, commitment_txid, Some(tx));
+			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, 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
@@ -2272,7 +2412,9 @@ 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", height, self.current_holder_commitment_tx.htlc_outputs.iter().map(|(a, _, c)| (a, c.as_ref())), logger);
+			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 {
 			if holder_tx.txid == commitment_txid {
 				is_holder_tx = true;
@@ -2280,7 +2422,9 @@ 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", height, holder_tx.htlc_outputs.iter().map(|(a, _, c)| (a, c.as_ref())), logger);
+				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);
 			}
 		}
 
@@ -2355,7 +2499,8 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		let block_hash = header.block_hash();
 		self.best_block = BestBlock::new(block_hash, height);
 
-		self.transactions_confirmed(header, txdata, height, broadcaster, fee_estimator, logger)
+		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
+		self.transactions_confirmed(header, txdata, height, broadcaster, &bounded_fee_estimator, logger)
 	}
 
 	fn best_block_updated<B: Deref, F: Deref, L: Deref>(
@@ -2363,7 +2508,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		header: &BlockHeader,
 		height: u32,
 		broadcaster: B,
-		fee_estimator: F,
+		fee_estimator: &LowerBoundedFeeEstimator<F>,
 		logger: L,
 	) -> Vec<TransactionOutputs>
 	where
@@ -2390,7 +2535,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		txdata: &TransactionData,
 		height: u32,
 		broadcaster: B,
-		fee_estimator: F,
+		fee_estimator: &LowerBoundedFeeEstimator<F>,
 		logger: L,
 	) -> Vec<TransactionOutputs>
 	where
@@ -2424,14 +2569,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);
 								}
@@ -2443,9 +2593,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 {
@@ -2487,7 +2639,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		mut watch_outputs: Vec<TransactionOutputs>,
 		mut claimable_outpoints: Vec<PackageTemplate>,
 		broadcaster: &B,
-		fee_estimator: &F,
+		fee_estimator: &LowerBoundedFeeEstimator<F>,
 		logger: &L,
 	) -> Vec<TransactionOutputs>
 	where
@@ -2561,7 +2713,8 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						matured_htlcs.push(source.clone());
 					}
 
-					log_debug!(logger, "HTLC {} failure update has got enough confirmations to be passed upstream", log_bytes!(payment_hash.0));
+					log_debug!(logger, "HTLC {} failure update in {} has got enough confirmations to be passed upstream",
+						log_bytes!(payment_hash.0), entry.txid);
 					self.pending_monitor_events.push(MonitorEvent::HTLCEvent(HTLCUpdate {
 						payment_hash,
 						payment_preimage: None,
@@ -2581,8 +2734,9 @@ 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 });
 				},
-				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;
 				},
 			}
 		}
@@ -2624,7 +2778,8 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		//- maturing spendable output has transaction paying us has been disconnected
 		self.onchain_events_awaiting_threshold_conf.retain(|ref entry| entry.height < height);
 
-		self.onchain_tx_handler.block_disconnected(height, broadcaster, fee_estimator, logger);
+		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
+		self.onchain_tx_handler.block_disconnected(height, broadcaster, &bounded_fee_estimator, logger);
 
 		self.best_block = BestBlock::new(header.prev_blockhash, height - 1);
 	}
@@ -2633,14 +2788,17 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		&mut self,
 		txid: &Txid,
 		broadcaster: B,
-		fee_estimator: F,
+		fee_estimator: &LowerBoundedFeeEstimator<F>,
 		logger: L,
 	) where
 		B::Target: BroadcasterInterface,
 		F::Target: FeeEstimator,
 		L::Target: Logger,
 	{
-		self.onchain_events_awaiting_threshold_conf.retain(|ref entry| entry.txid != *txid);
+		self.onchain_events_awaiting_threshold_conf.retain(|ref entry| if entry.txid == *txid {
+			log_info!(logger, "Removing onchain event with txid {}", txid);
+			false
+		} else { true });
 		self.onchain_tx_handler.transaction_unconfirmed(txid, broadcaster, fee_estimator, logger);
 	}
 
@@ -2671,14 +2829,21 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					if *idx == input.previous_output.vout {
 						#[cfg(test)]
 						{
-						        // If the expected script is a known type, check that the witness
-						        // appears to be spending the correct type (ie that the match would
-						        // actually succeed in BIP 158/159-style filters).
-						        if _script_pubkey.is_v0_p2wsh() {
-						                assert_eq!(&bitcoin::Address::p2wsh(&Script::from(input.witness.last().unwrap().to_vec()), bitcoin::Network::Bitcoin).script_pubkey(), _script_pubkey);
-						        } else if _script_pubkey.is_v0_p2wpkh() {
-						                assert_eq!(&bitcoin::Address::p2wpkh(&bitcoin::PublicKey::from_slice(&input.witness.last().unwrap()).unwrap(), bitcoin::Network::Bitcoin).unwrap().script_pubkey(), _script_pubkey);
-						        } else { panic!(); }
+							// If the expected script is a known type, check that the witness
+							// appears to be spending the correct type (ie that the match would
+							// actually succeed in BIP 158/159-style filters).
+							if _script_pubkey.is_v0_p2wsh() {
+								if input.witness.last().unwrap().to_vec() == deliberately_bogus_accepted_htlc_witness_program() {
+									// In at least one test we use a deliberately bogus witness
+									// script which hit an old panic. Thus, we check for that here
+									// and avoid the assert if its the expected bogus script.
+									return true;
+								}
+
+								assert_eq!(&bitcoin::Address::p2wsh(&Script::from(input.witness.last().unwrap().to_vec()), bitcoin::Network::Bitcoin).script_pubkey(), _script_pubkey);
+							} else if _script_pubkey.is_v0_p2wpkh() {
+								assert_eq!(&bitcoin::Address::p2wpkh(&bitcoin::PublicKey::from_slice(&input.witness.last().unwrap()).unwrap(), bitcoin::Network::Bitcoin).unwrap().script_pubkey(), _script_pubkey);
+							} else { panic!(); }
 						}
 						return true;
 					}
@@ -2763,10 +2928,13 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			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);
+			let accepted_preimage_claim = witness_items == 5 && htlctype == Some(HTLCType::AcceptedHTLC)
+				&& input.witness.second_to_last().unwrap().len() == 32;
 			#[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;
+			let offered_preimage_claim = witness_items == 3 && htlctype == Some(HTLCType::OfferedHTLC) &&
+				!revocation_sig_claim && input.witness.second_to_last().unwrap().len() == 32;
+
 			#[cfg(not(fuzzing))]
 			let offered_timeout_claim = witness_items == 5 && htlctype == Some(HTLCType::OfferedHTLC);
 
@@ -2846,7 +3014,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 								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,
+										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 {
@@ -2898,6 +3066,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),
@@ -2918,6 +3087,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,
@@ -2944,6 +3114,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					});
 					let entry = OnchainEventEntry {
 						txid: tx.txid(),
+						transaction: Some(tx.clone()),
 						height,
 						event: OnchainEvent::HTLCUpdate {
 							source, payment_hash,
@@ -3017,6 +3188,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() },
 			};
@@ -3276,69 +3448,73 @@ impl<'a, Signer: Sign, K: KeysInterface<Signer = Signer>> ReadableArgs<&'a K>
 		let mut funding_spend_confirmed = None;
 		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();
 		secp_ctx.seeded_randomize(&keys_manager.get_secure_random_bytes());
 
-		Ok((best_block.block_hash(), ChannelMonitor {
-			inner: Mutex::new(ChannelMonitorImpl {
-				latest_update_id,
-				commitment_transaction_number_obscure_factor,
+		Ok((best_block.block_hash(), ChannelMonitor::from_impl(ChannelMonitorImpl {
+			latest_update_id,
+			commitment_transaction_number_obscure_factor,
 
-				destination_script,
-				broadcasted_holder_revokable_script,
-				counterparty_payment_script,
-				shutdown_script,
+			destination_script,
+			broadcasted_holder_revokable_script,
+			counterparty_payment_script,
+			shutdown_script,
 
-				channel_keys_id,
-				holder_revocation_basepoint,
-				funding_info,
-				current_counterparty_commitment_txid,
-				prev_counterparty_commitment_txid,
+			channel_keys_id,
+			holder_revocation_basepoint,
+			funding_info,
+			current_counterparty_commitment_txid,
+			prev_counterparty_commitment_txid,
 
-				counterparty_commitment_params,
-				funding_redeemscript,
-				channel_value_satoshis,
-				their_cur_per_commitment_points,
+			counterparty_commitment_params,
+			funding_redeemscript,
+			channel_value_satoshis,
+			their_cur_per_commitment_points,
 
-				on_holder_tx_csv,
+			on_holder_tx_csv,
 
-				commitment_secrets,
-				counterparty_claimable_outpoints,
-				counterparty_commitment_txn_on_chain,
-				counterparty_hash_commitment_number,
+			commitment_secrets,
+			counterparty_claimable_outpoints,
+			counterparty_commitment_txn_on_chain,
+			counterparty_hash_commitment_number,
 
-				prev_holder_signed_commitment_tx,
-				current_holder_commitment_tx,
-				current_counterparty_commitment_number,
-				current_holder_commitment_number,
+			prev_holder_signed_commitment_tx,
+			current_holder_commitment_tx,
+			current_counterparty_commitment_number,
+			current_holder_commitment_number,
 
-				payment_preimages,
-				pending_monitor_events: pending_monitor_events.unwrap(),
-				pending_events,
+			payment_preimages,
+			pending_monitor_events: pending_monitor_events.unwrap(),
+			pending_events,
 
-				onchain_events_awaiting_threshold_conf,
-				outputs_to_watch,
+			onchain_events_awaiting_threshold_conf,
+			outputs_to_watch,
 
-				onchain_tx_handler,
+			onchain_tx_handler,
 
-				lockdown_from_offchain,
-				holder_tx_signed,
-				funding_spend_seen: funding_spend_seen.unwrap(),
-				funding_spend_confirmed,
-				htlcs_resolved_on_chain: htlcs_resolved_on_chain.unwrap(),
+			lockdown_from_offchain,
+			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,
+			best_block,
+			counterparty_node_id,
 
-				secp_ctx,
-			}),
-		}))
+			secp_ctx,
+		})))
 	}
 }
 
@@ -3360,6 +3536,8 @@ mod tests {
 
 	use hex;
 
+	use crate::chain::chaininterface::LowerBoundedFeeEstimator;
+
 	use super::ChannelMonitorUpdateStep;
 	use ::{check_added_monitors, check_closed_broadcast, check_closed_event, check_spends, get_local_commitment_txn, get_monitor, get_route_and_payment_hash, unwrap_send_err};
 	use chain::{BestBlock, Confirm};
@@ -3380,7 +3558,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) {
@@ -3424,7 +3602,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);
@@ -3456,7 +3634,7 @@ mod tests {
 
 		let broadcaster = TestBroadcaster::new(Arc::clone(&nodes[1].blocks));
 		assert!(
-			pre_update_monitor.update_monitor(&replay_update, &&broadcaster, &&chanmon_cfgs[1].fee_estimator, &nodes[1].logger)
+			pre_update_monitor.update_monitor(&replay_update, &&broadcaster, &chanmon_cfgs[1].fee_estimator, &nodes[1].logger)
 			.is_err());
 		// Even though we error'd on the first update, we should still have generated an HTLC claim
 		// transaction
@@ -3481,10 +3659,10 @@ mod tests {
 		let secp_ctx = Secp256k1::new();
 		let logger = Arc::new(TestLogger::new());
 		let broadcaster = Arc::new(TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), blocks: Arc::new(Mutex::new(Vec::new()))});
-		let fee_estimator = Arc::new(TestFeeEstimator { sat_per_kw: Mutex::new(253) });
+		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();
 		{
@@ -3550,7 +3728,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,
@@ -3571,7 +3749,7 @@ mod tests {
 		                                  (OutPoint { txid: Txid::from_slice(&[43; 32]).unwrap(), index: 0 }, Script::new()),
 		                                  &channel_parameters,
 		                                  Script::new(), 46, 0,
-		                                  HolderCommitmentTransaction::dummy(), best_block);
+		                                  HolderCommitmentTransaction::dummy(), best_block, dummy_key);
 
 		monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 		let dummy_txid = dummy_tx.txid();
@@ -3580,7 +3758,8 @@ mod tests {
 		monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 		monitor.provide_latest_counterparty_commitment_tx(dummy_txid, preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 		for &(ref preimage, ref hash) in preimages.iter() {
-			monitor.provide_payment_preimage(hash, preimage, &broadcaster, &fee_estimator, &logger);
+			let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
+			monitor.provide_payment_preimage(hash, preimage, &broadcaster, &bounded_fee_estimator, &logger);
 		}
 
 		// Now provide a secret, pruning preimages 10-15
@@ -3663,7 +3842,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 {
@@ -3672,7 +3851,7 @@ mod tests {
 						vout: i,
 					},
 					script_sig: Script::new(),
-					sequence: 0xfffffffd,
+					sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
 					witness: Witness::new(),
 				});
 			}
@@ -3695,7 +3874,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 {
@@ -3704,7 +3883,7 @@ mod tests {
 						vout: i,
 					},
 					script_sig: Script::new(),
-					sequence: 0xfffffffd,
+					sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
 					witness: Witness::new(),
 				});
 			}
@@ -3727,7 +3906,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 {
@@ -3735,7 +3914,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 {