use bitcoin_hashes::hash160::Hash as Hash160;
use secp256k1::key::{SecretKey, PublicKey};
-use secp256k1::{Secp256k1, Signature};
+use secp256k1::{Secp256k1, Signature, Signing};
use secp256k1;
use util::byte_utils;
use util::logger::Logger;
-use util::ser::Writeable;
+use util::ser::{Writeable, Writer, Readable};
use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys};
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
-
-/// When on-chain outputs are created by rust-lightning an event is generated which informs the
-/// user thereof. This enum describes the format of the output and provides the OutPoint.
+use std::io::Error;
+use ln::msgs::DecodeError;
+
+/// When on-chain outputs are created by rust-lightning (which our counterparty is not able to
+/// claim at any point in the future) an event is generated which you must track and be able to
+/// 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)]
pub enum SpendableOutputDescriptor {
- /// Outpoint with an output to a script which was provided via KeysInterface, thus you should
- /// have stored somewhere how to spend script_pubkey!
- /// Outputs from a justice tx, claim tx or preimage tx
+ /// 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
+ /// script_pubkey as it appears in the output.
+ /// These may include outputs from a transaction punishing our counterparty or claiming an HTLC
+ /// on-chain using the payment preimage or after it has timed out.
StaticOutput {
- /// The outpoint spendable by user wallet
+ /// The outpoint which is spendable
outpoint: OutPoint,
- /// The output which is referenced by the given outpoint
+ /// The output which is referenced by the given outpoint.
output: TxOut,
},
- /// Outpoint commits to a P2WSH
- /// P2WSH should be spend by the following witness :
- /// <local_delayedsig> 0 <witnessScript>
- /// With input nSequence set to_self_delay.
- /// Outputs from a HTLC-Success/Timeout tx/commitment tx
+ /// An output to a P2WSH script which can be spent with a single signature after a CSV delay.
+ /// The private key which should be used to sign the transaction is provided, as well as the
+ /// full witness redeemScript which is hashed in the output script_pubkey.
+ /// The witness in the spending input should be:
+ /// <BIP 143 signature generated with the given key> <one zero byte aka OP_0>
+ /// <witness_script as provided>
+ /// Note that the nSequence field in the input must be set to_self_delay (which corresponds to
+ /// the transaction not being broadcastable until at least to_self_delay blocks after the input
+ /// confirms).
+ /// These are generally the result of a "revocable" output to us, spendable only by us unless
+ /// it is an output from us having broadcast an old state (which should never happen).
DynamicOutputP2WSH {
- /// Outpoint spendable by user wallet
+ /// The outpoint which is spendable
outpoint: OutPoint,
- /// local_delayedkey = delayed_payment_basepoint_secret + SHA256(per_commitment_point || delayed_payment_basepoint) OR
+ /// The secret key which must be used to sign the spending transaction
key: SecretKey,
- /// witness redeemScript encumbering output.
+ /// The witness redeemScript which is hashed to create the script_pubkey in the given output
witness_script: Script,
- /// nSequence input must commit to self_delay to satisfy script's OP_CSV
+ /// The nSequence value which must be set in the spending input to satisfy the OP_CSV in
+ /// the witness_script.
to_self_delay: u16,
/// The output which is referenced by the given outpoint
output: TxOut,
},
- /// Outpoint commits to a P2WPKH
- /// P2WPKH should be spend by the following witness :
- /// <local_sig> <local_pubkey>
- /// Outputs to_remote from a commitment tx
+ /// 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>
+ /// These are generally the result of our counterparty having broadcast the current state,
+ /// allowing us to claim the non-HTLC-encumbered outputs immediately.
DynamicOutputP2WPKH {
- /// Outpoint spendable by user wallet
+ /// The outpoint which is spendable
outpoint: OutPoint,
- /// localkey = payment_basepoint_secret + SHA256(per_commitment_point || payment_basepoint
+ /// The secret key which must be used to sign the spending transaction
key: SecretKey,
/// The output which is reference by the given outpoint
output: TxOut,
}
}
+impl Writeable for SpendableOutputDescriptor {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+ match self {
+ &SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output } => {
+ 0u8.write(writer)?;
+ outpoint.write(writer)?;
+ output.write(writer)?;
+ },
+ &SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref key, ref witness_script, ref to_self_delay, ref output } => {
+ 1u8.write(writer)?;
+ outpoint.write(writer)?;
+ key.write(writer)?;
+ witness_script.write(writer)?;
+ to_self_delay.write(writer)?;
+ output.write(writer)?;
+ },
+ &SpendableOutputDescriptor::DynamicOutputP2WPKH { ref outpoint, ref key, ref output } => {
+ 2u8.write(writer)?;
+ outpoint.write(writer)?;
+ key.write(writer)?;
+ output.write(writer)?;
+ },
+ }
+ Ok(())
+ }
+}
+
+impl Readable for SpendableOutputDescriptor {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ match Readable::read(reader)? {
+ 0u8 => Ok(SpendableOutputDescriptor::StaticOutput {
+ outpoint: Readable::read(reader)?,
+ output: Readable::read(reader)?,
+ }),
+ 1u8 => Ok(SpendableOutputDescriptor::DynamicOutputP2WSH {
+ outpoint: Readable::read(reader)?,
+ key: Readable::read(reader)?,
+ witness_script: Readable::read(reader)?,
+ to_self_delay: Readable::read(reader)?,
+ output: Readable::read(reader)?,
+ }),
+ 2u8 => Ok(SpendableOutputDescriptor::DynamicOutputP2WPKH {
+ outpoint: Readable::read(reader)?,
+ key: Readable::read(reader)?,
+ output: Readable::read(reader)?,
+ }),
+ _ => Err(DecodeError::InvalidValue),
+ }
+ }
+}
+
/// A trait to describe an object which can get user secrets and key material.
pub trait KeysInterface: Send + Sync {
/// A type which implements ChannelKeys which will be returned by get_channel_keys.
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
-pub trait ChannelKeys : Send {
+/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
+/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
+pub trait ChannelKeys : Send+Clone {
/// Gets the private key for the anchor tx
fn funding_key<'a>(&'a self) -> &'a SecretKey;
/// Gets the local secret key for blinded revocation pubkey
fn htlc_base_key<'a>(&'a self) -> &'a SecretKey;
/// Gets the commitment seed
fn commitment_seed<'a>(&'a self) -> &'a [u8; 32];
+ /// Gets the local channel public keys and basepoints
+ fn pubkeys<'a>(&'a self) -> &'a ChannelPublicKeys;
/// Create a signature for a remote commitment transaction and associated HTLC transactions.
///
///
/// 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<T: secp256k1::Signing>(&self, channel_funding_redeemscript: &Script, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;
+ fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;
/// Signs a channel announcement message with our funding key, proving it comes from one
/// of the channel participants.
/// A simple implementation of ChannelKeys that just keeps the private keys in memory.
pub struct InMemoryChannelKeys {
/// Private key of anchor tx
- pub funding_key: SecretKey,
+ funding_key: SecretKey,
/// Local secret key for blinded revocation pubkey
- pub revocation_base_key: SecretKey,
+ revocation_base_key: SecretKey,
/// Local secret key used in commitment tx htlc outputs
- pub payment_base_key: SecretKey,
+ payment_base_key: SecretKey,
/// Local secret key used in HTLC tx
- pub delayed_payment_base_key: SecretKey,
+ delayed_payment_base_key: SecretKey,
/// Local htlc secret key used in commitment tx htlc outputs
- pub htlc_base_key: SecretKey,
+ htlc_base_key: SecretKey,
/// Commitment seed
- pub commitment_seed: [u8; 32],
+ commitment_seed: [u8; 32],
+ /// Local public keys and basepoints
+ pub(crate) local_channel_pubkeys: ChannelPublicKeys,
/// Remote public keys and base points
- pub remote_channel_pubkeys: Option<ChannelPublicKeys>,
+ pub(crate) remote_channel_pubkeys: Option<ChannelPublicKeys>,
/// The total value of this channel
- pub channel_value_satoshis: u64,
+ channel_value_satoshis: u64,
+}
+
+impl InMemoryChannelKeys {
+ /// Create a new InMemoryChannelKeys
+ pub fn new<C: Signing>(
+ secp_ctx: &Secp256k1<C>,
+ funding_key: SecretKey,
+ revocation_base_key: SecretKey,
+ payment_base_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,
+ &htlc_base_key);
+ InMemoryChannelKeys {
+ funding_key,
+ revocation_base_key,
+ payment_base_key,
+ delayed_payment_base_key,
+ htlc_base_key,
+ commitment_seed,
+ channel_value_satoshis,
+ local_channel_pubkeys,
+ remote_channel_pubkeys: None,
+ }
+ }
+
+ fn make_local_keys<C: Signing>(secp_ctx: &Secp256k1<C>,
+ funding_key: &SecretKey,
+ revocation_base_key: &SecretKey,
+ payment_base_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),
+ delayed_payment_basepoint: from_secret(&delayed_payment_base_key),
+ htlc_basepoint: from_secret(&htlc_base_key),
+ }
+ }
}
impl ChannelKeys for InMemoryChannelKeys {
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 pubkeys<'a>(&'a self) -> &'a ChannelPublicKeys { &self.local_channel_pubkeys }
fn sign_remote_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, feerate_per_kw: u64, commitment_tx: &Transaction, keys: &TxCreationKeys, htlcs: &[&HTLCOutputInCommitment], to_self_delay: u16, secp_ctx: &Secp256k1<T>) -> Result<(Signature, Vec<Signature>), ()> {
if commitment_tx.input.len() != 1 { return Err(()); }
Ok((commitment_sig, htlc_sigs))
}
- fn sign_closing_transaction<T: secp256k1::Signing>(&self, channel_funding_redeemscript: &Script, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
+ fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
if closing_tx.input.len() != 1 { return Err(()); }
if closing_tx.input[0].witness.len() != 0 { return Err(()); }
if closing_tx.output.len() > 2 { return Err(()); }
+ let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
+ let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
+ let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);
+
let sighash = hash_to_message!(&bip143::SighashComponents::new(closing_tx)
.sighash_all(&closing_tx.input[0], &channel_funding_redeemscript, self.channel_value_satoshis)[..]);
Ok(secp_ctx.sign(&sighash, &self.funding_key))
}
}
-impl_writeable!(InMemoryChannelKeys, 0, {
- funding_key,
- revocation_base_key,
- payment_base_key,
- delayed_payment_base_key,
- htlc_base_key,
- commitment_seed,
- remote_channel_pubkeys,
- channel_value_satoshis
-});
+impl Writeable for InMemoryChannelKeys {
+ 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.delayed_payment_base_key.write(writer)?;
+ self.htlc_base_key.write(writer)?;
+ self.commitment_seed.write(writer)?;
+ self.remote_channel_pubkeys.write(writer)?;
+ self.channel_value_satoshis.write(writer)?;
+
+ Ok(())
+ }
+}
+
+impl Readable for InMemoryChannelKeys {
+ 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 delayed_payment_base_key = Readable::read(reader)?;
+ let htlc_base_key = Readable::read(reader)?;
+ let commitment_seed = Readable::read(reader)?;
+ let remote_channel_pubkeys = Readable::read(reader)?;
+ let channel_value_satoshis = 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,
+ &htlc_base_key);
+
+ Ok(InMemoryChannelKeys {
+ funding_key,
+ revocation_base_key,
+ payment_base_key,
+ delayed_payment_base_key,
+ htlc_base_key,
+ commitment_seed,
+ channel_value_satoshis,
+ local_channel_pubkeys,
+ remote_channel_pubkeys
+ })
+ }
+}
/// Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key
/// and derives keys from that.
let delayed_payment_base_key = key_step!(b"delayed payment base key", payment_base_key);
let htlc_base_key = key_step!(b"HTLC base key", delayed_payment_base_key);
- InMemoryChannelKeys {
+ InMemoryChannelKeys::new(
+ &self.secp_ctx,
funding_key,
revocation_base_key,
payment_base_key,
delayed_payment_base_key,
htlc_base_key,
commitment_seed,
- remote_channel_pubkeys: None,
- channel_value_satoshis,
- }
+ channel_value_satoshis
+ )
}
fn get_onion_rand(&self) -> (SecretKey, [u8; 32]) {