Add ability to send payjoin transactions.

Implements the payjoin sender part as describe in BIP77.

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

Cargo.toml

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

bindings/ldk_node.udl

@@ -151,6 +151,9 @@ enum NodeError {
 	"InsufficientFunds",
 	"LiquiditySourceUnavailable",
 	"LiquidityFeeTooHigh",
+	"PayjoinRequestAmountMissing",
+	"ConstructingPayjoinRequestFailed",
+	"PayjoinSenderUnavailable"
 };
 
 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_sender::PayjoinSender;
 use crate::payment::store::PaymentStore;
 use crate::peer_store::PeerStore;
 use crate::tx_broadcaster::TransactionBroadcaster;
@@ -94,6 +95,11 @@ struct LiquiditySourceConfig {
 	lsps2_service: Option<(SocketAddress, PublicKey, Option<String>)>,
 }
 
+#[derive(Debug, Clone)]
+struct PayjoinSenderConfig {
+	payjoin_relay: payjoin::Url,
+}
+
 impl Default for LiquiditySourceConfig {
 	fn default() -> Self {
 		Self { lsps2_service: None }
@@ -173,6 +179,7 @@ pub struct NodeBuilder {
 	chain_data_source_config: Option<ChainDataSourceConfig>,
 	gossip_source_config: Option<GossipSourceConfig>,
 	liquidity_source_config: Option<LiquiditySourceConfig>,
+	payjoin_sender_config: Option<PayjoinSenderConfig>,
 }
 
 impl NodeBuilder {
@@ -188,12 +195,14 @@ impl NodeBuilder {
 		let chain_data_source_config = None;
 		let gossip_source_config = None;
 		let liquidity_source_config = None;
+		let payjoin_sender_config = None;
 		Self {
 			config,
 			entropy_source_config,
 			chain_data_source_config,
 			gossip_source_config,
 			liquidity_source_config,
+			payjoin_sender_config,
 		}
 	}
 
@@ -248,6 +257,12 @@ impl NodeBuilder {
 		self
 	}
 
+	/// Configures the [`Node`] instance to enable sending payjoin transactions.
+	pub fn set_payjoin_sender_config(&mut self, payjoin_relay: payjoin::Url) -> &mut Self {
+		self.payjoin_sender_config = Some(PayjoinSenderConfig { payjoin_relay });
+		self
+	}
+
 	/// Configures the [`Node`] instance to source its inbound liquidity from the given
 	/// [LSPS2](https://github.com/BitcoinAndLightningLayerSpecs/lsp/blob/main/LSPS2/README.md)
 	/// service.
@@ -369,6 +384,7 @@ impl NodeBuilder {
 			seed_bytes,
 			logger,
 			vss_store,
+			self.payjoin_sender_config.as_ref(),
 		)
 	}
 
@@ -390,6 +406,7 @@ impl NodeBuilder {
 			seed_bytes,
 			logger,
 			kv_store,
+			self.payjoin_sender_config.as_ref(),
 		)
 	}
 }
@@ -454,6 +471,11 @@ impl ArcedNodeBuilder {
 		self.inner.write().unwrap().set_gossip_source_p2p();
 	}
 
+	/// Configures the [`Node`] instance to enable sending payjoin transactions.
+	pub fn set_payjoin_sender_config(&self, payjoin_relay: payjoin::Url) {
+		self.inner.write().unwrap().set_payjoin_sender_config(payjoin_relay);
+	}
+
 	/// Configures the [`Node`] instance to source its gossip data from the given RapidGossipSync
 	/// server.
 	pub fn set_gossip_source_rgs(&self, rgs_server_url: String) {
@@ -524,6 +546,7 @@ fn build_with_store_internal(
 	gossip_source_config: Option<&GossipSourceConfig>,
 	liquidity_source_config: Option<&LiquiditySourceConfig>, seed_bytes: [u8; 64],
 	logger: Arc<FilesystemLogger>, kv_store: Arc<DynStore>,
+	payjoin_sender_config: Option<&PayjoinSenderConfig>,
 ) -> Result<Node, BuildError> {
 	// Initialize the on-chain wallet and chain access
 	let xprv = bitcoin::bip32::ExtendedPrivKey::new_master(config.network.into(), &seed_bytes)
@@ -973,6 +996,16 @@ fn build_with_store_internal(
 	};
 
 	let (stop_sender, _) = tokio::sync::watch::channel(());
+	let payjoin_sender = if let Some(payjoin_sender_config) = payjoin_sender_config {
+		let payjoin_sender = PayjoinSender::new(
+			Arc::clone(&logger),
+			Arc::clone(&wallet),
+			&payjoin_sender_config.payjoin_relay,
+		);
+		Some(Arc::new(payjoin_sender))
+	} else {
+		None
+	};
 
 	let is_listening = Arc::new(AtomicBool::new(false));
 	let latest_wallet_sync_timestamp = Arc::new(RwLock::new(None));
@@ -993,6 +1026,7 @@ fn build_with_store_internal(
 		channel_manager,
 		chain_monitor,
 		output_sweeper,
+		payjoin_sender,
 		peer_manager,
 		connection_manager,
 		keys_manager,

src/error.rs

@@ -71,6 +71,12 @@ pub enum Error {
 	LiquiditySourceUnavailable,
 	/// The given operation failed due to the LSP's required opening fee being too high.
 	LiquidityFeeTooHigh,
+	/// Amount is not prvoided and neither defined in the URI.
+	PayjoinRequestAmountMissing,
+	/// Failed to build a payjoin request.
+	ConstructingPayjoinRequestFailed,
+	/// Failed to access payjoin sender object.
+	PayjoinSenderUnavailable,
 }
 
 impl fmt::Display for Error {
@@ -121,7 +127,12 @@ impl fmt::Display for Error {
 			},
 			Self::LiquidityFeeTooHigh => {
 				write!(f, "The given operation failed due to the LSP's required opening fee being too high.")
+			}, Self::ConstructingPayjoinRequestFailed => write!(f, "Failed construct a payjoin request.
+				Make sure the provided URI is valid and the configured payjoin relay as available."),
+			Self::PayjoinRequestAmountMissing => {
+				write!(f, "Amount is not provided and neither defined in the URI.")
 			},
+			Self::PayjoinSenderUnavailable => write!(f, "Failed to access payjoin sender object. Make sure you have configured the node to act as payjoin sender."),
 		}
 	}
 }

src/lib.rs

@@ -88,6 +88,7 @@ pub mod io;
 mod liquidity;
 mod logger;
 mod message_handler;
+mod payjoin_sender;
 pub mod payment;
 mod peer_store;
 mod sweep;
@@ -99,6 +100,7 @@ mod wallet;
 
 pub use bip39;
 pub use bitcoin;
+use bitcoin::address::NetworkChecked;
 pub use lightning;
 pub use lightning_invoice;
 
@@ -108,6 +110,7 @@ pub use error::Error as NodeError;
 use error::Error;
 
 pub use event::Event;
+use payjoin_sender::PayjoinSender;
 pub use types::ChannelConfig;
 
 pub use io::utils::generate_entropy_mnemonic;
@@ -181,6 +184,7 @@ pub struct Node {
 	output_sweeper: Arc<Sweeper>,
 	peer_manager: Arc<PeerManager>,
 	connection_manager: Arc<ConnectionManager<Arc<FilesystemLogger>>>,
+	payjoin_sender: Option<Arc<PayjoinSender<Arc<FilesystemLogger>>>>,
 	keys_manager: Arc<KeysManager>,
 	network_graph: Arc<NetworkGraph>,
 	gossip_source: Arc<GossipSource>,
@@ -697,6 +701,60 @@ impl Node {
 		Ok(())
 	}
 
+	/// This method can be used to send a payjoin transaction as defined in BIP77.
+	///
+	/// The method will construct an `Original PSBT` from the data provided in the `payjoin_uri`
+	/// and `amount` parameters. The amount must be set either in the `payjoin_uri` or in the
+	/// `amount` parameter. If both are set, the paramter amount will be used.
+	///
+	/// After constructing the `Original PSBT`, the method will extract the payjoin request data
+	/// from the `Original PSBT` and `payjoin_uri` utilising the `payjoin` crate.
+	///
+	/// Then we start a background process that will run for 1 hour, polling the payjoin endpoint
+	/// every 10 seconds. If an `OK` (ie status code == 200) is received, polling will stop and we
+	/// will try to process the response from the payjoin receiver. If the response(or `Payjoin
+	/// Proposal`) is valid, we will finalise the transaction and broadcast it to the network.
+	///
+	/// Notice that the `Txid` returned from this method is the `Original PSBT` transaction id, but
+	/// the `Payjoin Proposal` transaction id could be different if the receiver changed the
+	/// transaction.
+	pub fn send_payjoin_transaction(
+		&self, payjoin_uri: payjoin::Uri<'static, NetworkChecked>, amount: Option<bitcoin::Amount>,
+	) -> Result<Option<bitcoin::Txid>, Error> {
+		let rt_lock = self.runtime.read().unwrap();
+		if rt_lock.is_none() {
+			return Err(Error::NotRunning);
+		}
+		let payjoin_sender =
+			Arc::clone(self.payjoin_sender.as_ref().ok_or(Error::PayjoinSenderUnavailable)?);
+		let original_psbt = payjoin_sender.create_payjoin_request(payjoin_uri.clone(), amount)?;
+		let txid = original_psbt.clone().unsigned_tx.txid();
+		let (request, context) =
+			payjoin_sender.extract_request_data(payjoin_uri, original_psbt.clone())?;
+
+		let time = std::time::Instant::now();
+		let runtime = rt_lock.as_ref().unwrap();
+		runtime.spawn(async move {
+			let response = payjoin_sender.poll(&request, time).await;
+			if let Some(response) = response {
+				let psbt = context.process_response(&mut response.as_slice());
+				match psbt {
+					Ok(Some(psbt)) => {
+						let finalized =
+							payjoin_sender.finalise_payjoin_tx(psbt, original_psbt.clone());
+						if let Ok(txid) = finalized {
+							let txid: bitcoin::Txid = txid.into();
+							return Some(txid);
+						}
+					},
+					_ => return None,
+				}
+			}
+			None
+		});
+		Ok(Some(txid))
+	}
+
 	/// Disconnects all peers, stops all running background tasks, and shuts down [`Node`].
 	///
 	/// After this returns most API methods will return [`Error::NotRunning`].