From: Antoine Riard Date: Tue, 27 Nov 2018 00:50:16 +0000 (-0500) Subject: Refactor KeyStorage as Storage X-Git-Url: http://git.bitcoin.ninja/?a=commitdiff_plain;h=28b1ae09d551b40b00477015786d812c06cc65fb;p=rust-lightning Refactor KeyStorage as Storage Move PrivMode as Local, SigsMode as Watchtower Cut funnding_txo from ChannelMonitor, move it inside Local, add also short_channel_id for onchain cross-channel linking Renmae log_funding_option as log_funding_info --- diff --git a/src/ln/channel.rs b/src/ln/channel.rs index 0ad0c0f52..db1296a71 100644 --- a/src/ln/channel.rs +++ b/src/ln/channel.rs @@ -2850,9 +2850,11 @@ impl Channel { } } self.funding_tx_confirmations = 1; - self.short_channel_id = Some(((height as u64) << (5*8)) | - ((*index_in_block as u64) << (2*8)) | - ((txo_idx as u64) << (0*8))); + let short_channel_id = ((height as u64) << (5*8)) | + ((*index_in_block as u64) << (2*8)) | + ((txo_idx as u64) << (0*8)); + self.channel_monitor.set_short_channel_id(short_channel_id); + self.short_channel_id = Some(short_channel_id); } } } diff --git a/src/ln/channelmonitor.rs b/src/ln/channelmonitor.rs index 6ce4b22d5..4b6b30cd5 100644 --- a/src/ln/channelmonitor.rs +++ b/src/ln/channelmonitor.rs @@ -170,21 +170,27 @@ impl SimpleManyChannelMonitor let mut monitors = self.monitors.lock().unwrap(); match monitors.get_mut(&key) { Some(orig_monitor) => { - log_trace!(self, "Updating Channel Monitor for channel {}", log_funding_option!(monitor.funding_txo)); + log_trace!(self, "Updating Channel Monitor for channel {}", log_funding_info!(monitor.key_storage)); return orig_monitor.insert_combine(monitor); }, None => {} }; - match &monitor.funding_txo { - &None => { - log_trace!(self, "Got new Channel Monitor for no-funding-set channel (monitoring all txn!)"); - self.chain_monitor.watch_all_txn() - }, - &Some((ref outpoint, ref script)) => { - log_trace!(self, "Got new Channel Monitor for channel {}", log_bytes!(outpoint.to_channel_id()[..])); - self.chain_monitor.install_watch_tx(&outpoint.txid, script); - self.chain_monitor.install_watch_outpoint((outpoint.txid, outpoint.index as u32), script); + match monitor.key_storage { + Storage::Local { ref funding_info, .. } => { + match funding_info { + &None => { + return Err(MonitorUpdateError("Try to update a useless monitor without funding_txo !")); + }, + &Some((ref outpoint, ref script)) => { + log_trace!(self, "Got new Channel Monitor for channel {}", log_bytes!(outpoint.to_channel_id()[..])); + self.chain_monitor.install_watch_tx(&outpoint.txid, script); + self.chain_monitor.install_watch_outpoint((outpoint.txid, outpoint.index as u32), script); + }, + } }, + Storage::Watchtower { .. } => { + self.chain_monitor.watch_all_txn(); + } } monitors.insert(key, monitor); Ok(()) @@ -223,8 +229,8 @@ pub(crate) const CLTV_CLAIM_BUFFER: u32 = 6; pub(crate) const HTLC_FAIL_TIMEOUT_BLOCKS: u32 = 3; #[derive(Clone, PartialEq)] -enum KeyStorage { - PrivMode { +enum Storage { + Local { revocation_base_key: SecretKey, htlc_base_key: SecretKey, delayed_payment_base_key: SecretKey, @@ -232,8 +238,10 @@ enum KeyStorage { shutdown_pubkey: PublicKey, prev_latest_per_commitment_point: Option, latest_per_commitment_point: Option, + funding_info: Option<(OutPoint, Script)>, + short_channel_id: Option, }, - SigsMode { + Watchtower { revocation_base_key: PublicKey, htlc_base_key: PublicKey, sigs: HashMap, @@ -263,10 +271,9 @@ const MIN_SERIALIZATION_VERSION: u8 = 1; /// information and are actively monitoring the chain. #[derive(Clone)] pub struct ChannelMonitor { - funding_txo: Option<(OutPoint, Script)>, commitment_transaction_number_obscure_factor: u64, - key_storage: KeyStorage, + key_storage: Storage, their_htlc_base_key: Option, their_delayed_payment_base_key: Option, // first is the idx of the first of the two revocation points @@ -319,8 +326,7 @@ pub struct ChannelMonitor { /// underlying object impl PartialEq for ChannelMonitor { fn eq(&self, other: &Self) -> bool { - if self.funding_txo != other.funding_txo || - self.commitment_transaction_number_obscure_factor != other.commitment_transaction_number_obscure_factor || + if self.commitment_transaction_number_obscure_factor != other.commitment_transaction_number_obscure_factor || self.key_storage != other.key_storage || self.their_htlc_base_key != other.their_htlc_base_key || self.their_delayed_payment_base_key != other.their_delayed_payment_base_key || @@ -351,10 +357,9 @@ impl PartialEq for ChannelMonitor { impl ChannelMonitor { pub(super) fn new(revocation_base_key: &SecretKey, delayed_payment_base_key: &SecretKey, htlc_base_key: &SecretKey, payment_base_key: &SecretKey, shutdown_pubkey: &PublicKey, our_to_self_delay: u16, destination_script: Script, logger: Arc) -> ChannelMonitor { ChannelMonitor { - funding_txo: None, commitment_transaction_number_obscure_factor: 0, - key_storage: KeyStorage::PrivMode { + key_storage: Storage::Local { revocation_base_key: revocation_base_key.clone(), htlc_base_key: htlc_base_key.clone(), delayed_payment_base_key: delayed_payment_base_key.clone(), @@ -362,6 +367,8 @@ impl ChannelMonitor { shutdown_pubkey: shutdown_pubkey.clone(), prev_latest_per_commitment_point: None, latest_per_commitment_point: None, + funding_info: None, + short_channel_id: None, }, their_htlc_base_key: None, their_delayed_payment_base_key: None, @@ -501,7 +508,7 @@ 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 + /// Also update Storage 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()); @@ -516,8 +523,8 @@ 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, ref payment_base_key, ref shutdown_pubkey, ref latest_per_commitment_point, .. } = self.key_storage { - KeyStorage::PrivMode { + self.key_storage = if let Storage::Local { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref latest_per_commitment_point, ref mut funding_info, ref short_channel_id, .. } = self.key_storage { + Storage::Local { revocation_base_key: *revocation_base_key, htlc_base_key: *htlc_base_key, delayed_payment_base_key: *delayed_payment_base_key, @@ -525,6 +532,8 @@ impl ChannelMonitor { shutdown_pubkey: *shutdown_pubkey, prev_latest_per_commitment_point: *latest_per_commitment_point, latest_per_commitment_point: Some(local_keys.per_commitment_point), + funding_info: funding_info.take(), + short_channel_id: *short_channel_id, } } else { unimplemented!(); }; } @@ -539,15 +548,56 @@ impl ChannelMonitor { /// After a successful call this ChannelMonitor is up-to-date and is safe to use to monitor the /// chain for new blocks/transactions. pub fn insert_combine(&mut self, mut other: ChannelMonitor) -> Result<(), MonitorUpdateError> { - if self.funding_txo.is_some() { - // We should be able to compare the entire funding_txo, but in fuzztarget its trivially - // easy to collide the funding_txo hash and have a different scriptPubKey. - if other.funding_txo.is_some() && other.funding_txo.as_ref().unwrap().0 != self.funding_txo.as_ref().unwrap().0 { - return Err(MonitorUpdateError("Funding transaction outputs are not identical!")); - } - } else { - self.funding_txo = other.funding_txo.take(); - } + + self.key_storage = match self.key_storage { + Storage::Local { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref prev_latest_per_commitment_point, ref latest_per_commitment_point, ref mut funding_info, ref mut short_channel_id, .. } => { + + macro_rules! new_storage_local { + ($funding_info: expr, $short_channel_id: expr) => { + Storage::Local { + revocation_base_key: *revocation_base_key, + htlc_base_key: *htlc_base_key, + delayed_payment_base_key: *delayed_payment_base_key, + payment_base_key: *payment_base_key, + shutdown_pubkey: *shutdown_pubkey, + prev_latest_per_commitment_point: *prev_latest_per_commitment_point, + latest_per_commitment_point: *latest_per_commitment_point, + funding_info: $funding_info, + short_channel_id: $short_channel_id, + } + } + } + + let our_funding_info = funding_info; + let our_short_channel_id = short_channel_id; + if let Storage::Local { ref mut funding_info, ref mut short_channel_id, .. } = other.key_storage { + if our_funding_info.is_some() { + // We should be able to compare the entire funding_txo, but in fuzztarget its trivially + // easy to collide the funding_txo hash and have a different scriptPubKey. + if funding_info.is_some() && our_funding_info.is_some() && funding_info.as_ref().unwrap().0 != our_funding_info.as_ref().unwrap().0 { + return Err(MonitorUpdateError("Funding transaction outputs are not identical!")); + } else { + new_storage_local!(our_funding_info.take(), our_short_channel_id.take()) + } + } else { + new_storage_local!(funding_info.take(), short_channel_id.take()) + } + } else { + return Err(MonitorUpdateError("Try to combine a Local monitor with a Watchtower one !")); + } + }, + Storage::Watchtower { .. } => { + if let Storage::Watchtower { ref revocation_base_key, ref htlc_base_key, ref mut sigs } = other.key_storage { + Storage::Watchtower { + revocation_base_key: *revocation_base_key, + htlc_base_key: *htlc_base_key, + sigs: sigs.drain().collect(), + } + } else { + return Err(MonitorUpdateError("Try to combine a Watchtower monitor with a Local one !")); + } + }, + }; let other_min_secret = other.get_min_seen_secret(); let our_min_secret = self.get_min_seen_secret(); if our_min_secret > other_min_secret { @@ -595,7 +645,49 @@ impl ChannelMonitor { /// It's the responsibility of the caller to register outpoint and script with passing the former /// value as key to add_update_monitor. pub(super) fn set_funding_info(&mut self, funding_info: (OutPoint, Script)) { - self.funding_txo = Some(funding_info); + self.key_storage = match self.key_storage { + Storage::Local { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref prev_latest_per_commitment_point, ref latest_per_commitment_point, short_channel_id, .. } => { + Storage::Local { + revocation_base_key: *revocation_base_key, + htlc_base_key: *htlc_base_key, + delayed_payment_base_key: *delayed_payment_base_key, + payment_base_key: *payment_base_key, + shutdown_pubkey: *shutdown_pubkey, + prev_latest_per_commitment_point: *prev_latest_per_commitment_point, + latest_per_commitment_point: *latest_per_commitment_point, + funding_info: Some(funding_info.clone()), + short_channel_id: short_channel_id, + } + }, + Storage::Watchtower { .. } => { + unimplemented!(); + } + }; + } + + /// Allows this monitor to get preimages from upstream ChannelMonitor (linked by ManyChannelMonitor) + /// in cas of onchain remote commitment tx resolved by a HTLC-Succes one but you may wish to + /// avoid this (or call unset_funding_info) on a monitor you wish to send to a watchtower as it + /// provides slightly better privacy. + pub(super) fn set_short_channel_id(&mut self, short_channel_id: u64) { + self.key_storage = match self.key_storage { + Storage::Local { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref prev_latest_per_commitment_point, ref latest_per_commitment_point, ref mut funding_info, .. } => { + Storage::Local { + revocation_base_key: *revocation_base_key, + htlc_base_key: *htlc_base_key, + delayed_payment_base_key: *delayed_payment_base_key, + payment_base_key: *payment_base_key, + shutdown_pubkey: *shutdown_pubkey, + prev_latest_per_commitment_point: *prev_latest_per_commitment_point, + latest_per_commitment_point: *latest_per_commitment_point, + funding_info: funding_info.take(), + short_channel_id: Some(short_channel_id), + } + }, + Storage::Watchtower { .. } => { + unimplemented!(); + } + }; } /// We log these base keys at channel opening to being able to rebuild redeemscript in case of leaked revoked commit tx @@ -609,14 +701,38 @@ impl ChannelMonitor { } pub(super) fn unset_funding_info(&mut self) { - self.funding_txo = None; + self.key_storage = match self.key_storage { + Storage::Local { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref prev_latest_per_commitment_point, ref latest_per_commitment_point, short_channel_id, .. } => { + Storage::Local { + revocation_base_key: *revocation_base_key, + htlc_base_key: *htlc_base_key, + delayed_payment_base_key: *delayed_payment_base_key, + payment_base_key: *payment_base_key, + shutdown_pubkey: *shutdown_pubkey, + prev_latest_per_commitment_point: *prev_latest_per_commitment_point, + latest_per_commitment_point: *latest_per_commitment_point, + funding_info: None, + short_channel_id: short_channel_id, + } + }, + Storage::Watchtower { .. } => { + unimplemented!(); + }, + } } /// Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for. pub fn get_funding_txo(&self) -> Option { - match self.funding_txo { - Some((outpoint, _)) => Some(outpoint), - None => None + match self.key_storage { + Storage::Local { ref funding_info, .. } => { + match funding_info { + &Some((outpoint, _)) => Some(outpoint), + &None => None + } + }, + Storage::Watchtower { .. } => { + return None; + } } } @@ -641,24 +757,11 @@ impl ChannelMonitor { writer.write_all(&[SERIALIZATION_VERSION; 1])?; writer.write_all(&[MIN_SERIALIZATION_VERSION; 1])?; - match &self.funding_txo { - &Some((ref outpoint, ref script)) => { - writer.write_all(&outpoint.txid[..])?; - writer.write_all(&byte_utils::be16_to_array(outpoint.index))?; - script.write(writer)?; - }, - &None => { - // We haven't even been initialized...not sure why anyone is serializing us, but - // not much to give them. - return Ok(()); - }, - } - // Set in initial Channel-object creation, so should always be set by now: U48(self.commitment_transaction_number_obscure_factor).write(writer)?; match self.key_storage { - KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref prev_latest_per_commitment_point, ref latest_per_commitment_point } => { + Storage::Local { ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref prev_latest_per_commitment_point, ref latest_per_commitment_point, ref funding_info, ref short_channel_id } => { writer.write_all(&[0; 1])?; writer.write_all(&revocation_base_key[..])?; writer.write_all(&htlc_base_key[..])?; @@ -677,9 +780,27 @@ impl ChannelMonitor { } else { writer.write_all(&[0; 1])?; } - + match funding_info { + &Some((ref outpoint, ref script)) => { + writer.write_all(&outpoint.txid[..])?; + writer.write_all(&byte_utils::be16_to_array(outpoint.index))?; + script.write(writer)?; + }, + &None => { + debug_assert!(false, "Try to serialize a useless Local monitor !"); + }, + } + match short_channel_id { + &Some(short_channel_id) => { + writer.write_all(&[1; 1])?; + writer.write_all(&byte_utils::be64_to_array(short_channel_id))?; + } + &None => { + writer.write_all(&[0; 1])?; + } + } }, - KeyStorage::SigsMode { .. } => unimplemented!(), + Storage::Watchtower { .. } => unimplemented!(), } writer.write_all(&self.their_htlc_base_key.as_ref().unwrap().serialize())?; @@ -890,13 +1011,13 @@ 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, local_payment_key) = match self.key_storage { - KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key, ref payment_base_key, .. } => { + Storage::Local { ref revocation_base_key, ref htlc_base_key, ref payment_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))), Some(ignore_error!(chan_utils::derive_private_key(&self.secp_ctx, &per_commitment_point, &payment_base_key)))) }, - KeyStorage::SigsMode { ref revocation_base_key, ref htlc_base_key, .. } => { + Storage::Watchtower { 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, &revocation_base_key)), ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &htlc_base_key)), @@ -951,7 +1072,7 @@ impl ChannelMonitor { ($sighash_parts: expr, $input: expr, $htlc_idx: expr, $amount: expr) => { { let (sig, redeemscript) = match self.key_storage { - KeyStorage::PrivMode { ref revocation_base_key, .. } => { + Storage::Local { ref revocation_base_key, .. } => { let redeemscript = if $htlc_idx.is_none() { revokeable_redeemscript.clone() } else { let htlc = &per_commitment_option.unwrap()[$htlc_idx.unwrap()]; chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &a_htlc_key, &b_htlc_key, &revocation_pubkey) @@ -960,7 +1081,7 @@ impl ChannelMonitor { let revocation_key = ignore_error!(chan_utils::derive_private_revocation_key(&self.secp_ctx, &per_commitment_key, &revocation_base_key)); (self.secp_ctx.sign(&sighash, &revocation_key), redeemscript) }, - KeyStorage::SigsMode { .. } => { + Storage::Watchtower { .. } => { unimplemented!(); } }; @@ -1067,11 +1188,11 @@ 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, .. } => { + Storage::Local { 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)))) }, - KeyStorage::SigsMode { ref revocation_base_key, ref htlc_base_key, .. } => { + Storage::Watchtower { ref revocation_base_key, ref htlc_base_key, .. } => { (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, revocation_point, &revocation_base_key)), ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, revocation_point, &htlc_base_key))) }, @@ -1084,7 +1205,7 @@ impl ChannelMonitor { for (idx, outp) in tx.output.iter().enumerate() { if outp.script_pubkey.is_v0_p2wpkh() { match self.key_storage { - KeyStorage::PrivMode { ref payment_base_key, .. } => { + Storage::Local { ref payment_base_key, .. } => { if let Ok(local_key) = chan_utils::derive_private_key(&self.secp_ctx, &revocation_point, &payment_base_key) { spendable_outputs.push(SpendableOutputDescriptor::DynamicOutputP2WPKH { outpoint: BitcoinOutPoint { txid: commitment_txid, vout: idx as u32 }, @@ -1093,7 +1214,7 @@ impl ChannelMonitor { }); } }, - KeyStorage::SigsMode { .. } => {} + Storage::Watchtower { .. } => {} } break; // Only to_remote ouput is claimable } @@ -1107,14 +1228,14 @@ impl ChannelMonitor { ($sighash_parts: expr, $input: expr, $amount: expr, $preimage: expr) => { { let (sig, redeemscript) = match self.key_storage { - KeyStorage::PrivMode { ref htlc_base_key, .. } => { + Storage::Local { ref htlc_base_key, .. } => { let htlc = &per_commitment_option.unwrap()[$input.sequence as usize]; let redeemscript = chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &a_htlc_key, &b_htlc_key, &revocation_pubkey); let sighash = ignore_error!(Message::from_slice(&$sighash_parts.sighash_all(&$input, &redeemscript, $amount)[..])); let htlc_key = ignore_error!(chan_utils::derive_private_key(&self.secp_ctx, revocation_point, &htlc_base_key)); (self.secp_ctx.sign(&sighash, &htlc_key), redeemscript) }, - KeyStorage::SigsMode { .. } => { + Storage::Watchtower { .. } => { unimplemented!(); } }; @@ -1214,10 +1335,10 @@ impl ChannelMonitor { let per_commitment_key = ignore_error!(SecretKey::from_slice(&self.secp_ctx, &secret)); let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key); let revocation_pubkey = match self.key_storage { - KeyStorage::PrivMode { ref revocation_base_key, .. } => { + Storage::Local { ref revocation_base_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))) }, - KeyStorage::SigsMode { ref revocation_base_key, .. } => { + Storage::Watchtower { ref revocation_base_key, .. } => { ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &revocation_base_key)) }, }; @@ -1261,12 +1382,12 @@ impl ChannelMonitor { let sighash_parts = bip143::SighashComponents::new(&spend_tx); let sig = match self.key_storage { - KeyStorage::PrivMode { ref revocation_base_key, .. } => { + Storage::Local { ref revocation_base_key, .. } => { let sighash = ignore_error!(Message::from_slice(&sighash_parts.sighash_all(&spend_tx.input[0], &redeemscript, amount)[..])); let revocation_key = ignore_error!(chan_utils::derive_private_revocation_key(&self.secp_ctx, &per_commitment_key, &revocation_base_key)); self.secp_ctx.sign(&sighash, &revocation_key) } - KeyStorage::SigsMode { .. } => { + Storage::Watchtower { .. } => { unimplemented!(); } }; @@ -1360,10 +1481,10 @@ impl ChannelMonitor { if let &Some(ref local_tx) = &self.current_local_signed_commitment_tx { if local_tx.txid == commitment_txid { match self.key_storage { - KeyStorage::PrivMode { ref delayed_payment_base_key, ref latest_per_commitment_point, .. } => { + Storage::Local { ref delayed_payment_base_key, ref latest_per_commitment_point, .. } => { return self.broadcast_by_local_state(local_tx, latest_per_commitment_point, &Some(*delayed_payment_base_key)); }, - KeyStorage::SigsMode { .. } => { + Storage::Watchtower { .. } => { return self.broadcast_by_local_state(local_tx, &None, &None); } } @@ -1372,10 +1493,10 @@ impl ChannelMonitor { if let &Some(ref local_tx) = &self.prev_local_signed_commitment_tx { if local_tx.txid == commitment_txid { match self.key_storage { - KeyStorage::PrivMode { ref delayed_payment_base_key, ref prev_latest_per_commitment_point, .. } => { + Storage::Local { 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 { .. } => { + Storage::Watchtower { .. } => { return self.broadcast_by_local_state(local_tx, &None, &None); } } @@ -1388,7 +1509,7 @@ impl ChannelMonitor { fn check_spend_closing_transaction(&self, tx: &Transaction) -> Option { if tx.input[0].sequence == 0xFFFFFFFF && tx.input[0].witness.last().unwrap().len() == 71 { match self.key_storage { - KeyStorage::PrivMode { ref shutdown_pubkey, .. } => { + Storage::Local { ref shutdown_pubkey, .. } => { let our_channel_close_key_hash = Hash160::from_data(&shutdown_pubkey.serialize()); let shutdown_script = Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_close_key_hash[..]).into_script(); for (idx, output) in tx.output.iter().enumerate() { @@ -1400,7 +1521,7 @@ impl ChannelMonitor { } } } - KeyStorage::SigsMode { .. } => { + Storage::Watchtower { .. } => { //TODO: we need to ensure an offline client will generate the event when it // cames back online after only the watchtower saw the transaction } @@ -1415,7 +1536,7 @@ impl ChannelMonitor { if let &Some(ref local_tx) = &self.current_local_signed_commitment_tx { let mut res = vec![local_tx.tx.clone()]; match self.key_storage { - KeyStorage::PrivMode { ref delayed_payment_base_key, ref prev_latest_per_commitment_point, .. } => { + Storage::Local { ref delayed_payment_base_key, ref prev_latest_per_commitment_point, .. } => { res.append(&mut self.broadcast_by_local_state(local_tx, prev_latest_per_commitment_point, &Some(*delayed_payment_base_key)).0); }, _ => panic!("Can only broadcast by local channelmonitor"), @@ -1437,7 +1558,15 @@ impl ChannelMonitor { // filters. 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 funding_txo = match self.key_storage { + Storage::Local { ref funding_info, .. } => { + funding_info.clone() + } + Storage::Watchtower { .. } => { + unimplemented!(); + } + }; + if funding_txo.is_none() || (prevout.txid == funding_txo.as_ref().unwrap().0.txid && prevout.vout == funding_txo.as_ref().unwrap().0.index as u32) { let (remote_txn, new_outputs, mut spendable_output) = self.check_spend_remote_transaction(tx, height); txn = remote_txn; spendable_outputs.append(&mut spendable_output); @@ -1449,7 +1578,7 @@ impl ChannelMonitor { spendable_outputs.append(&mut outputs); txn = remote_txn; } - if !self.funding_txo.is_none() && txn.is_empty() { + if !funding_txo.is_none() && txn.is_empty() { if let Some(spendable_output) = self.check_spend_closing_transaction(tx) { spendable_outputs.push(spendable_output); } @@ -1474,14 +1603,14 @@ impl ChannelMonitor { if self.would_broadcast_at_height(height) { broadcaster.broadcast_transaction(&cur_local_tx.tx); match self.key_storage { - KeyStorage::PrivMode { ref delayed_payment_base_key, ref latest_per_commitment_point, .. } => { + Storage::Local { ref delayed_payment_base_key, 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 { .. } => { + Storage::Watchtower { .. } => { let (txs, mut outputs) = self.broadcast_by_local_state(&cur_local_tx, &None, &None); spendable_outputs.append(&mut outputs); for tx in txs { @@ -1548,13 +1677,6 @@ impl ReadableArgs> for (Sha256dHash, ChannelM return Err(DecodeError::UnknownVersion); } - // Technically this can fail and serialize fail a round-trip, but only for serialization of - // barely-init'd ChannelMonitors that we can't do anything with. - let outpoint = OutPoint { - txid: Readable::read(reader)?, - index: Readable::read(reader)?, - }; - let funding_txo = Some((outpoint, Readable::read(reader)?)); let commitment_transaction_number_obscure_factor = >::read(reader)?.0; let key_storage = match >::read(reader)? { @@ -1574,7 +1696,19 @@ impl ReadableArgs> for (Sha256dHash, ChannelM 1 => Some(Readable::read(reader)?), _ => return Err(DecodeError::InvalidValue), }; - KeyStorage::PrivMode { + // Technically this can fail and serialize fail a round-trip, but only for serialization of + // barely-init'd ChannelMonitors that we can't do anything with. + let outpoint = OutPoint { + txid: Readable::read(reader)?, + index: Readable::read(reader)?, + }; + let funding_info = Some((outpoint, Readable::read(reader)?)); + let short_channel_id = match >::read(reader)? { + 0 => None, + 1 => Some(Readable::read(reader)?), + _ => return Err(DecodeError::InvalidValue), + }; + Storage::Local { revocation_base_key, htlc_base_key, delayed_payment_base_key, @@ -1582,6 +1716,8 @@ impl ReadableArgs> for (Sha256dHash, ChannelM shutdown_pubkey, prev_latest_per_commitment_point, latest_per_commitment_point, + funding_info, + short_channel_id, } }, _ => return Err(DecodeError::InvalidValue), @@ -1741,7 +1877,6 @@ impl ReadableArgs> for (Sha256dHash, ChannelM let destination_script = Readable::read(reader)?; Ok((last_block_hash.clone(), ChannelMonitor { - funding_txo, commitment_transaction_number_obscure_factor, key_storage, diff --git a/src/util/macro_logger.rs b/src/util/macro_logger.rs index c10e2c204..fb38e347c 100644 --- a/src/util/macro_logger.rs +++ b/src/util/macro_logger.rs @@ -52,8 +52,8 @@ macro_rules! log_funding_channel_id { } } -pub(crate) struct DebugFundingOption<'a, T: 'a>(pub &'a Option<(OutPoint, T)>); -impl<'a, T> std::fmt::Display for DebugFundingOption<'a, T> { +pub(crate) struct DebugFundingInfo<'a, T: 'a>(pub &'a Option<(OutPoint, T)>); +impl<'a, T> std::fmt::Display for DebugFundingInfo<'a, T> { fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { match self.0.as_ref() { Some(&(ref funding_output, _)) => DebugBytes(&funding_output.to_channel_id()[..]).fmt(f), @@ -61,9 +61,16 @@ impl<'a, T> std::fmt::Display for DebugFundingOption<'a, T> { } } } -macro_rules! log_funding_option { - ($funding_option: expr) => { - ::util::macro_logger::DebugFundingOption(&$funding_option) +macro_rules! log_funding_info { + ($key_storage: expr) => { + match $key_storage { + Storage::Local { ref funding_info, .. } => { + ::util::macro_logger::DebugFundingInfo(&funding_info) + }, + Storage::Watchtower { .. } => { + ::util::macro_logger::DebugFundingInfo(&None) + } + } } }