Skip to content

Commit

Permalink
Add Electrum integration test
Browse files Browse the repository at this point in the history
  • Loading branch information
tnull committed Oct 30, 2023
1 parent e3edff2 commit e38abe0
Show file tree
Hide file tree
Showing 2 changed files with 137 additions and 2 deletions.
2 changes: 2 additions & 0 deletions ci/ci-tests.sh
Original file line number Diff line number Diff line change
Expand Up @@ -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

Expand Down
137 changes: 135 additions & 2 deletions lightning-transaction-sync/tests/integration_tests.rs
Original file line number Diff line number Diff line change
@@ -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;
Expand All @@ -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;
Expand Down Expand Up @@ -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(_) => {
Expand Down Expand Up @@ -391,3 +395,132 @@ async fn test_esplora_syncs() {
_ => 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 = 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"),
}
}

0 comments on commit e38abe0

Please sign in to comment.