Don't fail send_all retaining reserves for 0 channels

Previouly, `OnchainPayment::send_all_to_address` would fail in the
`retain_reserves` mode if the maintained reserves were below the dust
limit. Most notably this would happen if we had no channels open at all.

Here, we fix this by simply falling back to the draining case (not
considering reserves) if the anchor reserves are below dust. We also add
a unit test that would have caught this regression in the first place.

Author: tnull

src/wallet/mod.rs

@@ -355,14 +355,17 @@ where
 			let mut locked_wallet = self.inner.lock().unwrap();
 
 			// Prepare the tx_builder. We properly check the reserve requirements (again) further down.
+			const DUST_LIMIT_SATS: u64 = 546;
 			let tx_builder = match send_amount {
 				OnchainSendAmount::ExactRetainingReserve { amount_sats, .. } => {
 					let mut tx_builder = locked_wallet.build_tx();
 					let amount = Amount::from_sat(amount_sats);
 					tx_builder.add_recipient(address.script_pubkey(), amount).fee_rate(fee_rate);
 					tx_builder
 				},
-				OnchainSendAmount::AllRetainingReserve { cur_anchor_reserve_sats } => {
+				OnchainSendAmount::AllRetainingReserve { cur_anchor_reserve_sats }
+					if cur_anchor_reserve_sats > DUST_LIMIT_SATS =>
+				{
 					let change_address_info = locked_wallet.peek_address(KeychainKind::Internal, 0);
 					let balance = locked_wallet.balance();
 					let spendable_amount_sats = self
@@ -419,7 +422,8 @@ where
 						.fee_absolute(estimated_tx_fee);
 					tx_builder
 				},
-				OnchainSendAmount::AllDrainingReserve => {
+				OnchainSendAmount::AllDrainingReserve
+				| OnchainSendAmount::AllRetainingReserve { cur_anchor_reserve_sats: _ } => {
 					let mut tx_builder = locked_wallet.build_tx();
 					tx_builder.drain_wallet().drain_to(address.script_pubkey()).fee_rate(fee_rate);
 					tx_builder

tests/integration_tests_rust.rs

@@ -496,6 +496,89 @@ fn onchain_send_receive() {
 	assert_eq!(node_b_payments.len(), 5);
 }
 
+#[test]
+fn onchain_send_all_retains_reserve() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = TestChainSource::Esplora(&electrsd);
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+
+	// Setup nodes
+	let addr_a = node_a.onchain_payment().new_address().unwrap();
+	let addr_b = node_b.onchain_payment().new_address().unwrap();
+
+	let premine_amount_sat = 1_000_000;
+	let reserve_amount_sat = 25_000;
+	let onchain_fee_buffer_sat = 1000;
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![addr_a.clone(), addr_b.clone()],
+		Amount::from_sat(premine_amount_sat),
+	);
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+	assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
+	assert_eq!(node_b.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
+
+	// Send all over, with 0 reserve as we don't have any channels open.
+	let txid = node_a.onchain_payment().send_all_to_address(&addr_b, true, None).unwrap();
+
+	wait_for_tx(&electrsd.client, txid);
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+	// Check node a sent all and node b received it
+	assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, 0);
+	assert!(((premine_amount_sat * 2 - onchain_fee_buffer_sat)..=(premine_amount_sat * 2))
+		.contains(&node_b.list_balances().spendable_onchain_balance_sats));
+
+	// Refill to make sure we have enough reserve for the channel open.
+	let txid = bitcoind
+		.client
+		.send_to_address(&addr_a, Amount::from_sat(reserve_amount_sat))
+		.unwrap()
+		.0
+		.parse()
+		.unwrap();
+	wait_for_tx(&electrsd.client, txid);
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+	assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, reserve_amount_sat);
+
+	// Open a channel.
+	open_channel(&node_b, &node_a, premine_amount_sat, false, &electrsd);
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+	expect_channel_ready_event!(node_a, node_b.node_id());
+	expect_channel_ready_event!(node_b, node_a.node_id());
+
+	// Check node a sent all and node b received it
+	assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, 0);
+	assert!(((premine_amount_sat - reserve_amount_sat - onchain_fee_buffer_sat)
+		..=premine_amount_sat)
+		.contains(&node_b.list_balances().spendable_onchain_balance_sats));
+
+	// Send all over again, this time ensuring the reserve is accounted for
+	let txid = node_b.onchain_payment().send_all_to_address(&addr_a, true, None).unwrap();
+
+	wait_for_tx(&electrsd.client, txid);
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	// Check node b sent all and node a received it
+	assert_eq!(node_b.list_balances().total_onchain_balance_sats, reserve_amount_sat);
+	assert_eq!(node_b.list_balances().spendable_onchain_balance_sats, 0);
+	assert!(((premine_amount_sat - reserve_amount_sat - onchain_fee_buffer_sat)
+		..=premine_amount_sat)
+		.contains(&node_a.list_balances().spendable_onchain_balance_sats));
+}
+
 #[test]
 fn onchain_wallet_recovery() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();