X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fchain%2Fkeysinterface.rs;h=5599bfbb9fd763e88c58dd475735ace5a86a0079;hb=bc4f4631ccda9045a0f3ec884109de49f3a0db12;hp=7c68256e02f69c246c018cd501440b6975c2adf7;hpb=9a23130db94246df059cd6fa2b69a40796a52e1e;p=rust-lightning diff --git a/lightning/src/chain/keysinterface.rs b/lightning/src/chain/keysinterface.rs index 7c68256e..5599bfbb 100644 --- a/lightning/src/chain/keysinterface.rs +++ b/lightning/src/chain/keysinterface.rs @@ -33,7 +33,7 @@ use util::ser::{Writeable, Writer, Readable}; use chain::transaction::OutPoint; use ln::chan_utils; -use ln::chan_utils::{HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction, PreCalculatedTxCreationKeys}; +use ln::chan_utils::{HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, HolderCommitmentTransaction, PreCalculatedTxCreationKeys}; use ln::msgs::UnsignedChannelAnnouncement; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -45,7 +45,7 @@ use ln::msgs::DecodeError; /// spend on-chain. The information needed to do this is provided in this enum, including the /// outpoint describing which txid and output index is available, the full output which exists at /// that txid/index, and any keys or other information required to sign. -#[derive(Clone, PartialEq)] +#[derive(Clone, Debug, PartialEq)] pub enum SpendableOutputDescriptor { /// An output to a script which was provided via KeysInterface, thus you should already know /// how to spend it. No keys are provided as rust-lightning was never given any keys - only the @@ -71,14 +71,14 @@ pub enum SpendableOutputDescriptor { /// it is an output from an old state which we broadcast (which should never happen). /// /// To derive the delayed_payment key which is used to sign for this input, you must pass the - /// local delayed_payment_base_key (ie the private key which corresponds to the pubkey in + /// holder delayed_payment_base_key (ie the private key which corresponds to the pubkey in /// ChannelKeys::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to /// chan_utils::derive_private_key. The public key can be generated without the secret key /// using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in /// ChannelKeys::pubkeys(). /// - /// To derive the remote_revocation_pubkey provided here (which is used in the witness - /// script generation), you must pass the remote revocation_basepoint (which appears in the + /// To derive the revocation_pubkey provided here (which is used in the witness + /// script generation), you must pass the counterparty revocation_basepoint (which appears in the /// call to ChannelKeys::on_accept) and the provided per_commitment point /// to chan_utils::derive_public_revocation_key. /// @@ -101,8 +101,8 @@ pub enum SpendableOutputDescriptor { /// The channel keys state used to proceed to derivation of signing key. Must /// be pass to KeysInterface::derive_channel_keys. key_derivation_params: (u64, u64), - /// The remote_revocation_pubkey used to derive witnessScript - remote_revocation_pubkey: PublicKey + /// The revocation_pubkey used to derive witnessScript + revocation_pubkey: PublicKey }, /// An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which /// corresponds to the public key in ChannelKeys::pubkeys().payment_point). @@ -111,7 +111,7 @@ pub enum SpendableOutputDescriptor { /// /// These are generally the result of our counterparty having broadcast the current state, /// allowing us to claim the non-HTLC-encumbered outputs immediately. - StaticOutputRemotePayment { + StaticOutputCounterpartyPayment { /// The outpoint which is spendable outpoint: OutPoint, /// The output which is reference by the given outpoint @@ -130,7 +130,7 @@ impl Writeable for SpendableOutputDescriptor { outpoint.write(writer)?; output.write(writer)?; }, - &SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref remote_revocation_pubkey } => { + &SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref revocation_pubkey } => { 1u8.write(writer)?; outpoint.write(writer)?; per_commitment_point.write(writer)?; @@ -138,9 +138,9 @@ impl Writeable for SpendableOutputDescriptor { output.write(writer)?; key_derivation_params.0.write(writer)?; key_derivation_params.1.write(writer)?; - remote_revocation_pubkey.write(writer)?; + revocation_pubkey.write(writer)?; }, - &SpendableOutputDescriptor::StaticOutputRemotePayment { ref outpoint, ref output, ref key_derivation_params } => { + &SpendableOutputDescriptor::StaticOutputCounterpartyPayment { ref outpoint, ref output, ref key_derivation_params } => { 2u8.write(writer)?; outpoint.write(writer)?; output.write(writer)?; @@ -165,9 +165,9 @@ impl Readable for SpendableOutputDescriptor { to_self_delay: Readable::read(reader)?, output: Readable::read(reader)?, key_derivation_params: (Readable::read(reader)?, Readable::read(reader)?), - remote_revocation_pubkey: Readable::read(reader)?, + revocation_pubkey: Readable::read(reader)?, }), - 2u8 => Ok(SpendableOutputDescriptor::StaticOutputRemotePayment { + 2u8 => Ok(SpendableOutputDescriptor::StaticOutputCounterpartyPayment { outpoint: Readable::read(reader)?, output: Readable::read(reader)?, key_derivation_params: (Readable::read(reader)?, Readable::read(reader)?), @@ -242,14 +242,14 @@ pub trait ChannelKeys : Send+Clone { // // TODO: Document the things someone using this interface should enforce before signing. // TODO: Add more input vars to enable better checking (preferably removing commitment_tx and - fn sign_holder_commitment(&self, holder_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1) -> Result; + fn sign_holder_commitment(&self, holder_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, holder_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1) -> Result; + fn unsafe_sign_holder_commitment(&self, holder_commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1) -> Result; /// Create a signature for each HTLC transaction spending a holder's commitment transaction. /// @@ -264,7 +264,7 @@ pub trait ChannelKeys : Send+Clone { /// (implying they were considered dust at the time the commitment transaction was negotiated), /// a corresponding None should be included in the return value. All other positions in the /// return value must contain a signature. - fn sign_holder_commitment_htlc_transactions(&self, holder_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1) -> Result>, ()>; + fn sign_holder_commitment_htlc_transactions(&self, holder_commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1) -> Result>, ()>; /// Create a signature for the given input in a transaction spending an HTLC or commitment /// transaction output when our counterparty broadcasts an old state. @@ -319,13 +319,13 @@ pub trait ChannelKeys : Send+Clone { /// protocol. fn sign_channel_announcement(&self, msg: &UnsignedChannelAnnouncement, secp_ctx: &Secp256k1) -> Result; - /// Set the counterparty channel basepoints and counterparty_selected/locally_selected_contest_delay. + /// Set the counterparty channel basepoints and counterparty_selected/holder_selected_contest_delay. /// This is done immediately on incoming channels and as soon as the channel is accepted on outgoing channels. /// - /// We bind locally_selected_contest_delay late here for API convenience. + /// We bind holder_selected_contest_delay late here for API convenience. /// /// Will be called before any signatures are applied. - fn on_accept(&mut self, channel_points: &ChannelPublicKeys, counterparty_selected_contest_delay: u16, locally_selected_contest_delay: u16); + fn on_accept(&mut self, channel_points: &ChannelPublicKeys, counterparty_selected_contest_delay: u16, holder_selected_contest_delay: u16); } /// A trait to describe an object which can get user secrets and key material. @@ -356,7 +356,7 @@ pub trait KeysInterface: Send + Sync { struct AcceptedChannelData { /// Counterparty public keys and base points counterparty_channel_pubkeys: ChannelPublicKeys, - /// The contest_delay value specified by our counterparty and applied on locally-broadcastable + /// The contest_delay value specified by our counterparty and applied on holder-broadcastable /// transactions, ie the amount of time that we have to wait to recover our funds if we /// broadcast a transaction. You'll likely want to pass this to the /// ln::chan_utils::build*_transaction functions when signing holder's transactions. @@ -364,7 +364,7 @@ struct AcceptedChannelData { /// The contest_delay value specified by us and applied on transactions broadcastable /// by our counterparty, ie the amount of time that they have to wait to recover their funds /// if they broadcast a transaction. - locally_selected_contest_delay: u16, + holder_selected_contest_delay: u16, } #[derive(Clone)] @@ -384,7 +384,7 @@ pub struct InMemoryChannelKeys { pub commitment_seed: [u8; 32], /// Holder public keys and basepoints pub(crate) holder_channel_pubkeys: ChannelPublicKeys, - /// Counterparty public keys and counterparty/locally selected_contest_delay, populated on channel acceptance + /// Counterparty public keys and counterparty/holder selected_contest_delay, populated on channel acceptance accepted_channel_data: Option, /// The total value of this channel channel_value_satoshis: u64, @@ -442,7 +442,7 @@ impl InMemoryChannelKeys { /// Will panic if on_accept wasn't called. pub fn counterparty_pubkeys(&self) -> &ChannelPublicKeys { &self.accepted_channel_data.as_ref().unwrap().counterparty_channel_pubkeys } - /// The contest_delay value specified by our counterparty and applied on locally-broadcastable + /// The contest_delay value specified by our counterparty and applied on holder-broadcastable /// transactions, ie the amount of time that we have to wait to recover our funds if we /// broadcast a transaction. You'll likely want to pass this to the /// ln::chan_utils::build*_transaction functions when signing holder's transactions. @@ -453,7 +453,7 @@ impl InMemoryChannelKeys { /// by our counterparty, ie the amount of time that they have to wait to recover their funds /// if they broadcast a transaction. /// Will panic if on_accept wasn't called. - pub fn locally_selected_contest_delay(&self) -> u16 { self.accepted_channel_data.as_ref().unwrap().locally_selected_contest_delay } + pub fn holder_selected_contest_delay(&self) -> u16 { self.accepted_channel_data.as_ref().unwrap().holder_selected_contest_delay } } impl ChannelKeys for InMemoryChannelKeys { @@ -485,7 +485,7 @@ impl ChannelKeys for InMemoryChannelKeys { let mut htlc_sigs = Vec::with_capacity(htlcs.len()); for ref htlc in htlcs { if let Some(_) = htlc.transaction_output_index { - let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, feerate_per_kw, accepted_data.locally_selected_contest_delay, htlc, &keys.broadcaster_delayed_payment_key, &keys.revocation_key); + let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, feerate_per_kw, accepted_data.holder_selected_contest_delay, htlc, &keys.broadcaster_delayed_payment_key, &keys.revocation_key); let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &keys); let htlc_sighash = hash_to_message!(&bip143::SigHashCache::new(&htlc_tx).signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, SigHashType::All)[..]); let our_htlc_key = match chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key) { @@ -499,24 +499,24 @@ impl ChannelKeys for InMemoryChannelKeys { Ok((commitment_sig, htlc_sigs)) } - fn sign_holder_commitment(&self, holder_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1) -> Result { + fn sign_holder_commitment(&self, holder_commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1) -> Result { let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key); let counterparty_channel_data = self.accepted_channel_data.as_ref().expect("must accept before signing"); let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &counterparty_channel_data.counterparty_channel_pubkeys.funding_pubkey); - Ok(holder_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx)) + Ok(holder_commitment_tx.get_holder_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx)) } #[cfg(any(test,feature = "unsafe_revoked_tx_signing"))] - fn unsafe_sign_holder_commitment(&self, holder_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1) -> Result { + fn unsafe_sign_holder_commitment(&self, holder_commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1) -> Result { let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key); let counterparty_channel_pubkeys = &self.accepted_channel_data.as_ref().expect("must accept before signing").counterparty_channel_pubkeys; let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &counterparty_channel_pubkeys.funding_pubkey); - Ok(holder_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx)) + Ok(holder_commitment_tx.get_holder_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx)) } - fn sign_holder_commitment_htlc_transactions(&self, holder_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1) -> Result>, ()> { + fn sign_holder_commitment_htlc_transactions(&self, holder_commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1) -> Result>, ()> { let counterparty_selected_contest_delay = self.accepted_channel_data.as_ref().unwrap().counterparty_selected_contest_delay; holder_commitment_tx.get_htlc_sigs(&self.htlc_base_key, counterparty_selected_contest_delay, secp_ctx) } @@ -546,7 +546,7 @@ impl ChannelKeys for InMemoryChannelKeys { Ok(counterparty_delayedpubkey) => counterparty_delayedpubkey, Err(_) => return Err(()) }; - chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.locally_selected_contest_delay(), &counterparty_delayedpubkey) + chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.holder_selected_contest_delay(), &counterparty_delayedpubkey) }; let mut sighash_parts = bip143::SigHashCache::new(justice_tx); let sighash = hash_to_message!(&sighash_parts.signature_hash(input, &witness_script, amount, SigHashType::All)[..]); @@ -588,18 +588,18 @@ impl ChannelKeys for InMemoryChannelKeys { Ok(secp_ctx.sign(&msghash, &self.funding_key)) } - fn on_accept(&mut self, channel_pubkeys: &ChannelPublicKeys, counterparty_selected_contest_delay: u16, locally_selected_contest_delay: u16) { + fn on_accept(&mut self, channel_pubkeys: &ChannelPublicKeys, counterparty_selected_contest_delay: u16, holder_selected_contest_delay: u16) { assert!(self.accepted_channel_data.is_none(), "Already accepted"); self.accepted_channel_data = Some(AcceptedChannelData { counterparty_channel_pubkeys: channel_pubkeys.clone(), counterparty_selected_contest_delay, - locally_selected_contest_delay, + holder_selected_contest_delay, }); } } impl_writeable!(AcceptedChannelData, 0, - { counterparty_channel_pubkeys, counterparty_selected_contest_delay, locally_selected_contest_delay }); + { counterparty_channel_pubkeys, counterparty_selected_contest_delay, holder_selected_contest_delay }); impl Writeable for InMemoryChannelKeys { fn write(&self, writer: &mut W) -> Result<(), Error> {