From: valentinewallace Date: Mon, 15 Apr 2024 15:23:09 +0000 (-0400) Subject: Merge pull request #2987 from TheBlueMatt/2024-04-test-ser-bug X-Git-Tag: v0.0.123-beta~11 X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=322e1f3a9817e6b5701dd4e529f99fd4ec7b0375;hp=38b78eccb5e579558369f6e152647588acd11b38;p=rust-lightning Merge pull request #2987 from TheBlueMatt/2024-04-test-ser-bug Add test coverage for cc78b77c715d6ef62693d4c1bc7190da990ec0fa --- diff --git a/lightning/src/ln/chan_utils.rs b/lightning/src/ln/chan_utils.rs index c002dfae..b7676ddf 100644 --- a/lightning/src/ln/chan_utils.rs +++ b/lightning/src/ln/chan_utils.rs @@ -852,6 +852,11 @@ impl ChannelTransactionParameters { self.counterparty_parameters.is_some() && self.funding_outpoint.is_some() } + /// Whether the channel supports zero-fee HTLC transaction anchors. + pub(crate) fn supports_anchors(&self) -> bool { + self.channel_type_features.supports_anchors_zero_fee_htlc_tx() + } + /// Convert the holder/counterparty parameters to broadcaster/countersignatory-organized parameters, /// given that the holder is the broadcaster. /// diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs index 2698abee..58d35a1a 100644 --- a/lightning/src/ln/channel.rs +++ b/lightning/src/ln/channel.rs @@ -2730,7 +2730,7 @@ impl ChannelContext where SP::Target: SignerProvider { feerate_per_kw = cmp::max(feerate_per_kw, feerate); } let feerate_plus_quarter = feerate_per_kw.checked_mul(1250).map(|v| v / 1000); - cmp::max(2530, feerate_plus_quarter.unwrap_or(u32::max_value())) + cmp::max(feerate_per_kw + 2530, feerate_plus_quarter.unwrap_or(u32::max_value())) } /// Get forwarding information for the counterparty. diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index 5ea3e637..8dd3f1fc 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -9950,7 +9950,10 @@ fn do_test_max_dust_htlc_exposure(dust_outbound_balance: bool, exposure_breach_e let dust_outbound_htlc_on_holder_tx_msat: u64 = (dust_buffer_feerate * htlc_timeout_tx_weight(&channel_type_features) / 1000 + open_channel.common_fields.dust_limit_satoshis - 1) * 1000; let dust_outbound_htlc_on_holder_tx: u64 = max_dust_htlc_exposure_msat / dust_outbound_htlc_on_holder_tx_msat; - let dust_inbound_htlc_on_holder_tx_msat: u64 = (dust_buffer_feerate * htlc_success_tx_weight(&channel_type_features) / 1000 + open_channel.common_fields.dust_limit_satoshis - 1) * 1000; + // Substract 3 sats for multiplier and 2 sats for fixed limit to make sure we are 50% below the dust limit. + // This is to make sure we fully use the dust limit. If we don't, we could end up with `dust_ibd_htlc_on_holder_tx` being 1 + // while `max_dust_htlc_exposure_msat` is not equal to `dust_outbound_htlc_on_holder_tx_msat`. + let dust_inbound_htlc_on_holder_tx_msat: u64 = (dust_buffer_feerate * htlc_success_tx_weight(&channel_type_features) / 1000 + open_channel.common_fields.dust_limit_satoshis - if multiplier_dust_limit { 3 } else { 2 }) * 1000; let dust_inbound_htlc_on_holder_tx: u64 = max_dust_htlc_exposure_msat / dust_inbound_htlc_on_holder_tx_msat; let dust_htlc_on_counterparty_tx: u64 = 4; diff --git a/lightning/src/sign/ecdsa.rs b/lightning/src/sign/ecdsa.rs index 45152cf6..aa22eb36 100644 --- a/lightning/src/sign/ecdsa.rs +++ b/lightning/src/sign/ecdsa.rs @@ -2,14 +2,16 @@ use bitcoin::blockdata::transaction::Transaction; -use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; -use bitcoin::secp256k1::ecdsa::Signature; use bitcoin::secp256k1; +use bitcoin::secp256k1::ecdsa::Signature; +use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; -use crate::util::ser::Writeable; -use crate::ln::PaymentPreimage; -use crate::ln::chan_utils::{HTLCOutputInCommitment, HolderCommitmentTransaction, CommitmentTransaction, ClosingTransaction}; +use crate::ln::chan_utils::{ + ClosingTransaction, CommitmentTransaction, HTLCOutputInCommitment, HolderCommitmentTransaction, +}; use crate::ln::msgs::UnsignedChannelAnnouncement; +use crate::ln::PaymentPreimage; +use crate::util::ser::Writeable; #[allow(unused_imports)] use crate::prelude::*; @@ -40,8 +42,8 @@ pub trait EcdsaChannelSigner: ChannelSigner { /// irrelevant or duplicate preimages. // // TODO: Document the things someone using this interface should enforce before signing. - fn sign_counterparty_commitment(&self, commitment_tx: &CommitmentTransaction, - inbound_htlc_preimages: Vec, + fn sign_counterparty_commitment( + &self, commitment_tx: &CommitmentTransaction, inbound_htlc_preimages: Vec, outbound_htlc_preimages: Vec, secp_ctx: &Secp256k1, ) -> Result<(Signature, Vec), ()>; /// Creates a signature for a holder's commitment transaction. @@ -62,15 +64,17 @@ pub trait EcdsaChannelSigner: ChannelSigner { /// [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked // // TODO: Document the things someone using this interface should enforce before signing. - fn sign_holder_commitment(&self, commitment_tx: &HolderCommitmentTransaction, - secp_ctx: &Secp256k1) -> Result; + fn sign_holder_commitment( + &self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1, + ) -> Result; /// Same as [`sign_holder_commitment`], but exists only for tests to get access to holder /// commitment transactions which will be broadcasted later, after the channel has moved on to a /// newer state. Thus, needs its own method as [`sign_holder_commitment`] may enforce that we /// only ever get called once. - #[cfg(any(test,feature = "unsafe_revoked_tx_signing"))] - fn unsafe_sign_holder_commitment(&self, commitment_tx: &HolderCommitmentTransaction, - secp_ctx: &Secp256k1) -> Result; + #[cfg(any(test, feature = "unsafe_revoked_tx_signing"))] + fn unsafe_sign_holder_commitment( + &self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1, + ) -> Result; /// 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. /// @@ -92,8 +96,9 @@ pub trait EcdsaChannelSigner: ChannelSigner { /// monitor. /// /// [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked - fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, - per_commitment_key: &SecretKey, secp_ctx: &Secp256k1 + fn sign_justice_revoked_output( + &self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, + secp_ctx: &Secp256k1, ) -> Result; /// Create a signature for the given input in a transaction spending a commitment transaction /// HTLC output when our counterparty broadcasts an old state. @@ -120,9 +125,10 @@ pub trait EcdsaChannelSigner: ChannelSigner { /// monitor. /// /// [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked - fn sign_justice_revoked_htlc(&self, justice_tx: &Transaction, input: usize, amount: u64, - per_commitment_key: &SecretKey, htlc: &HTLCOutputInCommitment, - secp_ctx: &Secp256k1) -> Result; + fn sign_justice_revoked_htlc( + &self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, + htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1, + ) -> Result; /// Computes the signature for a commitment transaction's HTLC output used as an input within /// `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned /// must be be computed using [`EcdsaSighashType::All`]. @@ -139,8 +145,9 @@ pub trait EcdsaChannelSigner: ChannelSigner { /// [`EcdsaSighashType::All`]: bitcoin::sighash::EcdsaSighashType::All /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor /// [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked - fn sign_holder_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, - htlc_descriptor: &HTLCDescriptor, secp_ctx: &Secp256k1 + fn sign_holder_htlc_transaction( + &self, htlc_tx: &Transaction, input: usize, htlc_descriptor: &HTLCDescriptor, + secp_ctx: &Secp256k1, ) -> Result; /// Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment /// transaction, either offered or received. @@ -166,15 +173,17 @@ pub trait EcdsaChannelSigner: ChannelSigner { /// monitor. /// /// [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked - fn sign_counterparty_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, amount: u64, - per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, - secp_ctx: &Secp256k1) -> Result; + fn sign_counterparty_htlc_transaction( + &self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, + htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1, + ) -> Result; /// Create a signature for a (proposed) closing transaction. /// /// Note that, due to rounding, there may be one "missing" satoshi, and either party may have /// chosen to forgo their output as dust. - fn sign_closing_transaction(&self, closing_tx: &ClosingTransaction, - secp_ctx: &Secp256k1) -> Result; + fn sign_closing_transaction( + &self, closing_tx: &ClosingTransaction, secp_ctx: &Secp256k1, + ) -> Result; /// Computes the signature for a commitment transaction's anchor output used as an /// input within `anchor_tx`, which spends the commitment transaction, at index `input`. /// @@ -199,7 +208,7 @@ pub trait EcdsaChannelSigner: ChannelSigner { /// /// [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message fn sign_channel_announcement_with_funding_key( - &self, msg: &UnsignedChannelAnnouncement, secp_ctx: &Secp256k1 + &self, msg: &UnsignedChannelAnnouncement, secp_ctx: &Secp256k1, ) -> Result; } diff --git a/lightning/src/sign/mod.rs b/lightning/src/sign/mod.rs index 2a5d19ef..23266c13 100644 --- a/lightning/src/sign/mod.rs +++ b/lightning/src/sign/mod.rs @@ -12,60 +12,66 @@ //! The provided output descriptors follow a custom LDK data format and are currently not fully //! compatible with Bitcoin Core output descriptors. +use bitcoin::bip32::{ChildNumber, ExtendedPrivKey, ExtendedPubKey}; use bitcoin::blockdata::locktime::absolute::LockTime; -use bitcoin::blockdata::transaction::{Transaction, TxOut, TxIn}; -use bitcoin::blockdata::script::{Script, ScriptBuf, Builder}; use bitcoin::blockdata::opcodes; +use bitcoin::blockdata::script::{Builder, Script, ScriptBuf}; +use bitcoin::blockdata::transaction::{Transaction, TxIn, TxOut}; use bitcoin::ecdsa::Signature as EcdsaSignature; use bitcoin::network::constants::Network; use bitcoin::psbt::PartiallySignedTransaction; -use bitcoin::bip32::{ExtendedPrivKey, ExtendedPubKey, ChildNumber}; use bitcoin::sighash; use bitcoin::sighash::EcdsaSighashType; use bitcoin::bech32::u5; -use bitcoin::hashes::{Hash, HashEngine}; +use bitcoin::hash_types::WPubkeyHash; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::hashes::sha256d::Hash as Sha256dHash; -use bitcoin::hash_types::WPubkeyHash; +use bitcoin::hashes::{Hash, HashEngine}; -#[cfg(taproot)] -use bitcoin::secp256k1::All; -use bitcoin::secp256k1::{KeyPair, PublicKey, Scalar, Secp256k1, SecretKey, Signing}; use bitcoin::secp256k1::ecdh::SharedSecret; use bitcoin::secp256k1::ecdsa::{RecoverableSignature, Signature}; use bitcoin::secp256k1::schnorr; -use bitcoin::{secp256k1, Sequence, Witness, Txid}; +#[cfg(taproot)] +use bitcoin::secp256k1::All; +use bitcoin::secp256k1::{KeyPair, PublicKey, Scalar, Secp256k1, SecretKey, Signing}; +use bitcoin::{secp256k1, Sequence, Txid, Witness}; -use crate::util::transaction_utils; -use crate::crypto::utils::{hkdf_extract_expand_twice, sign, sign_with_aux_rand}; -use crate::util::ser::{Writeable, Writer, Readable, ReadableArgs}; use crate::chain::transaction::OutPoint; +use crate::crypto::utils::{hkdf_extract_expand_twice, sign, sign_with_aux_rand}; +use crate::ln::chan_utils::{ + make_funding_redeemscript, ChannelPublicKeys, ChannelTransactionParameters, ClosingTransaction, + CommitmentTransaction, HTLCOutputInCommitment, HolderCommitmentTransaction, +}; use crate::ln::channel::ANCHOR_OUTPUT_VALUE_SATOSHI; -use crate::ln::{chan_utils, PaymentPreimage}; -use crate::ln::chan_utils::{HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, HolderCommitmentTransaction, ChannelTransactionParameters, CommitmentTransaction, ClosingTransaction}; -use crate::ln::channel_keys::{DelayedPaymentBasepoint, DelayedPaymentKey, HtlcKey, HtlcBasepoint, RevocationKey, RevocationBasepoint}; -use crate::ln::msgs::{UnsignedChannelAnnouncement, UnsignedGossipMessage}; +use crate::ln::channel_keys::{ + DelayedPaymentBasepoint, DelayedPaymentKey, HtlcBasepoint, HtlcKey, RevocationBasepoint, + RevocationKey, +}; #[cfg(taproot)] use crate::ln::msgs::PartialSignatureWithNonce; +use crate::ln::msgs::{UnsignedChannelAnnouncement, UnsignedGossipMessage}; use crate::ln::script::ShutdownScript; +use crate::ln::{chan_utils, PaymentPreimage}; use crate::offers::invoice::UnsignedBolt12Invoice; use crate::offers::invoice_request::UnsignedInvoiceRequest; +use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer}; +use crate::util::transaction_utils; -use crate::prelude::*; -use core::ops::Deref; -use core::sync::atomic::{AtomicUsize, Ordering}; -#[cfg(taproot)] -use musig2::types::{PartialSignature, PublicNonce}; +use crate::crypto::chacha20::ChaCha20; use crate::io::{self, Error}; use crate::ln::features::ChannelTypeFeatures; use crate::ln::msgs::{DecodeError, MAX_VALUE_MSAT}; +use crate::prelude::*; use crate::sign::ecdsa::{EcdsaChannelSigner, WriteableEcdsaChannelSigner}; #[cfg(taproot)] use crate::sign::taproot::TaprootChannelSigner; use crate::util::atomic_counter::AtomicCounter; -use crate::crypto::chacha20::ChaCha20; use crate::util::invoice::construct_invoice_preimage; +use core::ops::Deref; +use core::sync::atomic::{AtomicUsize, Ordering}; +#[cfg(taproot)] +use musig2::types::{PartialSignature, PublicNonce}; pub(crate) mod type_resolver; @@ -109,7 +115,8 @@ impl DelayedPaymentOutputDescriptor { /// shorter. // Calculated as 1 byte length + 73 byte signature, 1 byte empty vec push, 1 byte length plus // redeemscript push length. - pub const MAX_WITNESS_LENGTH: u64 = 1 + 73 + 1 + chan_utils::REVOKEABLE_REDEEMSCRIPT_MAX_LENGTH as u64 + 1; + pub const MAX_WITNESS_LENGTH: u64 = + 1 + 73 + 1 + chan_utils::REVOKEABLE_REDEEMSCRIPT_MAX_LENGTH as u64 + 1; } impl_writeable_tlv_based!(DelayedPaymentOutputDescriptor, { @@ -154,25 +161,21 @@ impl StaticPaymentOutputDescriptor { /// Note that this will only return `Some` for [`StaticPaymentOutputDescriptor`]s that /// originated from an anchor outputs channel, as they take the form of a P2WSH script. pub fn witness_script(&self) -> Option { - self.channel_transaction_parameters.as_ref() - .and_then(|channel_params| - if channel_params.channel_type_features.supports_anchors_zero_fee_htlc_tx() { - let payment_point = channel_params.holder_pubkeys.payment_point; - Some(chan_utils::get_to_countersignatory_with_anchors_redeemscript(&payment_point)) - } else { - None - } - ) + self.channel_transaction_parameters.as_ref().and_then(|channel_params| { + if channel_params.supports_anchors() { + let payment_point = channel_params.holder_pubkeys.payment_point; + Some(chan_utils::get_to_countersignatory_with_anchors_redeemscript(&payment_point)) + } else { + None + } + }) } /// The maximum length a well-formed witness spending one of these should have. /// Note: If you have the grind_signatures feature enabled, this will be at least 1 byte /// shorter. pub fn max_witness_length(&self) -> u64 { - if self.channel_transaction_parameters.as_ref() - .map(|channel_params| channel_params.channel_type_features.supports_anchors_zero_fee_htlc_tx()) - .unwrap_or(false) - { + if self.channel_transaction_parameters.as_ref().map_or(false, |p| p.supports_anchors()) { let witness_script_weight = 1 /* pubkey push */ + 33 /* pubkey */ + 1 /* OP_CHECKSIGVERIFY */ + 1 /* OP_1 */ + 1 /* OP_CHECKSEQUENCEVERIFY */; 1 /* num witness items */ + 1 /* sig push */ + 73 /* sig including sighash flag */ + @@ -222,7 +225,7 @@ pub enum SpendableOutputDescriptor { /// /// For channels which were generated prior to LDK 0.0.119, no such argument existed, /// however this field may still be filled in if such data is available. - channel_keys_id: Option<[u8; 32]> + channel_keys_id: Option<[u8; 32]>, }, /// An output to a P2WSH script which can be spent with a single signature after an `OP_CSV` /// delay. @@ -307,10 +310,7 @@ impl SpendableOutputDescriptor { match self { SpendableOutputDescriptor::StaticOutput { output, .. } => { // Is a standard P2WPKH, no need for witness script - bitcoin::psbt::Input { - witness_utxo: Some(output.clone()), - ..Default::default() - } + bitcoin::psbt::Input { witness_utxo: Some(output.clone()), ..Default::default() } }, SpendableOutputDescriptor::DelayedPaymentOutput(descriptor) => { // TODO we could add the witness script as well @@ -345,7 +345,11 @@ impl SpendableOutputDescriptor { /// does not match the one we can spend. /// /// We do not enforce that outputs meet the dust limit or that any output scripts are standard. - pub fn create_spendable_outputs_psbt(descriptors: &[&SpendableOutputDescriptor], outputs: Vec, change_destination_script: ScriptBuf, feerate_sat_per_1000_weight: u32, locktime: Option) -> Result<(PartiallySignedTransaction, u64), ()> { + pub fn create_spendable_outputs_psbt( + descriptors: &[&SpendableOutputDescriptor], outputs: Vec, + change_destination_script: ScriptBuf, feerate_sat_per_1000_weight: u32, + locktime: Option, + ) -> Result<(PartiallySignedTransaction, u64), ()> { let mut input = Vec::with_capacity(descriptors.len()); let mut input_value = 0; let mut witness_weight = 0; @@ -353,16 +357,18 @@ impl SpendableOutputDescriptor { for outp in descriptors { match outp { SpendableOutputDescriptor::StaticPaymentOutput(descriptor) => { - if !output_set.insert(descriptor.outpoint) { return Err(()); } - let sequence = - if descriptor.channel_transaction_parameters.as_ref() - .map(|channel_params| channel_params.channel_type_features.supports_anchors_zero_fee_htlc_tx()) - .unwrap_or(false) - { - Sequence::from_consensus(1) - } else { - Sequence::ZERO - }; + if !output_set.insert(descriptor.outpoint) { + return Err(()); + } + let sequence = if descriptor + .channel_transaction_parameters + .as_ref() + .map_or(false, |p| p.supports_anchors()) + { + Sequence::from_consensus(1) + } else { + Sequence::ZERO + }; input.push(TxIn { previous_output: descriptor.outpoint.into_bitcoin_outpoint(), script_sig: ScriptBuf::new(), @@ -371,11 +377,16 @@ impl SpendableOutputDescriptor { }); witness_weight += descriptor.max_witness_length(); #[cfg(feature = "grind_signatures")] - { witness_weight -= 1; } // Guarantees a low R signature + { + // Guarantees a low R signature + witness_weight -= 1; + } input_value += descriptor.output.value; }, SpendableOutputDescriptor::DelayedPaymentOutput(descriptor) => { - if !output_set.insert(descriptor.outpoint) { return Err(()); } + if !output_set.insert(descriptor.outpoint) { + return Err(()); + } input.push(TxIn { previous_output: descriptor.outpoint.into_bitcoin_outpoint(), script_sig: ScriptBuf::new(), @@ -384,11 +395,16 @@ impl SpendableOutputDescriptor { }); witness_weight += DelayedPaymentOutputDescriptor::MAX_WITNESS_LENGTH; #[cfg(feature = "grind_signatures")] - { witness_weight -= 1; } // Guarantees a low R signature + { + // Guarantees a low R signature + witness_weight -= 1; + } input_value += descriptor.output.value; }, SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output, .. } => { - if !output_set.insert(*outpoint) { return Err(()); } + if !output_set.insert(*outpoint) { + return Err(()); + } input.push(TxIn { previous_output: outpoint.into_bitcoin_outpoint(), script_sig: ScriptBuf::new(), @@ -397,11 +413,16 @@ impl SpendableOutputDescriptor { }); witness_weight += 1 + 73 + 34; #[cfg(feature = "grind_signatures")] - { witness_weight -= 1; } // Guarantees a low R signature + { + // Guarantees a low R signature + witness_weight -= 1; + } input_value += output.value; - } + }, + } + if input_value > MAX_VALUE_MSAT / 1000 { + return Err(()); } - if input_value > MAX_VALUE_MSAT / 1000 { return Err(()); } } let mut tx = Transaction { version: 2, @@ -409,8 +430,13 @@ impl SpendableOutputDescriptor { input, output: outputs, }; - let expected_max_weight = - transaction_utils::maybe_add_change_output(&mut tx, input_value, witness_weight, feerate_sat_per_1000_weight, change_destination_script)?; + let expected_max_weight = transaction_utils::maybe_add_change_output( + &mut tx, + input_value, + witness_weight, + feerate_sat_per_1000_weight, + change_destination_script, + )?; let psbt_inputs = descriptors.iter().map(|d| d.to_psbt_input()).collect::>(); let psbt = PartiallySignedTransaction { @@ -439,9 +465,9 @@ pub struct ChannelDerivationParameters { } impl_writeable_tlv_based!(ChannelDerivationParameters, { - (0, value_satoshis, required), - (2, keys_id, required), - (4, transaction_parameters, required), + (0, value_satoshis, required), + (2, keys_id, required), + (4, transaction_parameters, required), }); /// A descriptor used to sign for a commitment transaction's HTLC output. @@ -469,7 +495,7 @@ pub struct HTLCDescriptor { /// taken. pub preimage: Option, /// The counterparty's signature required to spend the HTLC output. - pub counterparty_sig: Signature + pub counterparty_sig: Signature, } impl_writeable_tlv_based!(HTLCDescriptor, { @@ -495,7 +521,9 @@ impl HTLCDescriptor { /// Returns the UTXO to be spent by the HTLC input, which can be obtained via /// [`Self::unsigned_tx_input`]. - pub fn previous_utxo(&self, secp: &Secp256k1) -> TxOut { + pub fn previous_utxo( + &self, secp: &Secp256k1, + ) -> TxOut { TxOut { script_pubkey: self.witness_script(secp).to_v0_p2wsh(), value: self.htlc.amount_msat / 1000, @@ -506,40 +534,69 @@ impl HTLCDescriptor { /// transaction. pub fn unsigned_tx_input(&self) -> TxIn { chan_utils::build_htlc_input( - &self.commitment_txid, &self.htlc, &self.channel_derivation_parameters.transaction_parameters.channel_type_features + &self.commitment_txid, + &self.htlc, + &self.channel_derivation_parameters.transaction_parameters.channel_type_features, ) } /// Returns the delayed output created as a result of spending the HTLC output in the commitment /// transaction. - pub fn tx_output(&self, secp: &Secp256k1) -> TxOut { - let channel_params = self.channel_derivation_parameters.transaction_parameters.as_holder_broadcastable(); + pub fn tx_output( + &self, secp: &Secp256k1, + ) -> TxOut { + let channel_params = + self.channel_derivation_parameters.transaction_parameters.as_holder_broadcastable(); let broadcaster_keys = channel_params.broadcaster_pubkeys(); let counterparty_keys = channel_params.countersignatory_pubkeys(); let broadcaster_delayed_key = DelayedPaymentKey::from_basepoint( - secp, &broadcaster_keys.delayed_payment_basepoint, &self.per_commitment_point + secp, + &broadcaster_keys.delayed_payment_basepoint, + &self.per_commitment_point, + ); + let counterparty_revocation_key = &RevocationKey::from_basepoint( + &secp, + &counterparty_keys.revocation_basepoint, + &self.per_commitment_point, ); - let counterparty_revocation_key = &RevocationKey::from_basepoint(&secp, &counterparty_keys.revocation_basepoint, &self.per_commitment_point); chan_utils::build_htlc_output( - self.feerate_per_kw, channel_params.contest_delay(), &self.htlc, - channel_params.channel_type_features(), &broadcaster_delayed_key, &counterparty_revocation_key + self.feerate_per_kw, + channel_params.contest_delay(), + &self.htlc, + channel_params.channel_type_features(), + &broadcaster_delayed_key, + &counterparty_revocation_key, ) } /// Returns the witness script of the HTLC output in the commitment transaction. - pub fn witness_script(&self, secp: &Secp256k1) -> ScriptBuf { - let channel_params = self.channel_derivation_parameters.transaction_parameters.as_holder_broadcastable(); + pub fn witness_script( + &self, secp: &Secp256k1, + ) -> ScriptBuf { + let channel_params = + self.channel_derivation_parameters.transaction_parameters.as_holder_broadcastable(); let broadcaster_keys = channel_params.broadcaster_pubkeys(); let counterparty_keys = channel_params.countersignatory_pubkeys(); let broadcaster_htlc_key = HtlcKey::from_basepoint( - secp, &broadcaster_keys.htlc_basepoint, &self.per_commitment_point + secp, + &broadcaster_keys.htlc_basepoint, + &self.per_commitment_point, ); let counterparty_htlc_key = HtlcKey::from_basepoint( - secp, &counterparty_keys.htlc_basepoint, &self.per_commitment_point, + secp, + &counterparty_keys.htlc_basepoint, + &self.per_commitment_point, + ); + let counterparty_revocation_key = &RevocationKey::from_basepoint( + &secp, + &counterparty_keys.revocation_basepoint, + &self.per_commitment_point, ); - let counterparty_revocation_key = &RevocationKey::from_basepoint(&secp, &counterparty_keys.revocation_basepoint, &self.per_commitment_point); chan_utils::get_htlc_redeemscript_with_explicit_keys( - &self.htlc, channel_params.channel_type_features(), &broadcaster_htlc_key, &counterparty_htlc_key, + &self.htlc, + channel_params.channel_type_features(), + &broadcaster_htlc_key, + &counterparty_htlc_key, &counterparty_revocation_key, ) } @@ -548,21 +605,27 @@ impl HTLCDescriptor { /// transaction. pub fn tx_input_witness(&self, signature: &Signature, witness_script: &Script) -> Witness { chan_utils::build_htlc_input_witness( - signature, &self.counterparty_sig, &self.preimage, witness_script, - &self.channel_derivation_parameters.transaction_parameters.channel_type_features + signature, + &self.counterparty_sig, + &self.preimage, + witness_script, + &self.channel_derivation_parameters.transaction_parameters.channel_type_features, ) } /// Derives the channel signer required to sign the HTLC input. - pub fn derive_channel_signer(&self, signer_provider: &SP) -> S + pub fn derive_channel_signer( + &self, signer_provider: &SP, + ) -> S where - SP::Target: SignerProvider + SP::Target: SignerProvider, { let mut signer = signer_provider.derive_channel_signer( self.channel_derivation_parameters.value_satoshis, self.channel_derivation_parameters.keys_id, ); - signer.provide_channel_parameters(&self.channel_derivation_parameters.transaction_parameters); + signer + .provide_channel_parameters(&self.channel_derivation_parameters.transaction_parameters); signer } } @@ -573,7 +636,8 @@ pub trait ChannelSigner { /// Gets the per-commitment point for a specific commitment number /// /// Note that the commitment number starts at `(1 << 48) - 1` and counts backwards. - fn get_per_commitment_point(&self, idx: u64, secp_ctx: &Secp256k1) -> PublicKey; + fn get_per_commitment_point(&self, idx: u64, secp_ctx: &Secp256k1) + -> PublicKey; /// Gets the commitment secret for a specific commitment number as part of the revocation process /// @@ -599,8 +663,10 @@ pub trait ChannelSigner { /// /// Note that all the relevant preimages will be provided, but there may also be additional /// irrelevant or duplicate preimages. - fn validate_holder_commitment(&self, holder_tx: &HolderCommitmentTransaction, - outbound_htlc_preimages: Vec) -> Result<(), ()>; + fn validate_holder_commitment( + &self, holder_tx: &HolderCommitmentTransaction, + outbound_htlc_preimages: Vec, + ) -> Result<(), ()>; /// Validate the counterparty's revocation. /// @@ -681,7 +747,9 @@ pub trait NodeSigner { /// should be resolved to allow LDK to resume forwarding HTLCs. /// /// Errors if the [`Recipient`] variant is not supported by the implementation. - fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result; + fn ecdh( + &self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>, + ) -> Result; /// Sign an invoice. /// @@ -694,7 +762,9 @@ pub trait NodeSigner { /// The secret key used to sign the invoice is dependent on the [`Recipient`]. /// /// Errors if the [`Recipient`] variant is not supported by the implementation. - fn sign_invoice(&self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient) -> Result; + fn sign_invoice( + &self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient, + ) -> Result; /// Signs the [`TaggedHash`] of a BOLT 12 invoice request. /// @@ -708,7 +778,7 @@ pub trait NodeSigner { /// /// [`TaggedHash`]: crate::offers::merkle::TaggedHash fn sign_bolt12_invoice_request( - &self, invoice_request: &UnsignedInvoiceRequest + &self, invoice_request: &UnsignedInvoiceRequest, ) -> Result; /// Signs the [`TaggedHash`] of a BOLT 12 invoice. @@ -723,7 +793,7 @@ pub trait NodeSigner { /// /// [`TaggedHash`]: crate::offers::merkle::TaggedHash fn sign_bolt12_invoice( - &self, invoice: &UnsignedBolt12Invoice + &self, invoice: &UnsignedBolt12Invoice, ) -> Result; /// Sign a gossip message. @@ -740,7 +810,8 @@ pub trait NodeSigner { #[cfg(taproot)] #[doc(hidden)] #[deprecated(note = "Remove once taproot cfg is removed")] -pub type DynSignerProvider = dyn SignerProvider; +pub type DynSignerProvider = + dyn SignerProvider; /// A dynamic [`SignerProvider`] temporarily needed for doc tests. #[cfg(not(taproot))] @@ -762,7 +833,9 @@ pub trait SignerProvider { /// `channel_keys_id`. /// /// This method must return a different value each time it is called. - fn generate_channel_keys_id(&self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128) -> [u8; 32]; + fn generate_channel_keys_id( + &self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128, + ) -> [u8; 32]; /// Derives the private key material backing a `Signer`. /// @@ -770,7 +843,9 @@ pub trait SignerProvider { /// [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be /// re-derived from its `channel_keys_id`, which can be obtained through its trait method /// [`ChannelSigner::channel_keys_id`]. - fn derive_channel_signer(&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32]) -> Self::EcdsaSigner; + fn derive_channel_signer( + &self, channel_value_satoshis: u64, channel_keys_id: [u8; 32], + ) -> Self::EcdsaSigner; /// Reads a [`Signer`] for this [`SignerProvider`] from the given input stream. /// This is only called during deserialization of other objects which contain @@ -840,16 +915,16 @@ pub struct InMemorySigner { impl PartialEq for InMemorySigner { fn eq(&self, other: &Self) -> bool { - self.funding_key == other.funding_key && - self.revocation_base_key == other.revocation_base_key && - self.payment_key == other.payment_key && - self.delayed_payment_base_key == other.delayed_payment_base_key && - self.htlc_base_key == other.htlc_base_key && - self.commitment_seed == other.commitment_seed && - self.holder_channel_pubkeys == other.holder_channel_pubkeys && - self.channel_parameters == other.channel_parameters && - self.channel_value_satoshis == other.channel_value_satoshis && - self.channel_keys_id == other.channel_keys_id + self.funding_key == other.funding_key + && self.revocation_base_key == other.revocation_base_key + && self.payment_key == other.payment_key + && self.delayed_payment_base_key == other.delayed_payment_base_key + && self.htlc_base_key == other.htlc_base_key + && self.commitment_seed == other.commitment_seed + && self.holder_channel_pubkeys == other.holder_channel_pubkeys + && self.channel_parameters == other.channel_parameters + && self.channel_value_satoshis == other.channel_value_satoshis + && self.channel_keys_id == other.channel_keys_id } } @@ -874,21 +949,19 @@ impl Clone for InMemorySigner { impl InMemorySigner { /// Creates a new [`InMemorySigner`]. pub fn new( - secp_ctx: &Secp256k1, - funding_key: SecretKey, - revocation_base_key: SecretKey, - payment_key: SecretKey, - delayed_payment_base_key: SecretKey, - htlc_base_key: SecretKey, - commitment_seed: [u8; 32], - channel_value_satoshis: u64, - channel_keys_id: [u8; 32], + secp_ctx: &Secp256k1, funding_key: SecretKey, revocation_base_key: SecretKey, + payment_key: SecretKey, delayed_payment_base_key: SecretKey, htlc_base_key: SecretKey, + commitment_seed: [u8; 32], channel_value_satoshis: u64, channel_keys_id: [u8; 32], rand_bytes_unique_start: [u8; 32], ) -> InMemorySigner { - let holder_channel_pubkeys = - InMemorySigner::make_holder_keys(secp_ctx, &funding_key, &revocation_base_key, - &payment_key, &delayed_payment_base_key, - &htlc_base_key); + let holder_channel_pubkeys = InMemorySigner::make_holder_keys( + secp_ctx, + &funding_key, + &revocation_base_key, + &payment_key, + &delayed_payment_base_key, + &htlc_base_key, + ); InMemorySigner { funding_key, revocation_base_key, @@ -904,18 +977,18 @@ impl InMemorySigner { } } - fn make_holder_keys(secp_ctx: &Secp256k1, - funding_key: &SecretKey, - revocation_base_key: &SecretKey, - payment_key: &SecretKey, - delayed_payment_base_key: &SecretKey, - htlc_base_key: &SecretKey) -> ChannelPublicKeys { + fn make_holder_keys( + secp_ctx: &Secp256k1, funding_key: &SecretKey, revocation_base_key: &SecretKey, + payment_key: &SecretKey, delayed_payment_base_key: &SecretKey, htlc_base_key: &SecretKey, + ) -> ChannelPublicKeys { let from_secret = |s: &SecretKey| PublicKey::from_secret_key(secp_ctx, s); ChannelPublicKeys { funding_pubkey: from_secret(&funding_key), revocation_basepoint: RevocationBasepoint::from(from_secret(&revocation_base_key)), payment_point: from_secret(&payment_key), - delayed_payment_basepoint: DelayedPaymentBasepoint::from(from_secret(&delayed_payment_base_key)), + delayed_payment_basepoint: DelayedPaymentBasepoint::from(from_secret( + &delayed_payment_base_key, + )), htlc_basepoint: HtlcBasepoint::from(from_secret(&htlc_base_key)), } } @@ -925,8 +998,9 @@ impl InMemorySigner { /// Will return `None` if [`ChannelSigner::provide_channel_parameters`] has not been called. /// In general, this is safe to `unwrap` only in [`ChannelSigner`] implementation. pub fn counterparty_pubkeys(&self) -> Option<&ChannelPublicKeys> { - self.get_channel_parameters() - .and_then(|params| params.counterparty_parameters.as_ref().map(|params| ¶ms.pubkeys)) + self.get_channel_parameters().and_then(|params| { + params.counterparty_parameters.as_ref().map(|params| ¶ms.pubkeys) + }) } /// Returns the `contest_delay` value specified by our counterparty and applied on holder-broadcastable @@ -936,8 +1010,9 @@ impl InMemorySigner { /// Will return `None` if [`ChannelSigner::provide_channel_parameters`] has not been called. /// In general, this is safe to `unwrap` only in [`ChannelSigner`] implementation. pub fn counterparty_selected_contest_delay(&self) -> Option { - self.get_channel_parameters() - .and_then(|params| params.counterparty_parameters.as_ref().map(|params| params.selected_contest_delay)) + self.get_channel_parameters().and_then(|params| { + params.counterparty_parameters.as_ref().map(|params| params.selected_contest_delay) + }) } /// Returns the `contest_delay` value specified by us and applied on transactions broadcastable @@ -992,19 +1067,30 @@ impl InMemorySigner { /// or if an output descriptor `script_pubkey` does not match the one we can spend. /// /// [`descriptor.outpoint`]: StaticPaymentOutputDescriptor::outpoint - pub fn sign_counterparty_payment_input(&self, spend_tx: &Transaction, input_idx: usize, descriptor: &StaticPaymentOutputDescriptor, secp_ctx: &Secp256k1) -> Result { + pub fn sign_counterparty_payment_input( + &self, spend_tx: &Transaction, input_idx: usize, + descriptor: &StaticPaymentOutputDescriptor, secp_ctx: &Secp256k1, + ) -> Result { // TODO: We really should be taking the SigHashCache as a parameter here instead of // spend_tx, but ideally the SigHashCache would expose the transaction's inputs read-only // so that we can check them. This requires upstream rust-bitcoin changes (as well as // bindings updates to support SigHashCache objects). - if spend_tx.input.len() <= input_idx { return Err(()); } - if !spend_tx.input[input_idx].script_sig.is_empty() { return Err(()); } - if spend_tx.input[input_idx].previous_output != descriptor.outpoint.into_bitcoin_outpoint() { return Err(()); } + if spend_tx.input.len() <= input_idx { + return Err(()); + } + if !spend_tx.input[input_idx].script_sig.is_empty() { + return Err(()); + } + if spend_tx.input[input_idx].previous_output != descriptor.outpoint.into_bitcoin_outpoint() + { + return Err(()); + } let remotepubkey = bitcoin::PublicKey::new(self.pubkeys().payment_point); // We cannot always assume that `channel_parameters` is set, so can't just call // `self.channel_parameters()` or anything that relies on it - let supports_anchors_zero_fee_htlc_tx = self.channel_type_features() + let supports_anchors_zero_fee_htlc_tx = self + .channel_type_features() .map(|features| features.supports_anchors_zero_fee_htlc_tx()) .unwrap_or(false); @@ -1013,7 +1099,16 @@ impl InMemorySigner { } else { ScriptBuf::new_p2pkh(&remotepubkey.pubkey_hash()) }; - let sighash = hash_to_message!(&sighash::SighashCache::new(spend_tx).segwit_signature_hash(input_idx, &witness_script, descriptor.output.value, EcdsaSighashType::All).unwrap()[..]); + let sighash = hash_to_message!( + &sighash::SighashCache::new(spend_tx) + .segwit_signature_hash( + input_idx, + &witness_script, + descriptor.output.value, + EcdsaSighashType::All + ) + .unwrap()[..] + ); let remotesig = sign_with_aux_rand(secp_ctx, &sighash, &self.payment_key, &self); let payment_script = if supports_anchors_zero_fee_htlc_tx { witness_script.to_v0_p2wsh() @@ -1021,7 +1116,9 @@ impl InMemorySigner { ScriptBuf::new_v0_p2wpkh(&remotepubkey.wpubkey_hash().unwrap()) }; - if payment_script != descriptor.output.script_pubkey { return Err(()); } + if payment_script != descriptor.output.script_pubkey { + return Err(()); + } let mut witness = Vec::with_capacity(2); witness.push(remotesig.serialize_der().to_vec()); @@ -1044,27 +1141,60 @@ impl InMemorySigner { /// /// [`descriptor.outpoint`]: DelayedPaymentOutputDescriptor::outpoint /// [`descriptor.to_self_delay`]: DelayedPaymentOutputDescriptor::to_self_delay - pub fn sign_dynamic_p2wsh_input(&self, spend_tx: &Transaction, input_idx: usize, descriptor: &DelayedPaymentOutputDescriptor, secp_ctx: &Secp256k1) -> Result { + pub fn sign_dynamic_p2wsh_input( + &self, spend_tx: &Transaction, input_idx: usize, + descriptor: &DelayedPaymentOutputDescriptor, secp_ctx: &Secp256k1, + ) -> Result { // TODO: We really should be taking the SigHashCache as a parameter here instead of // spend_tx, but ideally the SigHashCache would expose the transaction's inputs read-only // so that we can check them. This requires upstream rust-bitcoin changes (as well as // bindings updates to support SigHashCache objects). - if spend_tx.input.len() <= input_idx { return Err(()); } - if !spend_tx.input[input_idx].script_sig.is_empty() { return Err(()); } - if spend_tx.input[input_idx].previous_output != descriptor.outpoint.into_bitcoin_outpoint() { return Err(()); } - if spend_tx.input[input_idx].sequence.0 != descriptor.to_self_delay as u32 { return Err(()); } - - let delayed_payment_key = chan_utils::derive_private_key(&secp_ctx, &descriptor.per_commitment_point, &self.delayed_payment_base_key); - let delayed_payment_pubkey = DelayedPaymentKey::from_secret_key(&secp_ctx, &delayed_payment_key); - let witness_script = chan_utils::get_revokeable_redeemscript(&descriptor.revocation_pubkey, descriptor.to_self_delay, &delayed_payment_pubkey); - let sighash = hash_to_message!(&sighash::SighashCache::new(spend_tx).segwit_signature_hash(input_idx, &witness_script, descriptor.output.value, EcdsaSighashType::All).unwrap()[..]); + if spend_tx.input.len() <= input_idx { + return Err(()); + } + if !spend_tx.input[input_idx].script_sig.is_empty() { + return Err(()); + } + if spend_tx.input[input_idx].previous_output != descriptor.outpoint.into_bitcoin_outpoint() + { + return Err(()); + } + if spend_tx.input[input_idx].sequence.0 != descriptor.to_self_delay as u32 { + return Err(()); + } + + let delayed_payment_key = chan_utils::derive_private_key( + &secp_ctx, + &descriptor.per_commitment_point, + &self.delayed_payment_base_key, + ); + let delayed_payment_pubkey = + DelayedPaymentKey::from_secret_key(&secp_ctx, &delayed_payment_key); + let witness_script = chan_utils::get_revokeable_redeemscript( + &descriptor.revocation_pubkey, + descriptor.to_self_delay, + &delayed_payment_pubkey, + ); + let sighash = hash_to_message!( + &sighash::SighashCache::new(spend_tx) + .segwit_signature_hash( + input_idx, + &witness_script, + descriptor.output.value, + EcdsaSighashType::All + ) + .unwrap()[..] + ); let local_delayedsig = EcdsaSignature { sig: sign_with_aux_rand(secp_ctx, &sighash, &delayed_payment_key, &self), hash_ty: EcdsaSighashType::All, }; - let payment_script = bitcoin::Address::p2wsh(&witness_script, Network::Bitcoin).script_pubkey(); + let payment_script = + bitcoin::Address::p2wsh(&witness_script, Network::Bitcoin).script_pubkey(); - if descriptor.output.script_pubkey != payment_script { return Err(()); } + if descriptor.output.script_pubkey != payment_script { + return Err(()); + } Ok(Witness::from_slice(&[ &local_delayedsig.serialize()[..], @@ -1081,8 +1211,12 @@ impl EntropySource for InMemorySigner { } impl ChannelSigner for InMemorySigner { - fn get_per_commitment_point(&self, idx: u64, secp_ctx: &Secp256k1) -> PublicKey { - let commitment_secret = SecretKey::from_slice(&chan_utils::build_commitment_secret(&self.commitment_seed, idx)).unwrap(); + fn get_per_commitment_point( + &self, idx: u64, secp_ctx: &Secp256k1, + ) -> PublicKey { + let commitment_secret = + SecretKey::from_slice(&chan_utils::build_commitment_secret(&self.commitment_seed, idx)) + .unwrap(); PublicKey::from_secret_key(secp_ctx, &commitment_secret) } @@ -1090,7 +1224,10 @@ impl ChannelSigner for InMemorySigner { chan_utils::build_commitment_secret(&self.commitment_seed, idx) } - fn validate_holder_commitment(&self, _holder_tx: &HolderCommitmentTransaction, _outbound_htlc_preimages: Vec) -> Result<(), ()> { + fn validate_holder_commitment( + &self, _holder_tx: &HolderCommitmentTransaction, + _outbound_htlc_preimages: Vec, + ) -> Result<(), ()> { Ok(()) } @@ -1098,12 +1235,19 @@ impl ChannelSigner for InMemorySigner { Ok(()) } - fn pubkeys(&self) -> &ChannelPublicKeys { &self.holder_channel_pubkeys } + fn pubkeys(&self) -> &ChannelPublicKeys { + &self.holder_channel_pubkeys + } - fn channel_keys_id(&self) -> [u8; 32] { self.channel_keys_id } + fn channel_keys_id(&self) -> [u8; 32] { + self.channel_keys_id + } fn provide_channel_parameters(&mut self, channel_parameters: &ChannelTransactionParameters) { - assert!(self.channel_parameters.is_none() || self.channel_parameters.as_ref().unwrap() == channel_parameters); + assert!( + self.channel_parameters.is_none() + || self.channel_parameters.as_ref().unwrap() == channel_parameters + ); if self.channel_parameters.is_some() { // The channel parameters were already set and they match, return early. return; @@ -1113,19 +1257,30 @@ impl ChannelSigner for InMemorySigner { } } -const MISSING_PARAMS_ERR: &'static str = "ChannelSigner::provide_channel_parameters must be called before signing operations"; +const MISSING_PARAMS_ERR: &'static str = + "ChannelSigner::provide_channel_parameters must be called before signing operations"; impl EcdsaChannelSigner for InMemorySigner { - fn sign_counterparty_commitment(&self, commitment_tx: &CommitmentTransaction, _inbound_htlc_preimages: Vec, _outbound_htlc_preimages: Vec, secp_ctx: &Secp256k1) -> Result<(Signature, Vec), ()> { + fn sign_counterparty_commitment( + &self, commitment_tx: &CommitmentTransaction, + _inbound_htlc_preimages: Vec, + _outbound_htlc_preimages: Vec, secp_ctx: &Secp256k1, + ) -> Result<(Signature, Vec), ()> { let trusted_tx = commitment_tx.trust(); let keys = trusted_tx.keys(); let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key); let counterparty_keys = self.counterparty_pubkeys().expect(MISSING_PARAMS_ERR); - let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &counterparty_keys.funding_pubkey); + let channel_funding_redeemscript = + make_funding_redeemscript(&funding_pubkey, &counterparty_keys.funding_pubkey); let built_tx = trusted_tx.built_transaction(); - let commitment_sig = built_tx.sign_counterparty_commitment(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx); + let commitment_sig = built_tx.sign_counterparty_commitment( + &self.funding_key, + &channel_funding_redeemscript, + self.channel_value_satoshis, + secp_ctx, + ); let commitment_txid = built_tx.txid; let mut htlc_sigs = Vec::with_capacity(commitment_tx.htlcs().len()); @@ -1134,124 +1289,253 @@ impl EcdsaChannelSigner for InMemorySigner { let holder_selected_contest_delay = self.holder_selected_contest_delay().expect(MISSING_PARAMS_ERR); let chan_type = &channel_parameters.channel_type_features; - let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_tx.feerate_per_kw(), holder_selected_contest_delay, htlc, chan_type, &keys.broadcaster_delayed_payment_key, &keys.revocation_key); + let htlc_tx = chan_utils::build_htlc_transaction( + &commitment_txid, + commitment_tx.feerate_per_kw(), + holder_selected_contest_delay, + htlc, + chan_type, + &keys.broadcaster_delayed_payment_key, + &keys.revocation_key, + ); let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, chan_type, &keys); - let htlc_sighashtype = if chan_type.supports_anchors_zero_fee_htlc_tx() { EcdsaSighashType::SinglePlusAnyoneCanPay } else { EcdsaSighashType::All }; - let htlc_sighash = hash_to_message!(&sighash::SighashCache::new(&htlc_tx).segwit_signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, htlc_sighashtype).unwrap()[..]); - let holder_htlc_key = chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key); + let htlc_sighashtype = if chan_type.supports_anchors_zero_fee_htlc_tx() { + EcdsaSighashType::SinglePlusAnyoneCanPay + } else { + EcdsaSighashType::All + }; + let htlc_sighash = hash_to_message!( + &sighash::SighashCache::new(&htlc_tx) + .segwit_signature_hash( + 0, + &htlc_redeemscript, + htlc.amount_msat / 1000, + htlc_sighashtype + ) + .unwrap()[..] + ); + let holder_htlc_key = chan_utils::derive_private_key( + &secp_ctx, + &keys.per_commitment_point, + &self.htlc_base_key, + ); htlc_sigs.push(sign(secp_ctx, &htlc_sighash, &holder_htlc_key)); } Ok((commitment_sig, htlc_sigs)) } - fn sign_holder_commitment(&self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1) -> Result { + fn sign_holder_commitment( + &self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1, + ) -> Result { let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key); let counterparty_keys = self.counterparty_pubkeys().expect(MISSING_PARAMS_ERR); - let funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &counterparty_keys.funding_pubkey); + let funding_redeemscript = + make_funding_redeemscript(&funding_pubkey, &counterparty_keys.funding_pubkey); let trusted_tx = commitment_tx.trust(); - Ok(trusted_tx.built_transaction().sign_holder_commitment(&self.funding_key, &funding_redeemscript, self.channel_value_satoshis, &self, secp_ctx)) - } - - #[cfg(any(test,feature = "unsafe_revoked_tx_signing"))] - fn unsafe_sign_holder_commitment(&self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1) -> Result { + Ok(trusted_tx.built_transaction().sign_holder_commitment( + &self.funding_key, + &funding_redeemscript, + self.channel_value_satoshis, + &self, + secp_ctx, + )) + } + + #[cfg(any(test, feature = "unsafe_revoked_tx_signing"))] + fn unsafe_sign_holder_commitment( + &self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1, + ) -> Result { let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key); let counterparty_keys = self.counterparty_pubkeys().expect(MISSING_PARAMS_ERR); - let funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &counterparty_keys.funding_pubkey); + let funding_redeemscript = + make_funding_redeemscript(&funding_pubkey, &counterparty_keys.funding_pubkey); let trusted_tx = commitment_tx.trust(); - Ok(trusted_tx.built_transaction().sign_holder_commitment(&self.funding_key, &funding_redeemscript, self.channel_value_satoshis, &self, secp_ctx)) - } - - fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, secp_ctx: &Secp256k1) -> Result { - let revocation_key = chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key); + Ok(trusted_tx.built_transaction().sign_holder_commitment( + &self.funding_key, + &funding_redeemscript, + self.channel_value_satoshis, + &self, + secp_ctx, + )) + } + + fn sign_justice_revoked_output( + &self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, + secp_ctx: &Secp256k1, + ) -> Result { + 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, + &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 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.segwit_signature_hash(input, &witness_script, amount, EcdsaSighashType::All).unwrap()[..]); - return Ok(sign_with_aux_rand(secp_ctx, &sighash, &revocation_key, &self)) + let sighash = hash_to_message!( + &sighash_parts + .segwit_signature_hash(input, &witness_script, 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) -> Result { - let revocation_key = chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key); + fn sign_justice_revoked_htlc( + &self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, + htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1, + ) -> Result { + 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, + &secp_ctx, + &self.pubkeys().revocation_basepoint, + &per_commitment_point, ); let witness_script = { let counterparty_keys = self.counterparty_pubkeys().expect(MISSING_PARAMS_ERR); let counterparty_htlcpubkey = HtlcKey::from_basepoint( - &secp_ctx, &counterparty_keys.htlc_basepoint, &per_commitment_point, + &secp_ctx, + &counterparty_keys.htlc_basepoint, + &per_commitment_point, ); let holder_htlcpubkey = HtlcKey::from_basepoint( - &secp_ctx, &self.pubkeys().htlc_basepoint, &per_commitment_point, + &secp_ctx, + &self.pubkeys().htlc_basepoint, + &per_commitment_point, ); let chan_type = self.channel_type_features().expect(MISSING_PARAMS_ERR); - chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, chan_type, &counterparty_htlcpubkey, &holder_htlcpubkey, &revocation_pubkey) + chan_utils::get_htlc_redeemscript_with_explicit_keys( + &htlc, + chan_type, + &counterparty_htlcpubkey, + &holder_htlcpubkey, + &revocation_pubkey, + ) }; let mut sighash_parts = sighash::SighashCache::new(justice_tx); - let sighash = hash_to_message!(&sighash_parts.segwit_signature_hash(input, &witness_script, amount, EcdsaSighashType::All).unwrap()[..]); - return Ok(sign_with_aux_rand(secp_ctx, &sighash, &revocation_key, &self)) + let sighash = hash_to_message!( + &sighash_parts + .segwit_signature_hash(input, &witness_script, amount, EcdsaSighashType::All) + .unwrap()[..] + ); + return Ok(sign_with_aux_rand(secp_ctx, &sighash, &revocation_key, &self)); } fn sign_holder_htlc_transaction( &self, htlc_tx: &Transaction, input: usize, htlc_descriptor: &HTLCDescriptor, - secp_ctx: &Secp256k1 + secp_ctx: &Secp256k1, ) -> Result { let witness_script = htlc_descriptor.witness_script(secp_ctx); - let sighash = &sighash::SighashCache::new(&*htlc_tx).segwit_signature_hash( - input, &witness_script, htlc_descriptor.htlc.amount_msat / 1000, EcdsaSighashType::All - ).map_err(|_| ())?; + let sighash = &sighash::SighashCache::new(&*htlc_tx) + .segwit_signature_hash( + input, + &witness_script, + htlc_descriptor.htlc.amount_msat / 1000, + EcdsaSighashType::All, + ) + .map_err(|_| ())?; let our_htlc_private_key = chan_utils::derive_private_key( - &secp_ctx, &htlc_descriptor.per_commitment_point, &self.htlc_base_key + &secp_ctx, + &htlc_descriptor.per_commitment_point, + &self.htlc_base_key, ); - Ok(sign_with_aux_rand(&secp_ctx, &hash_to_message!(sighash.as_byte_array()), &our_htlc_private_key, &self)) + let sighash = hash_to_message!(sighash.as_byte_array()); + Ok(sign_with_aux_rand(&secp_ctx, &sighash, &our_htlc_private_key, &self)) } - fn sign_counterparty_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1) -> Result { - let htlc_key = chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &self.htlc_base_key); + fn sign_counterparty_htlc_transaction( + &self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, + htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1, + ) -> Result { + let htlc_key = + chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &self.htlc_base_key); let revocation_pubkey = RevocationKey::from_basepoint( - &secp_ctx, &self.pubkeys().revocation_basepoint, &per_commitment_point, + &secp_ctx, + &self.pubkeys().revocation_basepoint, + &per_commitment_point, ); let counterparty_keys = self.counterparty_pubkeys().expect(MISSING_PARAMS_ERR); let counterparty_htlcpubkey = HtlcKey::from_basepoint( - &secp_ctx, &counterparty_keys.htlc_basepoint, &per_commitment_point, + &secp_ctx, + &counterparty_keys.htlc_basepoint, + &per_commitment_point, ); - let htlcpubkey = HtlcKey::from_basepoint(&secp_ctx, &self.pubkeys().htlc_basepoint, &per_commitment_point); + let htlc_basepoint = self.pubkeys().htlc_basepoint; + let htlcpubkey = HtlcKey::from_basepoint(&secp_ctx, &htlc_basepoint, &per_commitment_point); let chan_type = self.channel_type_features().expect(MISSING_PARAMS_ERR); - let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, chan_type, &counterparty_htlcpubkey, &htlcpubkey, &revocation_pubkey); + let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys( + &htlc, + chan_type, + &counterparty_htlcpubkey, + &htlcpubkey, + &revocation_pubkey, + ); let mut sighash_parts = sighash::SighashCache::new(htlc_tx); - let sighash = hash_to_message!(&sighash_parts.segwit_signature_hash(input, &witness_script, amount, EcdsaSighashType::All).unwrap()[..]); + let sighash = hash_to_message!( + &sighash_parts + .segwit_signature_hash(input, &witness_script, amount, EcdsaSighashType::All) + .unwrap()[..] + ); Ok(sign_with_aux_rand(secp_ctx, &sighash, &htlc_key, &self)) } - fn sign_closing_transaction(&self, closing_tx: &ClosingTransaction, secp_ctx: &Secp256k1) -> Result { + fn sign_closing_transaction( + &self, closing_tx: &ClosingTransaction, secp_ctx: &Secp256k1, + ) -> Result { let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key); - let counterparty_funding_key = &self.counterparty_pubkeys().expect(MISSING_PARAMS_ERR).funding_pubkey; - let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, counterparty_funding_key); - Ok(closing_tx.trust().sign(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx)) + let counterparty_funding_key = + &self.counterparty_pubkeys().expect(MISSING_PARAMS_ERR).funding_pubkey; + let channel_funding_redeemscript = + make_funding_redeemscript(&funding_pubkey, counterparty_funding_key); + Ok(closing_tx.trust().sign( + &self.funding_key, + &channel_funding_redeemscript, + self.channel_value_satoshis, + secp_ctx, + )) } fn sign_holder_anchor_input( &self, anchor_tx: &Transaction, input: usize, secp_ctx: &Secp256k1, ) -> Result { - let witness_script = chan_utils::get_anchor_redeemscript(&self.holder_channel_pubkeys.funding_pubkey); - let sighash = sighash::SighashCache::new(&*anchor_tx).segwit_signature_hash( - input, &witness_script, ANCHOR_OUTPUT_VALUE_SATOSHI, EcdsaSighashType::All, - ).unwrap(); + let witness_script = + chan_utils::get_anchor_redeemscript(&self.holder_channel_pubkeys.funding_pubkey); + let sighash = sighash::SighashCache::new(&*anchor_tx) + .segwit_signature_hash( + input, + &witness_script, + ANCHOR_OUTPUT_VALUE_SATOSHI, + EcdsaSighashType::All, + ) + .unwrap(); Ok(sign_with_aux_rand(secp_ctx, &hash_to_message!(&sighash[..]), &self.funding_key, &self)) } fn sign_channel_announcement_with_funding_key( - &self, msg: &UnsignedChannelAnnouncement, secp_ctx: &Secp256k1 + &self, msg: &UnsignedChannelAnnouncement, secp_ctx: &Secp256k1, ) -> Result { let msghash = hash_to_message!(&Sha256dHash::hash(&msg.encode()[..])[..]); Ok(secp_ctx.sign_ecdsa(&msghash, &self.funding_key)) @@ -1260,39 +1544,64 @@ impl EcdsaChannelSigner for InMemorySigner { #[cfg(taproot)] impl TaprootChannelSigner for InMemorySigner { - fn generate_local_nonce_pair(&self, commitment_number: u64, secp_ctx: &Secp256k1) -> PublicNonce { + fn generate_local_nonce_pair( + &self, commitment_number: u64, secp_ctx: &Secp256k1, + ) -> PublicNonce { todo!() } - fn partially_sign_counterparty_commitment(&self, counterparty_nonce: PublicNonce, commitment_tx: &CommitmentTransaction, inbound_htlc_preimages: Vec, outbound_htlc_preimages: Vec, secp_ctx: &Secp256k1) -> Result<(PartialSignatureWithNonce, Vec), ()> { + fn partially_sign_counterparty_commitment( + &self, counterparty_nonce: PublicNonce, commitment_tx: &CommitmentTransaction, + inbound_htlc_preimages: Vec, + outbound_htlc_preimages: Vec, secp_ctx: &Secp256k1, + ) -> Result<(PartialSignatureWithNonce, Vec), ()> { todo!() } - fn finalize_holder_commitment(&self, commitment_tx: &HolderCommitmentTransaction, counterparty_partial_signature: PartialSignatureWithNonce, secp_ctx: &Secp256k1) -> Result { + fn finalize_holder_commitment( + &self, commitment_tx: &HolderCommitmentTransaction, + counterparty_partial_signature: PartialSignatureWithNonce, secp_ctx: &Secp256k1, + ) -> Result { todo!() } - fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, secp_ctx: &Secp256k1) -> Result { + fn sign_justice_revoked_output( + &self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, + secp_ctx: &Secp256k1, + ) -> Result { todo!() } - fn sign_justice_revoked_htlc(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1) -> Result { + fn sign_justice_revoked_htlc( + &self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, + htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1, + ) -> Result { todo!() } - fn sign_holder_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, htlc_descriptor: &HTLCDescriptor, secp_ctx: &Secp256k1) -> Result { + fn sign_holder_htlc_transaction( + &self, htlc_tx: &Transaction, input: usize, htlc_descriptor: &HTLCDescriptor, + secp_ctx: &Secp256k1, + ) -> Result { todo!() } - fn sign_counterparty_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1) -> Result { + fn sign_counterparty_htlc_transaction( + &self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, + htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1, + ) -> Result { todo!() } - fn partially_sign_closing_transaction(&self, closing_tx: &ClosingTransaction, secp_ctx: &Secp256k1) -> Result { + fn partially_sign_closing_transaction( + &self, closing_tx: &ClosingTransaction, secp_ctx: &Secp256k1, + ) -> Result { todo!() } - fn sign_holder_anchor_input(&self, anchor_tx: &Transaction, input: usize, secp_ctx: &Secp256k1) -> Result { + fn sign_holder_anchor_input( + &self, anchor_tx: &Transaction, input: usize, secp_ctx: &Secp256k1, + ) -> Result { todo!() } } @@ -1323,7 +1632,10 @@ impl Writeable for InMemorySigner { } } -impl ReadableArgs for InMemorySigner where ES::Target: EntropySource { +impl ReadableArgs for InMemorySigner +where + ES::Target: EntropySource, +{ fn read(reader: &mut R, entropy_source: ES) -> Result { let _ver = read_ver_prefix!(reader, SERIALIZATION_VERSION); @@ -1336,9 +1648,14 @@ impl ReadableArgs for InMemorySigner where ES::Target: EntropySou let counterparty_channel_data = Readable::read(reader)?; let channel_value_satoshis = Readable::read(reader)?; let secp_ctx = Secp256k1::signing_only(); - let holder_channel_pubkeys = - InMemorySigner::make_holder_keys(&secp_ctx, &funding_key, &revocation_base_key, - &payment_key, &delayed_payment_base_key, &htlc_base_key); + let holder_channel_pubkeys = InMemorySigner::make_holder_keys( + &secp_ctx, + &funding_key, + &revocation_base_key, + &payment_key, + &delayed_payment_base_key, + &htlc_base_key, + ); let keys_id = Readable::read(reader)?; read_tlv_fields!(reader, {}); @@ -1412,23 +1729,42 @@ impl KeysManager { // Note that when we aren't serializing the key, network doesn't matter match ExtendedPrivKey::new_master(Network::Testnet, seed) { Ok(master_key) => { - let node_secret = master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(0).unwrap()).expect("Your RNG is busted").private_key; + let node_secret = master_key + .ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(0).unwrap()) + .expect("Your RNG is busted") + .private_key; let node_id = PublicKey::from_secret_key(&secp_ctx, &node_secret); - let destination_script = match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(1).unwrap()) { + let destination_script = match master_key + .ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(1).unwrap()) + { Ok(destination_key) => { - let wpubkey_hash = WPubkeyHash::hash(&ExtendedPubKey::from_priv(&secp_ctx, &destination_key).to_pub().to_bytes()); - Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0) + let wpubkey_hash = WPubkeyHash::hash( + &ExtendedPubKey::from_priv(&secp_ctx, &destination_key) + .to_pub() + .to_bytes(), + ); + Builder::new() + .push_opcode(opcodes::all::OP_PUSHBYTES_0) .push_slice(&wpubkey_hash.to_byte_array()) .into_script() }, Err(_) => panic!("Your RNG is busted"), }; - let shutdown_pubkey = match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(2).unwrap()) { - Ok(shutdown_key) => ExtendedPubKey::from_priv(&secp_ctx, &shutdown_key).public_key, + let shutdown_pubkey = match master_key + .ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(2).unwrap()) + { + Ok(shutdown_key) => { + ExtendedPubKey::from_priv(&secp_ctx, &shutdown_key).public_key + }, Err(_) => panic!("Your RNG is busted"), }; - let channel_master_key = master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(3).unwrap()).expect("Your RNG is busted"); - let inbound_payment_key: SecretKey = master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(5).unwrap()).expect("Your RNG is busted").private_key; + let channel_master_key = master_key + .ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(3).unwrap()) + .expect("Your RNG is busted"); + let inbound_payment_key: SecretKey = master_key + .ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(5).unwrap()) + .expect("Your RNG is busted") + .private_key; let mut inbound_pmt_key_bytes = [0; 32]; inbound_pmt_key_bytes.copy_from_slice(&inbound_payment_key[..]); @@ -1437,7 +1773,8 @@ impl KeysManager { rand_bytes_engine.input(&starting_time_nanos.to_be_bytes()); rand_bytes_engine.input(seed); rand_bytes_engine.input(b"LDK PRNG Seed"); - let rand_bytes_unique_start = Sha256::from_engine(rand_bytes_engine).to_byte_array(); + let rand_bytes_unique_start = + Sha256::from_engine(rand_bytes_engine).to_byte_array(); let mut res = KeysManager { secp_ctx, @@ -1471,7 +1808,9 @@ impl KeysManager { } /// Derive an old [`WriteableEcdsaChannelSigner`] containing per-channel secrets based on a key derivation parameters. - pub fn derive_channel_keys(&self, channel_value_satoshis: u64, params: &[u8; 32]) -> InMemorySigner { + pub fn derive_channel_keys( + &self, channel_value_satoshis: u64, params: &[u8; 32], + ) -> InMemorySigner { let chan_id = u64::from_be_bytes(params[0..8].try_into().unwrap()); let mut unique_start = Sha256::engine(); unique_start.input(params); @@ -1480,9 +1819,14 @@ impl KeysManager { // We only seriously intend to rely on the channel_master_key for true secure // entropy, everything else just ensures uniqueness. We rely on the unique_start (ie // starting_time provided in the constructor) to be unique. - let child_privkey = self.channel_master_key.ckd_priv(&self.secp_ctx, - ChildNumber::from_hardened_idx((chan_id as u32) % (1 << 31)).expect("key space exhausted") - ).expect("Your RNG is busted"); + let child_privkey = self + .channel_master_key + .ckd_priv( + &self.secp_ctx, + ChildNumber::from_hardened_idx((chan_id as u32) % (1 << 31)) + .expect("key space exhausted"), + ) + .expect("Your RNG is busted"); unique_start.input(&child_privkey.private_key[..]); let seed = Sha256::from_engine(unique_start).to_byte_array(); @@ -1499,8 +1843,9 @@ impl KeysManager { sha.input(&seed); sha.input(&$prev_key[..]); sha.input(&$info[..]); - SecretKey::from_slice(&Sha256::from_engine(sha).to_byte_array()).expect("SHA-256 is busted") - }} + SecretKey::from_slice(&Sha256::from_engine(sha).to_byte_array()) + .expect("SHA-256 is busted") + }}; } let funding_key = key_step!(b"funding key", commitment_seed); let revocation_base_key = key_step!(b"revocation base key", funding_key); @@ -1531,48 +1876,82 @@ impl KeysManager { /// /// May panic if the [`SpendableOutputDescriptor`]s were not generated by channels which used /// this [`KeysManager`] or one of the [`InMemorySigner`] created by this [`KeysManager`]. - pub fn sign_spendable_outputs_psbt(&self, descriptors: &[&SpendableOutputDescriptor], mut psbt: PartiallySignedTransaction, secp_ctx: &Secp256k1) -> Result { + pub fn sign_spendable_outputs_psbt( + &self, descriptors: &[&SpendableOutputDescriptor], mut psbt: PartiallySignedTransaction, + secp_ctx: &Secp256k1, + ) -> Result { let mut keys_cache: Option<(InMemorySigner, [u8; 32])> = None; for outp in descriptors { + let get_input_idx = |outpoint: &OutPoint| { + psbt.unsigned_tx + .input + .iter() + .position(|i| i.previous_output == outpoint.into_bitcoin_outpoint()) + .ok_or(()) + }; match outp { SpendableOutputDescriptor::StaticPaymentOutput(descriptor) => { - let input_idx = psbt.unsigned_tx.input.iter().position(|i| i.previous_output == descriptor.outpoint.into_bitcoin_outpoint()).ok_or(())?; - if keys_cache.is_none() || keys_cache.as_ref().unwrap().1 != descriptor.channel_keys_id { - let mut signer = self.derive_channel_keys(descriptor.channel_value_satoshis, &descriptor.channel_keys_id); - if let Some(channel_params) = descriptor.channel_transaction_parameters.as_ref() { + let input_idx = get_input_idx(&descriptor.outpoint)?; + if keys_cache.is_none() + || keys_cache.as_ref().unwrap().1 != descriptor.channel_keys_id + { + let mut signer = self.derive_channel_keys( + descriptor.channel_value_satoshis, + &descriptor.channel_keys_id, + ); + if let Some(channel_params) = + descriptor.channel_transaction_parameters.as_ref() + { signer.provide_channel_parameters(channel_params); } keys_cache = Some((signer, descriptor.channel_keys_id)); } - let witness = keys_cache.as_ref().unwrap().0.sign_counterparty_payment_input(&psbt.unsigned_tx, input_idx, &descriptor, &secp_ctx)?; + let witness = keys_cache.as_ref().unwrap().0.sign_counterparty_payment_input( + &psbt.unsigned_tx, + input_idx, + &descriptor, + &secp_ctx, + )?; psbt.inputs[input_idx].final_script_witness = Some(witness); }, SpendableOutputDescriptor::DelayedPaymentOutput(descriptor) => { - let input_idx = psbt.unsigned_tx.input.iter().position(|i| i.previous_output == descriptor.outpoint.into_bitcoin_outpoint()).ok_or(())?; - if keys_cache.is_none() || keys_cache.as_ref().unwrap().1 != descriptor.channel_keys_id { + let input_idx = get_input_idx(&descriptor.outpoint)?; + if keys_cache.is_none() + || keys_cache.as_ref().unwrap().1 != descriptor.channel_keys_id + { keys_cache = Some(( - self.derive_channel_keys(descriptor.channel_value_satoshis, &descriptor.channel_keys_id), - descriptor.channel_keys_id)); + self.derive_channel_keys( + descriptor.channel_value_satoshis, + &descriptor.channel_keys_id, + ), + descriptor.channel_keys_id, + )); } - let witness = keys_cache.as_ref().unwrap().0.sign_dynamic_p2wsh_input(&psbt.unsigned_tx, input_idx, &descriptor, &secp_ctx)?; + let witness = keys_cache.as_ref().unwrap().0.sign_dynamic_p2wsh_input( + &psbt.unsigned_tx, + input_idx, + &descriptor, + &secp_ctx, + )?; psbt.inputs[input_idx].final_script_witness = Some(witness); }, SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output, .. } => { - let input_idx = psbt.unsigned_tx.input.iter().position(|i| i.previous_output == outpoint.into_bitcoin_outpoint()).ok_or(())?; - let derivation_idx = if output.script_pubkey == self.destination_script { - 1 - } else { - 2 - }; + let input_idx = get_input_idx(outpoint)?; + let derivation_idx = + if output.script_pubkey == self.destination_script { 1 } else { 2 }; let secret = { // Note that when we aren't serializing the key, network doesn't matter match ExtendedPrivKey::new_master(Network::Testnet, &self.seed) { Ok(master_key) => { - match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(derivation_idx).expect("key space exhausted")) { + match master_key.ckd_priv( + &secp_ctx, + ChildNumber::from_hardened_idx(derivation_idx) + .expect("key space exhausted"), + ) { Ok(key) => key, Err(_) => panic!("Your RNG is busted"), } - } + }, Err(_) => panic!("Your rng is busted"), } }; @@ -1580,16 +1959,31 @@ impl KeysManager { if derivation_idx == 2 { assert_eq!(pubkey.inner, self.shutdown_pubkey); } - let witness_script = bitcoin::Address::p2pkh(&pubkey, Network::Testnet).script_pubkey(); - let payment_script = bitcoin::Address::p2wpkh(&pubkey, Network::Testnet).expect("uncompressed key found").script_pubkey(); - - if payment_script != output.script_pubkey { return Err(()); }; + let witness_script = + bitcoin::Address::p2pkh(&pubkey, Network::Testnet).script_pubkey(); + let payment_script = bitcoin::Address::p2wpkh(&pubkey, Network::Testnet) + .expect("uncompressed key found") + .script_pubkey(); + + if payment_script != output.script_pubkey { + return Err(()); + }; - let sighash = hash_to_message!(&sighash::SighashCache::new(&psbt.unsigned_tx).segwit_signature_hash(input_idx, &witness_script, output.value, EcdsaSighashType::All).unwrap()[..]); + let sighash = hash_to_message!( + &sighash::SighashCache::new(&psbt.unsigned_tx) + .segwit_signature_hash( + input_idx, + &witness_script, + output.value, + EcdsaSighashType::All + ) + .unwrap()[..] + ); let sig = sign_with_aux_rand(secp_ctx, &sighash, &secret.private_key, &self); let mut sig_ser = sig.serialize_der().to_vec(); sig_ser.push(EcdsaSighashType::All as u8); - let witness = Witness::from_slice(&[&sig_ser, &pubkey.inner.serialize().to_vec()]); + let witness = + Witness::from_slice(&[&sig_ser, &pubkey.inner.serialize().to_vec()]); psbt.inputs[input_idx].final_script_witness = Some(witness); }, } @@ -1615,8 +2009,19 @@ impl KeysManager { /// /// May panic if the [`SpendableOutputDescriptor`]s were not generated by channels which used /// this [`KeysManager`] or one of the [`InMemorySigner`] created by this [`KeysManager`]. - pub fn spend_spendable_outputs(&self, descriptors: &[&SpendableOutputDescriptor], outputs: Vec, change_destination_script: ScriptBuf, feerate_sat_per_1000_weight: u32, locktime: Option, secp_ctx: &Secp256k1) -> Result { - let (mut psbt, expected_max_weight) = SpendableOutputDescriptor::create_spendable_outputs_psbt(descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime)?; + pub fn spend_spendable_outputs( + &self, descriptors: &[&SpendableOutputDescriptor], outputs: Vec, + change_destination_script: ScriptBuf, feerate_sat_per_1000_weight: u32, + locktime: Option, secp_ctx: &Secp256k1, + ) -> Result { + let (mut psbt, expected_max_weight) = + SpendableOutputDescriptor::create_spendable_outputs_psbt( + descriptors, + outputs, + change_destination_script, + feerate_sat_per_1000_weight, + locktime, + )?; psbt = self.sign_spendable_outputs_psbt(descriptors, psbt, secp_ctx)?; let spend_tx = psbt.extract_tx(); @@ -1624,7 +2029,9 @@ impl KeysManager { debug_assert!(expected_max_weight >= spend_tx.weight().to_wu()); // Note that witnesses with a signature vary somewhat in size, so allow // `expected_max_weight` to overshoot by up to 3 bytes per input. - debug_assert!(expected_max_weight <= spend_tx.weight().to_wu() + descriptors.len() as u64 * 3); + debug_assert!( + expected_max_weight <= spend_tx.weight().to_wu() + descriptors.len() as u64 * 3 + ); Ok(spend_tx) } @@ -1640,14 +2047,16 @@ impl NodeSigner for KeysManager { fn get_node_id(&self, recipient: Recipient) -> Result { match recipient { Recipient::Node => Ok(self.node_id.clone()), - Recipient::PhantomNode => Err(()) + Recipient::PhantomNode => Err(()), } } - fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result { + fn ecdh( + &self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>, + ) -> Result { let mut node_secret = match recipient { Recipient::Node => Ok(self.node_secret.clone()), - Recipient::PhantomNode => Err(()) + Recipient::PhantomNode => Err(()), }?; if let Some(tweak) = tweak { node_secret = node_secret.mul_tweak(tweak).map_err(|_| ())?; @@ -1659,17 +2068,22 @@ impl NodeSigner for KeysManager { self.inbound_payment_key.clone() } - fn sign_invoice(&self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient) -> Result { + fn sign_invoice( + &self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient, + ) -> Result { let preimage = construct_invoice_preimage(&hrp_bytes, &invoice_data); let secret = match recipient { Recipient::Node => Ok(&self.node_secret), - Recipient::PhantomNode => Err(()) + Recipient::PhantomNode => Err(()), }?; - Ok(self.secp_ctx.sign_ecdsa_recoverable(&hash_to_message!(&Sha256::hash(&preimage).to_byte_array()), secret)) + Ok(self.secp_ctx.sign_ecdsa_recoverable( + &hash_to_message!(&Sha256::hash(&preimage).to_byte_array()), + secret, + )) } fn sign_bolt12_invoice_request( - &self, invoice_request: &UnsignedInvoiceRequest + &self, invoice_request: &UnsignedInvoiceRequest, ) -> Result { let message = invoice_request.tagged_hash().as_digest(); let keys = KeyPair::from_secret_key(&self.secp_ctx, &self.node_secret); @@ -1678,7 +2092,7 @@ impl NodeSigner for KeysManager { } fn sign_bolt12_invoice( - &self, invoice: &UnsignedBolt12Invoice + &self, invoice: &UnsignedBolt12Invoice, ) -> Result { let message = invoice.tagged_hash().as_digest(); let keys = KeyPair::from_secret_key(&self.secp_ctx, &self.node_secret); @@ -1697,7 +2111,9 @@ impl SignerProvider for KeysManager { #[cfg(taproot)] type TaprootSigner = InMemorySigner; - fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, user_channel_id: u128) -> [u8; 32] { + fn generate_channel_keys_id( + &self, _inbound: bool, _channel_value_satoshis: u64, user_channel_id: u128, + ) -> [u8; 32] { let child_idx = self.channel_child_index.fetch_add(1, Ordering::AcqRel); // `child_idx` is the only thing guaranteed to make each channel unique without a restart // (though `user_channel_id` should help, depending on user behavior). If it manages to @@ -1713,7 +2129,9 @@ impl SignerProvider for KeysManager { id } - fn derive_channel_signer(&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32]) -> Self::EcdsaSigner { + fn derive_channel_signer( + &self, channel_value_satoshis: u64, channel_keys_id: [u8; 32], + ) -> Self::EcdsaSigner { self.derive_channel_keys(channel_value_satoshis, &channel_keys_id) } @@ -1772,7 +2190,9 @@ impl NodeSigner for PhantomKeysManager { } } - fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result { + fn ecdh( + &self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>, + ) -> Result { let mut node_secret = match recipient { Recipient::Node => self.inner.node_secret.clone(), Recipient::PhantomNode => self.phantom_secret.clone(), @@ -1787,23 +2207,28 @@ impl NodeSigner for PhantomKeysManager { self.inbound_payment_key.clone() } - fn sign_invoice(&self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient) -> Result { + fn sign_invoice( + &self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient, + ) -> Result { let preimage = construct_invoice_preimage(&hrp_bytes, &invoice_data); let secret = match recipient { Recipient::Node => &self.inner.node_secret, Recipient::PhantomNode => &self.phantom_secret, }; - Ok(self.inner.secp_ctx.sign_ecdsa_recoverable(&hash_to_message!(&Sha256::hash(&preimage).to_byte_array()), secret)) + Ok(self.inner.secp_ctx.sign_ecdsa_recoverable( + &hash_to_message!(&Sha256::hash(&preimage).to_byte_array()), + secret, + )) } fn sign_bolt12_invoice_request( - &self, invoice_request: &UnsignedInvoiceRequest + &self, invoice_request: &UnsignedInvoiceRequest, ) -> Result { self.inner.sign_bolt12_invoice_request(invoice_request) } fn sign_bolt12_invoice( - &self, invoice: &UnsignedBolt12Invoice + &self, invoice: &UnsignedBolt12Invoice, ) -> Result { self.inner.sign_bolt12_invoice(invoice) } @@ -1818,11 +2243,15 @@ impl SignerProvider for PhantomKeysManager { #[cfg(taproot)] type TaprootSigner = InMemorySigner; - fn generate_channel_keys_id(&self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128) -> [u8; 32] { + fn generate_channel_keys_id( + &self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128, + ) -> [u8; 32] { self.inner.generate_channel_keys_id(inbound, channel_value_satoshis, user_channel_id) } - fn derive_channel_signer(&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32]) -> Self::EcdsaSigner { + fn derive_channel_signer( + &self, channel_value_satoshis: u64, channel_keys_id: [u8; 32], + ) -> Self::EcdsaSigner { self.inner.derive_channel_signer(channel_value_satoshis, channel_keys_id) } @@ -1851,9 +2280,15 @@ impl PhantomKeysManager { /// same across restarts, or else inbound payments may fail. /// /// [phantom node payments]: PhantomKeysManager - pub fn new(seed: &[u8; 32], starting_time_secs: u64, starting_time_nanos: u32, cross_node_seed: &[u8; 32]) -> Self { + pub fn new( + seed: &[u8; 32], starting_time_secs: u64, starting_time_nanos: u32, + cross_node_seed: &[u8; 32], + ) -> Self { let inner = KeysManager::new(seed, starting_time_secs, starting_time_nanos); - let (inbound_key, phantom_key) = hkdf_extract_expand_twice(b"LDK Inbound and Phantom Payment Key Expansion", cross_node_seed); + let (inbound_key, phantom_key) = hkdf_extract_expand_twice( + b"LDK Inbound and Phantom Payment Key Expansion", + cross_node_seed, + ); let phantom_secret = SecretKey::from_slice(&phantom_key).unwrap(); let phantom_node_id = PublicKey::from_secret_key(&inner.secp_ctx, &phantom_secret); Self { @@ -1865,12 +2300,25 @@ impl PhantomKeysManager { } /// See [`KeysManager::spend_spendable_outputs`] for documentation on this method. - pub fn spend_spendable_outputs(&self, descriptors: &[&SpendableOutputDescriptor], outputs: Vec, change_destination_script: ScriptBuf, feerate_sat_per_1000_weight: u32, locktime: Option, secp_ctx: &Secp256k1) -> Result { - self.inner.spend_spendable_outputs(descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime, secp_ctx) + pub fn spend_spendable_outputs( + &self, descriptors: &[&SpendableOutputDescriptor], outputs: Vec, + change_destination_script: ScriptBuf, feerate_sat_per_1000_weight: u32, + locktime: Option, secp_ctx: &Secp256k1, + ) -> Result { + self.inner.spend_spendable_outputs( + descriptors, + outputs, + change_destination_script, + feerate_sat_per_1000_weight, + locktime, + secp_ctx, + ) } /// See [`KeysManager::derive_channel_keys`] for documentation on this method. - pub fn derive_channel_keys(&self, channel_value_satoshis: u64, params: &[u8; 32]) -> InMemorySigner { + pub fn derive_channel_keys( + &self, channel_value_satoshis: u64, params: &[u8; 32], + ) -> InMemorySigner { self.inner.derive_channel_keys(channel_value_satoshis, params) } @@ -1899,10 +2347,7 @@ pub struct RandomBytes { impl RandomBytes { /// Creates a new instance using the given seed. pub fn new(seed: [u8; 32]) -> Self { - Self { - seed, - index: AtomicCounter::new(), - } + Self { seed, index: AtomicCounter::new() } } } @@ -1923,13 +2368,13 @@ pub fn dyn_sign() { #[cfg(ldk_bench)] pub mod benches { - use std::sync::{Arc, mpsc}; + use crate::sign::{EntropySource, KeysManager}; + use bitcoin::blockdata::constants::genesis_block; + use bitcoin::Network; use std::sync::mpsc::TryRecvError; + use std::sync::{mpsc, Arc}; use std::thread; use std::time::Duration; - use bitcoin::blockdata::constants::genesis_block; - use bitcoin::Network; - use crate::sign::{EntropySource, KeysManager}; use criterion::Criterion; @@ -1943,24 +2388,23 @@ pub mod benches { for _ in 1..5 { let keys_manager_clone = Arc::clone(&keys_manager); let (stop_sender, stop_receiver) = mpsc::channel(); - let handle = thread::spawn(move || { - loop { - keys_manager_clone.get_secure_random_bytes(); - match stop_receiver.try_recv() { - Ok(_) | Err(TryRecvError::Disconnected) => { - println!("Terminating."); - break; - } - Err(TryRecvError::Empty) => {} - } + let handle = thread::spawn(move || loop { + keys_manager_clone.get_secure_random_bytes(); + match stop_receiver.try_recv() { + Ok(_) | Err(TryRecvError::Disconnected) => { + println!("Terminating."); + break; + }, + Err(TryRecvError::Empty) => {}, } }); handles.push(handle); stops.push(stop_sender); } - bench.bench_function("get_secure_random_bytes", |b| b.iter(|| - keys_manager.get_secure_random_bytes())); + bench.bench_function("get_secure_random_bytes", |b| { + b.iter(|| keys_manager.get_secure_random_bytes()) + }); for stop in stops { let _ = stop.send(()); diff --git a/lightning/src/sign/taproot.rs b/lightning/src/sign/taproot.rs index 230383f4..7536b68a 100644 --- a/lightning/src/sign/taproot.rs +++ b/lightning/src/sign/taproot.rs @@ -3,11 +3,13 @@ use alloc::vec::Vec; use bitcoin::blockdata::transaction::Transaction; use bitcoin::secp256k1; -use bitcoin::secp256k1::{PublicKey, schnorr::Signature, Secp256k1, SecretKey}; +use bitcoin::secp256k1::{schnorr::Signature, PublicKey, Secp256k1, SecretKey}; use musig2::types::{PartialSignature, PublicNonce}; -use crate::ln::chan_utils::{ClosingTransaction, CommitmentTransaction, HolderCommitmentTransaction, HTLCOutputInCommitment}; +use crate::ln::chan_utils::{ + ClosingTransaction, CommitmentTransaction, HTLCOutputInCommitment, HolderCommitmentTransaction, +}; use crate::ln::msgs::PartialSignatureWithNonce; use crate::ln::PaymentPreimage; use crate::sign::{ChannelSigner, HTLCDescriptor}; @@ -18,7 +20,9 @@ use crate::sign::{ChannelSigner, HTLCDescriptor}; pub trait TaprootChannelSigner: ChannelSigner { /// Generate a local nonce pair, which requires committing to ahead of time. /// The counterparty needs the public nonce generated herein to compute a partial signature. - fn generate_local_nonce_pair(&self, commitment_number: u64, secp_ctx: &Secp256k1) -> PublicNonce; + fn generate_local_nonce_pair( + &self, commitment_number: u64, secp_ctx: &Secp256k1, + ) -> PublicNonce; /// Create a signature for a counterparty's commitment transaction and associated HTLC transactions. /// @@ -36,8 +40,8 @@ pub trait TaprootChannelSigner: ChannelSigner { /// irrelevant or duplicate preimages. // // TODO: Document the things someone using this interface should enforce before signing. - fn partially_sign_counterparty_commitment(&self, counterparty_nonce: PublicNonce, - commitment_tx: &CommitmentTransaction, + fn partially_sign_counterparty_commitment( + &self, counterparty_nonce: PublicNonce, commitment_tx: &CommitmentTransaction, inbound_htlc_preimages: Vec, outbound_htlc_preimages: Vec, secp_ctx: &Secp256k1, ) -> Result<(PartialSignatureWithNonce, Vec), ()>; @@ -53,9 +57,10 @@ pub trait TaprootChannelSigner: ChannelSigner { /// An external signer implementation should check that the commitment has not been revoked. /// // TODO: Document the things someone using this interface should enforce before signing. - fn finalize_holder_commitment(&self, commitment_tx: &HolderCommitmentTransaction, + fn finalize_holder_commitment( + &self, commitment_tx: &HolderCommitmentTransaction, counterparty_partial_signature: PartialSignatureWithNonce, - secp_ctx: &Secp256k1 + secp_ctx: &Secp256k1, ) -> Result; /// Create a signature for the given input in a transaction spending an HTLC transaction output @@ -72,8 +77,9 @@ pub trait TaprootChannelSigner: ChannelSigner { /// 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). - fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, - per_commitment_key: &SecretKey, secp_ctx: &Secp256k1, + fn sign_justice_revoked_output( + &self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, + secp_ctx: &Secp256k1, ) -> Result; /// Create a signature for the given input in a transaction spending a commitment transaction @@ -94,9 +100,10 @@ pub trait TaprootChannelSigner: ChannelSigner { /// /// `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script /// (which is committed to in the BIP 341 signatures). - fn sign_justice_revoked_htlc(&self, justice_tx: &Transaction, input: usize, amount: u64, - per_commitment_key: &SecretKey, htlc: &HTLCOutputInCommitment, - secp_ctx: &Secp256k1) -> Result; + fn sign_justice_revoked_htlc( + &self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, + htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1, + ) -> Result; /// Computes the signature for a commitment transaction's HTLC output used as an input within /// `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned @@ -109,8 +116,9 @@ pub trait TaprootChannelSigner: ChannelSigner { /// /// [`TapSighashType::Default`]: bitcoin::sighash::TapSighashType::Default /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor - fn sign_holder_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, - htlc_descriptor: &HTLCDescriptor, secp_ctx: &Secp256k1, + fn sign_holder_htlc_transaction( + &self, htlc_tx: &Transaction, input: usize, htlc_descriptor: &HTLCDescriptor, + secp_ctx: &Secp256k1, ) -> Result; /// Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment @@ -130,16 +138,18 @@ pub trait TaprootChannelSigner: ChannelSigner { /// detected onchain. It has been generated by our counterparty and is used to derive /// channel state keys, which are then included in the witness script and committed to in the /// BIP 341 signature. - fn sign_counterparty_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, amount: u64, - per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, - secp_ctx: &Secp256k1) -> Result; + fn sign_counterparty_htlc_transaction( + &self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, + htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1, + ) -> Result; /// Create a signature for a (proposed) closing transaction. /// /// Note that, due to rounding, there may be one "missing" satoshi, and either party may have /// chosen to forgo their output as dust. - fn partially_sign_closing_transaction(&self, closing_tx: &ClosingTransaction, - secp_ctx: &Secp256k1) -> Result; + fn partially_sign_closing_transaction( + &self, closing_tx: &ClosingTransaction, secp_ctx: &Secp256k1, + ) -> Result; /// Computes the signature for a commitment transaction's anchor output used as an /// input within `anchor_tx`, which spends the commitment transaction, at index `input`. diff --git a/lightning/src/sign/type_resolver.rs b/lightning/src/sign/type_resolver.rs index 2a122da3..fad8c0ac 100644 --- a/lightning/src/sign/type_resolver.rs +++ b/lightning/src/sign/type_resolver.rs @@ -1,14 +1,20 @@ -use core::ops::Deref; use crate::sign::{ChannelSigner, SignerProvider}; +use core::ops::Deref; -pub(crate) enum ChannelSignerType where SP::Target: SignerProvider { +pub(crate) enum ChannelSignerType +where + SP::Target: SignerProvider, +{ // in practice, this will only ever be an EcdsaChannelSigner (specifically, Writeable) Ecdsa(::EcdsaSigner), #[cfg(taproot)] Taproot(::TaprootSigner), } -impl ChannelSignerType where SP::Target: SignerProvider { +impl ChannelSignerType +where + SP::Target: SignerProvider, +{ pub(crate) fn as_ref(&self) -> &dyn ChannelSigner { match self { ChannelSignerType::Ecdsa(ecs) => ecs, @@ -29,15 +35,17 @@ impl ChannelSignerType where SP::Target: SignerProvider { pub(crate) fn as_ecdsa(&self) -> Option<&::EcdsaSigner> { match self { ChannelSignerType::Ecdsa(ecs) => Some(ecs), - _ => None + _ => None, } } #[allow(unused)] - pub(crate) fn as_mut_ecdsa(&mut self) -> Option<&mut ::EcdsaSigner> { + pub(crate) fn as_mut_ecdsa( + &mut self, + ) -> Option<&mut ::EcdsaSigner> { match self { ChannelSignerType::Ecdsa(ecs) => Some(ecs), - _ => None + _ => None, } } } diff --git a/msrv-no-dev-deps-check/src/lib.rs b/msrv-no-dev-deps-check/src/lib.rs index e69de29b..8b137891 100644 --- a/msrv-no-dev-deps-check/src/lib.rs +++ b/msrv-no-dev-deps-check/src/lib.rs @@ -0,0 +1 @@ + diff --git a/rustfmt_excluded_files b/rustfmt_excluded_files index a6f59779..a6a81a0f 100644 --- a/rustfmt_excluded_files +++ b/rustfmt_excluded_files @@ -234,10 +234,6 @@ ./lightning/src/routing/scoring.rs ./lightning/src/routing/test_utils.rs ./lightning/src/routing/utxo.rs -./lightning/src/sign/ecdsa.rs -./lightning/src/sign/mod.rs -./lightning/src/sign/taproot.rs -./lightning/src/sign/type_resolver.rs ./lightning/src/sync/debug_sync.rs ./lightning/src/sync/fairrwlock.rs ./lightning/src/sync/mod.rs @@ -265,5 +261,3 @@ ./lightning/src/util/time.rs ./lightning/src/util/transaction_utils.rs ./lightning/src/util/wakers.rs -./msrv-no-dev-deps-check/src/lib.rs -./no-std-check/src/lib.rs