Introduce multi-hop payment test

tnull · tnull · commit c0112bbc1fa3 · 2023-11-07T12:23:32.000+01:00
We establish a simple 5-node topology and try to send a payment from one
end to the other.
diff --git a/src/test/functional_tests.rs b/src/test/functional_tests.rs
@@ -1,7 +1,7 @@
 use crate::builder::NodeBuilder;
 use crate::io::test_utils::TestSyncStore;
 use crate::test::utils::*;
-use crate::test::utils::{expect_event, random_config, setup_two_nodes};
+use crate::test::utils::{expect_channel_pending_event, expect_event, open_channel, random_config};
 use crate::{Error, Event, Node, PaymentDirection, PaymentStatus};
 
 use bitcoin::Amount;
@@ -86,24 +86,13 @@ fn do_channel_full_cycle<K: KVStore + Sync + Send>(
 		.unwrap();
 
 	assert_eq!(node_a.list_peers().first().unwrap().node_id, node_b.node_id());
-	expect_event!(node_a, ChannelPending);
+	let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id());
+	let funding_txo_b = expect_channel_pending_event!(node_b, node_a.node_id());
+	assert_eq!(funding_txo_a, funding_txo_b);
 
-	let funding_txo = match node_b.wait_next_event() {
-		ref e @ Event::ChannelPending { funding_txo, .. } => {
-			println!("{} got event {:?}", std::stringify!(node_b), e);
-			assert_eq!(node_b.next_event().as_ref(), Some(e));
-			node_b.event_handled();
-			funding_txo
-		}
-		ref e => {
-			panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e);
-		}
-	};
-
-	wait_for_tx(&electrsd, funding_txo.txid);
+	wait_for_tx(&electrsd, funding_txo_a.txid);
 
 	if !allow_0conf {
-		println!("\n .. generating blocks ..");
 		generate_blocks_and_wait(&bitcoind, &electrsd, 6);
 	}
 
@@ -276,7 +265,7 @@ fn do_channel_full_cycle<K: KVStore + Sync + Send>(
 	expect_event!(node_a, ChannelClosed);
 	expect_event!(node_b, ChannelClosed);
 
-	wait_for_outpoint_spend(&electrsd, funding_txo);
+	wait_for_outpoint_spend(&electrsd, funding_txo_b);
 
 	generate_blocks_and_wait(&bitcoind, &electrsd, 1);
 	node_a.sync_wallets().unwrap();
@@ -341,6 +330,83 @@ fn channel_open_fails_when_funds_insufficient() {
 	);
 }
 
+#[test]
+fn multi_hop_sending() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
+
+	// Setup and fund 5 nodes
+	let mut nodes = Vec::new();
+	for _ in 0..5 {
+		let config = random_config();
+		let mut builder = NodeBuilder::from_config(config);
+		builder.set_esplora_server(esplora_url.clone());
+		let node = builder.build().unwrap();
+		node.start().unwrap();
+		nodes.push(node);
+	}
+
+	let addresses = nodes.iter().map(|n| n.new_onchain_address().unwrap()).collect();
+	let premine_amount_sat = 5_000_000;
+	premine_and_distribute_funds(
+		&bitcoind,
+		&electrsd,
+		addresses,
+		Amount::from_sat(premine_amount_sat),
+	);
+
+	for n in &nodes {
+		n.sync_wallets().unwrap();
+		assert_eq!(n.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
+		assert_eq!(n.next_event(), None);
+	}
+
+	// Setup channel topology:
+	//                    (1M:0)- N2 -(1M:0)
+	//                   /                  \
+	//  N0 -(100k:0)-> N1                    N4
+	//                   \                  /
+	//                    (1M:0)- N3 -(1M:0)
+
+	open_channel(&nodes[0], &nodes[1], 100_000, true, &electrsd);
+	open_channel(&nodes[1], &nodes[2], 1_000_000, true, &electrsd);
+	// We need to sync wallets in-between back-to-back channel opens from the same node so BDK
+	// wallet picks up on the broadcast funding tx and doesn't double-spend itself.
+	//
+	// TODO: Remove once fixed in BDK.
+	nodes[1].sync_wallets().unwrap();
+	open_channel(&nodes[1], &nodes[3], 1_000_000, true, &electrsd);
+	open_channel(&nodes[2], &nodes[4], 1_000_000, true, &electrsd);
+	open_channel(&nodes[3], &nodes[4], 1_000_000, true, &electrsd);
+
+	generate_blocks_and_wait(&bitcoind, &electrsd, 6);
+
+	for n in &nodes {
+		n.sync_wallets().unwrap();
+	}
+
+	expect_event!(nodes[0], ChannelReady);
+	expect_event!(nodes[1], ChannelReady);
+	expect_event!(nodes[1], ChannelReady);
+	expect_event!(nodes[1], ChannelReady);
+	expect_event!(nodes[2], ChannelReady);
+	expect_event!(nodes[2], ChannelReady);
+	expect_event!(nodes[3], ChannelReady);
+	expect_event!(nodes[3], ChannelReady);
+	expect_event!(nodes[4], ChannelReady);
+	expect_event!(nodes[4], ChannelReady);
+
+	// Sleep a bit for gossip to propagate.
+	// FIXME: This doesn't work anyways currently and should be removed when we have a solution.
+	std::thread::sleep(std::time::Duration::from_secs(60));
+
+	let invoice = nodes[4].receive_payment(10000, &"asdf", 9217).unwrap();
+	nodes[0].send_payment(&invoice).unwrap();
+
+	expect_event!(nodes[4], PaymentReceived);
+	expect_event!(nodes[0], PaymentSuccessful);
+}
+
 #[test]
 fn connect_to_public_testnet_esplora() {
 	let mut config = random_config();
diff --git a/src/test/utils.rs b/src/test/utils.rs
@@ -1,7 +1,8 @@
 use crate::builder::NodeBuilder;
 use crate::io::test_utils::TestSyncStore;
-use crate::{Config, Node};
+use crate::{Config, Event, Node};
 use lightning::util::logger::{Level, Logger, Record};
+use lightning::util::persist::KVStore;
 
 use bitcoin::{Address, Amount, Network, OutPoint, Txid};
 
@@ -25,7 +26,7 @@ macro_rules! expect_event {
 	($node: expr, $event_type: ident) => {{
 		match $node.wait_next_event() {
 			ref e @ Event::$event_type { .. } => {
-				println!("{} got event {:?}", std::stringify!($node), e);
+				println!("{} got event {:?}", $node.node_id(), e);
 				$node.event_handled();
 			}
 			ref e => {
@@ -37,6 +38,24 @@ macro_rules! expect_event {
 
 pub(crate) use expect_event;
 
+macro_rules! expect_channel_pending_event {
+	($node: expr, $counterparty_node_id: expr) => {{
+		match $node.wait_next_event() {
+			ref e @ Event::ChannelPending { funding_txo, counterparty_node_id, .. } => {
+				println!("{} got event {:?}", $node.node_id(), e);
+				assert_eq!(counterparty_node_id, $counterparty_node_id);
+				$node.event_handled();
+				funding_txo
+			}
+			ref e => {
+				panic!("{} got unexpected event!: {:?}", std::stringify!($node), e);
+			}
+		}
+	}};
+}
+
+pub(crate) use expect_channel_pending_event;
+
 // Copied over from upstream LDK
 #[allow(dead_code)]
 pub struct TestLogger {
@@ -149,7 +168,7 @@ pub fn random_config() -> Config {
 	let listening_address_str = format!("127.0.0.1:{}", rand_port);
 	config.listening_address = Some(listening_address_str.parse().unwrap());
 
-	config.log_level = Level::Trace;
+	config.log_level = Level::Gossip;
 
 	config
 }
@@ -201,6 +220,7 @@ pub(crate) fn setup_node(electrsd: &ElectrsD, config: Config) -> Node<TestSyncSt
 }
 
 pub fn generate_blocks_and_wait(bitcoind: &BitcoinD, electrsd: &ElectrsD, num: usize) {
+	print!("Generating {} blocks...", num);
 	let cur_height = bitcoind.client.get_block_count().expect("failed to get current block height");
 	let address = bitcoind
 		.client
@@ -209,6 +229,8 @@ pub fn generate_blocks_and_wait(bitcoind: &BitcoinD, electrsd: &ElectrsD, num: u
 	// 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);
+	print!(" Done!");
+	println!("\n");
 }
 
 pub fn wait_for_block(electrsd: &ElectrsD, min_height: usize) {
@@ -301,3 +323,25 @@ pub fn premine_and_distribute_funds(
 
 	generate_blocks_and_wait(bitcoind, electrsd, 1);
 }
+
+pub fn open_channel<K: KVStore + Sync + Send>(
+	node_a: &Node<K>, node_b: &Node<K>, funding_amount_sat: u64, announce: bool,
+	electrsd: &ElectrsD,
+) {
+	node_a
+		.connect_open_channel(
+			node_b.node_id(),
+			node_b.listening_address().unwrap().into(),
+			funding_amount_sat,
+			None,
+			None,
+			announce,
+		)
+		.unwrap();
+	assert!(node_a.list_peers().iter().find(|c| { c.node_id == node_b.node_id() }).is_some());
+
+	let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id());
+	let funding_txo_b = expect_channel_pending_event!(node_b, node_a.node_id());
+	assert_eq!(funding_txo_a, funding_txo_b);
+	wait_for_tx(&electrsd, funding_txo_a.txid);
+}
