Delete EcdsaChannelSigner::sign_justice_revoked_output

Author: tankyleo

lightning/src/sign/ecdsa.rs

@@ -54,32 +54,6 @@ pub trait EcdsaChannelSigner: ChannelSigner {
 		&self, commitment_tx: &CommitmentTransaction, inbound_htlc_preimages: Vec<PaymentPreimage>,
 		outbound_htlc_preimages: Vec<PaymentPreimage>, secp_ctx: &Secp256k1<secp256k1::All>,
 	) -> Result<(Signature, Vec<Signature>), ()>;
-	/// Create a signature for the given input in a transaction spending an HTLC transaction output
-	/// or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
-	///
-	/// A justice transaction may claim multiple outputs at the same time if timelocks are
-	/// similar, but only a signature for the input at index `input` should be signed for here.
-	/// It may be called multiple times for same output(s) if a fee-bump is needed with regards
-	/// to an upcoming timelock expiration.
-	///
-	/// Amount is value of the output spent by this input, committed to in the BIP 143 signature.
-	///
-	/// `per_commitment_key` is revocation secret which was provided by our counterparty when they
-	/// revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
-	/// not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
-	/// so).
-	///
-	/// An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
-	/// signature and should be retried later. Once the signer is ready to provide a signature after
-	/// previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
-	/// monitor or [`ChainMonitor::signer_unblocked`] called to attempt unblocking all monitors.
-	///
-	/// [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
-	/// [`ChainMonitor::signer_unblocked`]: crate::chain::chainmonitor::ChainMonitor::signer_unblocked
-	fn sign_justice_revoked_output(
-		&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey,
-		secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> Result<Signature, ()>;
 	/// Create a signature for the given input in a transaction spending a commitment transaction
 	/// HTLC output when our counterparty broadcasts an old state.
 	///

lightning/src/sign/mod.rs

@@ -1661,14 +1661,23 @@ impl ChannelSigner for InMemorySigner {
 			contest_delay,
 			&keys.broadcaster_delayed_payment_key,
 		);
-		let sig = EcdsaChannelSigner::sign_justice_revoked_output(
-			self,
-			justice_tx,
-			input,
-			amount,
-			per_commitment_key,
-			secp_ctx,
-		)?;
+		let revocation_key = chan_utils::derive_private_revocation_key(
+			&secp_ctx,
+			&per_commitment_key,
+			&self.revocation_base_key,
+		);
+		let mut sighash_parts = sighash::SighashCache::new(justice_tx);
+		let sighash = hash_to_message!(
+			&sighash_parts
+				.p2wsh_signature_hash(
+					input,
+					&witness_script,
+					Amount::from_sat(amount),
+					EcdsaSighashType::All
+				)
+				.unwrap()[..]
+		);
+		let sig = sign_with_aux_rand(secp_ctx, &sighash, &revocation_key, &self);
 		let ecdsa_sig = EcdsaSignature::sighash_all(sig);
 		Ok(Witness::from(
 			&[ecdsa_sig.serialize().as_ref(), &[1][..], witness_script.as_bytes()][..],
@@ -1887,50 +1896,6 @@ impl EcdsaChannelSigner for InMemorySigner {
 		Ok((commitment_sig, htlc_sigs))
 	}
 
-	fn sign_justice_revoked_output(
-		&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey,
-		secp_ctx: &Secp256k1<secp256k1::All>,
-	) -> Result<Signature, ()> {
-		let revocation_key = chan_utils::derive_private_revocation_key(
-			&secp_ctx,
-			&per_commitment_key,
-			&self.revocation_base_key,
-		);
-		let per_commitment_point = PublicKey::from_secret_key(secp_ctx, &per_commitment_key);
-		let revocation_pubkey = RevocationKey::from_basepoint(
-			&secp_ctx,
-			&self.pubkeys().revocation_basepoint,
-			&per_commitment_point,
-		);
-		let witness_script = {
-			let counterparty_keys = self.counterparty_pubkeys().expect(MISSING_PARAMS_ERR);
-			let holder_selected_contest_delay =
-				self.holder_selected_contest_delay().expect(MISSING_PARAMS_ERR);
-			let counterparty_delayedpubkey = DelayedPaymentKey::from_basepoint(
-				&secp_ctx,
-				&counterparty_keys.delayed_payment_basepoint,
-				&per_commitment_point,
-			);
-			chan_utils::get_revokeable_redeemscript(
-				&revocation_pubkey,
-				holder_selected_contest_delay,
-				&counterparty_delayedpubkey,
-			)
-		};
-		let mut sighash_parts = sighash::SighashCache::new(justice_tx);
-		let sighash = hash_to_message!(
-			&sighash_parts
-				.p2wsh_signature_hash(
-					input,
-					&witness_script,
-					Amount::from_sat(amount),
-					EcdsaSighashType::All
-				)
-				.unwrap()[..]
-		);
-		return Ok(sign_with_aux_rand(secp_ctx, &sighash, &revocation_key, &self));
-	}
-
 	fn sign_justice_revoked_htlc(
 		&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey,
 		htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<secp256k1::All>,

lightning/src/util/test_channel_signer.rs

@@ -351,14 +351,6 @@ impl EcdsaChannelSigner for TestChannelSigner {
 		Ok(self.inner.sign_counterparty_commitment(commitment_tx, inbound_htlc_preimages, outbound_htlc_preimages, secp_ctx).unwrap())
 	}
 
-	fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
-		#[cfg(test)]
-		if !self.is_signer_available(SignerOp::SignJusticeRevokedOutput) {
-			return Err(());
-		}
-		Ok(EcdsaChannelSigner::sign_justice_revoked_output(&self.inner, justice_tx, input, amount, per_commitment_key, secp_ctx).unwrap())
-	}
-
 	fn sign_justice_revoked_htlc(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
 		#[cfg(test)]
 		if !self.is_signer_available(SignerOp::SignJusticeRevokedHtlc) {