Add ChannelScheduler

  Add a new struct to schedule new lightning channels, tracking them in
  different states mirroring the original protocol flow: Created,
  Accepted, FundingCreated, FundingSigned.

  Functions start with `mark_` are used in order to change the channel
  state.

  This can be utilised by users who want to schedule a channel opening
  for a future incoming payjoin transaction.

Author: jbesraa

lightning-payjoin/Cargo.toml

@@ -10,3 +10,5 @@ resolver = "2"
 version = "0.0.1"
 
 [dependencies]
+bitcoin = "0.30.2"
+lightning = { git = "https://github.com/jbesraa/rust-lightning.git", rev = "d3e2d5a", features = ["std"] }

lightning-payjoin/src/lib.rs

@@ -0,0 +1 @@
+pub mod scheduler;

lightning-payjoin/src/scheduler.rs

@@ -0,0 +1,335 @@
+/// A lightning network channel scheduler.
+use bitcoin::{psbt::Psbt, secp256k1::PublicKey, ScriptBuf, Txid};
+use lightning::ln::ChannelId;
+
+#[derive(Clone)]
+pub struct ChannelScheduler {
+	channels: Vec<ScheduledChannel>,
+}
+
+impl ChannelScheduler {
+	/// Create a new empty channel scheduler.
+	pub fn new() -> Self {
+		Self { channels: vec![] }
+	}
+	/// Schedule a new channel.
+	///
+	/// The channel will be created with `ScheduledChannelState::ChannelCreated` state.
+	pub fn schedule(
+		&mut self, channel_value_satoshi: bitcoin::Amount, counterparty_node_id: PublicKey,
+		channel_id: u128,
+	) {
+		let channel =
+			ScheduledChannel::new(channel_value_satoshi, counterparty_node_id, channel_id);
+		match channel.state {
+			ScheduledChannelState::ChannelCreated => {
+				self.channels.push(channel);
+			},
+			_ => {},
+		}
+	}
+	/// Mark a channel as accepted.
+	///
+	/// The channel will be updated to `ScheduledChannelState::ChannelAccepted` state.
+	pub fn set_channel_accepted(
+		&mut self, channel_id: u128, output_script: ScriptBuf, temporary_channel_id: ChannelId,
+	) {
+		for channel in &mut self.channels {
+			if channel.channel_id() == channel_id {
+				channel.state.set_channel_accepted(output_script, temporary_channel_id);
+				break;
+			}
+		}
+	}
+	/// Mark a channel as funding tx created.
+	///
+	/// The channel will be updated to `ScheduledChannelState::FundingTxCreated` state.
+	pub fn set_funding_tx_created(&mut self, channel_id: u128, funding_tx: Psbt) {
+		for channel in &mut self.channels {
+			if channel.channel_id() == channel_id {
+				channel.state.set_channel_funding_tx_created(funding_tx);
+				break;
+			}
+		}
+	}
+	/// Mark a channel as funding tx signed.
+	///
+	/// The channel will be updated to `ScheduledChannelState::FundingTxSigned` state.
+	pub fn set_funding_tx_signed(&mut self, txid: Txid) {
+		for channel in &mut self.channels {
+			if channel.txid() == Some(txid) {
+				channel.state.set_channel_funding_tx_signed(txid);
+				break;
+			}
+		}
+	}
+	/// Check if a channel is in the created state.
+	pub fn is_channel_created(&self, channel_id: u128) -> bool {
+		if let Some(c) = self.internal_find_channel(channel_id) {
+			return c.is_channel_created();
+		}
+		false
+	}
+	/// Check if a channel is in the funding tx created state.
+	pub fn is_funding_tx_created(&self, txid: &Txid) -> bool {
+		self.internal_find_channel_by_txid(txid)
+			.and_then(|ch| Some(ch.is_funding_tx_created()))
+			.unwrap_or(false)
+	}
+	/// Check if a channel is in the funding tx signed state.
+	pub fn is_funding_tx_signed(&self, txid: &Txid) -> bool {
+		self.internal_find_channel_by_txid(txid)
+			.and_then(|ch| Some(ch.is_funding_tx_signed()))
+			.unwrap_or(false)
+	}
+	/// Get the next channel matching the given channel amount.
+	///
+	/// The channel must be in the accepted state.
+	///
+	/// If more than one channel matches the given channel amount, the channel with the oldest
+	/// creation date will be returned.
+	pub fn get_next_channel(&self, channel_amount: bitcoin::Amount) -> Option<&ScheduledChannel> {
+		self.channels
+			.iter()
+			.filter(|channel| {
+				channel.channel_value_satoshi() == channel_amount && channel.is_channel_accepted()
+			})
+			.min_by_key(|channel| channel.created_at())
+	}
+	/// List all channels.
+	pub fn list_channels(&self) -> &Vec<ScheduledChannel> {
+		&self.channels
+	}
+	fn internal_find_channel(&self, channel_id: u128) -> Option<&ScheduledChannel> {
+		self.channels.iter().find(|channel| channel.channel_id() == channel_id)
+	}
+	fn internal_find_channel_by_txid(&self, txid: &Txid) -> Option<&ScheduledChannel> {
+		let channel = self.channels.iter().find(|channel| {
+			let ch_txid = match channel.txid() {
+				Some(txid) => txid,
+				None => return false,
+			};
+			return &ch_txid == txid;
+		});
+		channel
+	}
+	#[cfg(test)]
+	fn is_channel_accepted(&self, channel_id: u128) -> bool {
+		if let Some(c) = self.internal_find_channel(channel_id) {
+			return c.is_channel_accepted();
+		}
+		false
+	}
+}
+
+/// A struct representing a scheduled channel.
+#[derive(Clone, Debug)]
+pub struct ScheduledChannel {
+	state: ScheduledChannelState,
+	channel_value_satoshi: bitcoin::Amount,
+	channel_id: u128,
+	counterparty_node_id: PublicKey,
+	created_at: u64,
+}
+
+impl ScheduledChannel {
+	fn new(
+		channel_value_satoshi: bitcoin::Amount, counterparty_node_id: PublicKey, channel_id: u128,
+	) -> Self {
+		ScheduledChannel {
+			state: ScheduledChannelState::ChannelCreated,
+			channel_value_satoshi,
+			channel_id,
+			counterparty_node_id,
+			created_at: 0,
+		}
+	}
+
+	fn is_channel_created(&self) -> bool {
+		match self.state {
+			ScheduledChannelState::ChannelCreated => true,
+			_ => false,
+		}
+	}
+
+	fn is_channel_accepted(&self) -> bool {
+		match self.state {
+			ScheduledChannelState::ChannelAccepted(..) => true,
+			_ => false,
+		}
+	}
+
+	fn is_funding_tx_created(&self) -> bool {
+		match self.state {
+			ScheduledChannelState::FundingTxCreated(..) => true,
+			_ => false,
+		}
+	}
+
+	fn is_funding_tx_signed(&self) -> bool {
+		match self.state {
+			ScheduledChannelState::FundingTxSigned(..) => true,
+			_ => false,
+		}
+	}
+
+	fn channel_value_satoshi(&self) -> bitcoin::Amount {
+		self.channel_value_satoshi
+	}
+
+	/// Get the user channel id.
+	pub(crate) fn channel_id(&self) -> u128 {
+		self.channel_id
+	}
+
+	/// Get the counterparty node id.
+	pub(crate) fn node_id(&self) -> PublicKey {
+		self.counterparty_node_id
+	}
+
+	/// Get the output script.
+	pub(crate) fn output_script(&self) -> Option<&ScriptBuf> {
+		self.state.output_script()
+	}
+
+	/// Get the temporary channel id.
+	pub(crate) fn temporary_channel_id(&self) -> Option<ChannelId> {
+		self.state.temporary_channel_id()
+	}
+
+	fn created_at(&self) -> u64 {
+		self.created_at
+	}
+
+	fn txid(&self) -> Option<Txid> {
+		self.state.txid()
+	}
+}
+
+#[derive(Clone, Debug)]
+struct FundingTxParams {
+	output_script: ScriptBuf,
+	temporary_channel_id: ChannelId,
+}
+
+impl FundingTxParams {
+	fn new(output_script: ScriptBuf, temporary_channel_id: ChannelId) -> Self {
+		Self { output_script, temporary_channel_id }
+	}
+}
+
+#[derive(Clone, Debug)]
+enum ScheduledChannelState {
+	ChannelCreated,
+	ChannelAccepted(FundingTxParams),
+	FundingTxCreated(FundingTxParams, Psbt),
+	FundingTxSigned(FundingTxParams, (), Txid),
+}
+
+impl ScheduledChannelState {
+	fn output_script(&self) -> Option<&ScriptBuf> {
+		match self {
+			ScheduledChannelState::ChannelAccepted(funding_tx_params) => {
+				Some(&funding_tx_params.output_script)
+			},
+			ScheduledChannelState::FundingTxCreated(funding_tx_params, _) => {
+				Some(&funding_tx_params.output_script)
+			},
+			ScheduledChannelState::FundingTxSigned(funding_tx_params, _, _) => {
+				Some(&funding_tx_params.output_script)
+			},
+			_ => None,
+		}
+	}
+
+	fn temporary_channel_id(&self) -> Option<ChannelId> {
+		match self {
+			ScheduledChannelState::ChannelAccepted(funding_tx_params) => {
+				Some(funding_tx_params.temporary_channel_id)
+			},
+			ScheduledChannelState::FundingTxCreated(funding_tx_params, _) => {
+				Some(funding_tx_params.temporary_channel_id)
+			},
+			ScheduledChannelState::FundingTxSigned(funding_tx_params, _, _) => {
+				Some(funding_tx_params.temporary_channel_id)
+			},
+			_ => None,
+		}
+	}
+
+	fn txid(&self) -> Option<Txid> {
+		match self {
+			ScheduledChannelState::FundingTxCreated(_, funding_tx) => {
+				Some(funding_tx.clone().extract_tx().txid())
+			},
+			ScheduledChannelState::FundingTxSigned(_, _, txid) => Some(*txid),
+			_ => None,
+		}
+	}
+
+	fn set_channel_accepted(&mut self, output_script: ScriptBuf, temporary_channel_id: ChannelId) {
+		if let ScheduledChannelState::ChannelCreated = self {
+			*self = ScheduledChannelState::ChannelAccepted(FundingTxParams::new(
+				output_script,
+				temporary_channel_id,
+			));
+		}
+	}
+
+	fn set_channel_funding_tx_created(&mut self, funding_tx: Psbt) {
+		if let ScheduledChannelState::ChannelAccepted(funding_tx_params) = self {
+			*self = ScheduledChannelState::FundingTxCreated(funding_tx_params.clone(), funding_tx);
+		}
+	}
+
+	fn set_channel_funding_tx_signed(&mut self, txid: Txid) {
+		if let ScheduledChannelState::FundingTxCreated(funding_tx_params, psbt) = self {
+			if txid == psbt.unsigned_tx.txid() {
+				*self = ScheduledChannelState::FundingTxSigned(funding_tx_params.clone(), (), txid);
+			}
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+
+	use super::*;
+	use bitcoin::{
+		psbt::Psbt,
+		secp256k1::{self, Secp256k1},
+	};
+
+	#[tokio::test]
+	async fn test_channel_scheduler() {
+		let create_pubkey = || -> PublicKey {
+			let secp = Secp256k1::new();
+			PublicKey::from_secret_key(&secp, &secp256k1::SecretKey::from_slice(&[1; 32]).unwrap())
+		};
+		let channel_value_satoshi = 100;
+		let node_id = create_pubkey();
+		let channel_id: u128 = 0;
+		let mut channel_scheduler = ChannelScheduler::new();
+		channel_scheduler.schedule(
+			bitcoin::Amount::from_sat(channel_value_satoshi),
+			node_id,
+			channel_id,
+		);
+		assert_eq!(channel_scheduler.channels.len(), 1);
+		assert_eq!(channel_scheduler.is_channel_created(channel_id), true);
+		channel_scheduler.set_channel_accepted(
+			channel_id,
+			ScriptBuf::from(vec![1, 2, 3]),
+			ChannelId::new_zero(),
+		);
+		assert_eq!(channel_scheduler.is_channel_accepted(channel_id), true);
+		let str_psbt = "cHNidP8BAHMCAAAAAY8nutGgJdyYGXWiBEb45Hoe9lWGbkxh/6bNiOJdCDuDAAAAAAD+////AtyVuAUAAAAAF6kUHehJ8GnSdBUOOv6ujXLrWmsJRDCHgIQeAAAAAAAXqRR3QJbbz0hnQ8IvQ0fptGn+votneofTAAAAAAEBIKgb1wUAAAAAF6kU3k4ekGHKWRNbA1rV5tR5kEVDVNCHAQcXFgAUx4pFclNVgo1WWAdN1SYNX8tphTABCGsCRzBEAiB8Q+A6dep+Rz92vhy26lT0AjZn4PRLi8Bf9qoB/CMk0wIgP/Rj2PWZ3gEjUkTlhDRNAQ0gXwTO7t9n+V14pZ6oljUBIQMVmsAaoNWHVMS02LfTSe0e388LNitPa1UQZyOihY+FFgABABYAFEb2Giu6c4KO5YW0pfw3lGp9jMUUAAA=";
+		let mock_transaction = Psbt::from_str(str_psbt).unwrap();
+		channel_scheduler.set_funding_tx_created(channel_id, mock_transaction.clone());
+		let tx_id = mock_transaction.extract_tx().txid();
+		assert_eq!(channel_scheduler.is_funding_tx_created(&tx_id), true);
+		channel_scheduler.set_funding_tx_signed(tx_id);
+		assert_eq!(channel_scheduler.is_funding_tx_signed(&tx_id), true);
+	}
+}