f: move blinded path methods to bolt12payment

Author: joostjager

bindings/ldk_node.udl

@@ -158,10 +158,6 @@ interface Node {
 	boolean verify_signature([ByRef]sequence<u8> msg, [ByRef]string sig, [ByRef]PublicKey pkey);
 	[Throws=NodeError]
 	bytes export_pathfinding_scores();
-	[Throws=NodeError]
-	void set_paths_to_static_invoice_server(bytes paths);
-	[Throws=NodeError]
-	bytes blinded_paths_for_async_recipient(bytes recipient_id);
 };
 
 [Enum]
@@ -216,6 +212,10 @@ interface Bolt12Payment {
 	Refund initiate_refund(u64 amount_msat, u32 expiry_secs, u64? quantity, string? payer_note);
 	[Throws=NodeError]
 	Offer receive_async();
+	[Throws=NodeError]
+	void set_paths_to_static_invoice_server(bytes paths);
+	[Throws=NodeError]
+	bytes blinded_paths_for_async_recipient(bytes recipient_id);
 };
 
 interface SpontaneousPayment {

src/event.rs

@@ -5,7 +5,7 @@
 // http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
 // accordance with one or both of these licenses.
 
-use crate::payment::static_invoice_store::StaticInvoiceStore;
+use crate::payment::asynchronous::static_invoice_store::StaticInvoiceStore;
 use crate::types::{CustomTlvRecord, DynStore, PaymentStore, Sweeper, Wallet};
 use crate::{
 	hex_utils, BumpTransactionEventHandler, ChannelManager, Error, Graph, PeerInfo, PeerStore,

src/lib.rs

@@ -136,7 +136,7 @@ use gossip::GossipSource;
 use graph::NetworkGraph;
 use io::utils::write_node_metrics;
 use liquidity::{LSPS1Liquidity, LiquiditySource};
-use payment::static_invoice_store::StaticInvoiceStore;
+use payment::asynchronous::static_invoice_store::StaticInvoiceStore;
 use payment::{
 	Bolt11Payment, Bolt12Payment, OnchainPayment, PaymentDetails, SpontaneousPayment,
 	UnifiedQrPayment,
@@ -151,16 +151,13 @@ pub use types::{ChannelDetails, CustomTlvRecord, PeerDetails, UserChannelId};
 
 use logger::{log_debug, log_error, log_info, log_trace, LdkLogger, Logger};
 
-use lightning::blinded_path::message::BlindedMessagePath;
 use lightning::chain::BestBlock;
 use lightning::events::bump_transaction::Wallet as LdkWallet;
 use lightning::impl_writeable_tlv_based;
 use lightning::ln::channel_state::ChannelShutdownState;
 use lightning::ln::channelmanager::PaymentId;
 use lightning::ln::msgs::SocketAddress;
 use lightning::routing::gossip::NodeAlias;
-use lightning::util::ser::Readable;
-use lightning::util::ser::Writeable;
 
 use lightning_background_processor::process_events_async_with_kv_store_sync;
 
@@ -829,6 +826,7 @@ impl Node {
 		Bolt12Payment::new(
 			Arc::clone(&self.channel_manager),
 			Arc::clone(&self.payment_store),
+			self.config.async_payment_services_enabled,
 			Arc::clone(&self.is_running),
 			Arc::clone(&self.logger),
 		)
@@ -842,6 +840,7 @@ impl Node {
 		Arc::new(Bolt12Payment::new(
 			Arc::clone(&self.channel_manager),
 			Arc::clone(&self.payment_store),
+			self.config.async_payment_services_enabled,
 			Arc::clone(&self.is_running),
 			Arc::clone(&self.logger),
 		))
@@ -1492,43 +1491,6 @@ impl Node {
 				Error::PersistenceFailed
 			})
 	}
-
-	/// Sets the [`BlindedMessagePath`]s that we will use as an async recipient to interactively build [`Offer`]s with a
-	/// static invoice server, so the server can serve [`StaticInvoice`]s to payers on our behalf when we're offline.
-	///
-	/// [`Offer`]: lightning::offers::offer::Offer
-	/// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
-	pub fn set_paths_to_static_invoice_server(&self, paths: Vec<u8>) -> Result<(), Error> {
-		let decoded_paths = <Vec<BlindedMessagePath> as Readable>::read(&mut &paths[..])
-			.or(Err(Error::InvalidBlindedPaths))?;
-
-		self.channel_manager
-			.set_paths_to_static_invoice_server(decoded_paths)
-			.or(Err(Error::InvalidBlindedPaths))
-	}
-
-	/// [`BlindedMessagePath`]s for an async recipient to communicate with this node and interactively
-	/// build [`Offer`]s and [`StaticInvoice`]s for receiving async payments.
-	///
-	/// [`Offer`]: lightning::offers::offer::Offer
-	/// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
-	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)
-			.or(Err(Error::InvalidBlindedPaths))?;
-
-		let mut bytes = Vec::new();
-		paths.write(&mut bytes).or(Err(Error::InvalidBlindedPaths))?;
-
-		Ok(bytes)
-	}
 }
 
 impl Drop for Node {

src/payment/asynchronous/mod.rs

@@ -0,0 +1,2 @@
+mod rate_limiter;
+pub(crate) mod static_invoice_store;

src/payment/rate_limiter.rs renamed to src/payment/asynchronous/rate_limiter.rs

@@ -63,7 +63,7 @@ impl RateLimiter {
 
 #[cfg(test)]
 mod tests {
-	use crate::payment::rate_limiter::RateLimiter;
+	use crate::payment::asynchronous::rate_limiter::RateLimiter;
 
 	use std::time::Duration;
 

src/payment/static_invoice_store.rs renamed to src/payment/asynchronous/static_invoice_store.rs

@@ -1,6 +1,6 @@
 use crate::hex_utils;
 use crate::io::STATIC_INVOICES_PRIMARY_NAMESPACE;
-use crate::payment::rate_limiter::RateLimiter;
+use crate::payment::asynchronous::rate_limiter::RateLimiter;
 use crate::types::DynStore;
 
 use bitcoin::hashes::sha256::Hash as Sha256;
@@ -122,7 +122,8 @@ mod tests {
 	use lightning::util::test_utils::TestStore;
 	use lightning_types::features::BlindedHopFeatures;
 
-	use crate::{payment::static_invoice_store::StaticInvoiceStore, types::DynStore};
+	use crate::payment::asynchronous::static_invoice_store::StaticInvoiceStore;
+	use crate::types::DynStore;
 
 	#[tokio::test]
 	async fn static_invoice_store_test() {

src/payment/bolt12.rs

@@ -16,11 +16,14 @@ use crate::logger::{log_error, log_info, LdkLogger, Logger};
 use crate::payment::store::{PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus};
 use crate::types::{ChannelManager, PaymentStore};
 
+use lightning::blinded_path::message::BlindedMessagePath;
 use lightning::ln::channelmanager::{PaymentId, Retry};
 use lightning::offers::offer::{Amount, Offer as LdkOffer, Quantity};
 use lightning::offers::parse::Bolt12SemanticError;
 use lightning::routing::router::RouteParametersConfig;
 
+#[cfg(feature = "uniffi")]
+use lightning::util::ser::{Readable, Writeable};
 use lightning_types::string::UntrustedString;
 
 use rand::RngCore;
@@ -54,15 +57,16 @@ pub struct Bolt12Payment {
 	channel_manager: Arc<ChannelManager>,
 	payment_store: Arc<PaymentStore>,
 	is_running: Arc<RwLock<bool>>,
+	async_payment_services_enabled: bool,
 	logger: Arc<Logger>,
 }
 
 impl Bolt12Payment {
 	pub(crate) fn new(
 		channel_manager: Arc<ChannelManager>, payment_store: Arc<PaymentStore>,
-		is_running: Arc<RwLock<bool>>, logger: Arc<Logger>,
+		async_payment_services_enabled: bool, is_running: Arc<RwLock<bool>>, logger: Arc<Logger>,
 	) -> Self {
-		Self { channel_manager, payment_store, is_running, logger }
+		Self { channel_manager, payment_store, async_payment_services_enabled, is_running, logger }
 	}
 
 	/// Send a payment given an offer.
@@ -453,12 +457,11 @@ impl Bolt12Payment {
 
 	/// Retrieve an [`Offer`] for receiving async payments as an often-offline recipient.
 	///
-	/// Will only return an offer if [`Node::set_paths_to_static_invoice_server`] was called and we succeeded in
-	/// interactively building a [`StaticInvoice`] with the static invoice server.
+	/// Will only return an offer if [`Bolt12Payment::set_paths_to_static_invoice_server`] was called and we succeeded
+	/// in interactively building a [`StaticInvoice`] with the static invoice server.
 	///
 	/// Useful for posting offers to receive payments later, such as posting an offer on a website.
 	///
-	/// [`Node::set_paths_to_static_invoice_server`]: crate::Node::set_paths_to_static_invoice_server
 	/// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
 	/// [`Offer`]: lightning::offers::offer::Offer
 	pub fn receive_async(&self) -> Result<Offer, Error> {
@@ -467,4 +470,73 @@ impl Bolt12Payment {
 			.map(maybe_wrap)
 			.or(Err(Error::OfferCreationFailed))
 	}
+
+	/// Sets the [`BlindedMessagePath`]s that we will use as an async recipient to interactively build [`Offer`]s with a
+	/// static invoice server, so the server can serve [`StaticInvoice`]s to payers on our behalf when we're offline.
+	///
+	/// [`Offer`]: lightning::offers::offer::Offer
+	/// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
+	#[cfg(not(feature = "uniffi"))]
+	pub fn set_paths_to_static_invoice_server(
+		&self, paths: Vec<BlindedMessagePath>,
+	) -> Result<(), Error> {
+		self.channel_manager
+			.set_paths_to_static_invoice_server(paths)
+			.or(Err(Error::InvalidBlindedPaths))
+	}
+
+	/// Sets the [`BlindedMessagePath`]s that we will use as an async recipient to interactively build [`Offer`]s with a
+	/// static invoice server, so the server can serve [`StaticInvoice`]s to payers on our behalf when we're offline.
+	///
+	/// [`Offer`]: lightning::offers::offer::Offer
+	/// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
+	#[cfg(feature = "uniffi")]
+	pub fn set_paths_to_static_invoice_server(&self, paths: Vec<u8>) -> Result<(), Error> {
+		let decoded_paths = <Vec<BlindedMessagePath> as Readable>::read(&mut &paths[..])
+			.or(Err(Error::InvalidBlindedPaths))?;
+
+		self.channel_manager
+			.set_paths_to_static_invoice_server(decoded_paths)
+			.or(Err(Error::InvalidBlindedPaths))
+	}
+
+	/// [`BlindedMessagePath`]s for an async recipient to communicate with this node and interactively
+	/// build [`Offer`]s and [`StaticInvoice`]s for receiving async payments.
+	///
+	/// [`Offer`]: lightning::offers::offer::Offer
+	/// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
+	#[cfg(not(feature = "uniffi"))]
+	pub fn blinded_paths_for_async_recipient(
+		&self, recipient_id: Vec<u8>,
+	) -> Result<Vec<BlindedMessagePath>, Error> {
+		self.blinded_paths_for_async_recipient_internal(recipient_id)
+	}
+
+	/// [`BlindedMessagePath`]s for an async recipient to communicate with this node and interactively
+	/// build [`Offer`]s and [`StaticInvoice`]s for receiving async payments.
+	///
+	/// [`Offer`]: lightning::offers::offer::Offer
+	/// [`StaticInvoice`]: lightning::offers::static_invoice::StaticInvoice
+	#[cfg(feature = "uniffi")]
+	pub fn blinded_paths_for_async_recipient(
+		&self, recipient_id: Vec<u8>,
+	) -> Result<Vec<u8>, Error> {
+		let paths = self.blinded_paths_for_async_recipient_internal(recipient_id)?;
+
+		let mut bytes = Vec::new();
+		paths.write(&mut bytes).or(Err(Error::InvalidBlindedPaths))?;
+		Ok(bytes)
+	}
+
+	fn blinded_paths_for_async_recipient_internal(
+		&self, recipient_id: Vec<u8>,
+	) -> Result<Vec<BlindedMessagePath>, Error> {
+		if !self.async_payment_services_enabled {
+			return Err(Error::AsyncPaymentServicesDisabled);
+		}
+
+		self.channel_manager
+			.blinded_paths_for_async_recipient(recipient_id, None)
+			.or(Err(Error::InvalidBlindedPaths))
+	}
 }

src/payment/mod.rs

@@ -7,12 +7,11 @@
 
 //! Objects for different types of payments.
 
+pub(crate) mod asynchronous;
 mod bolt11;
 mod bolt12;
 mod onchain;
-mod rate_limiter;
 mod spontaneous;
-pub(crate) mod static_invoice_store;
 pub(crate) mod store;
 mod unified_qr;
 

tests/integration_tests_rust.rs

@@ -1211,8 +1211,9 @@ fn static_invoice_server() {
 	}
 
 	let recipient_id = vec![1, 2, 3];
-	let blinded_paths = node_receiver_lsp.blinded_paths_for_async_recipient(recipient_id).unwrap();
-	node_receiver.set_paths_to_static_invoice_server(blinded_paths).unwrap();
+	let blinded_paths =
+		node_receiver_lsp.bolt12_payment().blinded_paths_for_async_recipient(recipient_id).unwrap();
+	node_receiver.bolt12_payment().set_paths_to_static_invoice_server(blinded_paths).unwrap();
 
 	let offer = loop {
 		if let Ok(offer) = node_receiver.bolt12_payment().receive_async() {