X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannelmonitor.rs;h=5adfe926ce278f8d7c9858f00c13823354340714;hb=f1eb4639f860bec63d3e6a311a9128d56d9b2803;hp=fdd2fe8e9c58289cf4d4ced9dcf8a9e368711e11;hpb=28d0d44e442d2a5455d58b2820acaae794807415;p=rust-lightning diff --git a/src/ln/channelmonitor.rs b/src/ln/channelmonitor.rs index fdd2fe8e..5adfe926 100644 --- a/src/ln/channelmonitor.rs +++ b/src/ln/channelmonitor.rs @@ -1,8 +1,10 @@ //! The logic to monitor for on-chain transactions and create the relevant claim responses lives //! here. +//! //! ChannelMonitor objects are generated by ChannelManager in response to relevant //! messages/actions, and MUST be persisted to disk (and, preferably, remotely) before progress can //! be made in responding to certain messages, see ManyChannelMonitor for more. +//! //! Note that ChannelMonitors are an important part of the lightning trust model and a copy of the //! latest ChannelMonitor must always be actively monitoring for chain updates (and no out-of-date //! ChannelMonitors should do so). Thus, if you're building rust-lightning into an HSM or other @@ -28,22 +30,41 @@ use ln::chan_utils; use ln::chan_utils::HTLCOutputInCommitment; use chain::chaininterface::{ChainListener, ChainWatchInterface, BroadcasterInterface}; use chain::transaction::OutPoint; -use util::ser::Readable; +use chain::keysinterface::SpendableOutputDescriptor; +use util::ser::{Readable, 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). + /// /// Such a failure will "freeze" a channel, preventing us from revoking old states or /// 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 @@ -55,12 +76,14 @@ pub enum ChannelMonitorUpdateErr { /// them. Generally should be implemented by keeping a local SimpleManyChannelMonitor and passing /// events to it, while also taking any add_update_monitor events and passing them to some remote /// server(s). +/// /// Note that any updates to a channel's monitor *must* be applied to each instance of the /// channel's monitor everywhere (including remote watchtowers) *before* this function returns. If /// an update occurs and a remote watchtower is left with old state, it may broadcast transactions /// which we have revoked, allowing our counterparty to claim all funds in the channel! pub trait ManyChannelMonitor: Send + Sync { /// Adds or updates a monitor for the given `funding_txo`. + /// /// Implementor must also ensure that the funding_txo outpoint is registered with any relevant /// ChainWatchInterfaces such that the provided monitor receives block_connected callbacks with /// any spends of it. @@ -69,10 +92,13 @@ pub trait ManyChannelMonitor: Send + Sync { /// A simple implementation of a ManyChannelMonitor and ChainListener. Can be used to create a /// watchtower or watch our own channels. +/// /// Note that you must provide your own key by which to refer to channels. +/// /// If you're accepting remote monitors (ie are implementing a watchtower), you must verify that /// users cannot overwrite a given channel by providing a duplicate key. ie you should probably /// index by a PublicKey which is required to sign any updates. +/// /// If you're using this for local monitoring of your own channels, you probably want to use /// `OutPoint` as the key, which will give you a ManyChannelMonitor implementation. pub struct SimpleManyChannelMonitor { @@ -81,20 +107,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) { } @@ -107,7 +144,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); @@ -142,18 +180,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, @@ -180,6 +236,7 @@ const MIN_SERIALIZATION_VERSION: u8 = 1; /// A ChannelMonitor handles chain events (blocks connected and disconnected) and generates /// on-chain transactions to ensure no loss of funds occurs. +/// /// You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date /// information and are actively monitoring the chain. pub struct ChannelMonitor { @@ -187,7 +244,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 +285,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(), @@ -261,7 +316,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 || @@ -289,7 +343,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) -> ChannelMonitor { ChannelMonitor { funding_txo: None, commitment_transaction_number_obscure_factor: 0, @@ -297,8 +351,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, @@ -437,6 +493,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(); @@ -450,6 +508,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 @@ -531,81 +598,95 @@ impl ChannelMonitor { } /// Serializes into a vec, with various modes for the exposed pub fns - fn serialize(&self, for_local_storage: bool) -> Vec { - let mut res = Vec::new(); - res.push(SERIALIZATION_VERSION); - res.push(MIN_SERIALIZATION_VERSION); + fn write(&self, writer: &mut W, for_local_storage: bool) -> Result<(), ::std::io::Error> { + //TODO: We still write out all the serialization here manually instead of using the fancy + //serialization framework we have, we should migrate things over to it. + writer.write_all(&[SERIALIZATION_VERSION; 1])?; + writer.write_all(&[MIN_SERIALIZATION_VERSION; 1])?; match &self.funding_txo { &Some((ref outpoint, ref script)) => { - res.extend_from_slice(&outpoint.txid[..]); - res.extend_from_slice(&byte_utils::be16_to_array(outpoint.index)); - res.extend_from_slice(&byte_utils::be64_to_array(script.len() as u64)); - res.extend_from_slice(&script[..]); + writer.write_all(&outpoint.txid[..])?; + writer.write_all(&byte_utils::be16_to_array(outpoint.index))?; + writer.write_all(&byte_utils::be64_to_array(script.len() as u64))?; + writer.write_all(&script[..])?; }, &None => { // We haven't even been initialized...not sure why anyone is serializing us, but // not much to give them. - return res; + return Ok(()); }, } // Set in initial Channel-object creation, so should always be set by now: - res.extend_from_slice(&byte_utils::be48_to_array(self.commitment_transaction_number_obscure_factor)); + 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 } => { - res.push(0); - res.extend_from_slice(&revocation_base_key[..]); - res.extend_from_slice(&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!(), } - res.extend_from_slice(&self.delayed_payment_base_key.serialize()); - res.extend_from_slice(&self.their_htlc_base_key.as_ref().unwrap().serialize()); - res.extend_from_slice(&self.their_delayed_payment_base_key.as_ref().unwrap().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())?; match self.their_cur_revocation_points { Some((idx, pubkey, second_option)) => { - res.extend_from_slice(&byte_utils::be48_to_array(idx)); - res.extend_from_slice(&pubkey.serialize()); + writer.write_all(&byte_utils::be48_to_array(idx))?; + writer.write_all(&pubkey.serialize())?; match second_option { Some(second_pubkey) => { - res.extend_from_slice(&second_pubkey.serialize()); + writer.write_all(&second_pubkey.serialize())?; }, None => { - res.extend_from_slice(&[0; 33]); + writer.write_all(&[0; 33])?; }, } }, None => { - res.extend_from_slice(&byte_utils::be48_to_array(0)); + writer.write_all(&byte_utils::be48_to_array(0))?; }, } - res.extend_from_slice(&byte_utils::be16_to_array(self.our_to_self_delay)); - res.extend_from_slice(&byte_utils::be16_to_array(self.their_to_self_delay.unwrap())); + writer.write_all(&byte_utils::be16_to_array(self.our_to_self_delay))?; + writer.write_all(&byte_utils::be16_to_array(self.their_to_self_delay.unwrap()))?; for &(ref secret, ref idx) in self.old_secrets.iter() { - res.extend_from_slice(secret); - res.extend_from_slice(&byte_utils::be64_to_array(*idx)); + writer.write_all(secret)?; + writer.write_all(&byte_utils::be64_to_array(*idx))?; } macro_rules! serialize_htlc_in_commitment { ($htlc_output: expr) => { - res.push($htlc_output.offered as u8); - res.extend_from_slice(&byte_utils::be64_to_array($htlc_output.amount_msat)); - res.extend_from_slice(&byte_utils::be32_to_array($htlc_output.cltv_expiry)); - res.extend_from_slice(&$htlc_output.payment_hash); - res.extend_from_slice(&byte_utils::be32_to_array($htlc_output.transaction_output_index)); + writer.write_all(&[$htlc_output.offered as u8; 1])?; + writer.write_all(&byte_utils::be64_to_array($htlc_output.amount_msat))?; + writer.write_all(&byte_utils::be32_to_array($htlc_output.cltv_expiry))?; + writer.write_all(&$htlc_output.payment_hash)?; + writer.write_all(&byte_utils::be32_to_array($htlc_output.transaction_output_index))?; } } - res.extend_from_slice(&byte_utils::be64_to_array(self.remote_claimable_outpoints.len() as u64)); + writer.write_all(&byte_utils::be64_to_array(self.remote_claimable_outpoints.len() as u64))?; for (txid, htlc_outputs) in self.remote_claimable_outpoints.iter() { - res.extend_from_slice(&txid[..]); - res.extend_from_slice(&byte_utils::be64_to_array(htlc_outputs.len() as u64)); + writer.write_all(&txid[..])?; + writer.write_all(&byte_utils::be64_to_array(htlc_outputs.len() as u64))?; for htlc_output in htlc_outputs.iter() { serialize_htlc_in_commitment!(htlc_output); } @@ -613,77 +694,77 @@ impl ChannelMonitor { { let remote_commitment_txn_on_chain = self.remote_commitment_txn_on_chain.lock().unwrap(); - res.extend_from_slice(&byte_utils::be64_to_array(remote_commitment_txn_on_chain.len() as u64)); + writer.write_all(&byte_utils::be64_to_array(remote_commitment_txn_on_chain.len() as u64))?; for (txid, commitment_number) in remote_commitment_txn_on_chain.iter() { - res.extend_from_slice(&txid[..]); - res.extend_from_slice(&byte_utils::be48_to_array(*commitment_number)); + writer.write_all(&txid[..])?; + writer.write_all(&byte_utils::be48_to_array(*commitment_number))?; } } if for_local_storage { - res.extend_from_slice(&byte_utils::be64_to_array(self.remote_hash_commitment_number.len() as u64)); + writer.write_all(&byte_utils::be64_to_array(self.remote_hash_commitment_number.len() as u64))?; for (payment_hash, commitment_number) in self.remote_hash_commitment_number.iter() { - res.extend_from_slice(payment_hash); - res.extend_from_slice(&byte_utils::be48_to_array(*commitment_number)); + writer.write_all(payment_hash)?; + writer.write_all(&byte_utils::be48_to_array(*commitment_number))?; } } else { - res.extend_from_slice(&byte_utils::be64_to_array(0)); + writer.write_all(&byte_utils::be64_to_array(0))?; } macro_rules! serialize_local_tx { ($local_tx: expr) => { let tx_ser = serialize::serialize(&$local_tx.tx).unwrap(); - res.extend_from_slice(&byte_utils::be64_to_array(tx_ser.len() as u64)); - res.extend_from_slice(&tx_ser); + writer.write_all(&byte_utils::be64_to_array(tx_ser.len() as u64))?; + writer.write_all(&tx_ser)?; - res.extend_from_slice(&$local_tx.revocation_key.serialize()); - res.extend_from_slice(&$local_tx.a_htlc_key.serialize()); - res.extend_from_slice(&$local_tx.b_htlc_key.serialize()); - res.extend_from_slice(&$local_tx.delayed_payment_key.serialize()); + writer.write_all(&$local_tx.revocation_key.serialize())?; + writer.write_all(&$local_tx.a_htlc_key.serialize())?; + writer.write_all(&$local_tx.b_htlc_key.serialize())?; + writer.write_all(&$local_tx.delayed_payment_key.serialize())?; - res.extend_from_slice(&byte_utils::be64_to_array($local_tx.feerate_per_kw)); - res.extend_from_slice(&byte_utils::be64_to_array($local_tx.htlc_outputs.len() as u64)); + writer.write_all(&byte_utils::be64_to_array($local_tx.feerate_per_kw))?; + writer.write_all(&byte_utils::be64_to_array($local_tx.htlc_outputs.len() as u64))?; for &(ref htlc_output, ref their_sig, ref our_sig) in $local_tx.htlc_outputs.iter() { serialize_htlc_in_commitment!(htlc_output); - res.extend_from_slice(&their_sig.serialize_compact(&self.secp_ctx)); - res.extend_from_slice(&our_sig.serialize_compact(&self.secp_ctx)); + writer.write_all(&their_sig.serialize_compact(&self.secp_ctx))?; + writer.write_all(&our_sig.serialize_compact(&self.secp_ctx))?; } } } if let Some(ref prev_local_tx) = self.prev_local_signed_commitment_tx { - res.push(1); + writer.write_all(&[1; 1])?; serialize_local_tx!(prev_local_tx); } else { - res.push(0); + writer.write_all(&[0; 1])?; } if let Some(ref cur_local_tx) = self.current_local_signed_commitment_tx { - res.push(1); + writer.write_all(&[1; 1])?; serialize_local_tx!(cur_local_tx); } else { - res.push(0); + writer.write_all(&[0; 1])?; } - res.extend_from_slice(&byte_utils::be64_to_array(self.payment_preimages.len() as u64)); + writer.write_all(&byte_utils::be64_to_array(self.payment_preimages.len() as u64))?; for payment_preimage in self.payment_preimages.values() { - res.extend_from_slice(payment_preimage); + writer.write_all(payment_preimage)?; } - res.extend_from_slice(&byte_utils::be64_to_array(self.destination_script.len() as u64)); - res.extend_from_slice(&self.destination_script[..]); + writer.write_all(&byte_utils::be64_to_array(self.destination_script.len() as u64))?; + writer.write_all(&self.destination_script[..])?; - res + Ok(()) } - /// Encodes this monitor into a byte array, suitable for writing to disk. - pub fn serialize_for_disk(&self) -> Vec { - self.serialize(true) + /// Writes this monitor into the given writer, suitable for writing to disk. + pub fn write_for_disk(&self, writer: &mut W) -> Result<(), ::std::io::Error> { + self.write(writer, true) } - /// Encodes this monitor into a byte array, suitable for sending to a remote watchtower - pub fn serialize_for_watchtower(&self) -> Vec { - self.serialize(false) + /// Encodes this monitor into the given writer, suitable for sending to a remote watchtower + pub fn write_for_watchtower(&self, writer: &mut W) -> Result<(), ::std::io::Error> { + self.write(writer, false) } //TODO: Functions to serialize/deserialize (with different forms depending on which information @@ -715,11 +796,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); @@ -728,7 +810,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) } }; } @@ -738,7 +820,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)))) @@ -749,9 +831,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)), }; @@ -818,7 +900,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 { @@ -846,7 +928,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); } } } @@ -856,7 +938,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(), @@ -877,6 +959,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 @@ -897,7 +983,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)))) }, @@ -907,7 +993,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)), }; @@ -965,12 +1051,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(), @@ -991,23 +1081,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) } }; } @@ -1024,11 +1120,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; @@ -1076,12 +1173,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 { @@ -1097,6 +1197,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) { @@ -1112,34 +1224,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), @@ -1149,20 +1288,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() { @@ -1171,32 +1317,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; } } } @@ -1253,15 +1422,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)))); @@ -1424,7 +1612,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, @@ -1481,11 +1668,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()); secrets.clear(); secrets.push([0; 32]); @@ -1531,7 +1716,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()); secrets.clear(); secrets.push([0; 32]); @@ -1547,7 +1732,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()); secrets.clear(); secrets.push([0; 32]); @@ -1573,7 +1758,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()); secrets.clear(); secrets.push([0; 32]); @@ -1599,7 +1784,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()); secrets.clear(); secrets.push([0; 32]); @@ -1645,7 +1830,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()); secrets.clear(); secrets.push([0; 32]); @@ -1681,7 +1866,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()); secrets.clear(); secrets.push([0; 32]); @@ -1727,7 +1912,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()); secrets.clear(); secrets.push([0; 32]); @@ -1773,7 +1958,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()); secrets.clear(); secrets.push([0; 32]); @@ -1891,8 +2076,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()); 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]));