Use match arms for signer types.

Author: arik-so

lightning/src/ln/channel.rs

@@ -3243,10 +3243,14 @@ impl<SP: Deref> Channel<SP> where
 			*self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
 		}
 
-		self.context.holder_signer.as_ecdsa().unwrap().validate_counterparty_revocation(
-			self.context.cur_counterparty_commitment_transaction_number + 1,
-			&secret
-		).map_err(|_| ChannelError::Close("Failed to validate revocation from peer".to_owned()))?;
+		match &self.context.holder_signer {
+			ChannelSignerType::Ecdsa(ecdsa) => {
+				ecdsa.validate_counterparty_revocation(
+					self.context.cur_counterparty_commitment_transaction_number + 1,
+					&secret
+				).map_err(|_| ChannelError::Close("Failed to validate revocation from peer".to_owned()))?;
+			}
+		};
 
 		self.context.commitment_secrets.provide_secret(self.context.cur_counterparty_commitment_transaction_number + 1, msg.per_commitment_secret)
 			.map_err(|_| ChannelError::Close("Previous secrets did not match new one".to_owned()))?;
@@ -4115,20 +4119,24 @@ impl<SP: Deref> Channel<SP> where
 		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.context.holder_signer.as_ecdsa().unwrap()
-			.sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
-			.map_err(|()| ChannelError::Close("Failed to get signature for closing transaction.".to_owned()))?;
+		match &self.context.holder_signer {
+			ChannelSignerType::Ecdsa(ecdsa) => {
+				let sig = ecdsa
+					.sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
+					.map_err(|()| ChannelError::Close("Failed to get signature for closing transaction.".to_owned()))?;
 
-		self.context.last_sent_closing_fee = Some((total_fee_satoshis, sig.clone()));
-		Ok((Some(msgs::ClosingSigned {
-			channel_id: self.context.channel_id,
-			fee_satoshis: total_fee_satoshis,
-			signature: sig,
-			fee_range: Some(msgs::ClosingSignedFeeRange {
-				min_fee_satoshis: our_min_fee,
-				max_fee_satoshis: our_max_fee,
-			}),
-		}), None))
+				self.context.last_sent_closing_fee = Some((total_fee_satoshis, sig.clone()));
+				Ok((Some(msgs::ClosingSigned {
+					channel_id: self.context.channel_id,
+					fee_satoshis: total_fee_satoshis,
+					signature: sig,
+					fee_range: Some(msgs::ClosingSignedFeeRange {
+						min_fee_satoshis: our_min_fee,
+						max_fee_satoshis: our_max_fee,
+					}),
+				}), None))
+			}
+		}
 	}
 
 	// Marks a channel as waiting for a response from the counterparty. If it's not received
@@ -4344,27 +4352,31 @@ impl<SP: Deref> Channel<SP> where
 					self.build_closing_transaction($new_fee, false)
 				};
 
-				let sig = self.context.holder_signer.as_ecdsa().unwrap()
-					.sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
-					.map_err(|_| ChannelError::Close("External signer refused to sign closing transaction".to_owned()))?;
-
-				let signed_tx = if $new_fee == msg.fee_satoshis {
-					self.context.channel_state = ChannelState::ShutdownComplete as u32;
-					self.context.update_time_counter += 1;
-					let tx = self.build_signed_closing_transaction(&closing_tx, &msg.signature, &sig);
-					Some(tx)
-				} else { None };
+				return match &self.context.holder_signer {
+					ChannelSignerType::Ecdsa(ecdsa) => {
+						let sig = ecdsa
+							.sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
+							.map_err(|_| ChannelError::Close("External signer refused to sign closing transaction".to_owned()))?;
 
-				self.context.last_sent_closing_fee = Some((used_fee, sig.clone()));
-				return Ok((Some(msgs::ClosingSigned {
-					channel_id: self.context.channel_id,
-					fee_satoshis: used_fee,
-					signature: sig,
-					fee_range: Some(msgs::ClosingSignedFeeRange {
-						min_fee_satoshis: our_min_fee,
-						max_fee_satoshis: our_max_fee,
-					}),
-				}), signed_tx))
+						let signed_tx = if $new_fee == msg.fee_satoshis {
+							self.context.channel_state = ChannelState::ShutdownComplete as u32;
+							self.context.update_time_counter += 1;
+							let tx = self.build_signed_closing_transaction(&closing_tx, &msg.signature, &sig);
+							Some(tx)
+						} else { None };
+
+						self.context.last_sent_closing_fee = Some((used_fee, sig.clone()));
+						Ok((Some(msgs::ClosingSigned {
+							channel_id: self.context.channel_id,
+							fee_satoshis: used_fee,
+							signature: sig,
+							fee_range: Some(msgs::ClosingSignedFeeRange {
+								min_fee_satoshis: our_min_fee,
+								max_fee_satoshis: our_max_fee,
+							}),
+						}), signed_tx))
+					}
+				}
 			}
 		}
 
@@ -4954,26 +4966,30 @@ impl<SP: Deref> Channel<SP> where
 			},
 			Ok(v) => v
 		};
-		let our_bitcoin_sig = match self.context.holder_signer.as_ecdsa().unwrap().sign_channel_announcement_with_funding_key(&announcement, &self.context.secp_ctx) {
-			Err(_) => {
-				log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
-				return None;
-			},
-			Ok(v) => v
-		};
-		let short_channel_id = match self.context.get_short_channel_id() {
-			Some(scid) => scid,
-			None => return None,
-		};
+		match &self.context.holder_signer {
+			ChannelSignerType::Ecdsa(ecdsa) => {
+				let our_bitcoin_sig = match ecdsa.sign_channel_announcement_with_funding_key(&announcement, &self.context.secp_ctx) {
+					Err(_) => {
+						log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
+						return None;
+					},
+					Ok(v) => v
+				};
+				let short_channel_id = match self.context.get_short_channel_id() {
+					Some(scid) => scid,
+					None => return None,
+				};
 
-		self.context.announcement_sigs_state = AnnouncementSigsState::MessageSent;
+				self.context.announcement_sigs_state = AnnouncementSigsState::MessageSent;
 
-		Some(msgs::AnnouncementSignatures {
-			channel_id: self.context.channel_id(),
-			short_channel_id,
-			node_signature: our_node_sig,
-			bitcoin_signature: our_bitcoin_sig,
-		})
+				Some(msgs::AnnouncementSignatures {
+					channel_id: self.context.channel_id(),
+					short_channel_id,
+					node_signature: our_node_sig,
+					bitcoin_signature: our_bitcoin_sig,
+				})
+			}
+		}
 	}
 
 	/// Signs the given channel announcement, returning a ChannelError::Ignore if no keys are
@@ -4988,15 +5004,19 @@ impl<SP: Deref> Channel<SP> where
 
 			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.context.holder_signer.as_ecdsa().unwrap().sign_channel_announcement_with_funding_key(&announcement, &self.context.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 },
-				node_signature_2: if were_node_one { their_node_sig } else { our_node_sig },
-				bitcoin_signature_1: if were_node_one { our_bitcoin_sig } else { their_bitcoin_sig },
-				bitcoin_signature_2: if were_node_one { their_bitcoin_sig } else { our_bitcoin_sig },
-				contents: announcement,
-			})
+			match &self.context.holder_signer {
+				ChannelSignerType::Ecdsa(ecdsa) => {
+					let our_bitcoin_sig = ecdsa.sign_channel_announcement_with_funding_key(&announcement, &self.context.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 },
+						node_signature_2: if were_node_one { their_node_sig } else { our_node_sig },
+						bitcoin_signature_1: if were_node_one { our_bitcoin_sig } else { their_bitcoin_sig },
+						bitcoin_signature_2: if were_node_one { their_bitcoin_sig } else { our_bitcoin_sig },
+						contents: announcement,
+					})
+				}
+			}
 		} else {
 			Err(ChannelError::Ignore("Attempted to sign channel announcement before we'd received announcement_signatures".to_string()))
 		}
@@ -5322,40 +5342,45 @@ impl<SP: Deref> Channel<SP> where
 		let counterparty_keys = self.context.build_remote_transaction_keys();
 		let commitment_stats = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
 		let counterparty_commitment_txid = commitment_stats.tx.trust().txid();
-		let (signature, htlc_signatures);
 
-		{
-			let mut htlcs = Vec::with_capacity(commitment_stats.htlcs_included.len());
-			for &(ref htlc, _) in commitment_stats.htlcs_included.iter() {
-				htlcs.push(htlc);
-			}
+		match &self.context.holder_signer {
+			ChannelSignerType::Ecdsa(ecdsa) => {
+				let (signature, htlc_signatures);
 
-			let res = self.context.holder_signer.as_ecdsa().unwrap().sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.context.secp_ctx)
-				.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?;
-			signature = res.0;
-			htlc_signatures = res.1;
+				{
+					let mut htlcs = Vec::with_capacity(commitment_stats.htlcs_included.len());
+					for &(ref htlc, _) in commitment_stats.htlcs_included.iter() {
+						htlcs.push(htlc);
+					}
 
-			log_trace!(logger, "Signed remote commitment tx {} (txid {}) with redeemscript {} -> {} in channel {}",
-				encode::serialize_hex(&commitment_stats.tx.trust().built_transaction().transaction),
-				&counterparty_commitment_txid, encode::serialize_hex(&self.context.get_funding_redeemscript()),
-				log_bytes!(signature.serialize_compact()[..]), log_bytes!(self.context.channel_id()));
+					let res = ecdsa.sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.context.secp_ctx)
+						.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?;
+					signature = res.0;
+					htlc_signatures = res.1;
+
+					log_trace!(logger, "Signed remote commitment tx {} (txid {}) with redeemscript {} -> {} in channel {}",
+						encode::serialize_hex(&commitment_stats.tx.trust().built_transaction().transaction),
+						&counterparty_commitment_txid, encode::serialize_hex(&self.context.get_funding_redeemscript()),
+						log_bytes!(signature.serialize_compact()[..]), log_bytes!(self.context.channel_id()));
+
+					for (ref htlc_sig, ref htlc) in htlc_signatures.iter().zip(htlcs) {
+						log_trace!(logger, "Signed remote HTLC tx {} with redeemscript {} with pubkey {} -> {} in channel {}",
+							encode::serialize_hex(&chan_utils::build_htlc_transaction(&counterparty_commitment_txid, commitment_stats.feerate_per_kw, self.context.get_holder_selected_contest_delay(), htlc, &self.context.channel_type, &counterparty_keys.broadcaster_delayed_payment_key, &counterparty_keys.revocation_key)),
+							encode::serialize_hex(&chan_utils::get_htlc_redeemscript(&htlc, &self.context.channel_type, &counterparty_keys)),
+							log_bytes!(counterparty_keys.broadcaster_htlc_key.serialize()),
+							log_bytes!(htlc_sig.serialize_compact()[..]), log_bytes!(self.context.channel_id()));
+					}
+				}
 
-			for (ref htlc_sig, ref htlc) in htlc_signatures.iter().zip(htlcs) {
-				log_trace!(logger, "Signed remote HTLC tx {} with redeemscript {} with pubkey {} -> {} in channel {}",
-					encode::serialize_hex(&chan_utils::build_htlc_transaction(&counterparty_commitment_txid, commitment_stats.feerate_per_kw, self.context.get_holder_selected_contest_delay(), htlc, &self.context.channel_type, &counterparty_keys.broadcaster_delayed_payment_key, &counterparty_keys.revocation_key)),
-					encode::serialize_hex(&chan_utils::get_htlc_redeemscript(&htlc, &self.context.channel_type, &counterparty_keys)),
-					log_bytes!(counterparty_keys.broadcaster_htlc_key.serialize()),
-					log_bytes!(htlc_sig.serialize_compact()[..]), log_bytes!(self.context.channel_id()));
+				Ok((msgs::CommitmentSigned {
+					channel_id: self.context.channel_id,
+					signature,
+					htlc_signatures,
+					#[cfg(taproot)]
+					partial_signature_with_nonce: None,
+				}, (counterparty_commitment_txid, commitment_stats.htlcs_included)))
 			}
 		}
-
-		Ok((msgs::CommitmentSigned {
-			channel_id: self.context.channel_id,
-			signature,
-			htlc_signatures,
-			#[cfg(taproot)]
-			partial_signature_with_nonce: None,
-		}, (counterparty_commitment_txid, commitment_stats.htlcs_included)))
 	}
 
 	/// Adds a pending outbound HTLC to this channel, and builds a new remote commitment
@@ -5725,8 +5750,13 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
 	fn get_funding_created_signature<L: Deref>(&mut self, logger: &L) -> Result<Signature, ChannelError> where L::Target: Logger {
 		let counterparty_keys = self.context.build_remote_transaction_keys();
 		let counterparty_initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
-		Ok(self.context.holder_signer.as_ecdsa().unwrap().sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.context.secp_ctx)
-				.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0)
+		match &self.context.holder_signer {
+			// TODO (arik): move match into calling method for Taproot
+			ChannelSignerType::Ecdsa(ecdsa) => {
+				Ok(ecdsa.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.context.secp_ctx)
+					.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0)
+			}
+		}
 	}
 
 	/// Updates channel state with knowledge of the funding transaction's txid/index, and generates
@@ -6446,11 +6476,16 @@ impl<SP: Deref> InboundV1Channel<SP> where SP::Target: SignerProvider {
 		log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
 			log_bytes!(self.context.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
 
-		let counterparty_signature = self.context.holder_signer.as_ecdsa().unwrap().sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.context.secp_ctx)
-				.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0;
+		match &self.context.holder_signer {
+			// TODO (arik): move match into calling method for Taproot
+			ChannelSignerType::Ecdsa(ecdsa) => {
+				let counterparty_signature = ecdsa.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.context.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.
-		Ok((counterparty_initial_bitcoin_tx.txid, initial_commitment_tx, counterparty_signature))
+				// We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
+				Ok((counterparty_initial_bitcoin_tx.txid, initial_commitment_tx, counterparty_signature))
+			}
+		}
 	}
 
 	pub fn funding_created<L: Deref>(
@@ -6630,7 +6665,8 @@ impl<SP: Deref> Writeable for Channel<SP> where SP::Target: SignerProvider {
 		self.context.latest_monitor_update_id.write(writer)?;
 
 		let mut key_data = VecWriter(Vec::new());
-		self.context.holder_signer.as_ecdsa().unwrap().write(&mut key_data)?;
+		// TODO: Introduce serialization distinction for non-ECDSA signers.
+		self.context.holder_signer.as_ecdsa().expect("Only ECDSA signers may be serialized").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)?;