Check running state at public API boundaries

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!(

src/lib.rs

@@ -1373,10 +1373,6 @@ impl Node {
 		channel_config: Option<ChannelConfig>, announce_for_forwarding: bool,
 		disable_counterparty_reserve: bool,
 	) -> Result<UserChannelId, Error> {
-		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;

src/payment/bolt11.rs

@@ -204,10 +204,6 @@ impl Bolt11Payment {
 		route_parameters: Option<RouteParametersConfig>,
 		declared_total_mpp_value_msat_override: Option<u64>, invalid_amount_log: &'static str,
 	) -> Result<PaymentId, Error> {
-		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))? {

src/payment/bolt12.rs

@@ -127,10 +127,6 @@ impl Bolt12Payment {
 		&self, offer: &Offer, amount_msat: u64, quantity: Option<u64>, payer_note: Option<String>,
 		route_parameters: Option<RouteParametersConfig>, hrn: Option<HumanReadableName>,
 	) -> Result<PaymentId, Error> {
-		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<u64>, payer_note: Option<String>,
 		route_parameters: Option<RouteParametersConfig>,
 	) -> Result<PaymentId, Error> {
+		if !*self.is_running.read().expect("lock") {
+			return Err(Error::NotRunning);
+		}
+
 		let payment_id = self.send_using_amount_inner(
 			offer,
 			amount_msat,

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<bitcoin::FeeRate>,
 	) -> Result<Txid, Error> {
-		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 =

src/payment/spontaneous.rs

@@ -58,10 +58,6 @@ impl SpontaneousPayment {
 		route_parameters: Option<RouteParametersConfig>, custom_tlvs: Option<Vec<CustomTlvRecord>>,
 		preimage: Option<PaymentPreimage>,
 	) -> Result<PaymentId, Error> {
-		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<RouteParametersConfig>,
 	) -> Result<PaymentId, Error> {
+		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<RouteParametersConfig>, custom_tlvs: Vec<CustomTlvRecord>,
 	) -> Result<PaymentId, Error> {
+		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<RouteParametersConfig>,
 	) -> Result<PaymentId, Error> {
+		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<CustomTlvRecord>,
 		preimage: PaymentPreimage, route_parameters: Option<RouteParametersConfig>,
 	) -> Result<PaymentId, Error> {
+		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))
 	}
 

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)