Add Electrum integration test

Author: tnull

ci/ci-tests.sh

@@ -68,6 +68,8 @@ if [[ $RUSTC_MINOR_VERSION -gt 67 && "$HOST_PLATFORM" != *windows* ]]; then
 	cargo check --verbose --color always --features esplora-async
 	cargo test --verbose --color always --features esplora-async-https
 	cargo check --verbose --color always --features esplora-async-https
+	cargo test --verbose --color always --features electrum
+	cargo check --verbose --color always --features electrum
 	popd
 fi
 

lightning-transaction-sync/tests/integration_tests.rs

@@ -1,5 +1,9 @@
-#![cfg(any(feature = "esplora-blocking", feature = "esplora-async"))]
+#![cfg(any(feature = "esplora-blocking", feature = "esplora-async", feature = "electrum"))]
+
+#[cfg(any(feature = "esplora-blocking", feature = "esplora-async"))]
 use lightning_transaction_sync::EsploraSyncClient;
+#[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;
@@ -10,7 +14,6 @@ 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 std::env;
 use std::sync::Mutex;
@@ -49,6 +52,7 @@ pub fn generate_blocks_and_wait(bitcoind: &BitcoinD, electrsd: &ElectrsD, num: u
 }
 
 pub fn wait_for_block(electrsd: &ElectrsD, min_height: usize) {
+	use electrsd::electrum_client::ElectrumApi;
 	let mut header = match electrsd.client.block_headers_subscribe() {
 		Ok(header) => header,
 		Err(_) => {
@@ -409,3 +413,132 @@ async fn test_esplora_syncs() {
 
 	assert_eq!(seen_txids.len(), 0);
 }
+
+#[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 = match ElectrumSyncClient::new(electrum_url, &mut logger) {
+		Ok(tx_sync) => tx_sync,
+		Err(e) => {
+			eprintln!("{:?}", e);
+			panic!("{:?}", e);
+		}
+	};
+	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();
+	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.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());
+
+	// Now take a random output of the first 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);
+	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);
+	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();
+
+	// 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 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);
+		},
+		_ => panic!("Unexpected event"),
+	}
+
+	match events[1] {
+		TestConfirmableEvent::Unconfirmed(t) => {
+			assert!(t == txid || t == second_txid);
+		},
+		_ => panic!("Unexpected event"),
+	}
+
+	match events[2] {
+		TestConfirmableEvent::BestBlockUpdated(..) => {},
+		_ => panic!("Unexpected event"),
+	}
+
+	match events[3] {
+		TestConfirmableEvent::Confirmed(t, _, _) => {
+			assert!(t == txid || t == second_txid);
+		},
+		_ => panic!("Unexpected event"),
+	}
+
+	match events[4] {
+		TestConfirmableEvent::Confirmed(t, _, _) => {
+			assert!(t == txid || t == second_txid);
+		},
+		_ => panic!("Unexpected event"),
+	}
+}