Partly handle splice_init, splice_ack messages, with tests

Author: optout21

lightning/src/ln/channel.rs

@@ -11,7 +11,6 @@ use bitcoin::amount::Amount;
 use bitcoin::constants::ChainHash;
 use bitcoin::script::{Script, ScriptBuf, Builder};
 use bitcoin::transaction::Transaction;
-use bitcoin::sighash;
 use bitcoin::sighash::EcdsaSighashType;
 use bitcoin::consensus::encode;
 
@@ -23,7 +22,9 @@ use bitcoin::hash_types::{Txid, BlockHash};
 use bitcoin::secp256k1::constants::PUBLIC_KEY_SIZE;
 use bitcoin::secp256k1::{PublicKey,SecretKey};
 use bitcoin::secp256k1::{Secp256k1,ecdsa::Signature};
-use bitcoin::secp256k1;
+use bitcoin::{secp256k1, sighash};
+#[cfg(splicing)]
+use bitcoin::TxIn;
 
 use crate::ln::types::ChannelId;
 use crate::types::payment::{PaymentPreimage, PaymentHash};
@@ -1179,6 +1180,34 @@ impl UnfundedChannelContext {
 	}
 }
 
+/// Info about a pending splice, used in the pre-splice channel
+#[cfg(splicing)]
+#[derive(Clone)]
+pub(crate) struct PendingSpliceInfoPre {
+	pub our_funding_contribution: i64,
+	pub funding_feerate_perkw: u32,
+	pub locktime: u32,
+	/// The funding inputs we will be contributing to the splice.
+	/// TODO(splice): will be changed to TransactionU16LenLimited
+	pub our_funding_inputs: Vec<(TxIn, Transaction)>,
+}
+
+#[cfg(splicing)]
+impl PendingSpliceInfoPre {
+	fn add_checked(base: u64, delta: i64) -> u64 {
+		if delta >= 0 {
+			base.saturating_add(delta as u64)
+		} else {
+			base.saturating_sub(delta.abs() as u64)
+		}
+	}
+
+	/// Compute the post-splice channel value from the pre-splice values and the peer contributions
+	pub fn compute_post_value(pre_channel_value: u64, our_funding_contribution: i64, their_funding_contribution: i64) -> u64 {
+		Self::add_checked(pre_channel_value, our_funding_contribution.saturating_add(their_funding_contribution))
+	}
+}
+
 /// Contains everything about the channel including state, and various flags.
 pub(super) struct ChannelContext<SP: Deref> where SP::Target: SignerProvider {
 	config: LegacyChannelConfig,
@@ -1214,6 +1243,10 @@ pub(super) struct ChannelContext<SP: Deref> where SP::Target: SignerProvider {
 	secp_ctx: Secp256k1<secp256k1::All>,
 	channel_value_satoshis: u64,
 
+	/// Info about an in-progress, pending splice (if any), on the pre-splice channel
+	#[cfg(splicing)]
+	pub(crate) pending_splice_pre: Option<PendingSpliceInfoPre>,
+	
 	latest_monitor_update_id: u64,
 
 	holder_signer: ChannelSignerType<SP>,
@@ -1980,6 +2013,9 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 			blocked_monitor_updates: Vec::new(),
 
 			is_manual_broadcast: false,
+
+			#[cfg(splicing)]
+			pending_splice_pre: None,
 		};
 
 		Ok(channel_context)
@@ -2211,6 +2247,9 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 			blocked_monitor_updates: Vec::new(),
 			local_initiated_shutdown: None,
 			is_manual_broadcast: false,
+
+			#[cfg(splicing)]
+			pending_splice_pre: None,
 		})
 	}
 
@@ -3771,6 +3810,72 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 		self.channel_transaction_parameters.channel_type_features = self.channel_type.clone();
 		Ok(())
 	}
+
+	// /// Splice process starting; update state; update capacity, state, reset funding tx
+	// #[cfg(splicing)]
+	// pub(crate) fn splice_start<L: Deref>(&mut self, is_outgoing: bool, logger: &L) where L::Target: Logger {
+	// 	// Set state, by this point handshake is complete
+	// 	self.channel_state = ChannelState::NegotiatingFunding(NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT);
+
+	// 	log_info!(logger,
+	// 		"Splicing process started, new channel value {}, outgoing {}, channel_id {}",
+	// 		self.channel_value_satoshis, is_outgoing, self.channel_id,
+	// 	);
+	// }
+
+	/// Get the splice message that can be sent during splice initiation.
+	#[cfg(splicing)]
+	pub fn get_splice_init(&self, our_funding_contribution_satoshis: i64, signer_provider: &SP,
+		funding_feerate_perkw: u32, locktime: u32,
+	) -> msgs::SpliceInit {
+		if !self.is_outbound() {
+			panic!("Tried to initiate a splice on an inbound channel!");
+		}
+
+		// At this point we are not committed to the new channel value yet, but the funding pubkey
+		// depends on the channel value, so we create here a new funding pubkey with the new
+		// channel value.
+		// Note that channel_keys_id is supposed NOT to change
+		let funding_pubkey = {
+			// TODO: Funding pubkey generation requires the post channel value, but that is not known yet,
+			// the acceptor contribution is missing. There is a need for a way to generate a new funding pubkey,
+			// not based on the channel value
+			let pre_channel_value = self.channel_value_satoshis;
+			let placeholder_counterparty_contribution = 0;
+			let incomplete_post_splice_channel_value = PendingSpliceInfoPre::compute_post_value(pre_channel_value,
+				our_funding_contribution_satoshis, placeholder_counterparty_contribution);
+			let holder_signer = signer_provider.derive_channel_signer(incomplete_post_splice_channel_value, self.channel_keys_id);
+			holder_signer.pubkeys().funding_pubkey
+		};
+
+		msgs::SpliceInit {
+			channel_id: self.channel_id,
+			funding_contribution_satoshis: our_funding_contribution_satoshis,
+			funding_feerate_perkw,
+			locktime,
+			funding_pubkey,
+			require_confirmed_inputs: None,
+		}
+	}
+
+	/// Get the splice_ack message that can be sent in response to splice initiation.
+	#[cfg(splicing)]
+	pub fn get_splice_ack(&mut self, our_funding_contribution_satoshis: i64) -> Result<msgs::SpliceAck, ChannelError> {
+		if self.is_outbound() {
+			panic!("Tried to accept a splice on an outound channel!");
+		}
+
+		// TODO(splicing): checks
+
+		// Note: at this point keys are already updated
+		let funding_pubkey = self.get_holder_pubkeys().funding_pubkey;
+		Ok(msgs::SpliceAck {
+			channel_id: self.channel_id,
+			funding_contribution_satoshis: our_funding_contribution_satoshis,
+			funding_pubkey,
+			require_confirmed_inputs: None,
+		})
+	}
 }
 
 // Internal utility functions for channels
@@ -7350,6 +7455,28 @@ impl<SP: Deref> Channel<SP> where
 		}
 	}
 
+	#[cfg(splicing)]
+	pub fn splice_init<ES: Deref, L: Deref>(
+		&mut self, our_funding_contribution_satoshis: i64,
+		_signer_provider: &SP, _entropy_source: &ES, _holder_node_id: PublicKey, logger: &L
+	)
+		-> Result<msgs::SpliceAck, ChannelError>
+		where ES::Target: EntropySource, L::Target: Logger
+	{
+		if !self.context.is_outbound() {
+			// TODO(splicing): Enable starting in the line below
+			// Apply start of splice change in the state
+			// self.context.splice_start(false, logger);
+
+			let splice_ack_msg = self.context.get_splice_ack(our_funding_contribution_satoshis)?;
+			// TODO(splicing): start interactive funding negotiation
+			// let _msg = post_chan.begin_interactive_funding_tx_construction(signer_provider, entropy_source, holder_node_id)
+			// 	.map_err(|err| ChannelError::Warn(format!("Failed to start interactive transaction construction, {:?}", err)))?;
+			Ok(splice_ack_msg)
+		} else {
+			Err(ChannelError::Warn("Internal consistency error: splice_init on inbound channel".into()))
+		}
+	}
 
 	// Send stuff to our remote peers:
 
@@ -9618,6 +9745,9 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 
 				blocked_monitor_updates: blocked_monitor_updates.unwrap(),
 				is_manual_broadcast: is_manual_broadcast.unwrap_or(false),
+
+				#[cfg(splicing)]
+				pending_splice_pre: None,
 			},
 			#[cfg(any(dual_funding, splicing))]
 			dual_funding_channel_context: None,
@@ -11403,4 +11533,69 @@ mod tests {
 		assert_eq!(node_a_chan.context.channel_state, ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::THEIR_CHANNEL_READY));
 		assert!(node_a_chan.check_get_channel_ready(0, &&logger).is_some());
 	}
+
+	#[cfg(all(test, splicing))]
+	fn get_pre_and_post(pre_channel_value: u64, our_funding_contribution: i64, their_funding_contribution: i64) -> (u64, u64) {
+		use crate::ln::channel::PendingSpliceInfoPre;
+
+		let post_channel_value = PendingSpliceInfoPre::compute_post_value(pre_channel_value, our_funding_contribution, their_funding_contribution);
+		(pre_channel_value, post_channel_value)
+	}
+
+	#[cfg(all(test, splicing))]
+	#[test]
+	fn test_splice_compute_post_value() {
+		{
+			// increase, small amounts
+			let (pre_channel_value, post_channel_value) = get_pre_and_post(9_000, 6_000, 0);
+			assert_eq!(pre_channel_value, 9_000);
+			assert_eq!(post_channel_value, 15_000);
+		}
+		{
+			// increase, small amounts
+			let (pre_channel_value, post_channel_value) = get_pre_and_post(9_000, 4_000, 2_000);
+			assert_eq!(pre_channel_value, 9_000);
+			assert_eq!(post_channel_value, 15_000);
+		}
+		{
+			// increase, small amounts
+			let (pre_channel_value, post_channel_value) = get_pre_and_post(9_000, 0, 6_000);
+			assert_eq!(pre_channel_value, 9_000);
+			assert_eq!(post_channel_value, 15_000);
+		}
+		{
+			// decrease, small amounts
+			let (pre_channel_value, post_channel_value) = get_pre_and_post(15_000, -6_000, 0);
+			assert_eq!(pre_channel_value, 15_000);
+			assert_eq!(post_channel_value, 9_000);
+		}
+		{
+			// decrease, small amounts
+			let (pre_channel_value, post_channel_value) = get_pre_and_post(15_000, -4_000, -2_000);
+			assert_eq!(pre_channel_value, 15_000);
+			assert_eq!(post_channel_value, 9_000);
+		}
+		{
+			// increase and decrease
+			let (pre_channel_value, post_channel_value) = get_pre_and_post(15_000, 4_000, -2_000);
+			assert_eq!(pre_channel_value, 15_000);
+			assert_eq!(post_channel_value, 17_000);
+		}
+		let base2: u64 = 2;
+		let huge63i3 = (base2.pow(63) - 3) as i64;
+		assert_eq!(huge63i3, 9223372036854775805);
+		assert_eq!(-huge63i3, -9223372036854775805);
+		{
+			// increase, large amount
+			let (pre_channel_value, post_channel_value) = get_pre_and_post(9_000, huge63i3, 3);
+			assert_eq!(pre_channel_value, 9_000);
+			assert_eq!(post_channel_value, 9223372036854784807);
+		}
+		{
+			// increase, large amounts
+			let (pre_channel_value, post_channel_value) = get_pre_and_post(9_000, huge63i3, huge63i3);
+			assert_eq!(pre_channel_value, 9_000);
+			assert_eq!(post_channel_value, 9223372036854784807);
+		}
+	}
 }