diff --git a/src/builder.rs b/src/builder.rs index 54e79f4b3a..f2704b6425 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -2788,9 +2788,12 @@ mod tests { use bitcoin::secp256k1::PublicKey; use lightning::ln::channelmanager::PaymentId; use lightning::ln::msgs::SocketAddress; + use lightning::offers::offer::OfferBuilder; + use lightning_invoice::{Bolt11InvoiceDescription, Description}; use lightning_types::payment::PaymentPreimage; - use crate::{Error, UserChannelId}; + use crate::ffi::maybe_wrap; + use crate::{CustomTlvRecord, Error, UserChannelId}; let builder = NodeBuilder::new(); let logger = Arc::new(Logger::new_log_facade()); @@ -2809,6 +2812,60 @@ mod tests { let payment_id = PaymentId([0; 32]); let user_channel_id = UserChannelId(0); + let custom_tlvs = vec![CustomTlvRecord { type_num: 65_537, value: vec![1, 2, 3] }]; + let preimage = PaymentPreimage([42; 32]); + assert_eq!(node.spontaneous_payment().send(1_000, node_id, None), Err(Error::NotRunning)); + assert_eq!( + node.spontaneous_payment().send_with_custom_tlvs( + 1_000, + node_id, + None, + custom_tlvs.clone() + ), + Err(Error::NotRunning) + ); + assert_eq!( + node.spontaneous_payment().send_with_preimage(1_000, node_id, preimage, None), + Err(Error::NotRunning) + ); + assert_eq!( + node.spontaneous_payment().send_with_preimage_and_custom_tlvs( + 1_000, + node_id, + custom_tlvs, + preimage, + None, + ), + Err(Error::NotRunning) + ); + + let description = + Bolt11InvoiceDescription::Direct(Description::new("not running".to_string()).unwrap()) + .into(); + let invoice = node.bolt11_payment().receive(1_000, &description, 3_600).unwrap(); + assert_eq!(node.bolt11_payment().send(&invoice, None), Err(Error::NotRunning)); + assert_eq!( + node.bolt11_payment().send_using_amount(&invoice, 1_000, None), + Err(Error::NotRunning) + ); + assert_eq!( + node.bolt11_payment().send_using_amount_underpaying(&invoice, 500, None), + Err(Error::NotRunning) + ); + + let offer = maybe_wrap( + OfferBuilder::new(node_id) + .description("not running".to_string()) + .amount_msats(1_000) + .build() + .unwrap(), + ); + assert_eq!(node.bolt12_payment().send(&offer, None, None, None), Err(Error::NotRunning)); + assert_eq!( + node.bolt12_payment().send_using_amount(&offer, 1_000, None, None, None), + Err(Error::NotRunning) + ); + assert_eq!(node.onchain_payment().bump_fee_rbf(payment_id, None), Err(Error::NotRunning)); assert_eq!(node.close_channel(&user_channel_id, node_id), Err(Error::NotRunning)); assert_eq!( diff --git a/src/lib.rs b/src/lib.rs index a5f2a72e18..83bcc6afa4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1373,10 +1373,6 @@ impl Node { channel_config: Option, announce_for_forwarding: bool, disable_counterparty_reserve: bool, ) -> Result { - if !*self.is_running.read().expect("lock") { - return Err(Error::NotRunning); - } - let peer_info = PeerInfo { node_id, address }; let con_node_id = peer_info.node_id; diff --git a/src/payment/bolt11.rs b/src/payment/bolt11.rs index e2a34828cf..a294912ceb 100644 --- a/src/payment/bolt11.rs +++ b/src/payment/bolt11.rs @@ -204,10 +204,6 @@ impl Bolt11Payment { route_parameters: Option, declared_total_mpp_value_msat_override: Option, invalid_amount_log: &'static str, ) -> Result { - if !*self.is_running.read().expect("lock") { - return Err(Error::NotRunning); - } - let payment_hash = invoice.payment_hash(); let payment_id = PaymentId(invoice.payment_hash().0); if let Some(payment) = self.runtime.block_on(self.payment_store.get(&payment_id))? { diff --git a/src/payment/bolt12.rs b/src/payment/bolt12.rs index dcac54c172..0c0db6b9f0 100644 --- a/src/payment/bolt12.rs +++ b/src/payment/bolt12.rs @@ -127,10 +127,6 @@ impl Bolt12Payment { &self, offer: &Offer, amount_msat: u64, quantity: Option, payer_note: Option, route_parameters: Option, hrn: Option, ) -> Result { - if !*self.is_running.read().expect("lock") { - return Err(Error::NotRunning); - } - let offer = maybe_deref(offer); let payment_id = PaymentId(self.keys_manager.get_secure_random_bytes()); @@ -412,6 +408,10 @@ impl Bolt12Payment { &self, offer: &Offer, amount_msat: u64, quantity: Option, payer_note: Option, route_parameters: Option, ) -> Result { + if !*self.is_running.read().expect("lock") { + return Err(Error::NotRunning); + } + let payment_id = self.send_using_amount_inner( offer, amount_msat, diff --git a/src/payment/onchain.rs b/src/payment/onchain.rs index 98f5240220..dbb149fdf4 100644 --- a/src/payment/onchain.rs +++ b/src/payment/onchain.rs @@ -46,10 +46,6 @@ impl OnchainPayment { pub(crate) async fn send_to_address_inner( &self, address: &bitcoin::Address, amount_sats: u64, fee_rate: Option, ) -> Result { - if !*self.is_running.read().expect("lock") { - return Err(Error::NotRunning); - } - let cur_anchor_reserve_sats = crate::total_anchor_channels_reserve_sats(&self.channel_manager, &self.config); let send_amount = diff --git a/src/payment/spontaneous.rs b/src/payment/spontaneous.rs index f4e1cd93d6..5efcd38597 100644 --- a/src/payment/spontaneous.rs +++ b/src/payment/spontaneous.rs @@ -58,10 +58,6 @@ impl SpontaneousPayment { route_parameters: Option, custom_tlvs: Option>, preimage: Option, ) -> Result { - if !*self.is_running.read().expect("lock") { - return Err(Error::NotRunning); - } - let payment_preimage = preimage .unwrap_or_else(|| PaymentPreimage(self.keys_manager.get_secure_random_bytes())); @@ -174,6 +170,10 @@ impl SpontaneousPayment { &self, amount_msat: u64, node_id: PublicKey, route_parameters: Option, ) -> Result { + if !*self.is_running.read().expect("lock") { + return Err(Error::NotRunning); + } + self.send_inner(amount_msat, node_id, route_parameters, None, None) } @@ -182,6 +182,10 @@ impl SpontaneousPayment { &self, amount_msat: u64, node_id: PublicKey, route_parameters: Option, custom_tlvs: Vec, ) -> Result { + if !*self.is_running.read().expect("lock") { + return Err(Error::NotRunning); + } + self.send_inner(amount_msat, node_id, route_parameters, Some(custom_tlvs), None) } @@ -190,6 +194,10 @@ impl SpontaneousPayment { &self, amount_msat: u64, node_id: PublicKey, preimage: PaymentPreimage, route_parameters: Option, ) -> Result { + if !*self.is_running.read().expect("lock") { + return Err(Error::NotRunning); + } + self.send_inner(amount_msat, node_id, route_parameters, None, Some(preimage)) } @@ -198,6 +206,10 @@ impl SpontaneousPayment { &self, amount_msat: u64, node_id: PublicKey, custom_tlvs: Vec, preimage: PaymentPreimage, route_parameters: Option, ) -> Result { + if !*self.is_running.read().expect("lock") { + return Err(Error::NotRunning); + } + self.send_inner(amount_msat, node_id, route_parameters, Some(custom_tlvs), Some(preimage)) } diff --git a/src/payment/unified.rs b/src/payment/unified.rs index ea1186fd48..f7db4a7f11 100644 --- a/src/payment/unified.rs +++ b/src/payment/unified.rs @@ -298,6 +298,10 @@ impl UnifiedPayment { let payment_result = if let Ok(hrn) = HumanReadableName::from_encoded(uri_str) { let hrn = maybe_wrap(hrn.clone()); + if !*self.is_running.read().expect("lock") { + return Err(Error::NotRunning); + } + self.bolt12_payment.send_using_amount_inner( &offer, amount_msat.unwrap_or(0), @@ -390,6 +394,10 @@ impl UnifiedPayment { Error::InvalidAmount })?; + if !*self.is_running.read().expect("lock") { + return Err(Error::NotRunning); + } + let txid = self .onchain_payment .send_to_address_inner(&address, amt_sats, None)