X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannelmonitor.rs;h=fb965434514230a6ce094f4d4e75d778bff775f1;hb=74cec623fd1d6a505f41cdb8cc6479e6f6fae8ab;hp=f3c5c89f6e67cbc1c0e175b75439729385212d33;hpb=b2a855b57ace202243a3fd410b94e1e09f22a502;p=rust-lightning diff --git a/src/ln/channelmonitor.rs b/src/ln/channelmonitor.rs index f3c5c89f..fb965434 100644 --- a/src/ln/channelmonitor.rs +++ b/src/ln/channelmonitor.rs @@ -30,15 +30,18 @@ use ln::chan_utils; use ln::chan_utils::HTLCOutputInCommitment; use chain::chaininterface::{ChainListener, ChainWatchInterface, BroadcasterInterface}; use chain::transaction::OutPoint; -use util::ser::{Readable, Writer}; +use chain::keysinterface::SpendableOutputDescriptor; +use util::logger::Logger; +use util::ser::{ReadableArgs, Writer}; use util::sha2::Sha256; -use util::byte_utils; +use util::{byte_utils, events}; use std::collections::HashMap; use std::sync::{Arc,Mutex}; -use std::{hash,cmp}; +use std::{hash,cmp, mem}; /// An error enum representing a failure to persist a channel monitor update. +#[derive(Clone)] pub enum ChannelMonitorUpdateErr { /// Used to indicate a temporary failure (eg connection to a watchtower failed, but is expected /// to succeed at some point in the future). @@ -47,6 +50,22 @@ pub enum ChannelMonitorUpdateErr { /// submitting new commitment transactions to the remote party. /// ChannelManager::test_restore_channel_monitor can be used to retry the update(s) and restore /// the channel to an operational state. + /// + /// Note that continuing to operate when no copy of the updated ChannelMonitor could be + /// persisted is unsafe - if you failed to store the update on your own local disk you should + /// instead return PermanentFailure to force closure of the channel ASAP. + /// + /// Even when a channel has been "frozen" updates to the ChannelMonitor can continue to occur + /// (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting + /// to claim it on this channel) and those updates must be applied wherever they can be. At + /// least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should + /// be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to + /// the channel which would invalidate previous ChannelMonitors are not made when a channel has + /// been "frozen". + /// + /// Note that even if updates made after TemporaryFailure succeed you must still call + /// test_restore_channel_monitor to ensure you have the latest monitor and re-enable normal + /// channel operation. TemporaryFailure, /// Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a /// different watchtower and cannot update with all watchtowers that were previously informed @@ -89,20 +108,31 @@ pub struct SimpleManyChannelMonitor { #[cfg(not(test))] monitors: Mutex>, chain_monitor: Arc, - broadcaster: Arc + broadcaster: Arc, + pending_events: Mutex>, } impl ChainListener for SimpleManyChannelMonitor { fn block_connected(&self, _header: &BlockHeader, height: u32, txn_matched: &[&Transaction], _indexes_of_txn_matched: &[u32]) { - let monitors = self.monitors.lock().unwrap(); - for monitor in monitors.values() { - let txn_outputs = monitor.block_connected(txn_matched, height, &*self.broadcaster); - for (ref txid, ref outputs) in txn_outputs { - for (idx, output) in outputs.iter().enumerate() { - self.chain_monitor.install_watch_outpoint((txid.clone(), idx as u32), &output.script_pubkey); + let mut new_events: Vec = Vec::with_capacity(0); + { + let monitors = self.monitors.lock().unwrap(); + for monitor in monitors.values() { + let (txn_outputs, spendable_outputs) = monitor.block_connected(txn_matched, height, &*self.broadcaster); + if spendable_outputs.len() > 0 { + new_events.push(events::Event::SpendableOutputs { + outputs: spendable_outputs, + }); + } + for (ref txid, ref outputs) in txn_outputs { + for (idx, output) in outputs.iter().enumerate() { + self.chain_monitor.install_watch_outpoint((txid.clone(), idx as u32), &output.script_pubkey); + } } } } + let mut pending_events = self.pending_events.lock().unwrap(); + pending_events.append(&mut new_events); } fn block_disconnected(&self, _: &BlockHeader) { } @@ -115,7 +145,8 @@ impl SimpleManyChannelMonitor let res = Arc::new(SimpleManyChannelMonitor { monitors: Mutex::new(HashMap::new()), chain_monitor, - broadcaster + broadcaster, + pending_events: Mutex::new(Vec::new()), }); let weak_res = Arc::downgrade(&res); res.chain_monitor.register_listener(weak_res); @@ -150,18 +181,36 @@ impl ManyChannelMonitor for SimpleManyChannelMonitor { } } +impl events::EventsProvider for SimpleManyChannelMonitor { + fn get_and_clear_pending_events(&self) -> Vec { + let mut pending_events = self.pending_events.lock().unwrap(); + let mut ret = Vec::new(); + mem::swap(&mut ret, &mut *pending_events); + ret + } +} + /// If an HTLC expires within this many blocks, don't try to claim it in a shared transaction, /// instead claiming it in its own individual transaction. const CLTV_SHARED_CLAIM_BUFFER: u32 = 12; /// If an HTLC expires within this many blocks, force-close the channel to broadcast the /// HTLC-Success transaction. -const CLTV_CLAIM_BUFFER: u32 = 6; +/// In other words, this is an upper bound on how many blocks we think it can take us to get a +/// transaction confirmed (and we use it in a few more, equivalent, places). +pub(crate) const CLTV_CLAIM_BUFFER: u32 = 6; +/// Number of blocks by which point we expect our counterparty to have seen new blocks on the +/// network and done a full update_fail_htlc/commitment_signed dance (+ we've updated all our +/// copies of ChannelMonitors, including watchtowers). +pub(crate) const HTLC_FAIL_TIMEOUT_BLOCKS: u32 = 3; #[derive(Clone, PartialEq)] enum KeyStorage { PrivMode { revocation_base_key: SecretKey, htlc_base_key: SecretKey, + delayed_payment_base_key: SecretKey, + prev_latest_per_commitment_point: Option, + latest_per_commitment_point: Option, }, SigsMode { revocation_base_key: PublicKey, @@ -196,7 +245,6 @@ pub struct ChannelMonitor { commitment_transaction_number_obscure_factor: u64, key_storage: KeyStorage, - delayed_payment_base_key: PublicKey, their_htlc_base_key: Option, their_delayed_payment_base_key: Option, // first is the idx of the first of the two revocation points @@ -229,7 +277,9 @@ pub struct ChannelMonitor { payment_preimages: HashMap<[u8; 32], [u8; 32]>, destination_script: Script, + secp_ctx: Secp256k1, //TODO: dedup this a bit... + logger: Arc, } impl Clone for ChannelMonitor { fn clone(&self) -> Self { @@ -238,7 +288,6 @@ impl Clone for ChannelMonitor { commitment_transaction_number_obscure_factor: self.commitment_transaction_number_obscure_factor.clone(), key_storage: self.key_storage.clone(), - delayed_payment_base_key: self.delayed_payment_base_key.clone(), their_htlc_base_key: self.their_htlc_base_key.clone(), their_delayed_payment_base_key: self.their_delayed_payment_base_key.clone(), their_cur_revocation_points: self.their_cur_revocation_points.clone(), @@ -258,6 +307,7 @@ impl Clone for ChannelMonitor { destination_script: self.destination_script.clone(), secp_ctx: self.secp_ctx.clone(), + logger: self.logger.clone(), } } } @@ -270,7 +320,6 @@ impl PartialEq for ChannelMonitor { if self.funding_txo != other.funding_txo || self.commitment_transaction_number_obscure_factor != other.commitment_transaction_number_obscure_factor || self.key_storage != other.key_storage || - self.delayed_payment_base_key != other.delayed_payment_base_key || self.their_htlc_base_key != other.their_htlc_base_key || self.their_delayed_payment_base_key != other.their_delayed_payment_base_key || self.their_cur_revocation_points != other.their_cur_revocation_points || @@ -298,7 +347,7 @@ impl PartialEq for ChannelMonitor { } impl ChannelMonitor { - pub(super) fn new(revocation_base_key: &SecretKey, delayed_payment_base_key: &PublicKey, htlc_base_key: &SecretKey, our_to_self_delay: u16, destination_script: Script) -> ChannelMonitor { + pub(super) fn new(revocation_base_key: &SecretKey, delayed_payment_base_key: &SecretKey, htlc_base_key: &SecretKey, our_to_self_delay: u16, destination_script: Script, logger: Arc) -> ChannelMonitor { ChannelMonitor { funding_txo: None, commitment_transaction_number_obscure_factor: 0, @@ -306,8 +355,10 @@ impl ChannelMonitor { key_storage: KeyStorage::PrivMode { revocation_base_key: revocation_base_key.clone(), htlc_base_key: htlc_base_key.clone(), + delayed_payment_base_key: delayed_payment_base_key.clone(), + prev_latest_per_commitment_point: None, + latest_per_commitment_point: None, }, - delayed_payment_base_key: delayed_payment_base_key.clone(), their_htlc_base_key: None, their_delayed_payment_base_key: None, their_cur_revocation_points: None, @@ -324,9 +375,10 @@ impl ChannelMonitor { current_local_signed_commitment_tx: None, payment_preimages: HashMap::new(), - destination_script: destination_script, + secp_ctx: Secp256k1::new(), + logger, } } @@ -446,6 +498,8 @@ impl ChannelMonitor { /// is important that any clones of this channel monitor (including remote clones) by kept /// up-to-date as our local commitment transaction is updated. /// Panics if set_their_to_self_delay has never been called. + /// Also update KeyStorage with latest local per_commitment_point to derive local_delayedkey in + /// case of onchain HTLC tx pub(super) fn provide_latest_local_commitment_tx_info(&mut self, signed_commitment_tx: Transaction, local_keys: chan_utils::TxCreationKeys, feerate_per_kw: u64, htlc_outputs: Vec<(HTLCOutputInCommitment, Signature, Signature)>) { assert!(self.their_to_self_delay.is_some()); self.prev_local_signed_commitment_tx = self.current_local_signed_commitment_tx.take(); @@ -459,6 +513,15 @@ impl ChannelMonitor { feerate_per_kw, htlc_outputs, }); + self.key_storage = if let KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, prev_latest_per_commitment_point: _, ref latest_per_commitment_point } = self.key_storage { + KeyStorage::PrivMode { + revocation_base_key: *revocation_base_key, + htlc_base_key: *htlc_base_key, + delayed_payment_base_key: *delayed_payment_base_key, + prev_latest_per_commitment_point: *latest_per_commitment_point, + latest_per_commitment_point: Some(local_keys.per_commitment_point), + } + } else { unimplemented!(); }; } /// Provides a payment_hash->payment_preimage mapping. Will be automatically pruned when all @@ -564,15 +627,28 @@ impl ChannelMonitor { writer.write_all(&byte_utils::be48_to_array(self.commitment_transaction_number_obscure_factor))?; match self.key_storage { - KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key } => { + KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref prev_latest_per_commitment_point, ref latest_per_commitment_point } => { writer.write_all(&[0; 1])?; writer.write_all(&revocation_base_key[..])?; writer.write_all(&htlc_base_key[..])?; + writer.write_all(&delayed_payment_base_key[..])?; + if let Some(ref prev_latest_per_commitment_point) = *prev_latest_per_commitment_point { + writer.write_all(&[1; 1])?; + writer.write_all(&prev_latest_per_commitment_point.serialize())?; + } else { + writer.write_all(&[0; 1])?; + } + if let Some(ref latest_per_commitment_point) = *latest_per_commitment_point { + writer.write_all(&[1; 1])?; + writer.write_all(&latest_per_commitment_point.serialize())?; + } else { + writer.write_all(&[0; 1])?; + } + }, KeyStorage::SigsMode { .. } => unimplemented!(), } - writer.write_all(&self.delayed_payment_base_key.serialize())?; writer.write_all(&self.their_htlc_base_key.as_ref().unwrap().serialize())?; writer.write_all(&self.their_delayed_payment_base_key.as_ref().unwrap().serialize())?; @@ -725,11 +801,12 @@ impl ChannelMonitor { /// data in remote_claimable_outpoints. Will directly claim any HTLC outputs which expire at a /// height > height + CLTV_SHARED_CLAIM_BUFFER. In any case, will install monitoring for /// HTLC-Success/HTLC-Timeout transactions. - fn check_spend_remote_transaction(&self, tx: &Transaction, height: u32) -> (Vec, (Sha256dHash, Vec)) { + fn check_spend_remote_transaction(&self, tx: &Transaction, height: u32) -> (Vec, (Sha256dHash, Vec), Vec) { // Most secp and related errors trying to create keys means we have no hope of constructing // a spend transaction...so we return no transactions to broadcast let mut txn_to_broadcast = Vec::new(); let mut watch_outputs = Vec::new(); + let mut spendable_outputs = Vec::new(); let commitment_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers! let per_commitment_option = self.remote_claimable_outpoints.get(&commitment_txid); @@ -738,7 +815,7 @@ impl ChannelMonitor { ( $thing : expr ) => { match $thing { Ok(a) => a, - Err(_) => return (txn_to_broadcast, (commitment_txid, watch_outputs)) + Err(_) => return (txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs) } }; } @@ -748,7 +825,7 @@ impl ChannelMonitor { let secret = self.get_secret(commitment_number).unwrap(); let per_commitment_key = ignore_error!(SecretKey::from_slice(&self.secp_ctx, &secret)); let (revocation_pubkey, b_htlc_key) = match self.key_storage { - KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key } => { + KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key, .. } => { let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key); (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key))), ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key)))) @@ -759,9 +836,9 @@ impl ChannelMonitor { ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &htlc_base_key))) }, }; - let delayed_key = ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &self.delayed_payment_base_key)); + let delayed_key = ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &self.their_delayed_payment_base_key.unwrap())); let a_htlc_key = match self.their_htlc_base_key { - None => return (txn_to_broadcast, (commitment_txid, watch_outputs)), + None => return (txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs), Some(their_htlc_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &their_htlc_base_key)), }; @@ -828,7 +905,7 @@ impl ChannelMonitor { if htlc.transaction_output_index as usize >= tx.output.len() || tx.output[htlc.transaction_output_index as usize].value != htlc.amount_msat / 1000 || tx.output[htlc.transaction_output_index as usize].script_pubkey != expected_script.to_v0_p2wsh() { - return (txn_to_broadcast, (commitment_txid, watch_outputs)); // Corrupted per_commitment_data, fuck this user + return (txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs); // Corrupted per_commitment_data, fuck this user } let input = TxIn { previous_output: BitcoinOutPoint { @@ -856,7 +933,7 @@ impl ChannelMonitor { }; let sighash_parts = bip143::SighashComponents::new(&single_htlc_tx); sign_input!(sighash_parts, single_htlc_tx.input[0], Some(idx), htlc.amount_msat / 1000); - txn_to_broadcast.push(single_htlc_tx); // TODO: This is not yet tested in ChannelManager! + txn_to_broadcast.push(single_htlc_tx); } } } @@ -866,7 +943,7 @@ impl ChannelMonitor { watch_outputs.append(&mut tx.output.clone()); self.remote_commitment_txn_on_chain.lock().unwrap().insert(commitment_txid, commitment_number); } - if inputs.is_empty() { return (txn_to_broadcast, (commitment_txid, watch_outputs)); } // Nothing to be done...probably a false positive/local tx + if inputs.is_empty() { return (txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs); } // Nothing to be done...probably a false positive/local tx let outputs = vec!(TxOut { script_pubkey: self.destination_script.clone(), @@ -887,6 +964,10 @@ impl ChannelMonitor { sign_input!(sighash_parts, input, htlc_idx, value); } + spendable_outputs.push(SpendableOutputDescriptor::StaticOutput { + outpoint: BitcoinOutPoint { txid: spend_tx.txid(), vout: 0 }, + output: spend_tx.output[0].clone(), + }); txn_to_broadcast.push(spend_tx); } else if let Some(per_commitment_data) = per_commitment_option { // While this isn't useful yet, there is a potential race where if a counterparty @@ -907,7 +988,7 @@ impl ChannelMonitor { } else { None }; if let Some(revocation_point) = revocation_point_option { let (revocation_pubkey, b_htlc_key) = match self.key_storage { - KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key } => { + KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key, .. } => { (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, revocation_point, &PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key))), ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, revocation_point, &PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key)))) }, @@ -917,7 +998,7 @@ impl ChannelMonitor { }, }; let a_htlc_key = match self.their_htlc_base_key { - None => return (txn_to_broadcast, (commitment_txid, watch_outputs)), + None => return (txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs), Some(their_htlc_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, revocation_point, &their_htlc_base_key)), }; @@ -975,12 +1056,16 @@ impl ChannelMonitor { }; let sighash_parts = bip143::SighashComponents::new(&single_htlc_tx); sign_input!(sighash_parts, single_htlc_tx.input[0], htlc.amount_msat / 1000, payment_preimage.to_vec()); + spendable_outputs.push(SpendableOutputDescriptor::StaticOutput { + outpoint: BitcoinOutPoint { txid: single_htlc_tx.txid(), vout: 0 }, + output: single_htlc_tx.output[0].clone(), + }); txn_to_broadcast.push(single_htlc_tx); } } } - if inputs.is_empty() { return (txn_to_broadcast, (commitment_txid, watch_outputs)); } // Nothing to be done...probably a false positive/local tx + if inputs.is_empty() { return (txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs); } // Nothing to be done...probably a false positive/local tx let outputs = vec!(TxOut { script_pubkey: self.destination_script.clone(), @@ -1001,23 +1086,29 @@ impl ChannelMonitor { sign_input!(sighash_parts, input, value.0, value.1.to_vec()); } + spendable_outputs.push(SpendableOutputDescriptor::StaticOutput { + outpoint: BitcoinOutPoint { txid: spend_tx.txid(), vout: 0 }, + output: spend_tx.output[0].clone(), + }); txn_to_broadcast.push(spend_tx); } } } - (txn_to_broadcast, (commitment_txid, watch_outputs)) + (txn_to_broadcast, (commitment_txid, watch_outputs), spendable_outputs) } /// Attempst to claim a remote HTLC-Success/HTLC-Timeout s outputs using the revocation key - fn check_spend_remote_htlc(&self, tx: &Transaction, commitment_number: u64) -> Option { - let htlc_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers! + fn check_spend_remote_htlc(&self, tx: &Transaction, commitment_number: u64) -> (Option, Option) { + if tx.input.len() != 1 || tx.output.len() != 1 { + return (None, None) + } macro_rules! ignore_error { ( $thing : expr ) => { match $thing { Ok(a) => a, - Err(_) => return None + Err(_) => return (None, None) } }; } @@ -1034,11 +1125,12 @@ impl ChannelMonitor { }, }; let delayed_key = match self.their_delayed_payment_base_key { - None => return None, + None => return (None, None), Some(their_delayed_payment_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &their_delayed_payment_base_key)), }; let redeemscript = chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.their_to_self_delay.unwrap(), &delayed_key); let revokeable_p2wsh = redeemscript.to_v0_p2wsh(); + let htlc_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers! let mut inputs = Vec::new(); let mut amount = 0; @@ -1086,12 +1178,15 @@ impl ChannelMonitor { spend_tx.input[0].witness.push(vec!(1)); spend_tx.input[0].witness.push(redeemscript.into_bytes()); - Some(spend_tx) - } else { None } + let outpoint = BitcoinOutPoint { txid: spend_tx.txid(), vout: 0 }; + let output = spend_tx.output[0].clone(); + (Some(spend_tx), Some(SpendableOutputDescriptor::StaticOutput { outpoint, output })) + } else { (None, None) } } - fn broadcast_by_local_state(&self, local_tx: &LocalSignedTx) -> Vec { + fn broadcast_by_local_state(&self, local_tx: &LocalSignedTx, per_commitment_point: &Option, delayed_payment_base_key: &Option) -> (Vec, Vec) { let mut res = Vec::with_capacity(local_tx.htlc_outputs.len()); + let mut spendable_outputs = Vec::with_capacity(local_tx.htlc_outputs.len()); for &(ref htlc, ref their_sig, ref our_sig) in local_tx.htlc_outputs.iter() { if htlc.offered { @@ -1107,6 +1202,18 @@ impl ChannelMonitor { htlc_timeout_tx.input[0].witness.push(Vec::new()); htlc_timeout_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_bytes()); + if let Some(ref per_commitment_point) = *per_commitment_point { + if let Some(ref delayed_payment_base_key) = *delayed_payment_base_key { + if let Ok(local_delayedkey) = chan_utils::derive_private_key(&self.secp_ctx, per_commitment_point, delayed_payment_base_key) { + spendable_outputs.push(SpendableOutputDescriptor::DynamicOutput { + outpoint: BitcoinOutPoint { txid: htlc_timeout_tx.txid(), vout: 0 }, + local_delayedkey, + witness_script: chan_utils::get_revokeable_redeemscript(&local_tx.revocation_key, self.our_to_self_delay, &local_tx.delayed_payment_key), + to_self_delay: self.our_to_self_delay + }); + } + } + } res.push(htlc_timeout_tx); } else { if let Some(payment_preimage) = self.payment_preimages.get(&htlc.payment_hash) { @@ -1122,34 +1229,61 @@ impl ChannelMonitor { htlc_success_tx.input[0].witness.push(payment_preimage.to_vec()); htlc_success_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_bytes()); + if let Some(ref per_commitment_point) = *per_commitment_point { + if let Some(ref delayed_payment_base_key) = *delayed_payment_base_key { + if let Ok(local_delayedkey) = chan_utils::derive_private_key(&self.secp_ctx, per_commitment_point, delayed_payment_base_key) { + spendable_outputs.push(SpendableOutputDescriptor::DynamicOutput { + outpoint: BitcoinOutPoint { txid: htlc_success_tx.txid(), vout: 0 }, + local_delayedkey, + witness_script: chan_utils::get_revokeable_redeemscript(&local_tx.revocation_key, self.our_to_self_delay, &local_tx.delayed_payment_key), + to_self_delay: self.our_to_self_delay + }); + } + } + } res.push(htlc_success_tx); } } } - res + (res, spendable_outputs) } /// Attempts to claim any claimable HTLCs in a commitment transaction which was not (yet) /// revoked using data in local_claimable_outpoints. /// Should not be used if check_spend_revoked_transaction succeeds. - fn check_spend_local_transaction(&self, tx: &Transaction, _height: u32) -> Vec { + fn check_spend_local_transaction(&self, tx: &Transaction, _height: u32) -> (Vec, Vec) { let commitment_txid = tx.txid(); if let &Some(ref local_tx) = &self.current_local_signed_commitment_tx { if local_tx.txid == commitment_txid { - return self.broadcast_by_local_state(local_tx); + match self.key_storage { + KeyStorage::PrivMode { revocation_base_key: _, htlc_base_key: _, ref delayed_payment_base_key, prev_latest_per_commitment_point: _, ref latest_per_commitment_point } => { + return self.broadcast_by_local_state(local_tx, latest_per_commitment_point, &Some(*delayed_payment_base_key)); + }, + KeyStorage::SigsMode { .. } => { + return self.broadcast_by_local_state(local_tx, &None, &None); + } + } } } if let &Some(ref local_tx) = &self.prev_local_signed_commitment_tx { if local_tx.txid == commitment_txid { - return self.broadcast_by_local_state(local_tx); + match self.key_storage { + KeyStorage::PrivMode { revocation_base_key: _, htlc_base_key: _, ref delayed_payment_base_key, ref prev_latest_per_commitment_point, .. } => { + return self.broadcast_by_local_state(local_tx, prev_latest_per_commitment_point, &Some(*delayed_payment_base_key)); + }, + KeyStorage::SigsMode { .. } => { + return self.broadcast_by_local_state(local_tx, &None, &None); + } + } } } - Vec::new() + (Vec::new(), Vec::new()) } - fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface)-> Vec<(Sha256dHash, Vec)> { + fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface)-> (Vec<(Sha256dHash, Vec)>, Vec) { let mut watch_outputs = Vec::new(); + let mut spendable_outputs = Vec::new(); for tx in txn_matched { if tx.input.len() == 1 { // Assuming our keys were not leaked (in which case we're screwed no matter what), @@ -1159,20 +1293,27 @@ impl ChannelMonitor { let prevout = &tx.input[0].previous_output; let mut txn: Vec = Vec::new(); if self.funding_txo.is_none() || (prevout.txid == self.funding_txo.as_ref().unwrap().0.txid && prevout.vout == self.funding_txo.as_ref().unwrap().0.index as u32) { - let (remote_txn, new_outputs) = self.check_spend_remote_transaction(tx, height); + let (remote_txn, new_outputs, mut spendable_output) = self.check_spend_remote_transaction(tx, height); txn = remote_txn; + spendable_outputs.append(&mut spendable_output); if !new_outputs.1.is_empty() { watch_outputs.push(new_outputs); } if txn.is_empty() { - txn = self.check_spend_local_transaction(tx, height); + let (remote_txn, mut outputs) = self.check_spend_local_transaction(tx, height); + spendable_outputs.append(&mut outputs); + txn = remote_txn; } } else { let remote_commitment_txn_on_chain = self.remote_commitment_txn_on_chain.lock().unwrap(); if let Some(commitment_number) = remote_commitment_txn_on_chain.get(&prevout.txid) { - if let Some(tx) = self.check_spend_remote_htlc(tx, *commitment_number) { + let (tx, spendable_output) = self.check_spend_remote_htlc(tx, *commitment_number); + if let Some(tx) = tx { txn.push(tx); } + if let Some(spendable_output) = spendable_output { + spendable_outputs.push(spendable_output); + } } } for tx in txn.iter() { @@ -1181,32 +1322,55 @@ impl ChannelMonitor { } } if let Some(ref cur_local_tx) = self.current_local_signed_commitment_tx { - let mut needs_broadcast = false; - for &(ref htlc, _, _) in cur_local_tx.htlc_outputs.iter() { - if htlc.cltv_expiry <= height + CLTV_CLAIM_BUFFER { - if htlc.offered || self.payment_preimages.contains_key(&htlc.payment_hash) { - needs_broadcast = true; - } - } - } - - if needs_broadcast { + if self.would_broadcast_at_height(height) { broadcaster.broadcast_transaction(&cur_local_tx.tx); - for tx in self.broadcast_by_local_state(&cur_local_tx) { - broadcaster.broadcast_transaction(&tx); + match self.key_storage { + KeyStorage::PrivMode { revocation_base_key: _, htlc_base_key: _, ref delayed_payment_base_key, prev_latest_per_commitment_point: _, ref latest_per_commitment_point } => { + let (txs, mut outputs) = self.broadcast_by_local_state(&cur_local_tx, latest_per_commitment_point, &Some(*delayed_payment_base_key)); + spendable_outputs.append(&mut outputs); + for tx in txs { + broadcaster.broadcast_transaction(&tx); + } + }, + KeyStorage::SigsMode { .. } => { + let (txs, mut outputs) = self.broadcast_by_local_state(&cur_local_tx, &None, &None); + spendable_outputs.append(&mut outputs); + for tx in txs { + broadcaster.broadcast_transaction(&tx); + } + } } } } - watch_outputs + (watch_outputs, spendable_outputs) } pub(super) fn would_broadcast_at_height(&self, height: u32) -> bool { if let Some(ref cur_local_tx) = self.current_local_signed_commitment_tx { for &(ref htlc, _, _) in cur_local_tx.htlc_outputs.iter() { - if htlc.cltv_expiry <= height + CLTV_CLAIM_BUFFER { - if htlc.offered || self.payment_preimages.contains_key(&htlc.payment_hash) { - return true; - } + // For inbound HTLCs which we know the preimage for, we have to ensure we hit the + // chain with enough room to claim the HTLC without our counterparty being able to + // time out the HTLC first. + // For outbound HTLCs which our counterparty hasn't failed/claimed, our primary + // concern is being able to claim the corresponding inbound HTLC (on another + // channel) before it expires. In fact, we don't even really care if our + // counterparty here claims such an outbound HTLC after it expired as long as we + // can still claim the corresponding HTLC. Thus, to avoid needlessly hitting the + // chain when our counterparty is waiting for expiration to off-chain fail an HTLC + // we give ourselves a few blocks of headroom after expiration before going + // on-chain for an expired HTLC. + // Note that, to avoid a potential attack whereby a node delays claiming an HTLC + // from us until we've reached the point where we go on-chain with the + // corresponding inbound HTLC, we must ensure that outbound HTLCs go on chain at + // least CLTV_CLAIM_BUFFER blocks prior to the inbound HTLC. + // aka outbound_cltv + HTLC_FAIL_TIMEOUT_BLOCKS == height - CLTV_CLAIM_BUFFER + // inbound_cltv == height + CLTV_CLAIM_BUFFER + // outbound_cltv + HTLC_FAIL_TIMEOUT_BLOCKS + CLTV_CLAIM_BUFER <= inbound_cltv - CLTV_CLAIM_BUFFER + // HTLC_FAIL_TIMEOUT_BLOCKS + 2*CLTV_CLAIM_BUFER <= inbound_cltv - outbound_cltv + // HTLC_FAIL_TIMEOUT_BLOCKS + 2*CLTV_CLAIM_BUFER <= CLTV_EXPIRY_DELTA + if ( htlc.offered && htlc.cltv_expiry + HTLC_FAIL_TIMEOUT_BLOCKS <= height) || + (!htlc.offered && htlc.cltv_expiry <= height + CLTV_CLAIM_BUFFER && self.payment_preimages.contains_key(&htlc.payment_hash)) { + return true; } } } @@ -1214,8 +1378,8 @@ impl ChannelMonitor { } } -impl Readable for ChannelMonitor { - fn read(reader: &mut R) -> Result { +impl ReadableArgs> for ChannelMonitor { + fn read(reader: &mut R, logger: Arc) -> Result { // TODO: read_to_end and then deserializing from that vector is really dumb, we should // actually use the fancy serialization framework we have instead of hacking around it. let mut datavec = Vec::new(); @@ -1263,15 +1427,34 @@ impl Readable for ChannelMonitor { let key_storage = match read_bytes!(1)[0] { 0 => { + let revocation_base_key = unwrap_obj!(SecretKey::from_slice(&secp_ctx, read_bytes!(32))); + let htlc_base_key = unwrap_obj!(SecretKey::from_slice(&secp_ctx, read_bytes!(32))); + let delayed_payment_base_key = unwrap_obj!(SecretKey::from_slice(&secp_ctx, read_bytes!(32))); + let prev_latest_per_commitment_point = match read_bytes!(1)[0] { + 0 => None, + 1 => { + Some(unwrap_obj!(PublicKey::from_slice(&secp_ctx, read_bytes!(33)))) + }, + _ => return Err(DecodeError::InvalidValue), + }; + let latest_per_commitment_point = match read_bytes!(1)[0] { + 0 => None, + 1 => { + Some(unwrap_obj!(PublicKey::from_slice(&secp_ctx, read_bytes!(33)))) + }, + _ => return Err(DecodeError::InvalidValue), + }; KeyStorage::PrivMode { - revocation_base_key: unwrap_obj!(SecretKey::from_slice(&secp_ctx, read_bytes!(32))), - htlc_base_key: unwrap_obj!(SecretKey::from_slice(&secp_ctx, read_bytes!(32))), + revocation_base_key, + htlc_base_key, + delayed_payment_base_key, + prev_latest_per_commitment_point, + latest_per_commitment_point, } }, _ => return Err(DecodeError::InvalidValue), }; - let delayed_payment_base_key = unwrap_obj!(PublicKey::from_slice(&secp_ctx, read_bytes!(33))); let their_htlc_base_key = Some(unwrap_obj!(PublicKey::from_slice(&secp_ctx, read_bytes!(33)))); let their_delayed_payment_base_key = Some(unwrap_obj!(PublicKey::from_slice(&secp_ctx, read_bytes!(33)))); @@ -1434,7 +1617,6 @@ impl Readable for ChannelMonitor { commitment_transaction_number_obscure_factor, key_storage, - delayed_payment_base_key, their_htlc_base_key, their_delayed_payment_base_key, their_cur_revocation_points, @@ -1454,6 +1636,7 @@ impl Readable for ChannelMonitor { destination_script, secp_ctx, + logger, }) } @@ -1468,9 +1651,11 @@ mod tests { use ln::channelmonitor::ChannelMonitor; use ln::chan_utils::{HTLCOutputInCommitment, TxCreationKeys}; use util::sha2::Sha256; + use util::test_utils::TestLogger; use secp256k1::key::{SecretKey,PublicKey}; use secp256k1::{Secp256k1, Signature}; use rand::{thread_rng,Rng}; + use std::sync::Arc; #[test] fn test_per_commitment_storage() { @@ -1478,6 +1663,7 @@ mod tests { let mut secrets: Vec<[u8; 32]> = Vec::new(); let mut monitor: ChannelMonitor; let secp_ctx = Secp256k1::new(); + let logger = Arc::new(TestLogger::new()); macro_rules! test_secrets { () => { @@ -1491,11 +1677,9 @@ mod tests { }; } - let delayed_payment_base_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap()); - { // insert_secret correct sequence - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1541,7 +1725,7 @@ mod tests { { // insert_secret #1 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1557,7 +1741,7 @@ mod tests { { // insert_secret #2 incorrect (#1 derived from incorrect) - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1583,7 +1767,7 @@ mod tests { { // insert_secret #3 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1609,7 +1793,7 @@ mod tests { { // insert_secret #4 incorrect (1,2,3 derived from incorrect) - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1655,7 +1839,7 @@ mod tests { { // insert_secret #5 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1691,7 +1875,7 @@ mod tests { { // insert_secret #6 incorrect (5 derived from incorrect) - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1737,7 +1921,7 @@ mod tests { { // insert_secret #7 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1783,7 +1967,7 @@ mod tests { { // insert_secret #8 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); secrets.clear(); secrets.push([0; 32]); @@ -1831,6 +2015,7 @@ mod tests { #[test] fn test_prune_preimages() { let secp_ctx = Secp256k1::new(); + let logger = Arc::new(TestLogger::new()); let dummy_sig = Signature::from_der(&secp_ctx, &hex::decode("3045022100fa86fa9a36a8cd6a7bb8f06a541787d51371d067951a9461d5404de6b928782e02201c8b7c334c10aed8976a3a465be9a28abff4cb23acbf00022295b378ce1fa3cd").unwrap()[..]).unwrap(); macro_rules! dummy_keys { @@ -1901,8 +2086,7 @@ mod tests { // Prune with one old state and a local commitment tx holding a few overlaps with the // old state. - let delayed_payment_base_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap()); - let mut monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + let mut monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), &SecretKey::from_slice(&secp_ctx, &[44; 32]).unwrap(), 0, Script::new(), logger.clone()); monitor.set_their_to_self_delay(10); monitor.provide_latest_local_commitment_tx_info(dummy_tx.clone(), dummy_keys!(), 0, preimages_to_local_htlcs!(preimages[0..10]));