diff --git a/ci/ci-tests.sh b/ci/ci-tests.sh index 00fc54774d..2db32a1081 100755 --- a/ci/ci-tests.sh +++ b/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 diff --git a/lightning-transaction-sync/src/electrum.rs b/lightning-transaction-sync/src/electrum.rs index 4dbd536096..dda2d54c84 100644 --- a/lightning-transaction-sync/src/electrum.rs +++ b/lightning-transaction-sync/src/electrum.rs @@ -112,17 +112,29 @@ 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. - if self.check_update_tip(&mut tip_header, &mut tip_height)? - { - log_debug!(self.logger, - "Encountered inconsistency during transaction sync, restarting."); - sync_state.pending_sync = true; - continue; + match self.check_update_tip(&mut tip_header, &mut tip_height) { + Ok(false) => { + num_unconfirmed += unconfirmed_txs.len(); + sync_state.sync_unconfirmed_transactions(&confirmables, + unconfirmed_txs); + } + Ok(true) => { + log_debug!(self.logger, + "Encountered inconsistency during transaction sync, restarting."); + sync_state.pending_sync = true; + continue; + } + Err(err) => { + // (Semi-)permanent failure, retry later. + log_error!(self.logger, + "Failed during transaction sync, aborting. Synced so far: {} confirmed, {} unconfirmed.", + num_confirmed, + num_unconfirmed + ); + sync_state.pending_sync = true; + return Err(TxSyncError::from(err)); + } } - - num_unconfirmed += unconfirmed_txs.len(); - sync_state.sync_unconfirmed_transactions(&confirmables, - unconfirmed_txs); }, Err(err) => { // (Semi-)permanent failure, retry later. @@ -146,19 +158,29 @@ where Ok(confirmed_txs) => { // Double-check the tip hash. If it changed, a reorg happened since // we started syncing and we need to restart last-minute. - if self.check_update_tip(&mut tip_header, &mut tip_height)? - { - log_debug!(self.logger, - "Encountered inconsistency during transaction sync, restarting."); - sync_state.pending_sync = true; - continue; + match self.check_update_tip(&mut tip_header, &mut tip_height) { + Ok(false) => { + num_confirmed += confirmed_txs.len(); + sync_state.sync_confirmed_transactions(&confirmables, + confirmed_txs); + } + Ok(true) => { + log_debug!(self.logger, + "Encountered inconsistency during transaction sync, restarting."); + sync_state.pending_sync = true; + continue; + } + Err(err) => { + // (Semi-)permanent failure, retry later. + log_error!(self.logger, + "Failed during transaction sync, aborting. Synced so far: {} confirmed, {} unconfirmed.", + num_confirmed, + num_unconfirmed + ); + sync_state.pending_sync = true; + return Err(TxSyncError::from(err)); + } } - - num_confirmed += confirmed_txs.len(); - sync_state.sync_confirmed_transactions( - &confirmables, - confirmed_txs, - ); } Err(InternalError::Inconsistency) => { // Immediately restart syncing when we encounter any inconsistencies. diff --git a/lightning-transaction-sync/tests/integration_tests.rs b/lightning-transaction-sync/tests/integration_tests.rs index 9c04c82b7d..2288f2b981 100644 --- a/lightning-transaction-sync/tests/integration_tests.rs +++ b/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,135 @@ 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 = ElectrumSyncClient::new(electrum_url, &mut logger).unwrap(); + 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 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); + 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 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"), + } + + 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); +}