f Extend checks for trusted_peers_no_reserve

Author: tnull

tests/common/mod.rs

@@ -207,7 +207,7 @@ macro_rules! setup_builder {
 pub(crate) use setup_builder;
 
 pub(crate) fn setup_two_nodes(
-	electrsd: &ElectrsD, allow_0conf: bool, anchor_channels: bool,
+	electrsd: &ElectrsD, allow_0conf: bool, anchor_channels: bool, anchors_trusted_no_reserve: bool,
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
 	let config_a = random_config(anchor_channels);
@@ -218,6 +218,14 @@ pub(crate) fn setup_two_nodes(
 	if allow_0conf {
 		config_b.trusted_peers_0conf.push(node_a.node_id());
 	}
+	if anchor_channels && anchors_trusted_no_reserve {
+		config_b
+			.anchor_channels_config
+			.as_mut()
+			.unwrap()
+			.trusted_peers_no_reserve
+			.push(node_a.node_id());
+	}
 	let node_b = setup_node(electrsd, config_b);
 	(node_a, node_b)
 }
@@ -417,20 +425,40 @@ pub(crate) fn do_channel_full_cycle<E: ElectrumApi>(
 	node_b.sync_wallets().unwrap();
 
 	let onchain_fee_buffer_sat = 1500;
-	let anchor_reserve_sat = if expect_anchor_channel { 25_000 } else { 0 };
-	let node_a_upper_bound_sat = premine_amount_sat - anchor_reserve_sat - funding_amount_sat;
-	let node_a_lower_bound_sat =
-		premine_amount_sat - anchor_reserve_sat - funding_amount_sat - onchain_fee_buffer_sat;
+	let node_a_anchor_reserve_sat = if expect_anchor_channel { 25_000 } else { 0 };
+	let node_a_upper_bound_sat =
+		premine_amount_sat - node_a_anchor_reserve_sat - funding_amount_sat;
+	let node_a_lower_bound_sat = premine_amount_sat
+		- node_a_anchor_reserve_sat
+		- funding_amount_sat
+		- onchain_fee_buffer_sat;
 	assert!(node_a.list_balances().spendable_onchain_balance_sats < node_a_upper_bound_sat);
 	assert!(node_a.list_balances().spendable_onchain_balance_sats > node_a_lower_bound_sat);
 	assert_eq!(
-		node_b.list_balances().spendable_onchain_balance_sats,
-		premine_amount_sat - anchor_reserve_sat
+		node_a.list_balances().total_anchor_channels_reserve_sats,
+		node_a_anchor_reserve_sat
 	);
 
-	expect_channel_ready_event!(node_a, node_b.node_id());
+	let node_b_anchor_reserve_sat = if node_b
+		.config()
+		.anchor_channels_config
+		.map_or(true, |acc| acc.trusted_peers_no_reserve.contains(&node_a.node_id()))
+	{
+		0
+	} else {
+		25_000
+	};
+	assert_eq!(
+		node_b.list_balances().spendable_onchain_balance_sats,
+		premine_amount_sat - node_b_anchor_reserve_sat
+	);
+	assert_eq!(
+		node_b.list_balances().total_anchor_channels_reserve_sats,
+		node_b_anchor_reserve_sat
+	);
 
-	let user_channel_id = expect_channel_ready_event!(node_b, node_a.node_id());
+	let user_channel_id = expect_channel_ready_event!(node_a, node_b.node_id());
+	expect_channel_ready_event!(node_b, node_a.node_id());
 
 	println!("\nB receive");
 	let invoice_amount_1_msat = 2500_000;
@@ -589,9 +617,9 @@ pub(crate) fn do_channel_full_cycle<E: ElectrumApi>(
 	println!("\nB close_channel (force: {})", force_close);
 	if force_close {
 		std::thread::sleep(Duration::from_secs(1));
-		node_b.close_channel(&user_channel_id, node_a.node_id(), true).unwrap();
+		node_a.close_channel(&user_channel_id, node_b.node_id(), true).unwrap();
 	} else {
-		node_b.close_channel(&user_channel_id, node_a.node_id(), false).unwrap();
+		node_a.close_channel(&user_channel_id, node_b.node_id(), false).unwrap();
 	}
 
 	expect_event!(node_a, ChannelClosed);
@@ -604,84 +632,84 @@ pub(crate) fn do_channel_full_cycle<E: ElectrumApi>(
 	node_b.sync_wallets().unwrap();
 
 	if force_close {
-		// Check node_a properly sees all balances and sweeps them.
-		assert_eq!(node_a.list_balances().lightning_balances.len(), 1);
-		match node_a.list_balances().lightning_balances[0] {
+		// Check node_b properly sees all balances and sweeps them.
+		assert_eq!(node_b.list_balances().lightning_balances.len(), 1);
+		match node_b.list_balances().lightning_balances[0] {
 			LightningBalance::ClaimableAwaitingConfirmations {
 				counterparty_node_id,
 				confirmation_height,
 				..
 			} => {
-				assert_eq!(counterparty_node_id, node_b.node_id());
-				let cur_height = node_a.status().current_best_block.height;
+				assert_eq!(counterparty_node_id, node_a.node_id());
+				let cur_height = node_b.status().current_best_block.height;
 				let blocks_to_go = confirmation_height - cur_height;
 				generate_blocks_and_wait(&bitcoind, electrsd, blocks_to_go as usize);
-				node_a.sync_wallets().unwrap();
 				node_b.sync_wallets().unwrap();
+				node_a.sync_wallets().unwrap();
 			},
 			_ => panic!("Unexpected balance state!"),
 		}
 
-		assert!(node_a.list_balances().lightning_balances.is_empty());
-		assert_eq!(node_a.list_balances().pending_balances_from_channel_closures.len(), 1);
-		match node_a.list_balances().pending_balances_from_channel_closures[0] {
+		assert!(node_b.list_balances().lightning_balances.is_empty());
+		assert_eq!(node_b.list_balances().pending_balances_from_channel_closures.len(), 1);
+		match node_b.list_balances().pending_balances_from_channel_closures[0] {
 			PendingSweepBalance::BroadcastAwaitingConfirmation { .. } => {},
 			_ => panic!("Unexpected balance state!"),
 		}
 		generate_blocks_and_wait(&bitcoind, electrsd, 1);
-		node_a.sync_wallets().unwrap();
 		node_b.sync_wallets().unwrap();
+		node_a.sync_wallets().unwrap();
 
-		assert!(node_a.list_balances().lightning_balances.is_empty());
-		assert_eq!(node_a.list_balances().pending_balances_from_channel_closures.len(), 1);
-		match node_a.list_balances().pending_balances_from_channel_closures[0] {
+		assert!(node_b.list_balances().lightning_balances.is_empty());
+		assert_eq!(node_b.list_balances().pending_balances_from_channel_closures.len(), 1);
+		match node_b.list_balances().pending_balances_from_channel_closures[0] {
 			PendingSweepBalance::AwaitingThresholdConfirmations { .. } => {},
 			_ => panic!("Unexpected balance state!"),
 		}
 		generate_blocks_and_wait(&bitcoind, electrsd, 5);
-		node_a.sync_wallets().unwrap();
 		node_b.sync_wallets().unwrap();
+		node_a.sync_wallets().unwrap();
 
-		assert!(node_a.list_balances().lightning_balances.is_empty());
-		assert!(node_a.list_balances().pending_balances_from_channel_closures.is_empty());
+		assert!(node_b.list_balances().lightning_balances.is_empty());
+		assert!(node_b.list_balances().pending_balances_from_channel_closures.is_empty());
 
-		// Check node_b properly sees all balances and sweeps them.
-		assert_eq!(node_b.list_balances().lightning_balances.len(), 1);
-		match node_b.list_balances().lightning_balances[0] {
+		// Check node_a properly sees all balances and sweeps them.
+		assert_eq!(node_a.list_balances().lightning_balances.len(), 1);
+		match node_a.list_balances().lightning_balances[0] {
 			LightningBalance::ClaimableAwaitingConfirmations {
 				counterparty_node_id,
 				confirmation_height,
 				..
 			} => {
-				assert_eq!(counterparty_node_id, node_a.node_id());
-				let cur_height = node_b.status().current_best_block.height;
+				assert_eq!(counterparty_node_id, node_b.node_id());
+				let cur_height = node_a.status().current_best_block.height;
 				let blocks_to_go = confirmation_height - cur_height;
 				generate_blocks_and_wait(&bitcoind, electrsd, blocks_to_go as usize);
-				node_b.sync_wallets().unwrap();
 				node_a.sync_wallets().unwrap();
+				node_b.sync_wallets().unwrap();
 			},
 			_ => panic!("Unexpected balance state!"),
 		}
 
-		assert!(node_b.list_balances().lightning_balances.is_empty());
-		assert_eq!(node_b.list_balances().pending_balances_from_channel_closures.len(), 1);
-		match node_b.list_balances().pending_balances_from_channel_closures[0] {
+		assert!(node_a.list_balances().lightning_balances.is_empty());
+		assert_eq!(node_a.list_balances().pending_balances_from_channel_closures.len(), 1);
+		match node_a.list_balances().pending_balances_from_channel_closures[0] {
 			PendingSweepBalance::BroadcastAwaitingConfirmation { .. } => {},
 			_ => panic!("Unexpected balance state!"),
 		}
 		generate_blocks_and_wait(&bitcoind, electrsd, 1);
-		node_b.sync_wallets().unwrap();
 		node_a.sync_wallets().unwrap();
+		node_b.sync_wallets().unwrap();
 
-		assert!(node_b.list_balances().lightning_balances.is_empty());
-		assert_eq!(node_b.list_balances().pending_balances_from_channel_closures.len(), 1);
-		match node_b.list_balances().pending_balances_from_channel_closures[0] {
+		assert!(node_a.list_balances().lightning_balances.is_empty());
+		assert_eq!(node_a.list_balances().pending_balances_from_channel_closures.len(), 1);
+		match node_a.list_balances().pending_balances_from_channel_closures[0] {
 			PendingSweepBalance::AwaitingThresholdConfirmations { .. } => {},
 			_ => panic!("Unexpected balance state!"),
 		}
 		generate_blocks_and_wait(&bitcoind, electrsd, 5);
-		node_b.sync_wallets().unwrap();
 		node_a.sync_wallets().unwrap();
+		node_b.sync_wallets().unwrap();
 	}
 
 	let sum_of_all_payments_sat = (push_msat
@@ -701,6 +729,9 @@ pub(crate) fn do_channel_full_cycle<E: ElectrumApi>(
 	assert!(node_b.list_balances().spendable_onchain_balance_sats > node_b_lower_bound_sat);
 	assert!(node_b.list_balances().spendable_onchain_balance_sats <= node_b_upper_bound_sat);
 
+	assert_eq!(node_a.list_balances().total_anchor_channels_reserve_sats, 0);
+	assert_eq!(node_b.list_balances().total_anchor_channels_reserve_sats, 0);
+
 	// Check we handled all events
 	assert_eq!(node_a.next_event(), None);
 	assert_eq!(node_b.next_event(), None);

tests/integration_tests_rust.rs

@@ -22,35 +22,42 @@ use crate::common::expect_channel_ready_event;
 #[test]
 fn channel_full_cycle() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true, false);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, true, false);
 }
 
 #[test]
 fn channel_full_cycle_force_close() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true, false);
+	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, true, true);
+}
+
+#[test]
+fn channel_full_cycle_force_close_trusted_no_reserve() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true, true);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, true, true);
 }
 
 #[test]
 fn channel_full_cycle_0conf() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, true, true);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, true, true, false);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, true, true, false)
 }
 
 #[test]
 fn channel_full_cycle_legacy_staticremotekey() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, false, false);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, false, false);
 	do_channel_full_cycle(node_a, node_b, &bitcoind.client, &electrsd.client, false, false, false);
 }
 
 #[test]
 fn channel_open_fails_when_funds_insufficient() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true, false);
 
 	let addr_a = node_a.onchain_payment().new_address().unwrap();
 	let addr_b = node_b.onchain_payment().new_address().unwrap();
@@ -241,7 +248,7 @@ fn start_stop_reinit() {
 #[test]
 fn onchain_spend_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true, false);
 
 	let addr_a = node_a.onchain_payment().new_address().unwrap();
 	let addr_b = node_b.onchain_payment().new_address().unwrap();
@@ -307,7 +314,7 @@ fn connection_restart_behavior() {
 
 fn do_connection_restart_behavior(persist: bool) {
 	let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, false, false);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, false, false);
 
 	let node_id_a = node_a.node_id();
 	let node_id_b = node_b.node_id();
@@ -358,7 +365,7 @@ fn do_connection_restart_behavior(persist: bool) {
 #[test]
 fn concurrent_connections_succeed() {
 	let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true, false);
 
 	let node_a = Arc::new(node_a);
 	let node_b = Arc::new(node_b);
@@ -388,7 +395,7 @@ fn concurrent_connections_succeed() {
 #[test]
 fn simple_bolt12_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true);
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false, true, false);
 
 	let address_a = node_a.onchain_payment().new_address().unwrap();
 	let premine_amount_sat = 5_000_000;