Create ChannelSignerType enum.

Author: arik-so

lightning/src/ln/channel.rs

@@ -494,13 +494,18 @@ impl_writeable_tlv_based!(PendingChannelMonitorUpdate, {
 	(2, blocked, required),
 });
 
+enum ChannelSignerType<ECS: ChannelSigner> {
+	Ecdsa(ECS),
+}
+
 // TODO: We should refactor this to be an Inbound/OutboundChannel until initial setup handshaking
 // has been completed, and then turn into a Channel to get compiler-time enforcement of things like
 // calling channel_id() before we're set up or things like get_outbound_funding_signed on an
 // inbound channel.
 //
 // Holder designates channel data owned for the benefice of the user client.
 // Counterparty designates channel data owned by the another channel participant entity.
+#[allow(unused)]
 pub(super) struct Channel<Signer: ChannelSigner> {
 	config: LegacyChannelConfig,
 
@@ -534,7 +539,7 @@ pub(super) struct Channel<Signer: ChannelSigner> {
 
 	latest_monitor_update_id: u64,
 
-	holder_signer: Signer,
+	holder_signer: ChannelSignerType<Signer>,
 	shutdown_scriptpubkey: Option<ShutdownScript>,
 	destination_script: Script,
 
@@ -1042,7 +1047,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 			latest_monitor_update_id: 0,
 
-			holder_signer,
+			holder_signer: ChannelSignerType::Ecdsa(holder_signer),
 			shutdown_scriptpubkey,
 			destination_script,
 
@@ -1397,7 +1402,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 			latest_monitor_update_id: 0,
 
-			holder_signer,
+			holder_signer: ChannelSignerType::Ecdsa(holder_signer),
 			shutdown_scriptpubkey,
 			destination_script,
 
@@ -1836,7 +1841,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 	/// The result is a transaction which we can revoke broadcastership of (ie a "local" transaction)
 	/// TODO Some magic rust shit to compile-time check this?
 	fn build_holder_transaction_keys(&self, commitment_number: u64) -> TxCreationKeys {
-		let per_commitment_point = self.holder_signer.get_per_commitment_point(commitment_number, &self.secp_ctx);
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		let per_commitment_point = ecdsa_signer.get_per_commitment_point(commitment_number, &self.secp_ctx);
 		let delayed_payment_base = &self.get_holder_pubkeys().delayed_payment_basepoint;
 		let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
 		let counterparty_pubkeys = self.get_counterparty_pubkeys();
@@ -2323,7 +2329,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
 			log_bytes!(self.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
 
-		let counterparty_signature = self.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		let counterparty_signature = ecdsa_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
 				.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0;
 
 		// We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
@@ -2363,7 +2370,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		self.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
 		// This is an externally observable change before we finish all our checks.  In particular
 		// funding_created_signature may fail.
-		self.holder_signer.provide_channel_parameters(&self.channel_transaction_parameters);
+		let ecdsa_signer = match &mut self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		ecdsa_signer.provide_channel_parameters(&self.channel_transaction_parameters);
 
 		let (counterparty_initial_commitment_txid, initial_commitment_tx, signature) = match self.funding_created_signature(&msg.signature, logger) {
 			Ok(res) => res,
@@ -2386,7 +2394,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			self.counterparty_funding_pubkey()
 		);
 
-		self.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		ecdsa_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
 			.map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
 
 		// Now that we're past error-generating stuff, update our local state:
@@ -2476,7 +2485,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			self.counterparty_funding_pubkey()
 		);
 
-		self.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		ecdsa_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
 			.map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
 
 
@@ -3245,7 +3255,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			self.counterparty_funding_pubkey()
 		);
 
-		self.holder_signer.validate_holder_commitment(&holder_commitment_tx, commitment_stats.preimages)
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		ecdsa_signer.validate_holder_commitment(&holder_commitment_tx, commitment_stats.preimages)
 			.map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
 
 		// Update state now that we've passed all the can-fail calls...
@@ -3505,7 +3516,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			*self.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
 		}
 
-		self.holder_signer.validate_counterparty_revocation(
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		ecdsa_signer.validate_counterparty_revocation(
 			self.cur_counterparty_commitment_transaction_number + 1,
 			&secret
 		).map_err(|_| ChannelError::Close("Failed to validate revocation from peer".to_owned()))?;
@@ -3909,11 +3921,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		// * an inbound channel that failed to persist the monitor on funding_created and we got
 		//   the funding transaction confirmed before the monitor was persisted, or
 		// * a 0-conf channel and intended to send the channel_ready before any broadcast at all.
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
 		let channel_ready = if self.monitor_pending_channel_ready {
 			assert!(!self.is_outbound() || self.minimum_depth == Some(0),
 				"Funding transaction broadcast by the local client before it should have - LDK didn't do it!");
 			self.monitor_pending_channel_ready = false;
-			let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+			let next_per_commitment_point = ecdsa_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
 			Some(msgs::ChannelReady {
 				channel_id: self.channel_id(),
 				next_per_commitment_point,
@@ -3993,8 +4006,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 	}
 
 	fn get_last_revoke_and_ack(&self) -> msgs::RevokeAndACK {
-		let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
-		let per_commitment_secret = self.holder_signer.release_commitment_secret(self.cur_holder_commitment_transaction_number + 2);
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		let next_per_commitment_point = ecdsa_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+		let per_commitment_secret = ecdsa_signer.release_commitment_secret(self.cur_holder_commitment_transaction_number + 2);
 		msgs::RevokeAndACK {
 			channel_id: self.channel_id,
 			per_commitment_secret,
@@ -4096,7 +4110,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		}
 
 		if msg.next_remote_commitment_number > 0 {
-			let expected_point = self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.secp_ctx);
+			let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+			let expected_point = ecdsa_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.secp_ctx);
 			let given_secret = SecretKey::from_slice(&msg.your_last_per_commitment_secret)
 				.map_err(|_| ChannelError::Close("Peer sent a garbage channel_reestablish with unparseable secret key".to_owned()))?;
 			if expected_point != PublicKey::from_secret_key(&self.secp_ctx, &given_secret) {
@@ -4160,7 +4175,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			}
 
 			// We have OurChannelReady set!
-			let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+			let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+			let next_per_commitment_point = ecdsa_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
 			return Ok(ReestablishResponses {
 				channel_ready: Some(msgs::ChannelReady {
 					channel_id: self.channel_id(),
@@ -4196,7 +4212,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 		let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number == 1 {
 			// We should never have to worry about MonitorUpdateInProgress resending ChannelReady
-			let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+			let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+			let next_per_commitment_point = ecdsa_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
 			Some(msgs::ChannelReady {
 				channel_id: self.channel_id(),
 				next_per_commitment_point,
@@ -4345,7 +4362,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		log_trace!(logger, "Proposing initial closing_signed for our counterparty with a fee range of {}-{} sat (with initial proposal {} sats)",
 			our_min_fee, our_max_fee, total_fee_satoshis);
 
-		let sig = self.holder_signer
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		let sig = ecdsa_signer
 			.sign_closing_transaction(&closing_tx, &self.secp_ctx)
 			.map_err(|()| ChannelError::Close("Failed to get signature for closing transaction.".to_owned()))?;
 
@@ -4547,6 +4565,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 		let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);
 
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+
 		macro_rules! propose_fee {
 			($new_fee: expr) => {
 				let (closing_tx, used_fee) = if $new_fee == msg.fee_satoshis {
@@ -4555,7 +4575,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 					self.build_closing_transaction($new_fee, false)
 				};
 
-				let sig = self.holder_signer
+				let sig = ecdsa_signer
 					.sign_closing_transaction(&closing_tx, &self.secp_ctx)
 					.map_err(|_| ChannelError::Close("External signer refused to sign closing transaction".to_owned()))?;
 
@@ -4927,7 +4947,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 	#[cfg(test)]
 	pub fn get_signer(&self) -> &Signer {
-		&self.holder_signer
+		match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} }
 	}
 
 	#[cfg(test)]
@@ -5169,8 +5189,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		if need_commitment_update {
 			if self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) == 0 {
 				if self.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
+					let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
 					let next_per_commitment_point =
-						self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.secp_ctx);
+						ecdsa_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.secp_ctx);
 					return Some(msgs::ChannelReady {
 						channel_id: self.channel_id,
 						next_per_commitment_point,
@@ -5394,7 +5415,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			panic!("Tried to send an open_channel for a channel that has already advanced");
 		}
 
-		let first_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		let first_per_commitment_point = ecdsa_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
 		let keys = self.get_holder_pubkeys();
 
 		msgs::OpenChannel {
@@ -5464,7 +5486,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 	///
 	/// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
 	fn generate_accept_channel_message(&self) -> msgs::AcceptChannel {
-		let first_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		let first_per_commitment_point = ecdsa_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
 		let keys = self.get_holder_pubkeys();
 
 		msgs::AcceptChannel {
@@ -5505,7 +5528,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 	fn get_outbound_funding_created_signature<L: Deref>(&mut self, logger: &L) -> Result<Signature, ChannelError> where L::Target: Logger {
 		let counterparty_keys = self.build_remote_transaction_keys();
 		let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
-		Ok(self.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		Ok(ecdsa_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
 				.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0)
 	}
 
@@ -5530,7 +5554,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 		}
 
 		self.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
-		self.holder_signer.provide_channel_parameters(&self.channel_transaction_parameters);
+		let ecdsa_signer = match &mut self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		ecdsa_signer.provide_channel_parameters(&self.channel_transaction_parameters);
 
 		let signature = match self.get_outbound_funding_created_signature(logger) {
 			Ok(res) => res,
@@ -5639,7 +5664,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 			},
 			Ok(v) => v
 		};
-		let our_bitcoin_sig = match self.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx) {
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		let our_bitcoin_sig = match ecdsa_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx) {
 			Err(_) => {
 				log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
 				return None;
@@ -5668,7 +5694,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
 			let our_node_sig = node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement))
 				.map_err(|_| ChannelError::Ignore("Failed to generate node signature for channel_announcement".to_owned()))?;
-			let our_bitcoin_sig = self.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx)
+			let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+			let our_bitcoin_sig = ecdsa_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx)
 				.map_err(|_| ChannelError::Ignore("Signer rejected channel_announcement".to_owned()))?;
 			Ok(msgs::ChannelAnnouncement {
 				node_signature_1: if were_node_one { our_node_sig } else { their_node_sig },
@@ -6048,7 +6075,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 				htlcs.push(htlc);
 			}
 
-			let res = self.holder_signer.sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.secp_ctx)
+			let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+			let res = ecdsa_signer.sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.secp_ctx)
 				.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?;
 			signature = res.0;
 			htlc_signatures = res.1;
@@ -6360,7 +6388,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
 		self.latest_monitor_update_id.write(writer)?;
 
 		let mut key_data = VecWriter(Vec::new());
-		self.holder_signer.write(&mut key_data)?;
+		let ecdsa_signer = match &self.holder_signer { ChannelSignerType::Ecdsa(signer) => {signer} };
+		ecdsa_signer.write(&mut key_data)?;
 		assert!(key_data.0.len() < core::usize::MAX);
 		assert!(key_data.0.len() < core::u32::MAX as usize);
 		(key_data.0.len() as u32).write(writer)?;
@@ -7005,7 +7034,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 
 			latest_monitor_update_id,
 
-			holder_signer,
+			holder_signer: ChannelSignerType::Ecdsa(holder_signer),
 			shutdown_scriptpubkey,
 			destination_script,