use bitcoin::hashes::sha256::HashEngine as Sha256State;
use bitcoin::hashes::sha256::Hash as Sha256;
use bitcoin::hashes::sha256d::Hash as Sha256dHash;
-use bitcoin::hashes::hash160::Hash as Hash160;
+use bitcoin::hash_types::WPubkeyHash;
-use secp256k1::key::{SecretKey, PublicKey};
-use secp256k1::{Secp256k1, Signature, Signing};
-use secp256k1;
+use bitcoin::secp256k1::key::{SecretKey, PublicKey};
+use bitcoin::secp256k1::{Secp256k1, Signature, Signing};
+use bitcoin::secp256k1;
use util::byte_utils;
-use util::logger::Logger;
use util::ser::{Writeable, Writer, Readable};
use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::msgs;
-use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::io::Error;
use ln::msgs::DecodeError;
/// The output which is referenced by the given outpoint
output: TxOut,
},
+ // TODO: Note that because key is now static and exactly what is provided by us, we should drop
+ // this in favor of StaticOutput:
/// An output to a P2WPKH, spendable exclusively by the given private key.
/// The witness in the spending input, is, thus, simply:
/// <BIP 143 signature generated with the given key> <public key derived from the given key>
fn funding_key<'a>(&'a self) -> &'a SecretKey;
/// Gets the local secret key for blinded revocation pubkey
fn revocation_base_key<'a>(&'a self) -> &'a SecretKey;
- /// Gets the local secret key used in to_remote output of remote commitment tx
- /// (and also as part of obscured commitment number)
- fn payment_base_key<'a>(&'a self) -> &'a SecretKey;
+ /// Gets the local secret key used in the to_remote output of remote commitment tx (ie the
+ /// output to us in transactions our counterparty broadcasts).
+ /// Also as part of obscured commitment number.
+ fn payment_key<'a>(&'a self) -> &'a SecretKey;
/// Gets the local secret key used in HTLC-Success/HTLC-Timeout txn and to_local output
fn delayed_payment_base_key<'a>(&'a self) -> &'a SecretKey;
/// Gets the local htlc secret key used in commitment tx htlc outputs
funding_key: SecretKey,
/// Local secret key for blinded revocation pubkey
revocation_base_key: SecretKey,
- /// Local secret key used in commitment tx htlc outputs
- payment_base_key: SecretKey,
+ /// Local secret key used for our balance in remote-broadcasted commitment transactions
+ payment_key: SecretKey,
/// Local secret key used in HTLC tx
delayed_payment_base_key: SecretKey,
/// Local htlc secret key used in commitment tx htlc outputs
secp_ctx: &Secp256k1<C>,
funding_key: SecretKey,
revocation_base_key: SecretKey,
- payment_base_key: SecretKey,
+ payment_key: SecretKey,
delayed_payment_base_key: SecretKey,
htlc_base_key: SecretKey,
commitment_seed: [u8; 32],
channel_value_satoshis: u64) -> InMemoryChannelKeys {
let local_channel_pubkeys =
InMemoryChannelKeys::make_local_keys(secp_ctx, &funding_key, &revocation_base_key,
- &payment_base_key, &delayed_payment_base_key,
+ &payment_key, &delayed_payment_base_key,
&htlc_base_key);
InMemoryChannelKeys {
funding_key,
revocation_base_key,
- payment_base_key,
+ payment_key,
delayed_payment_base_key,
htlc_base_key,
commitment_seed,
fn make_local_keys<C: Signing>(secp_ctx: &Secp256k1<C>,
funding_key: &SecretKey,
revocation_base_key: &SecretKey,
- payment_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: from_secret(&revocation_base_key),
- payment_basepoint: from_secret(&payment_base_key),
+ payment_point: from_secret(&payment_key),
delayed_payment_basepoint: from_secret(&delayed_payment_base_key),
htlc_basepoint: from_secret(&htlc_base_key),
}
impl ChannelKeys for InMemoryChannelKeys {
fn funding_key(&self) -> &SecretKey { &self.funding_key }
fn revocation_base_key(&self) -> &SecretKey { &self.revocation_base_key }
- fn payment_base_key(&self) -> &SecretKey { &self.payment_base_key }
+ fn payment_key(&self) -> &SecretKey { &self.payment_key }
fn delayed_payment_base_key(&self) -> &SecretKey { &self.delayed_payment_base_key }
fn htlc_base_key(&self) -> &SecretKey { &self.htlc_base_key }
fn commitment_seed(&self) -> &[u8; 32] { &self.commitment_seed }
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
self.funding_key.write(writer)?;
self.revocation_base_key.write(writer)?;
- self.payment_base_key.write(writer)?;
+ self.payment_key.write(writer)?;
self.delayed_payment_base_key.write(writer)?;
self.htlc_base_key.write(writer)?;
self.commitment_seed.write(writer)?;
fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
let funding_key = Readable::read(reader)?;
let revocation_base_key = Readable::read(reader)?;
- let payment_base_key = Readable::read(reader)?;
+ let payment_key = Readable::read(reader)?;
let delayed_payment_base_key = Readable::read(reader)?;
let htlc_base_key = Readable::read(reader)?;
let commitment_seed = Readable::read(reader)?;
let secp_ctx = Secp256k1::signing_only();
let local_channel_pubkeys =
InMemoryChannelKeys::make_local_keys(&secp_ctx, &funding_key, &revocation_base_key,
- &payment_base_key, &delayed_payment_base_key,
+ &payment_key, &delayed_payment_base_key,
&htlc_base_key);
Ok(InMemoryChannelKeys {
funding_key,
revocation_base_key,
- payment_base_key,
+ payment_key,
delayed_payment_base_key,
htlc_base_key,
commitment_seed,
channel_id_child_index: AtomicUsize,
unique_start: Sha256State,
- logger: Arc<Logger>,
}
impl KeysManager {
/// Note that until the 0.1 release there is no guarantee of backward compatibility between
/// versions. Once the library is more fully supported, the docs will be updated to include a
/// detailed description of the guarantee.
- pub fn new(seed: &[u8; 32], network: Network, logger: Arc<Logger>, starting_time_secs: u64, starting_time_nanos: u32) -> KeysManager {
+ pub fn new(seed: &[u8; 32], network: Network, starting_time_secs: u64, starting_time_nanos: u32) -> KeysManager {
let secp_ctx = Secp256k1::signing_only();
match ExtendedPrivKey::new_master(network.clone(), 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.key;
let destination_script = match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(1).unwrap()) {
Ok(destination_key) => {
- let pubkey_hash160 = Hash160::hash(&ExtendedPubKey::from_private(&secp_ctx, &destination_key).public_key.key.serialize()[..]);
+ let wpubkey_hash = WPubkeyHash::hash(&ExtendedPubKey::from_private(&secp_ctx, &destination_key).public_key.to_bytes());
Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0)
- .push_slice(&pubkey_hash160.into_inner())
+ .push_slice(&wpubkey_hash.into_inner())
.into_script()
},
Err(_) => panic!("Your RNG is busted"),
channel_id_child_index: AtomicUsize::new(0),
unique_start,
- logger,
}
},
Err(_) => panic!("Your rng is busted"),
}
let funding_key = key_step!(b"funding key", commitment_seed);
let revocation_base_key = key_step!(b"revocation base key", funding_key);
- let payment_base_key = key_step!(b"payment base key", revocation_base_key);
- let delayed_payment_base_key = key_step!(b"delayed payment base key", payment_base_key);
+ let payment_key = key_step!(b"payment key", revocation_base_key);
+ let delayed_payment_base_key = key_step!(b"delayed payment base key", payment_key);
let htlc_base_key = key_step!(b"HTLC base key", delayed_payment_base_key);
InMemoryChannelKeys::new(
&self.secp_ctx,
funding_key,
revocation_base_key,
- payment_base_key,
+ payment_key,
delayed_payment_base_key,
htlc_base_key,
commitment_seed,
projects / rust-lightning / blobdiff