Add ability to receive Payjoin tx

Implements the payjoin receiver part as describe in BIP77.

This would allow the on chain wallet linked to LDK node to receive payjoin
transactions.

Receiving a payjoin transaction requires first to enroll with the
configured Payjoin directory and listening to our enrolled subdirectory
for upcoming request. When a request received, we validate it as
specified in BIP78, prepare our Payjoin proposal and send it back to the
payjoin sender via the subdirectory.

Author: jbesraa

Cargo.toml

@@ -68,7 +68,7 @@ tokio = { version = "1.37", default-features = false, features = [ "rt-multi-thr
 esplora-client = { version = "0.6", default-features = false }
 libc = "0.2"
 uniffi = { version = "0.26.0", features = ["build"], optional = true }
-payjoin = { version = "0.16.0", default-features = false, features = ["send", "v2"] }
+payjoin = { version = "0.16.0", default-features = false, features = ["send", "receive", "v2"] }
 
 [target.'cfg(vss)'.dependencies]
 vss-client = "0.2"

bindings/ldk_node.udl

@@ -209,6 +209,9 @@ enum NodeError {
 	"PayjoinRequestMissingAmount",
 	"PayjoinRequestCreationFailed",
 	"PayjoinResponseProcessingFailed",
+	"PayjoinReceiverUnavailable",
+	"PayjoinReceiverRequestValidationFailed",
+	"PayjoinReceiverEnrollementFailed"
 };
 
 dictionary NodeStatus {

src/builder.rs

@@ -11,6 +11,7 @@ use crate::io::sqlite_store::SqliteStore;
 use crate::liquidity::LiquiditySource;
 use crate::logger::{log_error, log_info, FilesystemLogger, Logger};
 use crate::message_handler::NodeCustomMessageHandler;
+use crate::payjoin_receiver::PayjoinReceiver;
 use crate::payment::store::PaymentStore;
 use crate::peer_store::PeerStore;
 use crate::tx_broadcaster::TransactionBroadcaster;
@@ -95,7 +96,9 @@ struct LiquiditySourceConfig {
 
 #[derive(Debug, Clone)]
 struct PayjoinConfig {
+	payjoin_directory: payjoin::Url,
 	payjoin_relay: payjoin::Url,
+	ohttp_keys: Option<payjoin::OhttpKeys>,
 }
 
 impl Default for LiquiditySourceConfig {
@@ -263,10 +266,18 @@ impl NodeBuilder {
 
 	/// Configures the [`Node`] instance to enable payjoin transactions.
 	pub fn set_payjoin_config(
-		&mut self, payjoin_relay: String
+		&mut self, payjoin_directory: String, payjoin_relay: String, ohttp_keys: Option<String>,
 	) -> Result<&mut Self, BuildError> {
 		let payjoin_relay = payjoin::Url::parse(&payjoin_relay).map_err(|_| BuildError::InvalidPayjoinConfig)?;
-		self.payjoin_config = Some(PayjoinConfig { payjoin_relay });
+		let payjoin_directory = payjoin::Url::parse(&payjoin_directory).map_err(|_| BuildError::InvalidPayjoinConfig)?;
+		let ohttp_keys = if let Some(ohttp_keys) = ohttp_keys {
+			let keys = match payjoin::OhttpKeys::decode(ohttp_keys.as_bytes()) {
+				Ok(keys) => keys,
+				Err(_) => return Err(BuildError::InvalidPayjoinConfig),
+			};
+			Some(keys)
+		} else { None };
+		self.payjoin_config = Some(PayjoinConfig { payjoin_directory, payjoin_relay, ohttp_keys });
 		Ok(self)
 	}
 
@@ -1002,13 +1013,21 @@ fn build_with_store_internal(
 	let (event_handling_stopped_sender, _) = tokio::sync::watch::channel(());
 
 	let mut payjoin_sender = None;
+	let mut payjoin_receiver = None;
 	if let Some(pj_config) = payjoin_config {
 		payjoin_sender = Some(Arc::new(PayjoinSender::new(
 					Arc::clone(&logger),
 					Arc::clone(&wallet),
 					Arc::clone(&tx_broadcaster),
 					pj_config.payjoin_relay.clone(),
 		)));
+		payjoin_receiver = Some(Arc::new(PayjoinReceiver::new(
+			Arc::clone(&logger),
+			Arc::clone(&wallet),
+			pj_config.payjoin_directory.clone(),
+			pj_config.payjoin_relay.clone(),
+			pj_config.ohttp_keys.clone(),
+		)));
 	}
 
 	let is_listening = Arc::new(AtomicBool::new(false));
@@ -1033,6 +1052,7 @@ fn build_with_store_internal(
 		chain_monitor,
 		output_sweeper,
 		payjoin_sender,
+		payjoin_receiver,
 		peer_manager,
 		connection_manager,
 		keys_manager,

src/error.rs

@@ -105,6 +105,12 @@ pub enum Error {
 	PayjoinRequestCreationFailed,
 	/// Payjoin response processing failed.
 	PayjoinResponseProcessingFailed,
+	/// Failed to access payjoin receiver object.
+	PayjoinReceiverUnavailable,
+	/// Failed to enroll payjoin receiver.
+	PayjoinReceiverEnrollementFailed,
+	/// Failed to validate an incoming payjoin request.
+	PayjoinReceiverRequestValidationFailed,
 }
 
 impl fmt::Display for Error {
@@ -187,6 +193,15 @@ impl fmt::Display for Error {
 			Self::PayjoinResponseProcessingFailed => {
 				write!(f, "Payjoin receiver responded to our request with an invalid response that was ignored")
 			},
+			Self::PayjoinReceiverUnavailable => {
+				write!(f, "Failed to access payjoin receiver object. Make sure you have enabled Payjoin receiving support.")
+			},
+			Self::PayjoinReceiverRequestValidationFailed => {
+				write!(f, "Failed to validate an incoming payjoin request. Payjoin sender request didnt pass the payjoin validation steps.")
+			},
+			Self::PayjoinReceiverEnrollementFailed => {
+				write!(f, "Failed to enroll payjoin receiver. Make sure the configured Payjoin directory & Payjoin relay are available.")
+			},
 		}
 	}
 }

src/lib.rs

@@ -89,6 +89,7 @@ pub mod io;
 mod liquidity;
 mod logger;
 mod message_handler;
+mod payjoin_receiver;
 mod payjoin_sender;
 pub mod payment;
 mod peer_store;
@@ -110,6 +111,7 @@ pub use error::Error as NodeError;
 use error::Error;
 
 pub use event::Event;
+use payjoin_receiver::PayjoinReceiver;
 pub use types::ChannelConfig;
 
 pub use io::utils::generate_entropy_mnemonic;
@@ -190,6 +192,7 @@ pub struct Node {
 	peer_manager: Arc<PeerManager>,
 	connection_manager: Arc<ConnectionManager<Arc<FilesystemLogger>>>,
 	payjoin_sender: Option<Arc<PayjoinSender>>,
+	payjoin_receiver: Option<Arc<PayjoinReceiver>>,
 	keys_manager: Arc<KeysManager>,
 	network_graph: Arc<Graph>,
 	gossip_source: Arc<GossipSource>,
@@ -690,6 +693,30 @@ impl Node {
 			Arc::clone(&self.logger),
 		));
 
+		// Check every 5 seconds if we have received a payjoin transaction to our enrolled
+		// subdirectory with the configured Payjoin directory.
+		if let Some(payjoin_receiver) = &self.payjoin_receiver {
+			let mut stop_payjoin_server = self.stop_sender.subscribe();
+			let payjoin_receiver = Arc::clone(&payjoin_receiver);
+			let payjoin_check_interval = 5;
+			runtime.spawn(async move {
+				let mut payjoin_interval =
+					tokio::time::interval(Duration::from_secs(payjoin_check_interval));
+				payjoin_interval.reset();
+				payjoin_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+				loop {
+					tokio::select! {
+						_ = stop_payjoin_server.changed() => {
+							return;
+						}
+						_ = payjoin_interval.tick() => {
+							let _ = payjoin_receiver.process_payjoin_request().await;
+						}
+					}
+				}
+			});
+		}
+
 		let event_handler = Arc::new(EventHandler::new(
 			Arc::clone(&self.event_queue),
 			Arc::clone(&self.wallet),
@@ -1077,9 +1104,11 @@ impl Node {
 	#[cfg(not(feature = "uniffi"))]
 	pub fn payjoin_payment(&self) -> PayjoinPayment {
 		let payjoin_sender = self.payjoin_sender.as_ref();
+		let payjoin_receiver = self.payjoin_receiver.as_ref();
 		PayjoinPayment::new(
 			Arc::clone(&self.runtime),
 			payjoin_sender.map(Arc::clone),
+			payjoin_receiver.map(Arc::clone),
 			Arc::clone(&self.config),
 			Arc::clone(&self.event_queue),
 		)
@@ -1094,9 +1123,11 @@ impl Node {
 	#[cfg(feature = "uniffi")]
 	pub fn payjoin_payment(&self) -> Arc<PayjoinPayment> {
 		let payjoin_sender = self.payjoin_sender.as_ref();
+		let payjoin_receiver = self.payjoin_receiver.as_ref();
 		Arc::new(PayjoinPayment::new(
 			Arc::clone(&self.runtime),
 			payjoin_sender.map(Arc::clone),
+			payjoin_receiver.map(Arc::clone),
 			Arc::clone(&self.config),
 			Arc::clone(&self.event_queue),
 		))