Fix lightning-transaction-sync warnings.

Version 0.32.2 of `rust-bitcoin` deprecates a number of methods that
are commonly used in this project, most visibly `txid()`, which is
now called `compute_txid()`. This resulted in a lot of warnings, and
this commit is part of a series that seeks to address that.

Author: arik-so

lightning-transaction-sync/Cargo.toml

@@ -16,9 +16,9 @@ rustdoc-args = ["--cfg", "docsrs"]
 [features]
 default = ["time"]
 time = []
-esplora-async = ["async-interface", "esplora-client/async", "futures"]
-esplora-async-https = ["esplora-async", "esplora-client/async-https-rustls"]
-esplora-blocking = ["esplora-client/blocking"]
+esplora-async = ["async-interface", "esplora-client/async", "futures", "electrum-client"]
+esplora-async-https = ["esplora-async", "esplora-client/async-https-rustls", "electrum-client"]
+esplora-blocking = ["esplora-client/blocking", "electrum-client"]
 electrum = ["electrum-client"]
 async-interface = []
 

lightning-transaction-sync/src/common.rs

@@ -74,11 +74,12 @@ impl SyncState {
 				);
 			}
 
-			self.watched_transactions.remove(&ctx.tx.txid());
+			self.watched_transactions.remove(&ctx.tx.compute_txid());
 
 			for input in &ctx.tx.input {
 				if let Some(output) = self.watched_outputs.remove(&input.previous_output) {
-					let spent = (ctx.tx.txid(), ctx.block_height, input.previous_output, output);
+					let spent =
+						(ctx.tx.compute_txid(), ctx.block_height, input.previous_output, output);
 					self.outputs_spends_pending_threshold_conf.push(spent);
 				}
 			}

lightning-transaction-sync/src/electrum.rs

@@ -13,6 +13,13 @@ use lightning::{log_debug, log_error, log_trace};
 use bitcoin::block::Header;
 use bitcoin::{BlockHash, Script, Transaction, Txid};
 
+use bitcoin::hashes::Hash as BitcoinHash;
+use electrum_client::bitcoin::hashes::Hash as ElectrumHash;
+
+use bitcoin::consensus::{Decodable as BitcoinDecodable, Encodable as BitcoinEncodable};
+use electrum_client::bitcoin::consensus::{
+	Decodable as ElectrumDecodable, Encodable as ElectrumEncodable,
+};
 use std::collections::HashSet;
 use std::ops::Deref;
 use std::sync::Mutex;
@@ -92,12 +99,15 @@ where
 		while let Some(_) = self.client.block_headers_pop()? {}
 
 		let tip_notification = self.client.block_headers_subscribe()?;
-		let mut tip_header = tip_notification.header;
+		let tip_header = tip_notification.header;
 		let mut tip_height = tip_notification.height as u32;
 
 		loop {
 			let pending_registrations = self.queue.lock().unwrap().process_queues(&mut sync_state);
-			let tip_is_new = Some(tip_header.block_hash()) != sync_state.last_sync_hash;
+			let tip_is_new = Some(tip_header.block_hash())
+				!= sync_state
+					.last_sync_hash
+					.map(|h| electrum_client::bitcoin::BlockHash::from_slice(h.as_ref()).unwrap());
 
 			// We loop until any registered transactions have been processed at least once, or the
 			// tip hasn't been updated during the last iteration.
@@ -112,7 +122,16 @@ where
 						Ok(unconfirmed_txs) => {
 							// Double-check the tip hash. If it changed, a reorg happened since
 							// we started syncing and we need to restart last-minute.
-							match self.check_update_tip(&mut tip_header, &mut tip_height) {
+
+							let mut header_buffer = Vec::new();
+							tip_header.consensus_encode(&mut header_buffer).unwrap();
+							let mut header_slice = &header_buffer[..];
+							let header_reader =
+								&mut lightning::util::ser::BufReader::<_>::new(&mut header_slice);
+							let mut bitcoin_header =
+								bitcoin::block::Header::consensus_decode(header_reader).unwrap();
+
+							match self.check_update_tip(&mut bitcoin_header, &mut tip_height) {
 								Ok(false) => {
 									num_unconfirmed += unconfirmed_txs.len();
 									sync_state.sync_unconfirmed_transactions(
@@ -150,9 +169,17 @@ where
 						},
 					}
 
+					let mut header_buffer = Vec::new();
+					tip_header.consensus_encode(&mut header_buffer).unwrap();
+					let mut header_slice = &header_buffer[..];
+					let header_reader =
+						&mut lightning::util::ser::BufReader::<_>::new(&mut header_slice);
+					let bitcoin_header =
+						bitcoin::block::Header::consensus_decode(header_reader).unwrap();
+
 					// Update the best block.
 					for c in &confirmables {
-						c.best_block_updated(&tip_header, tip_height);
+						c.best_block_updated(&bitcoin_header, tip_height);
 					}
 
 					// Prune any sufficiently confirmed output spends
@@ -161,9 +188,17 @@ where
 
 				match self.get_confirmed_transactions(&sync_state) {
 					Ok(confirmed_txs) => {
+						let mut header_buffer = Vec::new();
+						tip_header.consensus_encode(&mut header_buffer).unwrap();
+						let mut header_slice = &header_buffer[..];
+						let header_reader =
+							&mut lightning::util::ser::BufReader::<_>::new(&mut header_slice);
+						let mut bitcoin_header =
+							bitcoin::block::Header::consensus_decode(header_reader).unwrap();
+
 						// Double-check the tip hash. If it changed, a reorg happened since
 						// we started syncing and we need to restart last-minute.
-						match self.check_update_tip(&mut tip_header, &mut tip_height) {
+						match self.check_update_tip(&mut bitcoin_header, &mut tip_height) {
 							Ok(false) => {
 								num_confirmed += confirmed_txs.len();
 								sync_state
@@ -207,7 +242,8 @@ where
 						return Err(TxSyncError::from(err));
 					},
 				}
-				sync_state.last_sync_hash = Some(tip_header.block_hash());
+				sync_state.last_sync_hash =
+					Some(bitcoin::BlockHash::from_slice(tip_header.block_hash().as_ref()).unwrap());
 				sync_state.pending_sync = false;
 			}
 		}
@@ -240,15 +276,25 @@ where
 		// Restart if either the tip changed or we got some divergent tip
 		// change notification since we started. In the latter case we
 		// make sure we clear the queue before continuing.
-		let mut restart_sync = check_tip_hash != cur_tip_header.block_hash();
+		let mut restart_sync = check_tip_hash
+			!= electrum_client::bitcoin::BlockHash::from_slice(
+				cur_tip_header.block_hash().as_ref(),
+			)
+			.unwrap();
 		while let Some(queued_notif) = self.client.block_headers_pop()? {
 			if queued_notif.header.block_hash() != check_tip_hash {
 				restart_sync = true
 			}
 		}
 
 		if restart_sync {
-			*cur_tip_header = check_notification.header;
+			let mut header_buffer = Vec::new();
+			check_notification.header.consensus_encode(&mut header_buffer).unwrap();
+			let mut header_slice = &header_buffer[..];
+			let header_reader = &mut lightning::util::ser::BufReader::<_>::new(&mut header_slice);
+			let bitcoin_header = bitcoin::block::Header::consensus_decode(header_reader).unwrap();
+
+			*cur_tip_header = bitcoin_header;
 			*cur_tip_height = check_notification.height as u32;
 			Ok(true)
 		} else {
@@ -268,7 +314,9 @@ where
 		let mut watched_txs = Vec::with_capacity(sync_state.watched_transactions.len());
 
 		for txid in &sync_state.watched_transactions {
-			match self.client.transaction_get(&txid) {
+			match self.client.transaction_get(
+				&electrum_client::bitcoin::Txid::from_slice(txid.as_ref()).unwrap(),
+			) {
 				Ok(tx) => {
 					// Bitcoin Core's Merkle tree implementation has no way to discern between
 					// internal and leaf node entries. As a consequence it is susceptible to an
@@ -308,7 +356,9 @@ where
 		debug_assert_eq!(num_tx_lookups, watched_txs.len());
 
 		for output in sync_state.watched_outputs.values() {
-			watched_script_pubkeys.push(output.script_pubkey.clone());
+			watched_script_pubkeys.push(electrum_client::bitcoin::ScriptBuf::from_bytes(
+				output.script_pubkey.to_bytes(),
+			));
 		}
 
 		let num_output_spend_lookups = watched_script_pubkeys.len() - num_tx_lookups;
@@ -325,11 +375,22 @@ where
 					if confirmed_txs.iter().any(|ctx| ctx.txid == **txid) {
 						continue;
 					}
-					let mut filtered_history =
-						script_history.iter().filter(|h| h.tx_hash == **txid);
+					let mut filtered_history = script_history.iter().filter(|h| {
+						h.tx_hash
+							== electrum_client::bitcoin::Txid::from_slice(txid.as_ref()).unwrap()
+					});
 					if let Some(history) = filtered_history.next() {
+						let mut tx_buffer = Vec::new();
+						tx.consensus_encode(&mut tx_buffer).unwrap();
+						let mut tx_slice = &tx_buffer[..];
+						let tx_reader =
+							&mut lightning::util::ser::BufReader::<_>::new(&mut tx_slice);
+						let bitcoin_transaction =
+							bitcoin::Transaction::consensus_decode(tx_reader).unwrap();
+
 						let prob_conf_height = history.height as u32;
-						let confirmed_tx = self.get_confirmed_tx(tx, prob_conf_height)?;
+						let confirmed_tx =
+							self.get_confirmed_tx(&bitcoin_transaction, prob_conf_height)?;
 						confirmed_txs.push(confirmed_tx);
 					}
 					debug_assert!(filtered_history.next().is_none());
@@ -344,7 +405,9 @@ where
 						}
 
 						let txid = possible_output_spend.tx_hash;
-						if confirmed_txs.iter().any(|ctx| ctx.txid == txid) {
+						if confirmed_txs.iter().any(|ctx| {
+							ctx.txid == bitcoin::Txid::from_slice(txid.as_ref()).unwrap()
+						}) {
 							continue;
 						}
 
@@ -354,7 +417,19 @@ where
 								for txin in &tx.input {
 									let watched_outpoint =
 										watched_output.outpoint.into_bitcoin_outpoint();
-									if txin.previous_output == watched_outpoint {
+
+									let mut outpoint_buffer = Vec::new();
+									watched_outpoint
+										.consensus_encode(&mut outpoint_buffer)
+										.unwrap();
+									let mut outpoint_slice = &outpoint_buffer[..];
+									let esplora_outpoint =
+										electrum_client::bitcoin::OutPoint::consensus_decode(
+											&mut outpoint_slice,
+										)
+										.unwrap();
+
+									if txin.previous_output == esplora_outpoint {
 										is_spend = true;
 										break;
 									}
@@ -365,7 +440,17 @@ where
 								}
 
 								let prob_conf_height = possible_output_spend.height as u32;
-								let confirmed_tx = self.get_confirmed_tx(&tx, prob_conf_height)?;
+
+								let mut tx_buffer = Vec::new();
+								tx.consensus_encode(&mut tx_buffer).unwrap();
+								let mut tx_slice = &tx_buffer[..];
+								let tx_reader =
+									&mut lightning::util::ser::BufReader::<_>::new(&mut tx_slice);
+								let bitcoin_transaction =
+									bitcoin::Transaction::consensus_decode(tx_reader).unwrap();
+
+								let confirmed_tx =
+									self.get_confirmed_tx(&bitcoin_transaction, prob_conf_height)?;
 								confirmed_txs.push(confirmed_tx);
 							},
 							Err(e) => {
@@ -414,7 +499,9 @@ where
 		for (txid, conf_height, block_hash_opt) in relevant_txids {
 			if let Some(block_hash) = block_hash_opt {
 				let block_header = self.client.block_header(conf_height as usize)?;
-				if block_header.block_hash() == block_hash {
+				if block_header.block_hash()
+					== electrum_client::bitcoin::BlockHash::from_slice(block_hash.as_ref()).unwrap()
+				{
 					// Skip if the tx is still confirmed in the block in question.
 					continue;
 				}
@@ -432,25 +519,41 @@ where
 	fn get_confirmed_tx(
 		&self, tx: &Transaction, prob_conf_height: u32,
 	) -> Result<ConfirmedTx, InternalError> {
-		let txid = tx.txid();
-		match self.client.transaction_get_merkle(&txid, prob_conf_height as usize) {
+		let txid = tx.compute_txid();
+		match self.client.transaction_get_merkle(
+			&electrum_client::bitcoin::Txid::from_slice(txid.as_ref()).unwrap(),
+			prob_conf_height as usize,
+		) {
 			Ok(merkle_res) => {
 				debug_assert_eq!(prob_conf_height, merkle_res.block_height as u32);
 				match self.client.block_header(prob_conf_height as usize) {
 					Ok(block_header) => {
 						let pos = merkle_res.pos;
-						if !validate_merkle_proof(&txid, &block_header.merkle_root, &merkle_res) {
+						if !validate_merkle_proof(
+							&electrum_client::bitcoin::Txid::from_slice(txid.as_ref()).unwrap(),
+							&block_header.merkle_root,
+							&merkle_res,
+						) {
 							log_trace!(
 								self.logger,
 								"Inconsistency: Block {} was unconfirmed during syncing.",
 								block_header.block_hash()
 							);
 							return Err(InternalError::Inconsistency);
 						}
+
+						let mut header_buffer = Vec::new();
+						block_header.consensus_encode(&mut header_buffer).unwrap();
+						let mut header_slice = &header_buffer[..];
+						let header_reader =
+							&mut lightning::util::ser::BufReader::<_>::new(&mut header_slice);
+						let bitcoin_header =
+							bitcoin::block::Header::consensus_decode(header_reader).unwrap();
+
 						let confirmed_tx = ConfirmedTx {
 							tx: tx.clone(),
 							txid,
-							block_header,
+							block_header: bitcoin_header,
 							block_height: prob_conf_height,
 							pos,
 						};