Add PayjoinHandler

  Add two new structs `PayjoinHandler` and `PayjoinReceiver`.  The first
  is public and holds the later as a property and can be used in order to
  serve incoming payjoin transactions.

  `PayjoinReceiver` implemented `lightning_payjoin::Receiver` trait to
  allow us to receive payjoin transactions or open a channel.

Author: jbesraa

Cargo.toml

@@ -28,17 +28,20 @@ panic = 'abort'     # Abort on panic
 default = []
 
 [dependencies]
-lightning = { version = "0.0.123-beta", features = ["std"] }
-lightning-invoice = { version = "0.31.0-beta" }
-lightning-net-tokio = { version = "0.0.123-beta" }
-lightning-persister = { version = "0.0.123-beta" }
-lightning-background-processor = { version = "0.0.123-beta", features = ["futures"] }
-lightning-rapid-gossip-sync = { version = "0.0.123-beta" }
-lightning-transaction-sync = { version = "0.0.123-beta", features = ["esplora-async-https", "time"] }
+lightning = { git = "https://github.com/jbesraa/rust-lightning",rev = "0cb3d57", features = ["std"] }
+lightning-invoice = { git = "https://github.com/jbesraa/rust-lightning",rev = "0cb3d57" }
+lightning-net-tokio = { git = "https://github.com/jbesraa/rust-lightning",rev = "0cb3d57" }
+lightning-persister = { git = "https://github.com/jbesraa/rust-lightning",rev = "0cb3d57" }
+lightning-background-processor = { git = "https://github.com/jbesraa/rust-lightning", rev = "0cb3d57", features = ["futures"] }
+lightning-rapid-gossip-sync = { git = "https://github.com/jbesraa/rust-lightning", rev = "0cb3d57" }
+lightning-transaction-sync = { git = "https://github.com/jbesraa/rust-lightning", rev = "0cb3d57", features = ["esplora-async-https", "time"] }
 #lightning-liquidity = { version = "0.1.0-alpha.1", features = ["std"] }
 
-lightning-liquidity = { git = "https://github.com/tnull/lightning-liquidity", rev = "abf7088c0e03221c0f122e797f34802c9e99a3d4", features = ["std"] }
+# lightning-liquidity = {path = "../../lightning-liquidity" git = "https://github.com/jbesraa/lightning-liquidity", rev = "b6ac60d", features = ["std"] }
+lightning-liquidity = {path = "../../lightning-liquidity" , features = ["std"] }
+# lightning-liquidity = { git = "https://github.com/tnull/lightning-liquidity", rev = "abf7088c0e03221c0f122e797f34802c9e99a3d4", features = ["std"] }
 
+lightning-payjoin = { path = "./lightning-payjoin" }
 #lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main", features = ["std"] }
 #lightning-invoice = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" }
 #lightning-net-tokio = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" }
@@ -79,12 +82,14 @@ prost = { version = "0.11.6", default-features = false}
 winapi = { version = "0.3", features = ["winbase"] }
 
 [dev-dependencies]
-lightning = { version = "0.0.123-beta", features = ["std", "_test_utils"] }
+lightning = { git = "https://github.com/jbesraa/rust-lightning",rev = "0cb3d57", features = ["std", "_test_utils"] }
+# lightning = { version = "0.0.123-beta", features = ["std", "_test_utils"] }
 #lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main", features = ["std", "_test_utils"] }
 electrum-client = { version = "0.15.1", default-features = true }
 bitcoincore-rpc = { version = "0.17.0", default-features = false }
 proptest = "1.0.0"
 regex = "1.5.6"
+reqwest = { version = "0.11", default-features = false, features = ["blocking"] }
 
 [target.'cfg(not(no_download))'.dev-dependencies]
 electrsd = { version = "0.26.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_25_0"] }

lightning-payjoin/src/error.rs

@@ -1,5 +1,3 @@
-use lightning::util::errors::APIError;
-
 #[derive(Debug)]
 pub enum Error {
 	Internal(InternalError),
@@ -73,39 +71,39 @@ impl std::fmt::Display for Error {
 	}
 }
 
-// Maybe this should live in LDK-Node instead?
-impl From<APIError> for Error {
-	fn from(value: APIError) -> Self {
-		match value {
-			APIError::APIMisuseError { err } => {
-				Self::Internal(InternalError::FundingTxGenerationFailed(err))
-			},
-			APIError::FeeRateTooHigh { err, feerate } => Self::Internal(
-				InternalError::FundingTxGenerationFailed(format!("{} feerate: {}", err, feerate)),
-			),
-			APIError::InvalidRoute { err } => {
-				Self::Internal(InternalError::FundingTxGenerationFailed(format!(
-					"Invalid route provided: {}",
-					err
-				)))
-			},
-			APIError::ChannelUnavailable { err } => Self::Internal(
-				InternalError::FundingTxGenerationFailed(format!("Channel unavailable: {}", err)),
-			),
-			APIError::MonitorUpdateInProgress => {
-				Self::Internal(InternalError::FundingTxGenerationFailed(
-					"Client indicated a channel monitor update is in progress but not yet complete"
-						.to_string(),
-				))
-			},
-			APIError::IncompatibleShutdownScript { script } => {
-				Self::Internal(InternalError::FundingTxGenerationFailed(format!(
-					"Provided a scriptpubkey format not accepted by peer: {}",
-					script
-				)))
-			},
-		}
-	}
-}
+// // Maybe this should live in LDK-Node instead?
+// impl From<APIError> for Error {
+// 	fn from(value: APIError) -> Self {
+// 		match value {
+// 			APIError::APIMisuseError { err } => {
+// 				Self::Internal(InternalError::FundingTxGenerationFailed(err))
+// 			},
+// 			APIError::FeeRateTooHigh { err, feerate } => Self::Internal(
+// 				InternalError::FundingTxGenerationFailed(format!("{} feerate: {}", err, feerate)),
+// 			),
+// 			APIError::InvalidRoute { err } => {
+// 				Self::Internal(InternalError::FundingTxGenerationFailed(format!(
+// 					"Invalid route provided: {}",
+// 					err
+// 				)))
+// 			},
+// 			APIError::ChannelUnavailable { err } => Self::Internal(
+// 				InternalError::FundingTxGenerationFailed(format!("Channel unavailable: {}", err)),
+// 			),
+// 			APIError::MonitorUpdateInProgress => {
+// 				Self::Internal(InternalError::FundingTxGenerationFailed(
+// 					"Client indicated a channel monitor update is in progress but not yet complete"
+// 						.to_string(),
+// 				))
+// 			},
+// 			APIError::IncompatibleShutdownScript { script } => {
+// 				Self::Internal(InternalError::FundingTxGenerationFailed(format!(
+// 					"Provided a scriptpubkey format not accepted by peer: {}",
+// 					script
+// 				)))
+// 			},
+// 		}
+// 	}
+// }
 
 impl std::error::Error for Error {}

src/error.rs

@@ -139,3 +139,19 @@ impl From<lightning_transaction_sync::TxSyncError> for Error {
 		Self::TxSyncFailed
 	}
 }
+
+impl From<Error> for lightning_payjoin::error::Error {
+	fn from(e: Error) -> Self {
+		match e {
+			Error::WalletOperationFailed => lightning_payjoin::error::Error::Internal(
+				lightning_payjoin::error::InternalError::WalletOperationFailed,
+			),
+			Error::OnchainTxSigningFailed => lightning_payjoin::error::Error::Internal(
+				lightning_payjoin::error::InternalError::OnchainTxSigningFailed,
+			),
+			_ => lightning_payjoin::error::Error::Internal(
+				lightning_payjoin::error::InternalError::NodeFailed,
+			),
+		}
+	}
+}

src/event.rs

@@ -706,7 +706,7 @@ where
 				}
 			},
 			LdkEvent::SpendableOutputs { outputs, channel_id } => {
-				self.output_sweeper.track_spendable_outputs(outputs, channel_id, true, None)
+				self.output_sweeper.track_spendable_outputs(outputs, channel_id, true, None);
 			},
 			LdkEvent::OpenChannelRequest {
 				temporary_channel_id,

src/lib.rs

@@ -109,6 +109,7 @@ use error::Error;
 
 pub use event::Event;
 pub use types::ChannelConfig;
+mod payjoin_handler;
 
 pub use io::utils::generate_entropy_mnemonic;
 

src/payjoin_handler.rs

@@ -0,0 +1,134 @@
+use crate::types::{ChannelManager, Wallet};
+use bitcoin::secp256k1::PublicKey;
+use lightning::ln::ChannelId;
+use lightning_payjoin::error::Error as PayjoinError;
+use lightning_payjoin::scheduler::{ChannelScheduler, ScheduledChannel};
+use lightning_payjoin::{LightningPayjoin, ProvisionalProposal, UncheckedProposal};
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+#[derive(Clone)]
+pub(crate) struct PayjoinHandler {
+	inner: Arc<Mutex<LightningPayjoin>>,
+	scheduler: Arc<Mutex<ChannelScheduler>>,
+	wallet: Arc<Wallet>,
+	channel_manager: Arc<ChannelManager>,
+}
+
+impl PayjoinHandler {
+	pub(crate) fn new(
+		wallet: Arc<Wallet>,
+		channel_manager: Arc<ChannelManager>,
+		scheduler: Arc<Mutex<ChannelScheduler>>,
+		payjoin_directory: lightning_payjoin::Url,
+		payjoin_relay: lightning_payjoin::Url,
+	) -> Self {
+		let lightning_payjoin = LightningPayjoin::new(
+			payjoin_directory,
+			payjoin_relay,
+		);
+		let inner = Arc::new(Mutex::new(lightning_payjoin));
+		Self { inner, scheduler, wallet, channel_manager }
+	}
+
+	pub(crate) async fn process_request(&self) -> Result<(), PayjoinError> {
+		let mut inner = self.inner.lock().await;
+		let proposal = match inner.fetch_payjoin_proposal().await {
+			Ok(Some(proposal)) => proposal,
+			Ok(None) => return Ok(()),
+			Err(e) => return Err(e),
+		};
+		let min_fee_rate = bitcoin::FeeRate::from_sat_per_vb(1);
+		let provisional_proposal = self.validate_payjoin_request(proposal, min_fee_rate).await.unwrap();
+		let amt = bitcoin::Amount::from_sat(provisional_proposal.payjoin_amount());
+		let channel = self.scheduler.lock().await.get_next_channel(amt).cloned();
+		let finalized_proposal = match channel {
+			Some(channel) => {
+				let finalized_proposal = inner
+					.accept_payjoin_with_channel_opening(provisional_proposal, channel.clone())
+					.await
+					.unwrap();
+				self.scheduler.lock().await.set_funding_tx_created(
+					channel.channel_id(),
+					finalized_proposal.psbt().clone(),
+				);
+				let tx = finalized_proposal.psbt().clone().extract_tx();
+				let _ = self.channel_manager.funding_transaction_generated(
+					&ChannelId::from_bytes(channel.temporary_channel_id().unwrap()),
+					&channel.counterparty_node_id(),
+					tx.clone(),
+				);
+				let _ = self.wait_for_funding_tx_signed(tx.txid());
+				finalized_proposal
+			},
+			None => inner.accept_payjoin_without_channel_opening(provisional_proposal).unwrap(),
+		};
+		inner.send_response(finalized_proposal).await
+	}
+
+	pub(crate) async fn payjoin_uri(&self, amount: bitcoin::Amount) -> String {
+		let address = self.wallet.get_new_address().unwrap();
+		self.inner.lock().await.construct_payjoin_uri(amount, address)
+	}
+
+	pub(crate) async fn schedule_channel(
+		&self, amount: bitcoin::Amount, counterparty_node_id: PublicKey, channel_id: u128,
+	) {
+		let channel = ScheduledChannel::new(amount, counterparty_node_id, channel_id);
+		self.scheduler.lock().await.schedule(
+			channel.channel_value_satoshi(),
+			channel.counterparty_node_id(),
+			channel.channel_id(),
+		);
+	}
+
+	pub(crate) async fn list_scheduled_channels(&self) -> Vec<ScheduledChannel> {
+		self.scheduler.lock().await.list_channels().clone()
+	}
+
+	async fn wait_for_funding_tx_signed(&self, txid: bitcoin::Txid)-> Result<(), PayjoinError> {
+		let channel_scheduler = self.scheduler.clone();
+		let is_funding_signed =
+			tokio::time::timeout(tokio::time::Duration::from_secs(3), async move {
+				loop {
+					if channel_scheduler.lock().await.is_funding_tx_signed(&txid) {
+						break;
+					}
+				}
+			})
+			.await;
+		match is_funding_signed {
+			Ok(_) => {
+				return Ok(());
+			},
+			Err(_) => {
+				panic!("Funding tx not signed")
+			},
+		}
+	}
+
+	pub async fn validate_payjoin_request(
+		&self,
+		proposal: UncheckedProposal,
+		min_fee_rate: Option<bitcoin::FeeRate>,
+	) -> Result<ProvisionalProposal, PayjoinError> {
+		let proposal = {
+			let tx = proposal.extract_tx_to_schedule_broadcast();
+			let verified = match self.wallet.verify_tx(tx).await {
+				Ok(_verified) => true,
+				Err(_e) => false
+			};
+			let proposal = proposal.check_broadcast_suitability(min_fee_rate, |_t| { Ok(verified) }).unwrap();
+			proposal
+		};
+		let proposal = proposal.check_inputs_not_owned(|script| {
+			Ok(self.wallet.is_mine(&script.to_owned()).unwrap())
+		})?;
+		let proposal = proposal.check_no_mixed_input_scripts()?;
+		let proposal = proposal.check_no_inputs_seen_before(|_outpoint| Ok(false))?;
+		let original_proposal = proposal.clone().identify_receiver_outputs(|script| {
+			Ok(self.wallet.is_mine(&script.to_owned()).unwrap())
+		})?;
+		Ok(original_proposal)
+	}
+}