f: add async services flag

Author: joostjager

bindings/ldk_node.udl

@@ -13,6 +13,7 @@ dictionary Config {
 	u64 probing_liquidity_limit_multiplier;
 	AnchorChannelsConfig? anchor_channels_config;
 	RouteParametersConfig? route_parameters;
+	boolean async_payment_services_enabled;
 };
 
 dictionary AnchorChannelsConfig {
@@ -318,6 +319,7 @@ enum NodeError {
 	"LiquiditySourceUnavailable",
 	"LiquidityFeeTooHigh",
 	"InvalidBlindedPaths",
+	"AsyncPaymentServicesDisabled",
 };
 
 dictionary NodeStatus {

src/config.rs

@@ -179,6 +179,8 @@ pub struct Config {
 	/// **Note:** If unset, default parameters will be used, and you will be able to override the
 	/// parameters on a per-payment basis in the corresponding method calls.
 	pub route_parameters: Option<RouteParametersConfig>,
+	/// Whether to enable the static invoice service to support async payment reception for clients.
+	pub async_payment_services_enabled: bool,
 }
 
 impl Default for Config {
@@ -193,6 +195,7 @@ impl Default for Config {
 			anchor_channels_config: Some(AnchorChannelsConfig::default()),
 			route_parameters: None,
 			node_alias: None,
+			async_payment_services_enabled: false,
 		}
 	}
 }

src/error.rs

@@ -122,6 +122,8 @@ pub enum Error {
 	LiquidityFeeTooHigh,
 	/// The given blinded paths are invalid.
 	InvalidBlindedPaths,
+	/// Asynchronous payment services are disabled.
+	AsyncPaymentServicesDisabled,
 }
 
 impl fmt::Display for Error {
@@ -196,6 +198,9 @@ impl fmt::Display for Error {
 				write!(f, "The given operation failed due to the LSP's required opening fee being too high.")
 			},
 			Self::InvalidBlindedPaths => write!(f, "The given blinded paths are invalid."),
+			Self::AsyncPaymentServicesDisabled => {
+				write!(f, "Asynchronous payment services are disabled.")
+			},
 		}
 	}
 }

src/event.rs

@@ -458,7 +458,7 @@ where
 	runtime: Arc<Runtime>,
 	logger: L,
 	config: Arc<Config>,
-	static_invoice_store: StaticInvoiceStore,
+	static_invoice_store: Option<StaticInvoiceStore>,
 }
 
 impl<L: Deref + Clone + Sync + Send + 'static> EventHandler<L>
@@ -472,7 +472,7 @@ where
 		output_sweeper: Arc<Sweeper>, network_graph: Arc<Graph>,
 		liquidity_source: Option<Arc<LiquiditySource<Arc<Logger>>>>,
 		payment_store: Arc<PaymentStore>, peer_store: Arc<PeerStore<L>>,
-		static_invoice_store: StaticInvoiceStore, runtime: Arc<Runtime>, logger: L,
+		static_invoice_store: Option<StaticInvoiceStore>, runtime: Arc<Runtime>, logger: L,
 		config: Arc<Config>,
 	) -> Self {
 		Self {
@@ -1504,37 +1504,38 @@ where
 				recipient_id,
 				invoice_persisted_path,
 			} => {
-				match self
-					.static_invoice_store
-					.handle_persist_static_invoice(invoice, invoice_slot, recipient_id)
-					.await
-				{
-					Ok(_) => {},
-					Err(e) => {
-						log_error!(self.logger, "Failed to persist static invoice: {}", e);
-					},
-				};
+				if let Some(store) = self.static_invoice_store.as_ref() {
+					match store
+						.handle_persist_static_invoice(invoice, invoice_slot, recipient_id)
+						.await
+					{
+						Ok(_) => {},
+						Err(e) => {
+							log_error!(self.logger, "Failed to persist static invoice: {}", e);
+						},
+					};
 
-				self.channel_manager.static_invoice_persisted(invoice_persisted_path);
+					self.channel_manager.static_invoice_persisted(invoice_persisted_path);
+				}
 			},
 			LdkEvent::StaticInvoiceRequested { recipient_id, invoice_slot, reply_path } => {
-				let invoice = self
-					.static_invoice_store
-					.handle_static_invoice_requested(&recipient_id, invoice_slot)
-					.await;
-
-				match invoice {
-					Ok(Some(invoice)) => {
-						if let Err(e) =
-							self.channel_manager.send_static_invoice(invoice, reply_path)
-						{
-							log_error!(self.logger, "Failed to send static invoice: {:?}", e);
-						}
-					},
-					Ok(None) => {},
-					Err(e) => {
-						log_error!(self.logger, "Failed to retrieve static invoice: {}", e);
-					},
+				if let Some(store) = self.static_invoice_store.as_ref() {
+					let invoice =
+						store.handle_static_invoice_requested(&recipient_id, invoice_slot).await;
+
+					match invoice {
+						Ok(Some(invoice)) => {
+							if let Err(e) =
+								self.channel_manager.send_static_invoice(invoice, reply_path)
+							{
+								log_error!(self.logger, "Failed to send static invoice: {:?}", e);
+							}
+						},
+						Ok(None) => {},
+						Err(e) => {
+							log_error!(self.logger, "Failed to retrieve static invoice: {}", e);
+						},
+					}
 				}
 			},
 			LdkEvent::FundingTransactionReadyForSigning { .. } => {

src/lib.rs

@@ -502,7 +502,11 @@ impl Node {
 			Arc::clone(&self.logger),
 		));
 
-		let static_invoice_store = StaticInvoiceStore::new(Arc::clone(&self.kv_store));
+		let static_invoice_store = if self.config.async_payment_services_enabled {
+			Some(StaticInvoiceStore::new(Arc::clone(&self.kv_store)))
+		} else {
+			None
+		};
 
 		let event_handler = Arc::new(EventHandler::new(
 			Arc::clone(&self.event_queue),
@@ -1506,6 +1510,10 @@ impl Node {
 	pub fn blinded_paths_for_async_recipient(
 		&self, recipient_id: Vec<u8>,
 	) -> Result<Vec<u8>, Error> {
+		if !self.config.async_payment_services_enabled {
+			return Err(Error::AsyncPaymentServicesDisabled);
+		}
+
 		let paths = self
 			.channel_manager
 			.blinded_paths_for_async_recipient(recipient_id, None)

tests/integration_tests_rust.rs

@@ -1145,6 +1145,7 @@ fn static_invoice_server() {
 
 	let mut config_receiver_lsp = random_config(true);
 	config_receiver_lsp.node_config.storage_dir_path = "/tmp/node_receiver_lsp".into();
+	config_receiver_lsp.node_config.async_payment_services_enabled = true;
 	let node_receiver_lsp = setup_node(&chain_source, config_receiver_lsp, None);
 
 	let mut config_receiver = random_config(true);