use ln::chan_utils::{HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, HolderCommitmentTransaction, ChannelTransactionParameters, CommitmentTransaction};
use ln::msgs::UnsignedChannelAnnouncement;
-use std::collections::HashSet;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use prelude::*;
+use core::sync::atomic::{AtomicUsize, Ordering};
use std::io::Error;
use ln::msgs::{DecodeError, MAX_VALUE_MSAT};
pub const MAX_WITNESS_LENGTH: usize = 1 + 73 + 1 + chan_utils::REVOKEABLE_REDEEMSCRIPT_MAX_LENGTH + 1;
}
+impl_writeable_tlv_based!(DelayedPaymentOutputDescriptor, {
+ (0, outpoint, required),
+ (2, per_commitment_point, required),
+ (4, to_self_delay, required),
+ (6, output, required),
+ (8, revocation_pubkey, required),
+ (10, channel_keys_id, required),
+ (12, channel_value_satoshis, required),
+});
+
/// Information about a spendable output to our "payment key". See
/// SpendableOutputDescriptor::StaticPaymentOutput for more details on how to spend this.
#[derive(Clone, Debug, PartialEq)]
// redeemscript push length.
pub const MAX_WITNESS_LENGTH: usize = 1 + 73 + 34;
}
+impl_writeable_tlv_based!(StaticPaymentOutputDescriptor, {
+ (0, outpoint, required),
+ (2, output, required),
+ (4, channel_keys_id, required),
+ (6, channel_value_satoshis, required),
+});
/// 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
StaticPaymentOutput(StaticPaymentOutputDescriptor),
}
-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::DelayedPaymentOutput(ref descriptor) => {
- 1u8.write(writer)?;
- descriptor.outpoint.write(writer)?;
- descriptor.per_commitment_point.write(writer)?;
- descriptor.to_self_delay.write(writer)?;
- descriptor.output.write(writer)?;
- descriptor.revocation_pubkey.write(writer)?;
- descriptor.channel_keys_id.write(writer)?;
- descriptor.channel_value_satoshis.write(writer)?;
- },
- &SpendableOutputDescriptor::StaticPaymentOutput(ref descriptor) => {
- 2u8.write(writer)?;
- descriptor.outpoint.write(writer)?;
- descriptor.output.write(writer)?;
- descriptor.channel_keys_id.write(writer)?;
- descriptor.channel_value_satoshis.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::DelayedPaymentOutput(DelayedPaymentOutputDescriptor {
- outpoint: Readable::read(reader)?,
- per_commitment_point: Readable::read(reader)?,
- to_self_delay: Readable::read(reader)?,
- output: Readable::read(reader)?,
- revocation_pubkey: Readable::read(reader)?,
- channel_keys_id: Readable::read(reader)?,
- channel_value_satoshis: Readable::read(reader)?,
- })),
- 2u8 => Ok(SpendableOutputDescriptor::StaticPaymentOutput(StaticPaymentOutputDescriptor {
- outpoint: Readable::read(reader)?,
- output: Readable::read(reader)?,
- channel_keys_id: Readable::read(reader)?,
- channel_value_satoshis: Readable::read(reader)?,
- })),
- _ => Err(DecodeError::InvalidValue),
- }
- }
-}
+impl_writeable_tlv_based_enum!(SpendableOutputDescriptor,
+ (0, StaticOutput) => {
+ (0, outpoint, required),
+ (2, output, required),
+ },
+;
+ (1, DelayedPaymentOutput),
+ (2, StaticPaymentOutput),
+);
/// A trait to sign lightning channel transactions as described in BOLT 3.
///
let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_tx.feerate_per_kw(), self.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 holder_htlc_key = match chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key) {
- Ok(s) => s,
- Err(_) => return Err(()),
- };
+ let holder_htlc_key = chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key).map_err(|_| ())?;
htlc_sigs.push(secp_ctx.sign(&htlc_sighash, &holder_htlc_key));
}
}
fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
- let revocation_key = match chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key) {
- Ok(revocation_key) => revocation_key,
- Err(_) => return Err(())
- };
+ let revocation_key = chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key).map_err(|_| ())?;
let per_commitment_point = PublicKey::from_secret_key(secp_ctx, &per_commitment_key);
- let revocation_pubkey = match chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint) {
- Ok(revocation_pubkey) => revocation_pubkey,
- Err(_) => return Err(())
- };
+ let revocation_pubkey = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint).map_err(|_| ())?;
let witness_script = {
- let counterparty_delayedpubkey = match chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().delayed_payment_basepoint) {
- Ok(counterparty_delayedpubkey) => counterparty_delayedpubkey,
- Err(_) => return Err(())
- };
+ let counterparty_delayedpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().delayed_payment_basepoint).map_err(|_| ())?;
chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.holder_selected_contest_delay(), &counterparty_delayedpubkey)
};
let mut sighash_parts = bip143::SigHashCache::new(justice_tx);
}
fn sign_justice_revoked_htlc(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
- let revocation_key = match chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key) {
- Ok(revocation_key) => revocation_key,
- Err(_) => return Err(())
- };
+ let revocation_key = chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key).map_err(|_| ())?;
let per_commitment_point = PublicKey::from_secret_key(secp_ctx, &per_commitment_key);
- let revocation_pubkey = match chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint) {
- Ok(revocation_pubkey) => revocation_pubkey,
- Err(_) => return Err(())
- };
+ let revocation_pubkey = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint).map_err(|_| ())?;
let witness_script = {
- let counterparty_htlcpubkey = match chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().htlc_basepoint) {
- Ok(counterparty_htlcpubkey) => counterparty_htlcpubkey,
- Err(_) => return Err(())
- };
- let holder_htlcpubkey = match chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.pubkeys().htlc_basepoint) {
- Ok(holder_htlcpubkey) => holder_htlcpubkey,
- Err(_) => return Err(())
- };
+ let counterparty_htlcpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().htlc_basepoint).map_err(|_| ())?;
+ let holder_htlcpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.pubkeys().htlc_basepoint).map_err(|_| ())?;
chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, &counterparty_htlcpubkey, &holder_htlcpubkey, &revocation_pubkey)
};
let mut sighash_parts = bip143::SigHashCache::new(justice_tx);
}
}
+const SERIALIZATION_VERSION: u8 = 1;
+const MIN_SERIALIZATION_VERSION: u8 = 1;
+
impl Sign for InMemorySigner {}
impl Writeable for InMemorySigner {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
+ write_ver_prefix!(writer, SERIALIZATION_VERSION, MIN_SERIALIZATION_VERSION);
+
self.funding_key.write(writer)?;
self.revocation_base_key.write(writer)?;
self.payment_key.write(writer)?;
self.channel_value_satoshis.write(writer)?;
self.channel_keys_id.write(writer)?;
+ write_tlv_fields!(writer, {});
+
Ok(())
}
}
impl Readable for InMemorySigner {
fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let _ver = read_ver_prefix!(reader, SERIALIZATION_VERSION);
+
let funding_key = Readable::read(reader)?;
let revocation_base_key = Readable::read(reader)?;
let payment_key = Readable::read(reader)?;
&htlc_base_key);
let keys_id = Readable::read(reader)?;
+ read_tlv_fields!(reader, {});
+
Ok(InMemorySigner {
funding_key,
revocation_base_key,
/// onchain output detection for which a corresponding delayed_payment_key must be derived.
pub fn derive_channel_keys(&self, channel_value_satoshis: u64, params: &[u8; 32]) -> InMemorySigner {
let chan_id = byte_utils::slice_to_be64(¶ms[0..8]);
- assert!(chan_id <= std::u32::MAX as u64); // Otherwise the params field wasn't created by us
+ assert!(chan_id <= core::u32::MAX as u64); // Otherwise the params field wasn't created by us
let mut unique_start = Sha256::engine();
unique_start.input(params);
unique_start.input(&self.seed);
fn get_channel_signer(&self, _inbound: bool, channel_value_satoshis: u64) -> Self::Signer {
let child_ix = self.channel_child_index.fetch_add(1, Ordering::AcqRel);
- assert!(child_ix <= std::u32::MAX as usize);
+ assert!(child_ix <= core::u32::MAX as usize);
let mut id = [0; 32];
id[0..8].copy_from_slice(&byte_utils::be64_to_array(child_ix as u64));
id[8..16].copy_from_slice(&byte_utils::be64_to_array(self.starting_time_nanos as u64));
projects / rust-lightning / blobdiff