Fix esplora compilability.

Author: arik-so

lightning-transaction-sync/Cargo.toml

@@ -18,7 +18,7 @@ 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-blocking = ["esplora-client/blocking", "electrum-client"]
 electrum = ["electrum-client"]
 async-interface = []
 

lightning-transaction-sync/src/esplora.rs

@@ -16,6 +16,10 @@ use esplora_client::Builder;
 
 use core::ops::Deref;
 use std::collections::HashSet;
+use bitcoin::consensus::Decodable;
+use bitcoin::hashes::Hash as BitcoinHash;
+use electrum_client::bitcoin::hashes::Hash as ElectrumHash;
+use electrum_client::bitcoin::consensus::Encodable;
 
 /// Synchronizes LDK with a given [`Esplora`] server.
 ///
@@ -99,7 +103,7 @@ where
 
 		loop {
 			let pending_registrations = self.queue.lock().unwrap().process_queues(&mut sync_state);
-			let tip_is_new = Some(tip_hash) != sync_state.last_sync_hash;
+			let tip_is_new = Some(tip_hash) != sync_state.last_sync_hash.map(|hash| esplora_client::BlockHash::from_slice(hash.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.
@@ -156,7 +160,7 @@ where
 					match maybe_await!(self.sync_best_block_updated(
 						&confirmables,
 						&mut sync_state,
-						&tip_hash
+						&BlockHash::from_slice(tip_hash.as_ref()).unwrap()
 					)) {
 						Ok(()) => {},
 						Err(InternalError::Inconsistency) => {
@@ -231,7 +235,7 @@ where
 						return Err(TxSyncError::from(err));
 					},
 				}
-				sync_state.last_sync_hash = Some(tip_hash);
+				sync_state.last_sync_hash = Some(BlockHash::from_slice(tip_hash.as_ref()).unwrap());
 				sync_state.pending_sync = false;
 			}
 		}
@@ -263,12 +267,20 @@ where
 		C::Target: Confirm,
 	{
 		// Inform the interface of the new block.
-		let tip_header = maybe_await!(self.client.get_header_by_hash(tip_hash))?;
-		let tip_status = maybe_await!(self.client.get_block_status(&tip_hash))?;
+		let esplora_tip_hash = esplora_client::BlockHash::from_slice(tip_hash.as_ref()).unwrap();
+		let tip_status = maybe_await!(self.client.get_block_status(&esplora_tip_hash))?;
+
+		let tip_header: electrum_client::bitcoin::block::Header = maybe_await!(self.client.get_header_by_hash(&esplora_tip_hash))?;
+		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::<_, 4096>::new(&mut header_slice);
+		let bitcoin_header = bitcoin::block::Header::consensus_decode(header_reader).unwrap();
+
 		if tip_status.in_best_chain {
 			if let Some(tip_height) = tip_status.height {
 				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
@@ -301,11 +313,12 @@ where
 		for (_, output) in &sync_state.watched_outputs {
 			if let Some(output_status) = maybe_await!(self
 				.client
-				.get_output_status(&output.outpoint.txid, output.outpoint.index as u64))?
+				.get_output_status(&esplora_client::Txid::from_slice(output.outpoint.txid.as_ref()).unwrap(), output.outpoint.index as u64))?
 			{
 				if let Some(spending_txid) = output_status.txid {
+					let bitcoin_tx_id = bitcoin::Txid::from_slice(spending_txid.as_ref()).unwrap();
 					if let Some(spending_tx_status) = output_status.status {
-						if confirmed_txs.iter().any(|ctx| ctx.txid == spending_txid) {
+						if confirmed_txs.iter().any(|ctx| ctx.txid == bitcoin_tx_id) {
 							if spending_tx_status.confirmed {
 								// Skip inserting duplicate ConfirmedTx entry
 								continue;
@@ -316,8 +329,8 @@ where
 						}
 
 						if let Some(confirmed_tx) = maybe_await!(self.get_confirmed_tx(
-							spending_txid,
-							spending_tx_status.block_hash,
+							bitcoin_tx_id,
+							spending_tx_status.block_hash.map(|h| BlockHash::from_slice(h.as_ref()).unwrap()),
 							spending_tx_status.block_height,
 						))? {
 							confirmed_txs.push(confirmed_tx);
@@ -340,11 +353,11 @@ where
 	fn get_confirmed_tx(
 		&self, txid: Txid, expected_block_hash: Option<BlockHash>, known_block_height: Option<u32>,
 	) -> Result<Option<ConfirmedTx>, InternalError> {
-		if let Some(merkle_block) = maybe_await!(self.client.get_merkle_block(&txid))? {
+		if let Some(merkle_block) = maybe_await!(self.client.get_merkle_block(&esplora_client::Txid::from_slice(txid.as_ref()).unwrap()))? {
 			let block_header = merkle_block.header;
 			let block_hash = block_header.block_hash();
 			if let Some(expected_block_hash) = expected_block_hash {
-				if expected_block_hash != block_hash {
+				if expected_block_hash != bitcoin::BlockHash::from_slice(block_hash.as_ref()).unwrap() {
 					log_trace!(
 						self.logger,
 						"Inconsistency: Tx {} expected in block {}, but is confirmed in {}",
@@ -359,27 +372,53 @@ where
 			let mut matches = Vec::new();
 			let mut indexes = Vec::new();
 			let _ = merkle_block.txn.extract_matches(&mut matches, &mut indexes);
-			if indexes.len() != 1 || matches.len() != 1 || matches[0] != txid {
+			if indexes.len() != 1 || matches.len() != 1 || matches[0] != esplora_client::Txid::from_slice(txid.as_ref()).unwrap() {
 				log_error!(self.logger, "Retrieved Merkle block for txid {} doesn't match expectations. This should not happen. Please verify server integrity.", txid);
 				return Err(InternalError::Failed);
 			}
 
 			// unwrap() safety: len() > 0 is checked above
 			let pos = *indexes.first().unwrap() as usize;
-			if let Some(tx) = maybe_await!(self.client.get_tx(&txid))? {
-				if tx.txid() != txid {
+			if let Some(tx) = maybe_await!(self.client.get_tx(&esplora_client::Txid::from_slice(txid.as_ref()).unwrap()))? {
+				if tx.txid() != electrum_client::bitcoin::Txid::from_slice(txid.as_ref()).unwrap() {
 					log_error!(self.logger, "Retrieved transaction for txid {} doesn't match expectations. This should not happen. Please verify server integrity.", txid);
 					return Err(InternalError::Failed);
 				}
 
 				if let Some(block_height) = known_block_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::<_, 4096>::new(&mut tx_slice);
+					let bitcoin_transaction = bitcoin::Transaction::consensus_decode(tx_reader).unwrap();
+
+					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::<_, 4096>::new(&mut header_slice);
+					let bitcoin_header = bitcoin::block::Header::consensus_decode(header_reader).unwrap();
+
 					// We can take a shortcut here if a previous call already gave us the height.
-					return Ok(Some(ConfirmedTx { tx, txid, block_header, pos, block_height }));
+					return Ok(Some(ConfirmedTx { tx: bitcoin_transaction, txid, block_header: bitcoin_header, pos, block_height }));
 				}
 
 				let block_status = maybe_await!(self.client.get_block_status(&block_hash))?;
 				if let Some(block_height) = block_status.height {
-					return Ok(Some(ConfirmedTx { tx, txid, block_header, pos, block_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::<_, 4096>::new(&mut tx_slice);
+					let bitcoin_transaction = bitcoin::Transaction::consensus_decode(tx_reader).unwrap();
+
+					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::<_, 4096>::new(&mut header_slice);
+					let bitcoin_header = bitcoin::block::Header::consensus_decode(header_reader).unwrap();
+
+					return Ok(Some(ConfirmedTx { tx: bitcoin_transaction, txid, block_header: bitcoin_header, pos, block_height }));
 				} else {
 					// If any previously-confirmed block suddenly is no longer confirmed, we found
 					// an inconsistency and should start over.
@@ -413,7 +452,7 @@ where
 
 		for (txid, _conf_height, block_hash_opt) in relevant_txids {
 			if let Some(block_hash) = block_hash_opt {
-				let block_status = maybe_await!(self.client.get_block_status(&block_hash))?;
+				let block_status = maybe_await!(self.client.get_block_status(&electrum_client::bitcoin::BlockHash::from_slice(block_hash.as_ref()).unwrap()))?;
 				if block_status.in_best_chain {
 					// Skip if the block in question is still confirmed.
 					continue;