f: config via builder enum setter

Author: joostjager

src/builder.rs

@@ -7,9 +7,9 @@
 
 use crate::chain::ChainSource;
 use crate::config::{
-	default_user_config, may_announce_channel, AnnounceError, BitcoindRestClientConfig, Config,
-	ElectrumSyncConfig, EsploraSyncConfig, DEFAULT_ESPLORA_SERVER_URL, DEFAULT_LOG_FILENAME,
-	DEFAULT_LOG_LEVEL, WALLET_KEYS_SEED_LEN,
+	default_user_config, may_announce_channel, AnnounceError, AsyncPaymentsRole,
+	BitcoindRestClientConfig, Config, ElectrumSyncConfig, EsploraSyncConfig,
+	DEFAULT_ESPLORA_SERVER_URL, DEFAULT_LOG_FILENAME, DEFAULT_LOG_LEVEL, WALLET_KEYS_SEED_LEN,
 };
 
 use crate::connection::ConnectionManager;
@@ -242,6 +242,7 @@ pub struct NodeBuilder {
 	liquidity_source_config: Option<LiquiditySourceConfig>,
 	log_writer_config: Option<LogWriterConfig>,
 	runtime_handle: Option<tokio::runtime::Handle>,
+	async_payments_role: Option<AsyncPaymentsRole>,
 }
 
 impl NodeBuilder {
@@ -267,6 +268,7 @@ impl NodeBuilder {
 			liquidity_source_config,
 			log_writer_config,
 			runtime_handle,
+			async_payments_role: None,
 		}
 	}
 
@@ -545,6 +547,12 @@ impl NodeBuilder {
 		Ok(self)
 	}
 
+	/// Sets the role of the node in an asynchronous payments context.
+	pub fn set_async_payments_role(&mut self, role: Option<AsyncPaymentsRole>) -> &mut Self {
+		self.async_payments_role = role;
+		self
+	}
+
 	/// Builds a [`Node`] instance with a [`SqliteStore`] backend and according to the options
 	/// previously configured.
 	pub fn build(&self) -> Result<Node, BuildError> {
@@ -705,6 +713,7 @@ impl NodeBuilder {
 			runtime,
 			logger,
 			Arc::new(vss_store),
+			self.async_payments_role,
 		)
 	}
 
@@ -737,6 +746,7 @@ impl NodeBuilder {
 			runtime,
 			logger,
 			kv_store,
+			self.async_payments_role,
 		)
 	}
 }
@@ -1085,6 +1095,7 @@ fn build_with_store_internal(
 	gossip_source_config: Option<&GossipSourceConfig>,
 	liquidity_source_config: Option<&LiquiditySourceConfig>, seed_bytes: [u8; 64],
 	runtime: Arc<Runtime>, logger: Arc<Logger>, kv_store: Arc<DynStore>,
+	async_payments_role: Option<AsyncPaymentsRole>,
 ) -> Result<Node, BuildError> {
 	optionally_install_rustls_cryptoprovider();
 
@@ -1379,8 +1390,14 @@ fn build_with_store_internal(
 			100;
 	}
 
-	if config.async_payment_services_enabled {
-		user_config.accept_forwards_to_priv_channels = true;
+	if let Some(role) = async_payments_role {
+		match role {
+			AsyncPaymentsRole::Server => {
+				user_config.accept_forwards_to_priv_channels = true;
+				user_config.enable_htlc_hold = true;
+			},
+			AsyncPaymentsRole::Client => user_config.hold_outbound_htlcs_at_next_hop = true,
+		}
 	}
 
 	let message_router =
@@ -1453,31 +1470,32 @@ fn build_with_store_internal(
 	}
 
 	// Initialize the PeerManager
-	let onion_messenger: Arc<OnionMessenger> = if config.async_payment_services_enabled {
-		Arc::new(OnionMessenger::new_with_offline_peer_interception(
-			Arc::clone(&keys_manager),
-			Arc::clone(&keys_manager),
-			Arc::clone(&logger),
-			Arc::clone(&channel_manager),
-			message_router,
-			Arc::clone(&channel_manager),
-			Arc::clone(&channel_manager),
-			IgnoringMessageHandler {},
-			IgnoringMessageHandler {},
-		))
-	} else {
-		Arc::new(OnionMessenger::new(
-			Arc::clone(&keys_manager),
-			Arc::clone(&keys_manager),
-			Arc::clone(&logger),
-			Arc::clone(&channel_manager),
-			message_router,
-			Arc::clone(&channel_manager),
-			Arc::clone(&channel_manager),
-			IgnoringMessageHandler {},
-			IgnoringMessageHandler {},
-		))
-	};
+	let onion_messenger: Arc<OnionMessenger> =
+		if let Some(AsyncPaymentsRole::Server) = async_payments_role {
+			Arc::new(OnionMessenger::new_with_offline_peer_interception(
+				Arc::clone(&keys_manager),
+				Arc::clone(&keys_manager),
+				Arc::clone(&logger),
+				Arc::clone(&channel_manager),
+				message_router,
+				Arc::clone(&channel_manager),
+				Arc::clone(&channel_manager),
+				IgnoringMessageHandler {},
+				IgnoringMessageHandler {},
+			))
+		} else {
+			Arc::new(OnionMessenger::new(
+				Arc::clone(&keys_manager),
+				Arc::clone(&keys_manager),
+				Arc::clone(&logger),
+				Arc::clone(&channel_manager),
+				message_router,
+				Arc::clone(&channel_manager),
+				Arc::clone(&channel_manager),
+				IgnoringMessageHandler {},
+				IgnoringMessageHandler {},
+			))
+		};
 	let ephemeral_bytes: [u8; 32] = keys_manager.get_secure_random_bytes();
 
 	// Initialize the GossipSource
@@ -1664,7 +1682,7 @@ fn build_with_store_internal(
 		},
 	};
 
-	let om_mailbox = if config.async_payment_services_enabled {
+	let om_mailbox = if let Some(AsyncPaymentsRole::Server) = async_payments_role {
 		Some(Arc::new(OnionMessageMailbox::new()))
 	} else {
 		None
@@ -1703,6 +1721,7 @@ fn build_with_store_internal(
 		is_listening,
 		node_metrics,
 		om_mailbox,
+		async_payments_role,
 	})
 }
 

src/config.rs

@@ -179,15 +179,6 @@ 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,
-	/// If this is set to true, then if we as an often-offline payer receive a [`StaticInvoice`] to
-	/// pay, we will attempt to hold the corresponding outbound HTLCs with our next-hop channel
-	/// counterparty(s) that support the `htlc_hold` feature. This allows our node to go offline once
-	/// the HTLCs are locked in even though the recipient may not yet be online to receive them.
-	///
-	/// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
-	pub hold_outbound_htlcs_at_next_hop: bool,
 }
 
 impl Default for Config {
@@ -202,8 +193,6 @@ impl Default for Config {
 			anchor_channels_config: Some(AnchorChannelsConfig::default()),
 			route_parameters: None,
 			node_alias: None,
-			async_payment_services_enabled: false,
-			hold_outbound_htlcs_at_next_hop: false,
 		}
 	}
 }
@@ -338,13 +327,6 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 		user_config.channel_handshake_limits.force_announced_channel_preference = true;
 	}
 
-	if config.async_payment_services_enabled {
-		user_config.enable_htlc_hold = true;
-	}
-	if config.hold_outbound_htlcs_at_next_hop {
-		user_config.hold_outbound_htlcs_at_next_hop = true;
-	}
-
 	user_config
 }
 
@@ -552,6 +534,17 @@ impl From<MaxDustHTLCExposure> for LdkMaxDustHTLCExposure {
 	}
 }
 
+#[derive(Debug, Clone, Copy)]
+/// The role of the node in an asynchronous payments context.
+pub enum AsyncPaymentsRole {
+	/// Node acts a client in an async payments context. This means that if possible, it will instruct its peers to hold
+	/// htlcs for it, so that it can go offline.
+	Client,
+	/// Node acts as a server in an async payments context. This means that it will hold async payments htlcs and onion
+	/// messages for its peers.
+	Server,
+}
+
 #[cfg(test)]
 mod tests {
 	use std::str::FromStr;

src/lib.rs

@@ -126,6 +126,7 @@ pub use builder::BuildError;
 pub use builder::NodeBuilder as Builder;
 
 use chain::ChainSource;
+use config::AsyncPaymentsRole;
 use config::{
 	default_user_config, may_announce_channel, ChannelConfig, Config, NODE_ANN_BCAST_INTERVAL,
 	PEER_RECONNECTION_INTERVAL, RGS_SYNC_INTERVAL,
@@ -207,6 +208,7 @@ pub struct Node {
 	is_listening: Arc<AtomicBool>,
 	node_metrics: Arc<RwLock<NodeMetrics>>,
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
+	async_payments_role: Option<AsyncPaymentsRole>,
 }
 
 impl Node {
@@ -501,7 +503,8 @@ impl Node {
 			Arc::clone(&self.logger),
 		));
 
-		let static_invoice_store = if self.config.async_payment_services_enabled {
+		let static_invoice_store = if let Some(AsyncPaymentsRole::Server) = self.async_payments_role
+		{
 			Some(StaticInvoiceStore::new(Arc::clone(&self.kv_store)))
 		} else {
 			None
@@ -830,9 +833,9 @@ impl Node {
 		Bolt12Payment::new(
 			Arc::clone(&self.channel_manager),
 			Arc::clone(&self.payment_store),
-			Arc::clone(&self.config),
 			Arc::clone(&self.is_running),
 			Arc::clone(&self.logger),
+			self.async_payments_role,
 		)
 	}
 

src/payment/bolt12.rs

@@ -9,7 +9,7 @@
 //!
 //! [BOLT 12]: https://github.com/lightning/bolts/blob/master/12-offer-encoding.md
 
-use crate::config::{Config, LDK_PAYMENT_RETRY_TIMEOUT};
+use crate::config::{AsyncPaymentsRole, LDK_PAYMENT_RETRY_TIMEOUT};
 use crate::error::Error;
 use crate::ffi::{maybe_deref, maybe_wrap};
 use crate::logger::{log_error, log_info, LdkLogger, Logger};
@@ -57,16 +57,17 @@ pub struct Bolt12Payment {
 	channel_manager: Arc<ChannelManager>,
 	payment_store: Arc<PaymentStore>,
 	is_running: Arc<RwLock<bool>>,
-	config: Arc<Config>,
 	logger: Arc<Logger>,
+	async_payments_role: Option<AsyncPaymentsRole>,
 }
 
 impl Bolt12Payment {
 	pub(crate) fn new(
 		channel_manager: Arc<ChannelManager>, payment_store: Arc<PaymentStore>,
-		config: Arc<Config>, is_running: Arc<RwLock<bool>>, logger: Arc<Logger>,
+		is_running: Arc<RwLock<bool>>, logger: Arc<Logger>,
+		async_payments_role: Option<AsyncPaymentsRole>,
 	) -> Self {
-		Self { channel_manager, payment_store, config, is_running, logger }
+		Self { channel_manager, payment_store, is_running, logger, async_payments_role }
 	}
 
 	/// Send a payment given an offer.
@@ -554,8 +555,11 @@ impl Bolt12Payment {
 	fn blinded_paths_for_async_recipient_internal(
 		&self, recipient_id: Vec<u8>,
 	) -> Result<Vec<BlindedMessagePath>, Error> {
-		if !self.config.async_payment_services_enabled {
-			return Err(Error::AsyncPaymentServicesDisabled);
+		match self.async_payments_role {
+			Some(AsyncPaymentsRole::Server) => {},
+			_ => {
+				return Err(Error::AsyncPaymentServicesDisabled);
+			},
 		}
 
 		self.channel_manager

tests/common/mod.rs

@@ -12,7 +12,7 @@ pub(crate) mod logging;
 
 use logging::TestLogWriter;
 
-use ldk_node::config::{Config, ElectrumSyncConfig, EsploraSyncConfig};
+use ldk_node::config::{AsyncPaymentsRole, Config, ElectrumSyncConfig, EsploraSyncConfig};
 use ldk_node::io::sqlite_store::SqliteStore;
 use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus};
 use ldk_node::{
@@ -310,6 +310,13 @@ pub(crate) fn setup_two_nodes(
 
 pub(crate) fn setup_node(
 	chain_source: &TestChainSource, config: TestConfig, seed_bytes: Option<Vec<u8>>,
+) -> TestNode {
+	setup_node_for_async_payments(chain_source, config, seed_bytes, None)
+}
+
+pub(crate) fn setup_node_for_async_payments(
+	chain_source: &TestChainSource, config: TestConfig, seed_bytes: Option<Vec<u8>>,
+	async_payments_role: Option<AsyncPaymentsRole>,
 ) -> TestNode {
 	setup_builder!(builder, config.node_config);
 	match chain_source {
@@ -375,6 +382,8 @@ pub(crate) fn setup_node(
 		}
 	}
 
+	builder.set_async_payments_role(async_payments_role);
+
 	let test_sync_store = Arc::new(TestSyncStore::new(config.node_config.storage_dir_path.into()));
 	let node = builder.build_with_store(test_sync_store).unwrap();
 	node.start().unwrap();

tests/integration_tests_rust.rs

@@ -16,10 +16,11 @@ use common::{
 	logging::{init_log_logger, validate_log_entry, TestLogWriter},
 	open_channel, open_channel_push_amt, premine_and_distribute_funds, premine_blocks, prepare_rbf,
 	random_config, random_listening_addresses, setup_bitcoind_and_electrsd, setup_builder,
-	setup_node, setup_two_nodes, wait_for_tx, TestChainSource, TestSyncStore,
+	setup_node, setup_node_for_async_payments, setup_two_nodes, wait_for_tx, TestChainSource,
+	TestSyncStore,
 };
 
-use ldk_node::config::EsploraSyncConfig;
+use ldk_node::config::{AsyncPaymentsRole, EsploraSyncConfig};
 use ldk_node::liquidity::LSPS2ServiceConfig;
 use ldk_node::payment::{
 	ConfirmationStatus, PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus,
@@ -1139,23 +1140,35 @@ fn async_payment() {
 	let mut config_sender = random_config(true);
 	config_sender.node_config.listening_addresses = None;
 	config_sender.node_config.node_alias = None;
-	config_sender.node_config.hold_outbound_htlcs_at_next_hop = true;
 	config_sender.log_writer =
 		TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("sender      ".to_string())));
-	let node_sender = setup_node(&chain_source, config_sender, None);
+	let node_sender = setup_node_for_async_payments(
+		&chain_source,
+		config_sender,
+		None,
+		Some(AsyncPaymentsRole::Client),
+	);
 
 	let mut config_sender_lsp = random_config(true);
-	config_sender_lsp.node_config.async_payment_services_enabled = true;
 	config_sender_lsp.log_writer =
 		TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("sender_lsp  ".to_string())));
-	let node_sender_lsp = setup_node(&chain_source, config_sender_lsp, None);
+	let node_sender_lsp = setup_node_for_async_payments(
+		&chain_source,
+		config_sender_lsp,
+		None,
+		Some(AsyncPaymentsRole::Server),
+	);
 
 	let mut config_receiver_lsp = random_config(true);
-	config_receiver_lsp.node_config.async_payment_services_enabled = true;
 	config_receiver_lsp.log_writer =
 		TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("receiver_lsp".to_string())));
 
-	let node_receiver_lsp = setup_node(&chain_source, config_receiver_lsp, None);
+	let node_receiver_lsp = setup_node_for_async_payments(
+		&chain_source,
+		config_receiver_lsp,
+		None,
+		Some(AsyncPaymentsRole::Server),
+	);
 
 	let mut config_receiver = random_config(true);
 	config_receiver.node_config.listening_addresses = None;