Refactor ChannelMonitor::block_connected

Define an Electrum-friendly interface for ChannelMonitor where
transactions are confirmed and the latest connected block is updated
independently.

Author: jkczyz

lightning/src/chain/channelmonitor.rs

@@ -1299,6 +1299,36 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 		self.inner.lock().unwrap().block_disconnected(
 			header, height, broadcaster, fee_estimator, logger)
 	}
+
+	/// Processes transactions from a block with the given header and height, returning new outputs
+	/// to watch. See [`block_connected`] for details.
+	///
+	/// TODO: Expand docs.
+	pub fn transactions_confirmed<B: Deref, F: Deref, L: Deref>(
+		&self,
+		header: &BlockHeader,
+		txdata: &TransactionData,
+		height: u32,
+		broadcaster: B,
+		fee_estimator: F,
+		logger: L,
+	) -> Vec<(Txid, Vec<(u32, TxOut)>)>
+	where
+		B::Target: BroadcasterInterface,
+		F::Target: FeeEstimator,
+		L::Target: Logger,
+	{
+		self.inner.lock().unwrap().transactions_confirmed(
+			header, txdata, height, broadcaster, fee_estimator, &logger)
+	}
+
+	/// Updates the monitor with the current best chain tip.
+	///
+	/// TODO: Expand docs.
+	pub fn update_best_block<L: Deref>(&mut self, header: &BlockHeader, height: u32, logger: L)
+	where L::Target: Logger {
+		self.inner.lock().unwrap().update_best_block(header, height, &logger)
+	}
 }
 
 impl<Signer: Sign> ChannelMonitorImpl<Signer> {
@@ -1999,6 +2029,31 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		where B::Target: BroadcasterInterface,
 		      F::Target: FeeEstimator,
 					L::Target: Logger,
+	{
+		self.update_best_block(header, height, &logger);
+		self.transactions_confirmed(header, txdata, height, broadcaster, fee_estimator, &logger)
+	}
+
+	fn update_best_block<L: Deref>(&mut self, header: &BlockHeader, height: u32, logger: &L)
+	where L::Target: Logger {
+		let block_hash = header.block_hash();
+		log_trace!(logger, "New best block {} at height {}", block_hash, height);
+		self.last_block_hash = block_hash;
+	}
+
+	fn transactions_confirmed<B: Deref, F: Deref, L: Deref>(
+		&mut self,
+		header: &BlockHeader,
+		txdata: &TransactionData,
+		height: u32,
+		broadcaster: B,
+		fee_estimator: F,
+		logger: &L,
+	) -> Vec<(Txid, Vec<(u32, TxOut)>)>
+	where
+		B::Target: BroadcasterInterface,
+		F::Target: FeeEstimator,
+		L::Target: Logger,
 	{
 		let txn_matched = self.filter_block(txdata);
 		for tx in &txn_matched {
@@ -2024,12 +2079,12 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 				let prevout = &tx.input[0].previous_output;
 				if prevout.txid == self.funding_info.0.txid && prevout.vout == self.funding_info.0.index as u32 {
 					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 new_outpoints, new_outputs) = self.check_spend_counterparty_transaction(&tx, height, logger);
 						if !new_outputs.1.is_empty() {
 							watch_outputs.push(new_outputs);
 						}
 						if new_outpoints.is_empty() {
-							let (mut new_outpoints, new_outputs) = self.check_spend_holder_transaction(&tx, height, &logger);
+							let (mut new_outpoints, new_outputs) = self.check_spend_holder_transaction(&tx, height, logger);
 							if !new_outputs.1.is_empty() {
 								watch_outputs.push(new_outputs);
 							}
@@ -2039,7 +2094,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 					}
 				} else {
 					if let Some(&commitment_number) = self.counterparty_commitment_txn_on_chain.get(&prevout.txid) {
-						let (mut new_outpoints, new_outputs_option) = self.check_spend_counterparty_htlc(&tx, commitment_number, height, &logger);
+						let (mut new_outpoints, new_outputs_option) = self.check_spend_counterparty_htlc(&tx, commitment_number, height, logger);
 						claimable_outpoints.append(&mut new_outpoints);
 						if let Some(new_outputs) = new_outputs_option {
 							watch_outputs.push(new_outputs);
@@ -2050,11 +2105,11 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			// While all commitment/HTLC-Success/HTLC-Timeout transactions have one input, HTLCs
 			// can also be resolved in a few other ways which can have more than one output. Thus,
 			// we call is_resolving_htlc_output here outside of the tx.input.len() == 1 check.
-			self.is_resolving_htlc_output(&tx, height, &logger);
+			self.is_resolving_htlc_output(&tx, height, logger);
 
-			self.is_paying_spendable_output(&tx, height, &logger);
+			self.is_paying_spendable_output(&tx, height, logger);
 		}
-		let should_broadcast = self.would_broadcast_at_height(height, &logger);
+		let should_broadcast = self.would_broadcast_at_height(height, logger);
 		if should_broadcast {
 			claimable_outpoints.push(ClaimRequest { absolute_timelock: height, aggregable: false, outpoint: BitcoinOutPoint { txid: self.funding_info.0.txid.clone(), vout: self.funding_info.0.index as u32 }, witness_data: InputMaterial::Funding { funding_redeemscript: self.funding_redeemscript.clone() }});
 		}
@@ -2095,8 +2150,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			}
 		}
 
-		self.onchain_tx_handler.update_claims_view(&txn_matched, claimable_outpoints, Some(height), &&*broadcaster, &&*fee_estimator, &&*logger);
-		self.last_block_hash = block_hash;
+		self.onchain_tx_handler.update_claims_view(&txn_matched, claimable_outpoints, Some(height), &&*broadcaster, &&*fee_estimator, &*logger);
 
 		// Determine new outputs to watch by comparing against previously known outputs to watch,
 		// updating the latter in the process.