fmt

Author: tnull

src/builder.rs

@@ -523,8 +523,7 @@ impl NodeBuilder {
 
 		let liquidity_source_config =
 			self.liquidity_source_config.get_or_insert(LiquiditySourceConfig::default());
-		liquidity_source_config.sip_client =
-			Some(SIPClientConfig { node_id, address, csv_delay });
+		liquidity_source_config.sip_client = Some(SIPClientConfig { node_id, address, csv_delay });
 		self
 	}
 
@@ -1872,7 +1871,11 @@ fn build_with_store_internal(
 			});
 
 			lsc.sip_client.as_ref().map(|config| {
-				liquidity_source_builder.sip_client(config.node_id, config.address.clone(), config.csv_delay)
+				liquidity_source_builder.sip_client(
+					config.node_id,
+					config.address.clone(),
+					config.csv_delay,
+				)
 			});
 
 			lsc.sip_service.as_ref().map(|config| {
@@ -2020,18 +2023,17 @@ fn build_with_store_internal(
 		_leak_checker.0.push(Arc::downgrade(&wallet) as Weak<dyn Any + Send + Sync>);
 	}
 
-	let sip_manager = liquidity_source_config
-		.as_ref()
-		.and_then(|lsc| lsc.sip_client.as_ref())
-		.map(|sip_config| {
+	let sip_manager = liquidity_source_config.as_ref().and_then(|lsc| lsc.sip_client.as_ref()).map(
+		|sip_config| {
 			Arc::new(crate::sip::SipManager::new(
 				xprv,
 				sip_config.node_id,
 				sip_config.csv_delay,
 				config.network,
 				Arc::clone(&logger),
 			))
-		});
+		},
+	);
 
 	Ok(Node {
 		runtime,

src/event.rs

@@ -528,11 +528,11 @@ where
 		channel_manager: Arc<ChannelManager>, connection_manager: Arc<ConnectionManager<L>>,
 		output_sweeper: Arc<Sweeper>, network_graph: Arc<Graph>,
 		liquidity_source: Option<Arc<LiquiditySource<Arc<Logger>>>>,
-		sip_manager: Option<Arc<crate::sip::SipManager>>,
-		payment_store: Arc<PaymentStore>, peer_store: Arc<PeerStore<L>>,
-		keys_manager: Arc<KeysManager>, static_invoice_store: Option<StaticInvoiceStore>,
-		onion_messenger: Arc<OnionMessenger>, om_mailbox: Option<Arc<OnionMessageMailbox>>,
-		runtime: Arc<Runtime>, logger: L, config: Arc<Config>,
+		sip_manager: Option<Arc<crate::sip::SipManager>>, payment_store: Arc<PaymentStore>,
+		peer_store: Arc<PeerStore<L>>, keys_manager: Arc<KeysManager>,
+		static_invoice_store: Option<StaticInvoiceStore>, onion_messenger: Arc<OnionMessenger>,
+		om_mailbox: Option<Arc<OnionMessageMailbox>>, runtime: Arc<Runtime>, logger: L,
+		config: Arc<Config>,
 	) -> Self {
 		Self {
 			event_queue,
@@ -597,8 +597,7 @@ where
 						}
 
 						let cur_height = self.channel_manager.current_best_block().height;
-						let locktime =
-							LockTime::from_height(cur_height).unwrap_or(LockTime::ZERO);
+						let locktime = LockTime::from_height(cur_height).unwrap_or(LockTime::ZERO);
 
 						let mut outputs = vec![bitcoin::TxOut {
 							value: channel_amount,
@@ -1854,37 +1853,39 @@ where
 				..
 			} => {
 				// Check if any inputs belong to SIP UTXOs that need the server's signature.
-				let sip_inputs = self.sip_manager.as_ref().map(|sip_manager| {
-					let sip_wallet = sip_manager.wallet();
-					let utxos = sip_wallet.swappable_utxos();
-					unsigned_transaction
-						.input
-						.iter()
-						.enumerate()
-						.filter_map(|(i, input)| {
-							utxos
-								.iter()
-								.find(|u| u.outpoint == input.previous_output)
-								.map(|_| (i, input.previous_output))
-						})
-						.collect::<Vec<_>>()
-				}).unwrap_or_default();
+				let sip_inputs = self
+					.sip_manager
+					.as_ref()
+					.map(|sip_manager| {
+						let sip_wallet = sip_manager.wallet();
+						let utxos = sip_wallet.swappable_utxos();
+						unsigned_transaction
+							.input
+							.iter()
+							.enumerate()
+							.filter_map(|(i, input)| {
+								utxos
+									.iter()
+									.find(|u| u.outpoint == input.previous_output)
+									.map(|_| (i, input.previous_output))
+							})
+							.collect::<Vec<_>>()
+					})
+					.unwrap_or_default();
 
 				if !sip_inputs.is_empty() {
 					// This funding tx contains SIP inputs. Sign the wallet-owned inputs,
 					// then stash the partially-signed tx until the server's signatures arrive.
 					match self.wallet.sign_owned_inputs(unsigned_transaction) {
 						Ok(partially_signed_tx) => {
 							if let Some(sip_manager) = self.sip_manager.as_ref() {
-								sip_manager.stash_pending_funding(
-									crate::sip::PendingSipFunding {
-										channel_id,
-										counterparty_node_id,
-										tx: partially_signed_tx,
-										sip_inputs,
-										is_v1_open: false,
-									},
-								);
+								sip_manager.stash_pending_funding(crate::sip::PendingSipFunding {
+									channel_id,
+									counterparty_node_id,
+									tx: partially_signed_tx,
+									sip_inputs,
+									is_v1_open: false,
+								});
 							}
 						},
 						Err(()) => {

src/lib.rs

@@ -1965,8 +1965,7 @@ impl Node {
 	/// Call this when a deposit to a SIP address is detected on-chain. In production this
 	/// would be driven by chain sync; for testing it can be called manually.
 	pub fn register_sip_utxo(
-		&self, outpoint: OutPoint, value: Amount, address_index: u32,
-		prevtx: Transaction,
+		&self, outpoint: OutPoint, value: Amount, address_index: u32, prevtx: Transaction,
 	) -> Result<(), Error> {
 		let sip = self.sip_manager.as_ref().ok_or(Error::LiquiditySourceUnavailable)?;
 		sip.wallet().register_utxo(outpoint, value, address_index, prevtx);
@@ -2058,16 +2057,13 @@ impl Node {
 		// Create channel directly, bypassing check_sufficient_funds_for_channel
 		// since the funds come from SIP UTXOs, not the regular BDK wallet.
 		let user_channel_id: u128 = u128::from_ne_bytes(
-			self.keys_manager.get_secure_random_bytes()[..16]
-				.try_into()
-				.expect("16-byte slice"),
+			self.keys_manager.get_secure_random_bytes()[..16].try_into().expect("16-byte slice"),
 		);
 
 		let mut user_config = default_user_config(&self.config);
 		user_config.channel_handshake_config.announce_for_forwarding = false;
-		user_config
-			.channel_handshake_config
-			.max_inbound_htlc_value_in_flight_percent_of_channel = 100;
+		user_config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel =
+			100;
 
 		self.channel_manager
 			.create_channel(
@@ -2120,8 +2116,9 @@ impl Node {
 				Error::ChannelSplicingFailed
 			})?;
 
-		let min_feerate =
-			self.fee_estimator.estimate_fee_rate(crate::fee_estimator::ConfirmationTarget::ChannelFunding);
+		let min_feerate = self
+			.fee_estimator
+			.estimate_fee_rate(crate::fee_estimator::ConfirmationTarget::ChannelFunding);
 		let max_feerate = FeeRate::from_sat_per_kwu(min_feerate.to_sat_per_kwu() * 3 / 2);
 
 		let funding_template = self
@@ -2132,7 +2129,8 @@ impl Node {
 				Error::ChannelSplicingFailed
 			})?;
 
-		let sip_coin_source = crate::sip::coin_selection::SipCoinSelectionSource::new(sip.wallet_arc());
+		let sip_coin_source =
+			crate::sip::coin_selection::SipCoinSelectionSource::new(sip.wallet_arc());
 		let contribution = self
 			.runtime
 			.block_on(funding_template.splice_in(
@@ -2216,11 +2214,7 @@ impl Node {
 
 		for (input_idx, outpoint) in &pending.sip_inputs {
 			let server_sig = sip_signatures.get(outpoint).ok_or_else(|| {
-				log_error!(
-					self.logger,
-					"Missing server signature for SIP input {}",
-					outpoint
-				);
+				log_error!(self.logger, "Missing server signature for SIP input {}", outpoint);
 				Error::ChannelSplicingFailed
 			})?;
 
@@ -2267,22 +2261,14 @@ impl Node {
 
 		if pending.is_v1_open {
 			self.channel_manager
-				.funding_transaction_generated(
-					*channel_id,
-					pending.counterparty_node_id,
-					tx,
-				)
+				.funding_transaction_generated(*channel_id, pending.counterparty_node_id, tx)
 				.map_err(|e| {
 					log_error!(self.logger, "Failed to complete SIP channel open: {:?}", e);
 					Error::ChannelCreationFailed
 				})
 		} else {
 			self.channel_manager
-				.funding_transaction_signed(
-					channel_id,
-					&pending.counterparty_node_id,
-					tx,
-				)
+				.funding_transaction_signed(channel_id, &pending.counterparty_node_id, tx)
 				.map_err(|e| {
 					log_error!(self.logger, "Failed to complete SIP splice funding: {:?}", e);
 					Error::ChannelSplicingFailed
@@ -2291,9 +2277,7 @@ impl Node {
 	}
 
 	/// Marks a SIP UTXO as refunded after the refund transaction has been broadcast.
-	pub fn mark_sip_refunded(
-		&self, outpoint: &OutPoint, spending_txid: Txid,
-	) -> Result<(), Error> {
+	pub fn mark_sip_refunded(&self, outpoint: &OutPoint, spending_txid: Txid) -> Result<(), Error> {
 		let sip = self.sip_manager.as_ref().ok_or(Error::LiquiditySourceUnavailable)?;
 		sip.wallet().mark_refunded(outpoint, spending_txid);
 		Ok(())

src/liquidity.rs

@@ -293,8 +293,7 @@ where
 		let lsps1_client_config = self.lsps1_client.as_ref().map(|s| s.ldk_client_config.clone());
 		let lsps2_client_config = self.lsps2_client.as_ref().map(|s| s.ldk_client_config.clone());
 		let lsps5_client_config = None;
-		let sip_client_config =
-			self.sip_client.as_ref().map(|_| LdkSIPClientConfig {});
+		let sip_client_config = self.sip_client.as_ref().map(|_| LdkSIPClientConfig {});
 		let liquidity_client_config = Some(LiquidityClientConfig {
 			lsps1_client_config,
 			lsps2_client_config,
@@ -1011,16 +1010,8 @@ where
 					csv_delay,
 				);
 			},
-			LiquidityEvent::SIPClient(SIPClientEvent::UtxoRegistered {
-				lsp_node_id,
-				outpoint,
-			}) => {
-				log_info!(
-					self.logger,
-					"SIP UTXO {} registered with LSP {}",
-					outpoint,
-					lsp_node_id,
-				);
+			LiquidityEvent::SIPClient(SIPClientEvent::UtxoRegistered { lsp_node_id, outpoint }) => {
+				log_info!(self.logger, "SIP UTXO {} registered with LSP {}", outpoint, lsp_node_id,);
 			},
 			LiquidityEvent::SIPClient(SIPClientEvent::SwapAccepted {
 				lsp_node_id,

src/sip/coin_selection.rs

@@ -110,8 +110,7 @@ mod tests {
 	async fn test_empty_wallet_returns_err() {
 		let wallet = make_wallet();
 		let source = SipCoinSelectionSource::new(wallet);
-		let result =
-			source.select_confirmed_utxos(None, vec![], &[], 1000, u64::MAX).await;
+		let result = source.select_confirmed_utxos(None, vec![], &[], 1000, u64::MAX).await;
 		assert!(result.is_err());
 	}
 
@@ -137,19 +136,15 @@ mod tests {
 				sequence: Sequence::MAX,
 				witness: Witness::new(),
 			}],
-			output: vec![bitcoin::TxOut {
-				value: Amount::from_sat(100_000),
-				script_pubkey,
-			}],
+			output: vec![bitcoin::TxOut { value: Amount::from_sat(100_000), script_pubkey }],
 		};
 		let outpoint = OutPoint::new(prevtx.compute_txid(), 0);
 
 		wallet.register_utxo(outpoint, Amount::from_sat(100_000), addr.index, prevtx);
 		wallet.confirm_utxo(&outpoint, 800_000);
 
 		let source = SipCoinSelectionSource::new(Arc::clone(&wallet));
-		let result =
-			source.select_confirmed_utxos(None, vec![], &[], 1000, u64::MAX).await;
+		let result = source.select_confirmed_utxos(None, vec![], &[], 1000, u64::MAX).await;
 
 		assert!(result.is_ok());
 		let selection = result.unwrap();

src/sip/mod.rs

@@ -72,8 +72,13 @@ impl SipManager {
 		master_xpriv: Xpriv, server_pubkey: PublicKey, csv_delay: u16, network: Network,
 		logger: Arc<Logger>,
 	) -> Self {
-		let wallet =
-			Arc::new(SipWallet::new(master_xpriv, server_pubkey, csv_delay, network, logger.clone()));
+		let wallet = Arc::new(SipWallet::new(
+			master_xpriv,
+			server_pubkey,
+			csv_delay,
+			network,
+			logger.clone(),
+		));
 		Self {
 			wallet,
 			pending_fundings: Mutex::new(HashMap::new()),
@@ -95,9 +100,7 @@ impl SipManager {
 	}
 
 	/// Takes the pending funding for the given channel, if any.
-	pub(crate) fn take_pending_funding(
-		&self, channel_id: &ChannelId,
-	) -> Option<PendingSipFunding> {
+	pub(crate) fn take_pending_funding(&self, channel_id: &ChannelId) -> Option<PendingSipFunding> {
 		self.pending_fundings.lock().unwrap().remove(channel_id)
 	}
 
@@ -123,9 +126,7 @@ impl SipManager {
 	}
 
 	/// Returns a clone of the pending funding for the given channel, without removing it.
-	pub(crate) fn peek_pending_funding(
-		&self, channel_id: &ChannelId,
-	) -> Option<PendingSipFunding> {
+	pub(crate) fn peek_pending_funding(&self, channel_id: &ChannelId) -> Option<PendingSipFunding> {
 		self.pending_fundings.lock().unwrap().get(channel_id).cloned()
 	}