f Use match guard rather then reindented if

Author: tnull

src/wallet/mod.rs

@@ -355,83 +355,75 @@ 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 } => {
-					const DUST_LIMIT_SATS: u64 = 546;
-					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
-							.get_balances_inner(balance, cur_anchor_reserve_sats)
-							.map(|(_, s)| s)
-							.unwrap_or(0);
-						let tmp_tx = {
-							let mut tmp_tx_builder = locked_wallet.build_tx();
-							tmp_tx_builder
-								.drain_wallet()
-								.drain_to(address.script_pubkey())
-								.add_recipient(
-									change_address_info.address.script_pubkey(),
-									Amount::from_sat(cur_anchor_reserve_sats),
-								)
-								.fee_rate(fee_rate);
-							match tmp_tx_builder.finish() {
-								Ok(psbt) => psbt.unsigned_tx,
-								Err(err) => {
-									log_error!(
-										self.logger,
-										"Failed to create temporary transaction: {}",
-										err
-									);
-									return Err(err.into());
-								},
-							}
-						};
-
-						let estimated_tx_fee =
-							locked_wallet.calculate_fee(&tmp_tx).map_err(|e| {
+				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
+						.get_balances_inner(balance, cur_anchor_reserve_sats)
+						.map(|(_, s)| s)
+						.unwrap_or(0);
+					let tmp_tx = {
+						let mut tmp_tx_builder = locked_wallet.build_tx();
+						tmp_tx_builder
+							.drain_wallet()
+							.drain_to(address.script_pubkey())
+							.add_recipient(
+								change_address_info.address.script_pubkey(),
+								Amount::from_sat(cur_anchor_reserve_sats),
+							)
+							.fee_rate(fee_rate);
+						match tmp_tx_builder.finish() {
+							Ok(psbt) => psbt.unsigned_tx,
+							Err(err) => {
 								log_error!(
 									self.logger,
-									"Failed to calculate fee of temporary transaction: {}",
-									e
+									"Failed to create temporary transaction: {}",
+									err
 								);
-								e
-							})?;
-						let estimated_spendable_amount = Amount::from_sat(
-							spendable_amount_sats.saturating_sub(estimated_tx_fee.to_sat()),
-						);
-
-						if estimated_spendable_amount == Amount::ZERO {
-							log_error!(self.logger,
-								"Unable to send payment without infringing on Anchor reserves. Available: {}sats, estimated fee required: {}sats.",
-								spendable_amount_sats,
-								estimated_tx_fee,
-							);
-							return Err(Error::InsufficientFunds);
+								return Err(err.into());
+							},
 						}
+					};
 
-						let mut tx_builder = locked_wallet.build_tx();
-						tx_builder
-							.add_recipient(address.script_pubkey(), estimated_spendable_amount)
-							.fee_absolute(estimated_tx_fee);
-						tx_builder
-					} else {
-						let mut tx_builder = locked_wallet.build_tx();
-						tx_builder
-							.drain_wallet()
-							.drain_to(address.script_pubkey())
-							.fee_rate(fee_rate);
-						tx_builder
+					let estimated_tx_fee = locked_wallet.calculate_fee(&tmp_tx).map_err(|e| {
+						log_error!(
+							self.logger,
+							"Failed to calculate fee of temporary transaction: {}",
+							e
+						);
+						e
+					})?;
+					let estimated_spendable_amount = Amount::from_sat(
+						spendable_amount_sats.saturating_sub(estimated_tx_fee.to_sat()),
+					);
+
+					if estimated_spendable_amount == Amount::ZERO {
+						log_error!(self.logger,
+							"Unable to send payment without infringing on Anchor reserves. Available: {}sats, estimated fee required: {}sats.",
+							spendable_amount_sats,
+							estimated_tx_fee,
+						);
+						return Err(Error::InsufficientFunds);
 					}
+
+					let mut tx_builder = locked_wallet.build_tx();
+					tx_builder
+						.add_recipient(address.script_pubkey(), estimated_spendable_amount)
+						.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