X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-transaction-sync%2Ftests%2Fintegration_tests.rs;h=48044b236bf8c1e6360334d40b6c729dca468a03;hb=d1d7d8787e0931af972c50a0895e11ae0215c1a7;hp=617b1213e89d368903b1903f151176bbc5b9e50e;hpb=89fb5a38046da60e6b9f95f2c3aaf4a6fa200e32;p=rust-lightning

diff --git a/lightning-transaction-sync/tests/integration_tests.rs b/lightning-transaction-sync/tests/integration_tests.rs
index 617b1213..48044b23 100644
--- a/lightning-transaction-sync/tests/integration_tests.rs
+++ b/lightning-transaction-sync/tests/integration_tests.rs
@@ -1,16 +1,21 @@
-#![cfg(any(feature = "esplora-blocking", feature = "esplora-async"))]
+#![cfg(all(not(target_os = "windows"), any(feature = "esplora-blocking", feature = "esplora-async", feature = "electrum")))]
+
+#[cfg(any(feature = "esplora-blocking", feature = "esplora-async"))]
 use lightning_transaction_sync::EsploraSyncClient;
-use lightning::chain::{Confirm, Filter};
-use lightning::chain::transaction::TransactionData;
-use lightning::util::logger::{Logger, Record};
+#[cfg(feature = "electrum")]
+use lightning_transaction_sync::ElectrumSyncClient;
+use lightning::chain::{Confirm, Filter, WatchedOutput};
+use lightning::chain::transaction::{OutPoint, TransactionData};
+use lightning::util::test_utils::TestLogger;
 
 use electrsd::{bitcoind, bitcoind::BitcoinD, ElectrsD};
-use bitcoin::{Amount, Txid, BlockHash, BlockHeader};
+use bitcoin::{Amount, Txid, BlockHash};
+use bitcoin::blockdata::block::Header;
 use bitcoin::blockdata::constants::genesis_block;
 use bitcoin::network::constants::Network;
 use electrsd::bitcoind::bitcoincore_rpc::bitcoincore_rpc_json::AddressType;
 use bitcoind::bitcoincore_rpc::RpcApi;
-use electrum_client::ElectrumApi;
+use bdk_macros::maybe_await;
 
 use std::env;
 use std::sync::Mutex;
@@ -42,21 +47,23 @@ pub fn generate_blocks_and_wait(bitcoind: &BitcoinD, electrsd: &ElectrsD, num: u
 	let address = bitcoind
 		.client
 		.get_new_address(Some("test"), Some(AddressType::Legacy))
-		.expect("failed to get new address");
+		.expect("failed to get new address")
+		.assume_checked();
 	// TODO: expect this Result once the WouldBlock issue is resolved upstream.
 	let _block_hashes_res = bitcoind.client.generate_to_address(num as u64, &address);
 	wait_for_block(electrsd, cur_height as usize + num);
 }
 
 pub fn wait_for_block(electrsd: &ElectrsD, min_height: usize) {
-	let mut header = match electrsd.client.block_headers_subscribe() {
+	use electrsd::electrum_client::ElectrumApi;
+	let mut header = match electrsd.client.block_headers_subscribe_raw() {
 		Ok(header) => header,
 		Err(_) => {
 			// While subscribing should succeed the first time around, we ran into some cases where
 			// it didn't. Since we can't proceed without subscribing, we try again after a delay
 			// and panic if it still fails.
 			std::thread::sleep(Duration::from_secs(1));
-			electrsd.client.block_headers_subscribe().expect("failed to subscribe to block headers")
+			electrsd.client.block_headers_subscribe_raw().expect("failed to subscribe to block headers")
 		}
 	};
 	loop {
@@ -66,7 +73,7 @@ pub fn wait_for_block(electrsd: &ElectrsD, min_height: usize) {
 		header = exponential_backoff_poll(|| {
 			electrsd.trigger().expect("failed to trigger electrsd");
 			electrsd.client.ping().expect("failed to ping electrsd");
-			electrsd.client.block_headers_pop().expect("failed to pop block header")
+			electrsd.client.block_headers_pop_raw().expect("failed to pop block header")
 		});
 	}
 }
@@ -119,7 +126,7 @@ impl TestConfirmable {
 }
 
 impl Confirm for TestConfirmable {
-	fn transactions_confirmed(&self, header: &BlockHeader, txdata: &TransactionData<'_>, height: u32) {
+	fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData<'_>, height: u32) {
 		for (_, tx) in txdata {
 			let txid = tx.txid();
 			let block_hash = header.block_hash();
@@ -135,25 +142,140 @@ impl Confirm for TestConfirmable {
 		self.events.lock().unwrap().push(TestConfirmableEvent::Unconfirmed(*txid));
 	}
 
-	fn best_block_updated(&self, header: &BlockHeader, height: u32) {
+	fn best_block_updated(&self, header: &Header, height: u32) {
 		let block_hash = header.block_hash();
 		*self.best_block.lock().unwrap() = (block_hash, height);
 		self.events.lock().unwrap().push(TestConfirmableEvent::BestBlockUpdated(block_hash, height));
 	}
 
-	fn get_relevant_txids(&self) -> Vec<(Txid, Option<BlockHash>)> {
-		self.confirmed_txs.lock().unwrap().iter().map(|(&txid, (hash, _))| (txid, Some(*hash))).collect::<Vec<_>>()
+	fn get_relevant_txids(&self) -> Vec<(Txid, u32, Option<BlockHash>)> {
+		self.confirmed_txs.lock().unwrap().iter().map(|(&txid, (hash, height))| (txid, *height, Some(*hash))).collect::<Vec<_>>()
 	}
 }
 
-pub struct TestLogger {}
+macro_rules! test_syncing {
+	($tx_sync: expr, $confirmable: expr, $bitcoind: expr, $electrsd: expr) => {{
+		// Check we pick up on new best blocks
+		assert_eq!($confirmable.best_block.lock().unwrap().1, 0);
+
+		maybe_await!($tx_sync.sync(vec![&$confirmable])).unwrap();
+		assert_eq!($confirmable.best_block.lock().unwrap().1, 102);
+
+		let events = std::mem::take(&mut *$confirmable.events.lock().unwrap());
+		assert_eq!(events.len(), 1);
+
+		// Check registered confirmed transactions are marked confirmed
+		let new_address = $bitcoind.client.get_new_address(Some("test"),
+		Some(AddressType::Legacy)).unwrap().assume_checked();
+		let txid = $bitcoind.client.send_to_address(&new_address, Amount::from_sat(5000), None, None,
+		None, None, None, None).unwrap();
+		let second_txid = $bitcoind.client.send_to_address(&new_address, Amount::from_sat(5000), None,
+		None, None, None, None, None).unwrap();
+		$tx_sync.register_tx(&txid, &new_address.payload.script_pubkey());
+
+		maybe_await!($tx_sync.sync(vec![&$confirmable])).unwrap();
+
+		let events = std::mem::take(&mut *$confirmable.events.lock().unwrap());
+		assert_eq!(events.len(), 0);
+		assert!($confirmable.confirmed_txs.lock().unwrap().is_empty());
+		assert!($confirmable.unconfirmed_txs.lock().unwrap().is_empty());
+
+		generate_blocks_and_wait(&$bitcoind, &$electrsd, 1);
+		maybe_await!($tx_sync.sync(vec![&$confirmable])).unwrap();
+
+		let events = std::mem::take(&mut *$confirmable.events.lock().unwrap());
+		assert_eq!(events.len(), 2);
+		assert!($confirmable.confirmed_txs.lock().unwrap().contains_key(&txid));
+		assert!($confirmable.unconfirmed_txs.lock().unwrap().is_empty());
+
+		// Now take an arbitrary output of the second transaction and check we'll confirm its spend.
+		let tx_res = $bitcoind.client.get_transaction(&second_txid, None).unwrap();
+		let block_hash = tx_res.info.blockhash.unwrap();
+		let tx = tx_res.transaction().unwrap();
+		let prev_outpoint = tx.input.first().unwrap().previous_output;
+		let prev_tx = $bitcoind.client.get_transaction(&prev_outpoint.txid, None).unwrap().transaction()
+			.unwrap();
+		let prev_script_pubkey = prev_tx.output[prev_outpoint.vout as usize].script_pubkey.clone();
+		let output = WatchedOutput {
+			block_hash: Some(block_hash),
+			outpoint: OutPoint { txid: prev_outpoint.txid, index: prev_outpoint.vout as u16 },
+			script_pubkey: prev_script_pubkey
+		};
+
+		$tx_sync.register_output(output);
+		maybe_await!($tx_sync.sync(vec![&$confirmable])).unwrap();
+
+		let events = std::mem::take(&mut *$confirmable.events.lock().unwrap());
+		assert_eq!(events.len(), 1);
+		assert!($confirmable.confirmed_txs.lock().unwrap().contains_key(&second_txid));
+		assert_eq!($confirmable.confirmed_txs.lock().unwrap().len(), 2);
+		assert!($confirmable.unconfirmed_txs.lock().unwrap().is_empty());
+
+		// Check previously confirmed transactions are marked unconfirmed when they are reorged.
+		let best_block_hash = $bitcoind.client.get_best_block_hash().unwrap();
+		$bitcoind.client.invalidate_block(&best_block_hash).unwrap();
+
+		// We're getting back to the previous height with a new tip, but best block shouldn't change.
+		generate_blocks_and_wait(&$bitcoind, &$electrsd, 1);
+		assert_ne!($bitcoind.client.get_best_block_hash().unwrap(), best_block_hash);
+		maybe_await!($tx_sync.sync(vec![&$confirmable])).unwrap();
+		let events = std::mem::take(&mut *$confirmable.events.lock().unwrap());
+		assert_eq!(events.len(), 0);
+
+		// Now we're surpassing previous height, getting new tip.
+		generate_blocks_and_wait(&$bitcoind, &$electrsd, 1);
+		assert_ne!($bitcoind.client.get_best_block_hash().unwrap(), best_block_hash);
+		maybe_await!($tx_sync.sync(vec![&$confirmable])).unwrap();
+
+		// Transactions still confirmed but under new tip.
+		assert!($confirmable.confirmed_txs.lock().unwrap().contains_key(&txid));
+		assert!($confirmable.confirmed_txs.lock().unwrap().contains_key(&second_txid));
+		assert!($confirmable.unconfirmed_txs.lock().unwrap().is_empty());
+
+		// Check we got unconfirmed, then reconfirmed in the meantime.
+		let mut seen_txids = HashSet::new();
+		let events = std::mem::take(&mut *$confirmable.events.lock().unwrap());
+		assert_eq!(events.len(), 5);
+
+		match events[0] {
+			TestConfirmableEvent::Unconfirmed(t) => {
+				assert!(t == txid || t == second_txid);
+				assert!(seen_txids.insert(t));
+			},
+			_ => panic!("Unexpected event"),
+		}
 
-impl Logger for TestLogger {
-	fn log(&self, record: &Record) {
-		println!("{} -- {}",
-				record.level,
-				record.args);
-	}
+		match events[1] {
+			TestConfirmableEvent::Unconfirmed(t) => {
+				assert!(t == txid || t == second_txid);
+				assert!(seen_txids.insert(t));
+			},
+			_ => panic!("Unexpected event"),
+		}
+
+		match events[2] {
+			TestConfirmableEvent::BestBlockUpdated(..) => {},
+			_ => panic!("Unexpected event"),
+		}
+
+		match events[3] {
+			TestConfirmableEvent::Confirmed(t, _, _) => {
+				assert!(t == txid || t == second_txid);
+				assert!(seen_txids.remove(&t));
+			},
+			_ => panic!("Unexpected event"),
+		}
+
+		match events[4] {
+			TestConfirmableEvent::Confirmed(t, _, _) => {
+				assert!(t == txid || t == second_txid);
+				assert!(seen_txids.remove(&t));
+			},
+			_ => panic!("Unexpected event"),
+		}
+
+		assert_eq!(seen_txids.len(), 0);
+	}};
 }
 
 #[test]
@@ -161,82 +283,12 @@ impl Logger for TestLogger {
 fn test_esplora_syncs() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	generate_blocks_and_wait(&bitcoind, &electrsd, 101);
-	let mut logger = TestLogger {};
+	let mut logger = TestLogger::new();
 	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
 	let tx_sync = EsploraSyncClient::new(esplora_url, &mut logger);
 	let confirmable = TestConfirmable::new();
 
-	// Check we pick up on new best blocks
-	assert_eq!(confirmable.best_block.lock().unwrap().1, 0);
-
-	tx_sync.sync(vec![&confirmable]).unwrap();
-	assert_eq!(confirmable.best_block.lock().unwrap().1, 102);
-
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 1);
-
-	// Check registered confirmed transactions are marked confirmed
-	let new_address = bitcoind.client.get_new_address(Some("test"), Some(AddressType::Legacy)).unwrap();
-	let txid = bitcoind.client.send_to_address(&new_address, Amount::from_sat(5000), None, None, None, None, None, None).unwrap();
-	tx_sync.register_tx(&txid, &new_address.script_pubkey());
-
-	tx_sync.sync(vec![&confirmable]).unwrap();
-
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 0);
-	assert!(confirmable.confirmed_txs.lock().unwrap().is_empty());
-	assert!(confirmable.unconfirmed_txs.lock().unwrap().is_empty());
-
-	generate_blocks_and_wait(&bitcoind, &electrsd, 1);
-	tx_sync.sync(vec![&confirmable]).unwrap();
-
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 2);
-	assert!(confirmable.confirmed_txs.lock().unwrap().contains_key(&txid));
-	assert!(confirmable.unconfirmed_txs.lock().unwrap().is_empty());
-
-	// Check previously confirmed transactions are marked unconfirmed when they are reorged.
-	let best_block_hash = bitcoind.client.get_best_block_hash().unwrap();
-	bitcoind.client.invalidate_block(&best_block_hash).unwrap();
-
-	// We're getting back to the previous height with a new tip, but best block shouldn't change.
-	generate_blocks_and_wait(&bitcoind, &electrsd, 1);
-	assert_ne!(bitcoind.client.get_best_block_hash().unwrap(), best_block_hash);
-	tx_sync.sync(vec![&confirmable]).unwrap();
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 0);
-
-	// Now we're surpassing previous height, getting new tip.
-	generate_blocks_and_wait(&bitcoind, &electrsd, 1);
-	assert_ne!(bitcoind.client.get_best_block_hash().unwrap(), best_block_hash);
-	tx_sync.sync(vec![&confirmable]).unwrap();
-
-	// Transaction still confirmed but under new tip.
-	assert!(confirmable.confirmed_txs.lock().unwrap().contains_key(&txid));
-	assert!(confirmable.unconfirmed_txs.lock().unwrap().is_empty());
-
-	// Check we got unconfirmed, then reconfirmed in the meantime.
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 3);
-
-	match events[0] {
-		TestConfirmableEvent::Unconfirmed(t) => {
-			assert_eq!(t, txid);
-		},
-		_ => panic!("Unexpected event"),
-	}
-
-	match events[1] {
-		TestConfirmableEvent::BestBlockUpdated(..) => {},
-		_ => panic!("Unexpected event"),
-	}
-
-	match events[2] {
-		TestConfirmableEvent::Confirmed(t, _, _) => {
-			assert_eq!(t, txid);
-		},
-		_ => panic!("Unexpected event"),
-	}
+	test_syncing!(tx_sync, confirmable, bitcoind, electrsd);
 }
 
 #[tokio::test]
@@ -244,80 +296,22 @@ fn test_esplora_syncs() {
 async fn test_esplora_syncs() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	generate_blocks_and_wait(&bitcoind, &electrsd, 101);
-	let mut logger = TestLogger {};
+	let mut logger = TestLogger::new();
 	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
 	let tx_sync = EsploraSyncClient::new(esplora_url, &mut logger);
 	let confirmable = TestConfirmable::new();
 
-	// Check we pick up on new best blocks
-	assert_eq!(confirmable.best_block.lock().unwrap().1, 0);
-
-	tx_sync.sync(vec![&confirmable]).await.unwrap();
-	assert_eq!(confirmable.best_block.lock().unwrap().1, 102);
-
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 1);
-
-	// Check registered confirmed transactions are marked confirmed
-	let new_address = bitcoind.client.get_new_address(Some("test"), Some(AddressType::Legacy)).unwrap();
-	let txid = bitcoind.client.send_to_address(&new_address, Amount::from_sat(5000), None, None, None, None, None, None).unwrap();
-	tx_sync.register_tx(&txid, &new_address.script_pubkey());
-
-	tx_sync.sync(vec![&confirmable]).await.unwrap();
-
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 0);
-	assert!(confirmable.confirmed_txs.lock().unwrap().is_empty());
-	assert!(confirmable.unconfirmed_txs.lock().unwrap().is_empty());
-
-	generate_blocks_and_wait(&bitcoind, &electrsd, 1);
-	tx_sync.sync(vec![&confirmable]).await.unwrap();
-
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 2);
-	assert!(confirmable.confirmed_txs.lock().unwrap().contains_key(&txid));
-	assert!(confirmable.unconfirmed_txs.lock().unwrap().is_empty());
-
-	// Check previously confirmed transactions are marked unconfirmed when they are reorged.
-	let best_block_hash = bitcoind.client.get_best_block_hash().unwrap();
-	bitcoind.client.invalidate_block(&best_block_hash).unwrap();
-
-	// We're getting back to the previous height with a new tip, but best block shouldn't change.
-	generate_blocks_and_wait(&bitcoind, &electrsd, 1);
-	assert_ne!(bitcoind.client.get_best_block_hash().unwrap(), best_block_hash);
-	tx_sync.sync(vec![&confirmable]).await.unwrap();
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 0);
-
-	// Now we're surpassing previous height, getting new tip.
-	generate_blocks_and_wait(&bitcoind, &electrsd, 1);
-	assert_ne!(bitcoind.client.get_best_block_hash().unwrap(), best_block_hash);
-	tx_sync.sync(vec![&confirmable]).await.unwrap();
-
-	// Transaction still confirmed but under new tip.
-	assert!(confirmable.confirmed_txs.lock().unwrap().contains_key(&txid));
-	assert!(confirmable.unconfirmed_txs.lock().unwrap().is_empty());
-
-	// Check we got unconfirmed, then reconfirmed in the meantime.
-	let events = std::mem::take(&mut *confirmable.events.lock().unwrap());
-	assert_eq!(events.len(), 3);
-
-	match events[0] {
-		TestConfirmableEvent::Unconfirmed(t) => {
-			assert_eq!(t, txid);
-		},
-		_ => panic!("Unexpected event"),
-	}
-
-	match events[1] {
-		TestConfirmableEvent::BestBlockUpdated(..) => {},
-		_ => panic!("Unexpected event"),
-	}
+	test_syncing!(tx_sync, confirmable, bitcoind, electrsd);
+}
 
-	match events[2] {
-		TestConfirmableEvent::Confirmed(t, _, _) => {
-			assert_eq!(t, txid);
-		},
-		_ => panic!("Unexpected event"),
-	}
+#[test]
+#[cfg(feature = "electrum")]
+fn test_electrum_syncs() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	generate_blocks_and_wait(&bitcoind, &electrsd, 101);
+	let mut logger = TestLogger::new();
+	let electrum_url = format!("tcp://{}", electrsd.electrum_url);
+	let tx_sync = ElectrumSyncClient::new(electrum_url, &mut logger).unwrap();
+	let confirmable = TestConfirmable::new();
+	test_syncing!(tx_sync, confirmable, bitcoind, electrsd);
 }