X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannelmanager.rs;h=4dfa20a34ef6499b07608627c9d6ec1dd7dcf024;hb=6707db6eae050d86bc3d1db9e85a737cd7efc3c6;hp=8be2348a7e1e5374ba82bc063a3c7ac25a668bb8;hpb=8e79c05a2045f7c3c32365937db8866031172c7f;p=rust-lightning diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs index 8be2348a..4dfa20a3 100644 --- a/src/ln/channelmanager.rs +++ b/src/ln/channelmanager.rs @@ -12,14 +12,16 @@ use secp256k1::ecdh::SharedSecret; use secp256k1; use chain::chaininterface::{BroadcasterInterface,ChainListener,ChainWatchInterface,FeeEstimator}; -use ln::channel::Channel; +use chain::transaction::OutPoint; +use ln::channel::{Channel, ChannelKeys}; use ln::channelmonitor::ManyChannelMonitor; -use ln::router::Route; +use ln::router::{Route,RouteHop}; use ln::msgs; use ln::msgs::{HandleError,ChannelMessageHandler,MsgEncodable,MsgDecodable}; use util::{byte_utils, events, internal_traits, rng}; use util::sha2::Sha256; +use crypto; use crypto::mac::{Mac,MacResult}; use crypto::hmac::Hmac; use crypto::digest::Digest; @@ -32,29 +34,57 @@ use std::collections::hash_map; use std::{ptr, mem}; use std::time::{Instant,Duration}; -/// Stores the info we will need to send when we want to forward an HTLC onwards -pub struct PendingForwardHTLCInfo { - onion_packet: Option, - payment_hash: [u8; 32], - short_channel_id: u64, - prev_short_channel_id: u64, - amt_to_forward: u64, - outgoing_cltv_value: u32, -} -//TODO: This is public, and needed to call Channel::update_add_htlc, so there needs to be a way to -//initialize it usefully...probably make it optional in Channel instead). -impl PendingForwardHTLCInfo { - pub fn dummy() -> Self { - Self { - onion_packet: None, - payment_hash: [0; 32], - short_channel_id: 0, - prev_short_channel_id: 0, - amt_to_forward: 0, - outgoing_cltv_value: 0, +mod channel_held_info { + use ln::msgs; + + /// Stores the info we will need to send when we want to forward an HTLC onwards + pub struct PendingForwardHTLCInfo { + pub(super) onion_packet: Option, + pub(super) payment_hash: [u8; 32], + pub(super) short_channel_id: u64, + pub(super) prev_short_channel_id: u64, + pub(super) amt_to_forward: u64, + pub(super) outgoing_cltv_value: u32, + } + + #[cfg(feature = "fuzztarget")] + impl PendingForwardHTLCInfo { + pub fn dummy() -> Self { + Self { + onion_packet: None, + payment_hash: [0; 32], + short_channel_id: 0, + prev_short_channel_id: 0, + amt_to_forward: 0, + outgoing_cltv_value: 0, + } + } + } + + #[derive(Clone)] // See Channel::revoke_and_ack for why, tl;dr: Rust bug + pub enum HTLCFailReason { + ErrorPacket { + err: msgs::OnionErrorPacket, + }, + Reason { + failure_code: u16, + data: Vec, + } + } + + #[cfg(feature = "fuzztarget")] + impl HTLCFailReason { + pub fn dummy() -> Self { + HTLCFailReason::Reason { + failure_code: 0, data: Vec::new(), + } } } } +#[cfg(feature = "fuzztarget")] +pub use self::channel_held_info::*; +#[cfg(not(feature = "fuzztarget"))] +pub(crate) use self::channel_held_info::*; enum PendingOutboundHTLC { IntermediaryHopData { @@ -63,22 +93,14 @@ enum PendingOutboundHTLC { }, OutboundRoute { route: Route, + session_priv: SecretKey, }, /// Used for channel rebalancing CycledRoute { source_short_channel_id: u64, incoming_packet_shared_secret: SharedSecret, route: Route, - } -} - -enum HTLCFailReason<'a> { - ErrorPacket { - err: &'a msgs::OnionErrorPacket, - }, - Reason { - failure_code: u16, - data: &'a[u8], + session_priv: SecretKey, } } @@ -180,7 +202,7 @@ impl ChannelManager { /// the main "logic hub" for all channel-related actions, and implements ChannelMessageHandler. /// fee_proportional_millionths is an optional fee to charge any payments routed through us. /// Non-proportional fees are fixed according to our risk using the provided fee estimator. - /// panics if channel_value_satoshis is >= (1 << 24)! + /// panics if channel_value_satoshis is >= `MAX_FUNDING_SATOSHIS`! pub fn new(our_network_key: SecretKey, fee_proportional_millionths: u32, announce_channels_publicly: bool, network: Network, feeest: Arc, monitor: Arc, chain_monitor: Arc, tx_broadcaster: Arc) -> Result, secp256k1::Error> { let secp_ctx = Secp256k1::new(); @@ -212,7 +234,27 @@ impl ChannelManager { } pub fn create_channel(&self, their_network_key: PublicKey, channel_value_satoshis: u64, user_id: u64) -> Result { - let channel = Channel::new_outbound(&*self.fee_estimator, their_network_key, channel_value_satoshis, self.announce_channels_publicly, user_id); + let chan_keys = if cfg!(feature = "fuzztarget") { + ChannelKeys { + funding_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + revocation_base_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + payment_base_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + delayed_payment_base_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + htlc_base_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + channel_close_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + channel_monitor_claim_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + commitment_seed: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + } + } else { + let mut key_seed = [0u8; 32]; + rng::fill_bytes(&mut key_seed); + match ChannelKeys::new_from_seed(&key_seed) { + Ok(key) => key, + Err(_) => panic!("RNG is busted!") + } + }; + + let channel = Channel::new_outbound(&*self.fee_estimator, chan_keys, their_network_key, channel_value_satoshis, self.announce_channels_publicly, user_id); let res = channel.get_open_channel(self.genesis_hash.clone(), &*self.fee_estimator)?; let mut channel_state = self.channel_state.lock().unwrap(); match channel_state.by_id.insert(channel.channel_id(), channel) { @@ -242,22 +284,33 @@ impl ChannelManager { /// will be accepted on the given channel, and after additional timeout/the closing of all /// pending HTLCs, the channel will be closed on chain. pub fn close_channel(&self, channel_id: &Uint256) -> Result { - let res = { - let mut channel_state = self.channel_state.lock().unwrap(); + let (res, chan_option) = { + let mut channel_state_lock = self.channel_state.lock().unwrap(); + let channel_state = channel_state_lock.borrow_parts(); match channel_state.by_id.entry(channel_id.clone()) { hash_map::Entry::Occupied(mut chan_entry) => { let res = chan_entry.get_mut().get_shutdown()?; if chan_entry.get().is_shutdown() { - chan_entry.remove_entry(); - } - res + if let Some(short_id) = chan_entry.get().get_short_channel_id() { + channel_state.short_to_id.remove(&short_id); + } + (res, Some(chan_entry.remove_entry().1)) + } else { (res, None) } }, hash_map::Entry::Vacant(_) => return Err(HandleError{err: "No such channel", msg: None}) } }; for payment_hash in res.1 { // unknown_next_peer...I dunno who that is anymore.... - self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 10, data: &[0; 0] }); + self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 10, data: Vec::new() }); + } + if let Some(chan) = chan_option { + if let Ok(update) = self.get_channel_update(&chan) { + let mut events = self.pending_events.lock().unwrap(); + events.push(events::Event::BroadcastChannelUpdate { + msg: update + }); + } } Ok(res.0) } @@ -289,6 +342,7 @@ impl ChannelManager { res } + #[inline] fn gen_ammag_from_shared_secret(shared_secret: &SharedSecret) -> [u8; 32] { let mut hmac = Hmac::new(Sha256::new(), &[0x61, 0x6d, 0x6d, 0x61, 0x67]); // ammag hmac.input(&shared_secret[..]); @@ -297,8 +351,9 @@ impl ChannelManager { res } - fn construct_onion_keys(secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey) -> Result, HandleError> { - let mut res = Vec::with_capacity(route.hops.len()); + // can only fail if an intermediary hop has an invalid public key or session_priv is invalid + #[inline] + fn construct_onion_keys_callback (secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey, mut callback: FType) -> Result<(), HandleError> { let mut blinded_priv = session_priv.clone(); let mut blinded_pub = secp_call!(PublicKey::from_secret_key(secp_ctx, &blinded_priv)); let mut first_iteration = true; @@ -321,18 +376,29 @@ impl ChannelManager { secp_call!(blinded_priv.mul_assign(secp_ctx, &secp_call!(SecretKey::from_slice(secp_ctx, &blinding_factor)))); blinded_pub = secp_call!(PublicKey::from_secret_key(secp_ctx, &blinded_priv)); + callback(shared_secret, blinding_factor, ephemeral_pubkey, hop); + } + + Ok(()) + } + + // can only fail if an intermediary hop has an invalid public key or session_priv is invalid + fn construct_onion_keys(secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey) -> Result, HandleError> { + let mut res = Vec::with_capacity(route.hops.len()); + + Self::construct_onion_keys_callback(secp_ctx, route, session_priv, |shared_secret, _blinding_factor, ephemeral_pubkey, _| { let (rho, mu) = ChannelManager::gen_rho_mu_from_shared_secret(&shared_secret); res.push(OnionKeys { #[cfg(test)] - shared_secret: shared_secret, + shared_secret, #[cfg(test)] - blinding_factor: blinding_factor, - ephemeral_pubkey: ephemeral_pubkey, - rho: rho, - mu: mu, + blinding_factor: _blinding_factor, + ephemeral_pubkey, + rho, + mu, }); - } + })?; Ok(res) } @@ -487,13 +553,14 @@ impl ChannelManager { packet } + #[inline] fn build_first_hop_failure_packet(shared_secret: &SharedSecret, failure_type: u16, failure_data: &[u8]) -> msgs::OnionErrorPacket { let failure_packet = ChannelManager::build_failure_packet(shared_secret, failure_type, failure_data); ChannelManager::encrypt_failure_packet(shared_secret, &failure_packet.encode()[..]) } /// only fails if the channel does not yet have an assigned short_id - fn get_channel_update(&self, chan: &mut Channel) -> Result { + fn get_channel_update(&self, chan: &Channel) -> Result { let short_channel_id = match chan.get_short_channel_id() { None => return Err(HandleError{err: "Channel not yet established", msg: None}), Some(id) => id, @@ -521,11 +588,12 @@ impl ChannelManager { }) } - /// Sends a payment along a given route, returning the UpdateAddHTLC message to give to the - /// first hop in route. Value parameters are provided via the last hop in route, see - /// documentation for RouteHop fields for more info. + /// Sends a payment along a given route. + /// Value parameters are provided via the last hop in route, see documentation for RouteHop + /// fields for more info. /// See-also docs on Channel::send_htlc_and_commit. - pub fn send_payment(&self, route: Route, payment_hash: [u8; 32]) -> Result, HandleError> { + /// May generate a SendHTLCs event on success, which should be relayed. + pub fn send_payment(&self, route: Route, payment_hash: [u8; 32]) -> Result<(), HandleError> { if route.hops.len() < 1 || route.hops.len() > 20 { return Err(HandleError{err: "Route didn't go anywhere/had bogus size", msg: None}); } @@ -548,40 +616,60 @@ impl ChannelManager { let (onion_payloads, htlc_msat, htlc_cltv) = ChannelManager::build_onion_payloads(&route)?; let onion_packet = ChannelManager::construct_onion_packet(onion_payloads, onion_keys, associated_data)?; - let mut channel_state = self.channel_state.lock().unwrap(); - let id = match channel_state.short_to_id.get(&route.hops.first().unwrap().short_channel_id) { - None => return Err(HandleError{err: "No channel available with first hop!", msg: None}), - Some(id) => id.clone() - }; - let res = { - let chan = channel_state.by_id.get_mut(&id).unwrap(); - if chan.get_their_node_id() != route.hops.first().unwrap().pubkey { - return Err(HandleError{err: "Node ID mismatch on first hop!", msg: None}); + let (first_hop_node_id, (update_add, commitment_signed, chan_monitor)) = { + let mut channel_state = self.channel_state.lock().unwrap(); + let id = match channel_state.short_to_id.get(&route.hops.first().unwrap().short_channel_id) { + None => return Err(HandleError{err: "No channel available with first hop!", msg: None}), + Some(id) => id.clone() + }; + let res = { + let chan = channel_state.by_id.get_mut(&id).unwrap(); + if chan.get_their_node_id() != route.hops.first().unwrap().pubkey { + return Err(HandleError{err: "Node ID mismatch on first hop!", msg: None}); + } + chan.send_htlc_and_commit(htlc_msat, payment_hash.clone(), htlc_cltv, onion_packet)? + }; + + let first_hop_node_id = route.hops.first().unwrap().pubkey; + + if channel_state.claimable_htlcs.insert(payment_hash, PendingOutboundHTLC::OutboundRoute { + route, + session_priv, + }).is_some() { + // TODO: We need to track these better, we're not generating these, so a + // third-party might make this happen: + panic!("payment_hash was repeated! Don't let this happen"); + } + + match res { + Some(msgs) => (first_hop_node_id, msgs), + None => return Ok(()), } - chan.send_htlc_and_commit(htlc_msat, payment_hash.clone(), htlc_cltv, onion_packet)? }; - if channel_state.claimable_htlcs.insert(payment_hash, PendingOutboundHTLC::OutboundRoute { - route: route, - }).is_some() { - // TODO: We need to track these better, we're not generating these, so a - // third-party might make this happen: - panic!("payment_hash was repeated! Don't let this happen"); + if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) { + unimplemented!(); // maybe remove from claimable_htlcs? } - Ok(res) + let mut events = self.pending_events.lock().unwrap(); + events.push(events::Event::SendHTLCs { + node_id: first_hop_node_id, + msgs: vec![update_add], + commitment_msg: commitment_signed, + }); + Ok(()) } /// Call this upon creation of a funding transaction for the given channel. /// Panics if a funding transaction has already been provided for this channel. - pub fn funding_transaction_generated(&self, temporary_channel_id: &Uint256, funding_txo: (Sha256dHash, u16)) { - let (chan, msg) = { + pub fn funding_transaction_generated(&self, temporary_channel_id: &Uint256, funding_txo: OutPoint) { + let (chan, msg, chan_monitor) = { let mut channel_state = self.channel_state.lock().unwrap(); match channel_state.by_id.remove(&temporary_channel_id) { Some(mut chan) => { - match chan.get_outbound_funding_created(funding_txo.0, funding_txo.1) { + match chan.get_outbound_funding_created(funding_txo) { Ok(funding_msg) => { - (chan, funding_msg) + (chan, funding_msg.0, funding_msg.1) }, Err(_e) => { //TODO: Push e to pendingevents @@ -592,15 +680,9 @@ impl ChannelManager { None => return } }; // Release channel lock for install_watch_outpoint call, - let chan_monitor = chan.channel_monitor(); - match self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) { - Ok(()) => {}, - Err(_e) => { - //TODO: Push e to pendingevents? - return; - } - }; - + if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) { + unimplemented!(); // maybe remove from claimable_htlcs? + } { let mut pending_events = self.pending_events.lock().unwrap(); pending_events.push(events::Event::SendFundingCreated { @@ -635,7 +717,7 @@ impl ChannelManager { let mut channel_state_lock = self.channel_state.lock().unwrap(); let channel_state = channel_state_lock.borrow_parts(); - if Instant::now() < *channel_state.next_forward { + if cfg!(not(feature = "fuzztarget")) && Instant::now() < *channel_state.next_forward { return; } @@ -680,25 +762,25 @@ impl ChannelManager { } if !add_htlc_msgs.is_empty() { - let commitment_msg = match forward_chan.send_commitment() { - Ok(msg) => msg, + let (commitment_msg, monitor) = match forward_chan.send_commitment() { + Ok(res) => res, Err(_) => { //TODO: Handle...this is bad! continue; }, }; - new_events.push(events::Event::SendHTLCs { + new_events.push((Some(monitor), events::Event::SendHTLCs { node_id: forward_chan.get_their_node_id(), msgs: add_htlc_msgs, commitment_msg: commitment_msg, - }); + })); } } else { for forward_info in pending_forwards { - new_events.push(events::Event::PaymentReceived { + new_events.push((None, events::Event::PaymentReceived { payment_hash: forward_info.payment_hash, amt: forward_info.amt_to_forward, - }); + })); } } } @@ -706,23 +788,32 @@ impl ChannelManager { for failed_forward in failed_forwards.drain(..) { match failed_forward.2 { - None => self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failed_forward.0, HTLCFailReason::Reason { failure_code: failed_forward.1, data: &[0;0] }), - Some(chan_update) => self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failed_forward.0, HTLCFailReason::Reason { failure_code: failed_forward.1, data: &chan_update.encode()[..] }), + None => self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failed_forward.0, HTLCFailReason::Reason { failure_code: failed_forward.1, data: Vec::new() }), + Some(chan_update) => self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failed_forward.0, HTLCFailReason::Reason { failure_code: failed_forward.1, data: chan_update.encode_with_len() }), }; } if new_events.is_empty() { return } + new_events.retain(|event| { + if let &Some(ref monitor) = &event.0 { + if let Err(_e) = self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor.clone()) { + unimplemented!();// but def dont push the event... + } + } + true + }); + let mut events = self.pending_events.lock().unwrap(); events.reserve(new_events.len()); for event in new_events.drain(..) { - events.push(event); + events.push(event.1); } } /// Indicates that the preimage for payment_hash is unknown after a PaymentReceived event. pub fn fail_htlc_backwards(&self, payment_hash: &[u8; 32]) -> bool { - self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 15, data: &[0;0] }) + self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 15, data: Vec::new() }) } fn fail_htlc_backwards_internal(&self, mut channel_state: MutexGuard, payment_hash: &[u8; 32], onion_error: HTLCFailReason) -> bool { @@ -734,7 +825,11 @@ impl ChannelManager { }; match pending_htlc { - PendingOutboundHTLC::CycledRoute { source_short_channel_id, incoming_packet_shared_secret, .. } => { + PendingOutboundHTLC::CycledRoute { source_short_channel_id, incoming_packet_shared_secret, route, session_priv } => { + channel_state.claimable_htlcs.insert(payment_hash.clone(), PendingOutboundHTLC::OutboundRoute { + route, + session_priv, + }); pending_htlc = PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, incoming_packet_shared_secret }; }, _ => {} @@ -743,8 +838,8 @@ impl ChannelManager { match pending_htlc { PendingOutboundHTLC::CycledRoute { .. } => { panic!("WAT"); }, PendingOutboundHTLC::OutboundRoute { .. } => { - //TODO: DECRYPT route from OutboundRoute mem::drop(channel_state); + let mut pending_events = self.pending_events.lock().unwrap(); pending_events.push(events::Event::PaymentFailed { payment_hash: payment_hash.clone() @@ -754,7 +849,7 @@ impl ChannelManager { PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, incoming_packet_shared_secret } => { let err_packet = match onion_error { HTLCFailReason::Reason { failure_code, data } => { - let packet = ChannelManager::build_failure_packet(&incoming_packet_shared_secret, failure_code, data).encode(); + let packet = ChannelManager::build_failure_packet(&incoming_packet_shared_secret, failure_code, &data[..]).encode(); ChannelManager::encrypt_failure_packet(&incoming_packet_shared_secret, &packet) }, HTLCFailReason::ErrorPacket { err } => { @@ -762,14 +857,14 @@ impl ChannelManager { } }; - let (node_id, fail_msg) = { + let (node_id, fail_msgs) = { let chan_id = match channel_state.short_to_id.get(&source_short_channel_id) { Some(chan_id) => chan_id.clone(), None => return false }; let chan = channel_state.by_id.get_mut(&chan_id).unwrap(); - match chan.get_update_fail_htlc(payment_hash, err_packet) { + match chan.get_update_fail_htlc_and_commit(payment_hash, err_packet) { Ok(msg) => (chan.get_their_node_id(), msg), Err(_e) => { //TODO: Do something with e? @@ -778,12 +873,23 @@ impl ChannelManager { } }; - mem::drop(channel_state); - let mut pending_events = self.pending_events.lock().unwrap(); - pending_events.push(events::Event::SendFailHTLC { - node_id, - msg: fail_msg - }); + match fail_msgs { + Some((msg, commitment_msg, chan_monitor)) => { + mem::drop(channel_state); + + if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) { + unimplemented!();// but def dont push the event... + } + + let mut pending_events = self.pending_events.lock().unwrap(); + pending_events.push(events::Event::SendFailHTLC { + node_id, + msg: msg, + commitment_msg: commitment_msg, + }); + }, + None => {}, + } true }, @@ -793,6 +899,7 @@ impl ChannelManager { /// Provides a payment preimage in response to a PaymentReceived event, returning true and /// generating message events for the net layer to claim the payment, if possible. Thus, you /// should probably kick the net layer to go send messages if this returns true! + /// May panic if called except in response to a PaymentReceived event. pub fn claim_funds(&self, payment_preimage: [u8; 32]) -> bool { self.claim_funds_internal(payment_preimage, true) } @@ -811,13 +918,13 @@ impl ChannelManager { }; match pending_htlc { - PendingOutboundHTLC::CycledRoute { source_short_channel_id, incoming_packet_shared_secret, route } => { + PendingOutboundHTLC::CycledRoute { source_short_channel_id, incoming_packet_shared_secret, route, session_priv } => { if from_user { // This was the end hop back to us pending_htlc = PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, incoming_packet_shared_secret }; - channel_state.claimable_htlcs.insert(payment_hash, PendingOutboundHTLC::OutboundRoute { route }); + channel_state.claimable_htlcs.insert(payment_hash, PendingOutboundHTLC::OutboundRoute { route, session_priv }); } else { // This came from the first upstream node // Bank error in our favor! Maybe we should tell the user this somehow??? - pending_htlc = PendingOutboundHTLC::OutboundRoute { route }; + pending_htlc = PendingOutboundHTLC::OutboundRoute { route, session_priv }; channel_state.claimable_htlcs.insert(payment_hash, PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, incoming_packet_shared_secret }); } }, @@ -838,14 +945,14 @@ impl ChannelManager { false }, PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, .. } => { - let (node_id, fulfill_msg) = { + let (node_id, fulfill_msgs) = { let chan_id = match channel_state.short_to_id.get(&source_short_channel_id) { Some(chan_id) => chan_id.clone(), None => return false }; let chan = channel_state.by_id.get_mut(&chan_id).unwrap(); - match chan.get_update_fulfill_htlc(payment_preimage) { + match chan.get_update_fulfill_htlc_and_commit(payment_preimage) { Ok(msg) => (chan.get_their_node_id(), msg), Err(_e) => { //TODO: Do something with e? @@ -855,12 +962,21 @@ impl ChannelManager { }; mem::drop(channel_state); - let mut pending_events = self.pending_events.lock().unwrap(); - pending_events.push(events::Event::SendFulfillHTLC { - node_id: node_id, - msg: fulfill_msg - }); + match fulfill_msgs { + Some((msg, commitment_msg, chan_monitor)) => { + if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) { + unimplemented!();// but def dont push the event... + } + let mut pending_events = self.pending_events.lock().unwrap(); + pending_events.push(events::Event::SendFulfillHTLC { + node_id: node_id, + msg, + commitment_msg, + }); + }, + None => {}, + } true }, } @@ -870,6 +986,13 @@ impl ChannelManager { pub fn get_our_node_id(&self) -> PublicKey { PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key).unwrap() } + + /// Used to restore channels to normal operation after a + /// ChannelMonitorUpdateErr::TemporaryFailure was returned from a channel monitor update + /// operation. + pub fn test_restore_channel_monitor(&self) { + unimplemented!(); + } } impl events::EventsProvider for ChannelManager { @@ -883,36 +1006,68 @@ impl events::EventsProvider for ChannelManager { impl ChainListener for ChannelManager { fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]) { - let mut new_funding_locked_messages = Vec::new(); + let mut new_events = Vec::new(); { let mut channel_state = self.channel_state.lock().unwrap(); let mut short_to_ids_to_insert = Vec::new(); - for channel in channel_state.by_id.values_mut() { - match channel.block_connected(header, height, txn_matched, indexes_of_txn_matched) { - Some(funding_locked) => { - let announcement_sigs = match self.get_announcement_sigs(channel) { - Ok(res) => res, - Err(_e) => { - //TODO: push e on events and blow up the channel (it has bad keys) - continue; + let mut short_to_ids_to_remove = Vec::new(); + channel_state.by_id.retain(|_, channel| { + if let Some(funding_locked) = channel.block_connected(header, height, txn_matched, indexes_of_txn_matched) { + let announcement_sigs = match self.get_announcement_sigs(channel) { + Ok(res) => res, + Err(_e) => { + //TODO: push e on events and blow up the channel (it has bad keys) + return true; + } + }; + new_events.push(events::Event::SendFundingLocked { + node_id: channel.get_their_node_id(), + msg: funding_locked, + announcement_sigs: announcement_sigs + }); + short_to_ids_to_insert.push((channel.get_short_channel_id().unwrap(), channel.channel_id())); + } + if let Some(funding_txo) = channel.get_funding_txo() { + for tx in txn_matched { + for inp in tx.input.iter() { + if inp.prev_hash == funding_txo.txid && inp.prev_index == funding_txo.index as u32 { + if let Some(short_id) = channel.get_short_channel_id() { + short_to_ids_to_remove.push(short_id); + } + channel.force_shutdown(); + if let Ok(update) = self.get_channel_update(&channel) { + new_events.push(events::Event::BroadcastChannelUpdate { + msg: update + }); + } + return false; } - }; - new_funding_locked_messages.push(events::Event::SendFundingLocked { - node_id: channel.get_their_node_id(), - msg: funding_locked, - announcement_sigs: announcement_sigs + } + } + } + if channel.channel_monitor().would_broadcast_at_height(height) { + if let Some(short_id) = channel.get_short_channel_id() { + short_to_ids_to_remove.push(short_id); + } + channel.force_shutdown(); + if let Ok(update) = self.get_channel_update(&channel) { + new_events.push(events::Event::BroadcastChannelUpdate { + msg: update }); - short_to_ids_to_insert.push((channel.get_short_channel_id().unwrap(), channel.channel_id())); - }, - None => {} + } + return false; } + true + }); + for to_remove in short_to_ids_to_remove { + channel_state.short_to_id.remove(&to_remove); } for to_insert in short_to_ids_to_insert { channel_state.short_to_id.insert(to_insert.0, to_insert.1); } } let mut pending_events = self.pending_events.lock().unwrap(); - for funding_locked in new_funding_locked_messages.drain(..) { + for funding_locked in new_events.drain(..) { pending_events.push(funding_locked); } } @@ -937,7 +1092,28 @@ impl ChannelMessageHandler for ChannelManager { if channel_state.by_id.contains_key(&msg.temporary_channel_id) { return Err(HandleError{err: "temporary_channel_id collision!", msg: None}); } - let channel = Channel::new_from_req(&*self.fee_estimator, their_node_id.clone(), msg, 0, self.announce_channels_publicly)?; + + let chan_keys = if cfg!(feature = "fuzztarget") { + ChannelKeys { + funding_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + revocation_base_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + payment_base_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + delayed_payment_base_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + htlc_base_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + channel_close_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + channel_monitor_claim_key: SecretKey::from_slice(&self.secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(), + commitment_seed: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + } + } else { + let mut key_seed = [0u8; 32]; + rng::fill_bytes(&mut key_seed); + match ChannelKeys::new_from_seed(&key_seed) { + Ok(key) => key, + Err(_) => panic!("RNG is busted!") + } + }; + + let channel = Channel::new_from_req(&*self.fee_estimator, chan_keys, their_node_id.clone(), msg, 0, self.announce_channels_publicly)?; let accept_msg = channel.get_accept_channel()?; channel_state.by_id.insert(channel.channel_id(), channel); Ok(accept_msg) @@ -971,7 +1147,7 @@ impl ChannelMessageHandler for ChannelManager { //TODO: broke this - a node shouldn't be able to get their channel removed by sending a //funding_created a second time, or long after the first, or whatever (note this also //leaves the short_to_id map in a busted state. - let chan = { + let (chan, funding_msg, monitor_update) = { let mut channel_state = self.channel_state.lock().unwrap(); match channel_state.by_id.remove(&msg.temporary_channel_id) { Some(mut chan) => { @@ -979,8 +1155,8 @@ impl ChannelMessageHandler for ChannelManager { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) } match chan.funding_created(msg) { - Ok(funding_msg) => { - (chan, funding_msg) + Ok((funding_msg, monitor_update)) => { + (chan, funding_msg, monitor_update) }, Err(e) => { return Err(e); @@ -993,27 +1169,31 @@ impl ChannelMessageHandler for ChannelManager { // note that this means if the remote end is misbehaving and sends a message for the same // channel back-to-back with funding_created, we'll end up thinking they sent a message // for a bogus channel. - let chan_monitor = chan.0.channel_monitor(); - self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor)?; + if let Err(_e) = self.monitor.add_update_monitor(monitor_update.get_funding_txo().unwrap(), monitor_update) { + unimplemented!(); + } let mut channel_state = self.channel_state.lock().unwrap(); - channel_state.by_id.insert(chan.1.channel_id, chan.0); - Ok(chan.1) + channel_state.by_id.insert(funding_msg.channel_id, chan); + Ok(funding_msg) } fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &msgs::FundingSigned) -> Result<(), HandleError> { - let (funding_txo, user_id) = { + let (funding_txo, user_id, monitor) = { let mut channel_state = self.channel_state.lock().unwrap(); match channel_state.by_id.get_mut(&msg.channel_id) { Some(chan) => { if chan.get_their_node_id() != *their_node_id { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) } - chan.funding_signed(&msg)?; - (chan.get_funding_txo().unwrap(), chan.get_user_id()) + let chan_monitor = chan.funding_signed(&msg)?; + (chan.get_funding_txo().unwrap(), chan.get_user_id(), chan_monitor) }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) } }; + if let Err(_e) = self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor) { + unimplemented!(); + } let mut pending_events = self.pending_events.lock().unwrap(); pending_events.push(events::Event::FundingBroadcastSafe { funding_txo: funding_txo, @@ -1037,8 +1217,9 @@ impl ChannelMessageHandler for ChannelManager { } fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &msgs::Shutdown) -> Result<(Option, Option), HandleError> { - let res = { - let mut channel_state = self.channel_state.lock().unwrap(); + let (res, chan_option) = { + let mut channel_state_lock = self.channel_state.lock().unwrap(); + let channel_state = channel_state_lock.borrow_parts(); match channel_state.by_id.entry(msg.channel_id.clone()) { hash_map::Entry::Occupied(mut chan_entry) => { @@ -1047,23 +1228,34 @@ impl ChannelMessageHandler for ChannelManager { } let res = chan_entry.get_mut().shutdown(&*self.fee_estimator, &msg)?; if chan_entry.get().is_shutdown() { - chan_entry.remove_entry(); - } - res + if let Some(short_id) = chan_entry.get().get_short_channel_id() { + channel_state.short_to_id.remove(&short_id); + } + (res, Some(chan_entry.remove_entry().1)) + } else { (res, None) } }, hash_map::Entry::Vacant(_) => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) } }; for payment_hash in res.2 { // unknown_next_peer...I dunno who that is anymore.... - self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 10, data: &[0; 0] }); + self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 10, data: Vec::new() }); + } + if let Some(chan) = chan_option { + if let Ok(update) = self.get_channel_update(&chan) { + let mut events = self.pending_events.lock().unwrap(); + events.push(events::Event::BroadcastChannelUpdate { + msg: update + }); + } } Ok((res.0, res.1)) } fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &msgs::ClosingSigned) -> Result, HandleError> { - let res = { - let mut channel_state = self.channel_state.lock().unwrap(); + let (res, chan_option) = { + let mut channel_state_lock = self.channel_state.lock().unwrap(); + let channel_state = channel_state_lock.borrow_parts(); match channel_state.by_id.entry(msg.channel_id.clone()) { hash_map::Entry::Occupied(mut chan_entry) => { if chan_entry.get().get_their_node_id() != *their_node_id { @@ -1076,9 +1268,11 @@ impl ChannelMessageHandler for ChannelManager { // also implies there are no pending HTLCs left on the channel, so we can // fully delete it from tracking (the channel monitor is still around to // watch for old state broadcasts)! - chan_entry.remove_entry(); - } - res + if let Some(short_id) = chan_entry.get().get_short_channel_id() { + channel_state.short_to_id.remove(&short_id); + } + (res, Some(chan_entry.remove_entry().1)) + } else { (res, None) } }, hash_map::Entry::Vacant(_) => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) } @@ -1086,6 +1280,14 @@ impl ChannelMessageHandler for ChannelManager { if let Some(broadcast_tx) = res.1 { self.tx_broadcaster.broadcast_transaction(&broadcast_tx); } + if let Some(chan) = chan_option { + if let Ok(update) = self.get_channel_update(&chan) { + let mut events = self.pending_events.lock().unwrap(); + events.push(events::Event::BroadcastChannelUpdate { + msg: update + }); + } + } Ok(res.0) } @@ -1120,7 +1322,7 @@ impl ChannelMessageHandler for ChannelManager { ($msg: expr, $err_code: expr, $data: expr) => { return Err(msgs::HandleError { err: $msg, - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { + msg: Some(msgs::ErrorAction::UpdateFailHTLC { msg: msgs::UpdateFailHTLC { channel_id: msg.channel_id, htlc_id: msg.htlc_id, @@ -1250,7 +1452,7 @@ impl ChannelMessageHandler for ChannelManager { let chan = channel_state.by_id.get_mut(&forwarding_id).unwrap(); if !chan.is_live() { let chan_update = self.get_channel_update(chan).unwrap(); - return_err!("Forwarding channel is not in a ready state.", 0x4000 | 10, &chan_update.encode()[..]); + return_err!("Forwarding channel is not in a ready state.", 0x4000 | 7, &chan_update.encode_with_len()[..]); } } @@ -1294,16 +1496,17 @@ impl ChannelMessageHandler for ChannelManager { match claimable_htlcs_entry { hash_map::Entry::Occupied(mut e) => { let outbound_route = e.get_mut(); - let route = match outbound_route { - &mut PendingOutboundHTLC::OutboundRoute { ref route } => { - route.clone() + let (route, session_priv) = match outbound_route { + &mut PendingOutboundHTLC::OutboundRoute { ref route, ref session_priv } => { + (route.clone(), session_priv.clone()) }, _ => { panic!("WAT") }, }; *outbound_route = PendingOutboundHTLC::CycledRoute { source_short_channel_id, incoming_packet_shared_secret: shared_secret, - route + route, + session_priv, }; }, hash_map::Entry::Vacant(e) => { @@ -1318,73 +1521,165 @@ impl ChannelMessageHandler for ChannelManager { } fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFulfillHTLC) -> Result<(), HandleError> { - { + //TODO: Delay the claimed_funds relaying just like we do outbound relay! + // Claim funds first, cause we don't really care if the channel we received the message on + // is broken, we may have enough info to get our own money! + self.claim_funds_internal(msg.payment_preimage.clone(), false); + + let monitor = { let mut channel_state = self.channel_state.lock().unwrap(); match channel_state.by_id.get_mut(&msg.channel_id) { Some(chan) => { if chan.get_their_node_id() != *their_node_id { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) } - chan.update_fulfill_htlc(&msg)?; + chan.update_fulfill_htlc(&msg)? }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) } + }; + if let Err(_e) = self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor) { + unimplemented!(); } - //TODO: Delay the claimed_funds relaying just like we do outbound relay! - self.claim_funds_internal(msg.payment_preimage.clone(), false); Ok(()) } - fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailHTLC) -> Result<(), HandleError> { + fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailHTLC) -> Result, HandleError> { let mut channel_state = self.channel_state.lock().unwrap(); let payment_hash = match channel_state.by_id.get_mut(&msg.channel_id) { Some(chan) => { if chan.get_their_node_id() != *their_node_id { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) } - chan.update_fail_htlc(&msg)? + chan.update_fail_htlc(&msg, HTLCFailReason::ErrorPacket { err: msg.reason.clone() }) }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - }; - self.fail_htlc_backwards_internal(channel_state, &payment_hash, HTLCFailReason::ErrorPacket { err: &msg.reason }); - Ok(()) + }?; + + if let Some(pending_htlc) = channel_state.claimable_htlcs.get(&payment_hash) { + match pending_htlc { + &PendingOutboundHTLC::OutboundRoute { ref route, ref session_priv } => { + // Handle packed channel/node updates for passing back for the route handler + let mut packet_decrypted = msg.reason.data.clone(); + let mut res = None; + Self::construct_onion_keys_callback(&self.secp_ctx, &route, &session_priv, |shared_secret, _, _, route_hop| { + if res.is_some() { return; } + + let ammag = ChannelManager::gen_ammag_from_shared_secret(&shared_secret); + + let mut decryption_tmp = Vec::with_capacity(packet_decrypted.len()); + decryption_tmp.resize(packet_decrypted.len(), 0); + let mut chacha = ChaCha20::new(&ammag, &[0u8; 8]); + chacha.process(&packet_decrypted, &mut decryption_tmp[..]); + packet_decrypted = decryption_tmp; + + if let Ok(err_packet) = msgs::DecodedOnionErrorPacket::decode(&packet_decrypted) { + if err_packet.failuremsg.len() >= 2 { + let um = ChannelManager::gen_um_from_shared_secret(&shared_secret); + + let mut hmac = Hmac::new(Sha256::new(), &um); + hmac.input(&err_packet.encode()[32..]); + let mut calc_tag = [0u8; 32]; + hmac.raw_result(&mut calc_tag); + if crypto::util::fixed_time_eq(&calc_tag, &err_packet.hmac) { + const UNKNOWN_CHAN: u16 = 0x4000|10; + const TEMP_CHAN_FAILURE: u16 = 0x4000|7; + match byte_utils::slice_to_be16(&err_packet.failuremsg[0..2]) { + TEMP_CHAN_FAILURE => { + if err_packet.failuremsg.len() >= 4 { + let update_len = byte_utils::slice_to_be16(&err_packet.failuremsg[2..4]) as usize; + if err_packet.failuremsg.len() >= 4 + update_len { + if let Ok(chan_update) = msgs::ChannelUpdate::decode(&err_packet.failuremsg[4..4 + update_len]) { + res = Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { + msg: chan_update, + }); + } + } + } + }, + UNKNOWN_CHAN => { + // No such next-hop. We know this came from the + // current node as the HMAC validated. + res = Some(msgs::HTLCFailChannelUpdate::ChannelClosed { + short_channel_id: route_hop.short_channel_id + }); + }, + _ => {}, //TODO: Enumerate all of these! + } + } + } + } + }).unwrap(); + Ok(res) + }, + _ => { Ok(None) }, + } + } else { + Ok(None) + } } fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailMalformedHTLC) -> Result<(), HandleError> { let mut channel_state = self.channel_state.lock().unwrap(); - let payment_hash = match channel_state.by_id.get_mut(&msg.channel_id) { + match channel_state.by_id.get_mut(&msg.channel_id) { Some(chan) => { if chan.get_their_node_id() != *their_node_id { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) } - chan.update_fail_malformed_htlc(&msg)? + chan.update_fail_malformed_htlc(&msg, HTLCFailReason::Reason { failure_code: msg.failure_code, data: Vec::new() }) }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - }; - self.fail_htlc_backwards_internal(channel_state, &payment_hash, HTLCFailReason::Reason { failure_code: msg.failure_code, data: &[0;0] }); - Ok(()) + } } - fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &msgs::CommitmentSigned) -> Result { - let mut forward_event = None; - let (res, monitor) = { + fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &msgs::CommitmentSigned) -> Result<(msgs::RevokeAndACK, Option), HandleError> { + let (revoke_and_ack, commitment_signed, chan_monitor) = { let mut channel_state = self.channel_state.lock().unwrap(); + match channel_state.by_id.get_mut(&msg.channel_id) { + Some(chan) => { + if chan.get_their_node_id() != *their_node_id { + return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) + } + chan.commitment_signed(&msg)? + }, + None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + } + }; + if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) { + unimplemented!(); + } - let ((res, mut forwarding_infos), monitor) = match channel_state.by_id.get_mut(&msg.channel_id) { + Ok((revoke_and_ack, commitment_signed)) + } + + fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &msgs::RevokeAndACK) -> Result, HandleError> { + let (res, mut pending_forwards, mut pending_failures, chan_monitor) = { + let mut channel_state = self.channel_state.lock().unwrap(); + match channel_state.by_id.get_mut(&msg.channel_id) { Some(chan) => { if chan.get_their_node_id() != *their_node_id { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) } - (chan.commitment_signed(&msg)?, chan.channel_monitor()) + chan.revoke_and_ack(&msg)? }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - }; + } + }; + if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) { + unimplemented!(); + } + for failure in pending_failures.drain(..) { + self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failure.0, failure.1); + } + let mut forward_event = None; + if !pending_forwards.is_empty() { + let mut channel_state = self.channel_state.lock().unwrap(); if channel_state.forward_htlcs.is_empty() { forward_event = Some(Instant::now() + Duration::from_millis(((rng::rand_f32() * 4.0 + 1.0) * MIN_HTLC_RELAY_HOLDING_CELL_MILLIS as f32) as u64)); channel_state.next_forward = forward_event.unwrap(); } - for forward_info in forwarding_infos.drain(..) { + for forward_info in pending_forwards.drain(..) { match channel_state.forward_htlcs.entry(forward_info.short_channel_id) { hash_map::Entry::Occupied(mut entry) => { entry.get_mut().push(forward_info); @@ -1394,12 +1689,7 @@ impl ChannelMessageHandler for ChannelManager { } } } - - (res, monitor) - }; - //TODO: Only if we store HTLC sigs - self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; - + } match forward_event { Some(time) => { let mut pending_events = self.pending_events.lock().unwrap(); @@ -1413,23 +1703,6 @@ impl ChannelMessageHandler for ChannelManager { Ok(res) } - fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &msgs::RevokeAndACK) -> Result, msgs::CommitmentSigned)>, HandleError> { - let (res, monitor) = { - let mut channel_state = self.channel_state.lock().unwrap(); - match channel_state.by_id.get_mut(&msg.channel_id) { - Some(chan) => { - if chan.get_their_node_id() != *their_node_id { - return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) - } - (chan.revoke_and_ack(&msg)?, chan.channel_monitor()) - }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - } - }; - self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; - Ok(res) - } - fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFee) -> Result<(), HandleError> { let mut channel_state = self.channel_state.lock().unwrap(); match channel_state.by_id.get_mut(&msg.channel_id) { @@ -1480,11 +1753,56 @@ impl ChannelMessageHandler for ChannelManager { pending_events.push(events::Event::BroadcastChannelAnnouncement { msg: chan_announcement, update_msg: chan_update }); Ok(()) } + + fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool) { + let mut new_events = Vec::new(); + { + let mut channel_state_lock = self.channel_state.lock().unwrap(); + let channel_state = channel_state_lock.borrow_parts(); + let short_to_id = channel_state.short_to_id; + if no_connection_possible { + channel_state.by_id.retain(|_, chan| { + if chan.get_their_node_id() == *their_node_id { + if let Some(short_id) = chan.get_short_channel_id() { + short_to_id.remove(&short_id); + } + let txn_to_broadcast = chan.force_shutdown(); + for tx in txn_to_broadcast { + self.tx_broadcaster.broadcast_transaction(&tx); + } + if let Ok(update) = self.get_channel_update(&chan) { + new_events.push(events::Event::BroadcastChannelUpdate { + msg: update + }); + } + false + } else { + true + } + }); + } else { + for chan in channel_state.by_id { + if chan.1.get_their_node_id() == *their_node_id { + //TODO: mark channel disabled (and maybe announce such after a timeout). Also + //fail and wipe any uncommitted outbound HTLCs as those are considered after + //reconnect. + } + } + } + } + if !new_events.is_empty() { + let mut pending_events = self.pending_events.lock().unwrap(); + for event in new_events.drain(..) { + pending_events.push(event); + } + } + } } #[cfg(test)] mod tests { use chain::chaininterface; + use chain::transaction::OutPoint; use ln::channelmanager::{ChannelManager,OnionKeys}; use ln::router::{Route, RouteHop, Router}; use ln::msgs; @@ -1496,7 +1814,7 @@ mod tests { use bitcoin::util::hash::Sha256dHash; use bitcoin::util::uint::Uint256; use bitcoin::blockdata::block::BlockHeader; - use bitcoin::blockdata::transaction::Transaction; + use bitcoin::blockdata::transaction::{Transaction, TxOut}; use bitcoin::network::constants::Network; use bitcoin::network::serialize::serialize; use bitcoin::network::serialize::BitcoinHash; @@ -1509,9 +1827,11 @@ mod tests { use rand::{thread_rng,Rng}; - use std::sync::{Arc, Mutex}; + use std::collections::HashMap; use std::default::Default; + use std::sync::{Arc, Mutex}; use std::time::Instant; + use std::mem; fn build_test_onion_keys() -> Vec { // Keys from BOLT 4, used in both test vector tests @@ -1663,53 +1983,80 @@ mod tests { assert_eq!(onion_packet_5.data, hex_bytes("9c5add3963fc7f6ed7f148623c84134b5647e1306419dbe2174e523fa9e2fbed3a06a19f899145610741c83ad40b7712aefaddec8c6baf7325d92ea4ca4d1df8bce517f7e54554608bf2bd8071a4f52a7a2f7ffbb1413edad81eeea5785aa9d990f2865dc23b4bc3c301a94eec4eabebca66be5cf638f693ec256aec514620cc28ee4a94bd9565bc4d4962b9d3641d4278fb319ed2b84de5b665f307a2db0f7fbb757366067d88c50f7e829138fde4f78d39b5b5802f1b92a8a820865af5cc79f9f30bc3f461c66af95d13e5e1f0381c184572a91dee1c849048a647a1158cf884064deddbf1b0b88dfe2f791428d0ba0f6fb2f04e14081f69165ae66d9297c118f0907705c9c4954a199bae0bb96fad763d690e7daa6cfda59ba7f2c8d11448b604d12d").unwrap()); } - static mut CHAN_COUNT: u16 = 0; - fn confirm_transaction(chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction) { + fn confirm_transaction(chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction, chan_id: u32) { let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - let chan_id = unsafe { CHAN_COUNT }; - chain.block_connected_checked(&header, 1, &[tx; 1], &[chan_id as u32; 1]); + chain.block_connected_checked(&header, 1, &[tx; 1], &[chan_id; 1]); for i in 2..100 { header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; chain.block_connected_checked(&header, i, &[tx; 0], &[0; 0]); } } - fn create_chan_between_nodes(node_a: &ChannelManager, chain_a: &chaininterface::ChainWatchInterfaceUtil, node_b: &ChannelManager, chain_b: &chaininterface::ChainWatchInterfaceUtil) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, Uint256) { - let open_chan = node_a.create_channel(node_b.get_our_node_id(), 100000, 42).unwrap(); - let accept_chan = node_b.handle_open_channel(&node_a.get_our_node_id(), &open_chan).unwrap(); - node_a.handle_accept_channel(&node_b.get_our_node_id(), &accept_chan).unwrap(); + struct Node { + feeest: Arc, + chain_monitor: Arc, + tx_broadcaster: Arc, + chan_monitor: Arc, + node_id: SecretKey, + node: Arc, + router: Router, + } + + static mut CHAN_COUNT: u32 = 0; + fn create_chan_between_nodes(node_a: &Node, node_b: &Node) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, Uint256, Transaction) { + let open_chan = node_a.node.create_channel(node_b.node.get_our_node_id(), 100000, 42).unwrap(); + let accept_chan = node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), &open_chan).unwrap(); + node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), &accept_chan).unwrap(); let chan_id = unsafe { CHAN_COUNT }; - let tx = Transaction { version: chan_id as u32, lock_time: 0, input: Vec::new(), output: Vec::new() }; - let funding_output = (Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), chan_id); + let tx; + let funding_output; - let events_1 = node_a.get_and_clear_pending_events(); + let events_1 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_1.len(), 1); match events_1[0] { - Event::FundingGenerationReady { ref temporary_channel_id, ref channel_value_satoshis, output_script: _, user_channel_id } => { + Event::FundingGenerationReady { ref temporary_channel_id, ref channel_value_satoshis, ref output_script, user_channel_id } => { assert_eq!(*channel_value_satoshis, 100000); assert_eq!(user_channel_id, 42); - node_a.funding_transaction_generated(&temporary_channel_id, funding_output.clone()); - //TODO: Check that we got added to chan_monitor_a! + tx = Transaction { version: chan_id as u32, lock_time: 0, input: Vec::new(), output: vec![TxOut { + value: *channel_value_satoshis, script_pubkey: output_script.clone(), + }]}; + funding_output = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); + + node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output); + let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + assert_eq!(added_monitors[0].0, funding_output); + added_monitors.clear(); }, _ => panic!("Unexpected event"), } - let events_2 = node_a.get_and_clear_pending_events(); + let events_2 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_2.len(), 1); let funding_signed = match events_2[0] { Event::SendFundingCreated { ref node_id, ref msg } => { - assert_eq!(*node_id, node_b.get_our_node_id()); - node_b.handle_funding_created(&node_a.get_our_node_id(), msg).unwrap() - //TODO: Check that we got added to chan_monitor_b! + assert_eq!(*node_id, node_b.node.get_our_node_id()); + let res = node_b.node.handle_funding_created(&node_a.node.get_our_node_id(), msg).unwrap(); + let mut added_monitors = node_b.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + assert_eq!(added_monitors[0].0, funding_output); + added_monitors.clear(); + res }, _ => panic!("Unexpected event"), }; - node_a.handle_funding_signed(&node_b.get_our_node_id(), &funding_signed).unwrap(); + node_a.node.handle_funding_signed(&node_b.node.get_our_node_id(), &funding_signed).unwrap(); + { + let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + assert_eq!(added_monitors[0].0, funding_output); + added_monitors.clear(); + } - let events_3 = node_a.get_and_clear_pending_events(); + let events_3 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_3.len(), 1); match events_3[0] { Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => { @@ -1719,35 +2066,35 @@ mod tests { _ => panic!("Unexpected event"), }; - confirm_transaction(&chain_a, &tx); - let events_4 = node_a.get_and_clear_pending_events(); + confirm_transaction(&node_a.chain_monitor, &tx, chan_id); + let events_4 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_4.len(), 1); match events_4[0] { Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => { - assert_eq!(*node_id, node_b.get_our_node_id()); + assert_eq!(*node_id, node_b.node.get_our_node_id()); assert!(announcement_sigs.is_none()); - node_b.handle_funding_locked(&node_a.get_our_node_id(), msg).unwrap() + node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), msg).unwrap() }, _ => panic!("Unexpected event"), }; let channel_id; - confirm_transaction(&chain_b, &tx); - let events_5 = node_b.get_and_clear_pending_events(); + confirm_transaction(&node_b.chain_monitor, &tx, chan_id); + let events_5 = node_b.node.get_and_clear_pending_events(); assert_eq!(events_5.len(), 1); let as_announcement_sigs = match events_5[0] { Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => { - assert_eq!(*node_id, node_a.get_our_node_id()); + assert_eq!(*node_id, node_a.node.get_our_node_id()); channel_id = msg.channel_id.clone(); - let as_announcement_sigs = node_a.handle_funding_locked(&node_b.get_our_node_id(), msg).unwrap().unwrap(); - node_a.handle_announcement_signatures(&node_b.get_our_node_id(), &(*announcement_sigs).clone().unwrap()).unwrap(); + let as_announcement_sigs = node_a.node.handle_funding_locked(&node_b.node.get_our_node_id(), msg).unwrap().unwrap(); + node_a.node.handle_announcement_signatures(&node_b.node.get_our_node_id(), &(*announcement_sigs).clone().unwrap()).unwrap(); as_announcement_sigs }, _ => panic!("Unexpected event"), }; - let events_6 = node_a.get_and_clear_pending_events(); + let events_6 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_6.len(), 1); let (announcement, as_update) = match events_6[0] { Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { @@ -1756,8 +2103,8 @@ mod tests { _ => panic!("Unexpected event"), }; - node_b.handle_announcement_signatures(&node_a.get_our_node_id(), &as_announcement_sigs).unwrap(); - let events_7 = node_b.get_and_clear_pending_events(); + node_b.node.handle_announcement_signatures(&node_a.node.get_our_node_id(), &as_announcement_sigs).unwrap(); + let events_7 = node_b.node.get_and_clear_pending_events(); assert_eq!(events_7.len(), 1); let bs_update = match events_7[0] { Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { @@ -1771,12 +2118,22 @@ mod tests { CHAN_COUNT += 1; } - ((*announcement).clone(), (*as_update).clone(), (*bs_update).clone(), channel_id) + ((*announcement).clone(), (*as_update).clone(), (*bs_update).clone(), channel_id, tx) + } + + fn create_announced_chan_between_nodes(nodes: &Vec, a: usize, b: usize) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, Uint256, Transaction) { + let chan_announcement = create_chan_between_nodes(&nodes[a], &nodes[b]); + for node in nodes { + assert!(node.router.handle_channel_announcement(&chan_announcement.0).unwrap()); + node.router.handle_channel_update(&chan_announcement.1).unwrap(); + node.router.handle_channel_update(&chan_announcement.2).unwrap(); + } + (chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4) } - fn close_channel(outbound_node: &ChannelManager, outbound_broadcaster: &test_utils::TestBroadcaster, inbound_node: &ChannelManager, inbound_broadcaster: &test_utils::TestBroadcaster, channel_id: &Uint256, close_inbound_first: bool) { - let (node_a, broadcaster_a) = if close_inbound_first { (inbound_node, inbound_broadcaster) } else { (outbound_node, outbound_broadcaster) }; - let (node_b, broadcaster_b) = if close_inbound_first { (outbound_node, outbound_broadcaster) } else { (inbound_node, inbound_broadcaster) }; + fn close_channel(outbound_node: &Node, inbound_node: &Node, channel_id: &Uint256, funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate) { + let (node_a, broadcaster_a) = if close_inbound_first { (&inbound_node.node, &inbound_node.tx_broadcaster) } else { (&outbound_node.node, &outbound_node.tx_broadcaster) }; + let (node_b, broadcaster_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster) } else { (&inbound_node.node, &inbound_node.tx_broadcaster) }; let (tx_a, tx_b); let shutdown_a = node_a.close_channel(channel_id).unwrap(); @@ -1807,6 +2164,29 @@ mod tests { tx_a = broadcaster_a.txn_broadcasted.lock().unwrap().remove(0); } assert_eq!(tx_a, tx_b); + let mut funding_tx_map = HashMap::new(); + funding_tx_map.insert(funding_tx.txid(), funding_tx); + tx_a.verify(&funding_tx_map).unwrap(); + + let events_1 = node_a.get_and_clear_pending_events(); + assert_eq!(events_1.len(), 1); + let as_update = match events_1[0] { + Event::BroadcastChannelUpdate { ref msg } => { + msg.clone() + }, + _ => panic!("Unexpected event"), + }; + + let events_2 = node_b.get_and_clear_pending_events(); + assert_eq!(events_2.len(), 1); + let bs_update = match events_2[0] { + Event::BroadcastChannelUpdate { ref msg } => { + msg.clone() + }, + _ => panic!("Unexpected event"), + }; + + (as_update, bs_update) } struct SendEvent { @@ -1826,7 +2206,7 @@ mod tests { } static mut PAYMENT_COUNT: u8 = 0; - fn send_along_route(origin_node: &ChannelManager, route: Route, expected_route: &[&ChannelManager], recv_value: u64) -> ([u8; 32], [u8; 32]) { + fn send_along_route(origin_node: &Node, route: Route, expected_route: &[&Node], recv_value: u64) -> ([u8; 32], [u8; 32]) { let our_payment_preimage = unsafe { [PAYMENT_COUNT; 32] }; unsafe { PAYMENT_COUNT += 1 }; let our_payment_hash = { @@ -1838,33 +2218,60 @@ mod tests { }; let mut payment_event = { - let msgs = origin_node.send_payment(route, our_payment_hash).unwrap().unwrap(); - SendEvent { - node_id: expected_route[0].get_our_node_id(), - msgs: vec!(msgs.0), - commitment_msg: msgs.1, + origin_node.node.send_payment(route, our_payment_hash).unwrap(); + { + let mut added_monitors = origin_node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); } + + let mut events = origin_node.node.get_and_clear_pending_events(); + assert_eq!(events.len(), 1); + SendEvent::from_event(events.remove(0)) }; let mut prev_node = origin_node; - for (idx, node) in expected_route.iter().enumerate() { - assert_eq!(node.get_our_node_id(), payment_event.node_id); + for (idx, &node) in expected_route.iter().enumerate() { + assert_eq!(node.node.get_our_node_id(), payment_event.node_id); + + node.node.handle_update_add_htlc(&prev_node.node.get_our_node_id(), &payment_event.msgs[0]).unwrap(); + { + let added_monitors = node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 0); + } - node.handle_update_add_htlc(&prev_node.get_our_node_id(), &payment_event.msgs[0]).unwrap(); - let revoke_and_ack = node.handle_commitment_signed(&prev_node.get_our_node_id(), &payment_event.commitment_msg).unwrap(); - assert!(prev_node.handle_revoke_and_ack(&node.get_our_node_id(), &revoke_and_ack).unwrap().is_none()); + let revoke_and_ack = node.node.handle_commitment_signed(&prev_node.node.get_our_node_id(), &payment_event.commitment_msg).unwrap(); + { + let mut added_monitors = node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + assert!(prev_node.node.handle_revoke_and_ack(&node.node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + let prev_revoke_and_ack = prev_node.node.handle_commitment_signed(&node.node.get_our_node_id(), &revoke_and_ack.1.unwrap()).unwrap(); + { + let mut added_monitors = prev_node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!(node.node.handle_revoke_and_ack(&prev_node.node.get_our_node_id(), &prev_revoke_and_ack.0).unwrap().is_none()); + assert!(prev_revoke_and_ack.1.is_none()); + { + let mut added_monitors = node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } - let events_1 = node.get_and_clear_pending_events(); + let events_1 = node.node.get_and_clear_pending_events(); assert_eq!(events_1.len(), 1); match events_1[0] { Event::PendingHTLCsForwardable { .. } => { }, _ => panic!("Unexpected event"), }; - node.channel_state.lock().unwrap().next_forward = Instant::now(); - node.process_pending_htlc_forward(); + node.node.channel_state.lock().unwrap().next_forward = Instant::now(); + node.node.process_pending_htlc_forward(); - let mut events_2 = node.get_and_clear_pending_events(); + let mut events_2 = node.node.get_and_clear_pending_events(); assert_eq!(events_2.len(), 1); if idx == expected_route.len() - 1 { match events_2[0] { @@ -1875,9 +2282,12 @@ mod tests { _ => panic!("Unexpected event"), } } else { - for event in events_2.drain(..) { - payment_event = SendEvent::from_event(event); + { + let mut added_monitors = node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); } + payment_event = SendEvent::from_event(events_2.remove(0)); assert_eq!(payment_event.msgs.len(), 1); } @@ -1887,26 +2297,67 @@ mod tests { (our_payment_preimage, our_payment_hash) } - fn claim_payment(origin_node: &ChannelManager, expected_route: &[&ChannelManager], our_payment_preimage: [u8; 32]) { - assert!(expected_route.last().unwrap().claim_funds(our_payment_preimage)); + fn claim_payment(origin_node: &Node, expected_route: &[&Node], our_payment_preimage: [u8; 32]) { + assert!(expected_route.last().unwrap().node.claim_funds(our_payment_preimage)); + { + let mut added_monitors = expected_route.last().unwrap().chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + + let mut next_msgs: Option<(msgs::UpdateFulfillHTLC, msgs::CommitmentSigned)> = None; + macro_rules! update_fulfill_dance { + ($node: expr, $prev_node: expr, $last_node: expr) => { + { + $node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0).unwrap(); + { + let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap(); + if $last_node { + assert_eq!(added_monitors.len(), 1); + } else { + assert_eq!(added_monitors.len(), 2); + assert!(added_monitors[0].0 != added_monitors[1].0); + } + added_monitors.clear(); + } + let revoke_and_commit = $node.node.handle_commitment_signed(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().1).unwrap(); + { + let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + assert!($prev_node.node.handle_revoke_and_ack(&$node.node.get_our_node_id(), &revoke_and_commit.0).unwrap().is_none()); + let revoke_and_ack = $prev_node.node.handle_commitment_signed(&$node.node.get_our_node_id(), &revoke_and_commit.1.unwrap()).unwrap(); + assert!(revoke_and_ack.1.is_none()); + { + let mut added_monitors = $prev_node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!($node.node.handle_revoke_and_ack(&$prev_node.node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + { + let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + } + } + } - let mut expected_next_node = expected_route.last().unwrap().get_our_node_id(); + let mut expected_next_node = expected_route.last().unwrap().node.get_our_node_id(); let mut prev_node = expected_route.last().unwrap(); - let mut next_msg = None; for node in expected_route.iter().rev() { - assert_eq!(expected_next_node, node.get_our_node_id()); - match next_msg { - Some(msg) => { - node.handle_update_fulfill_htlc(&prev_node.get_our_node_id(), &msg).unwrap(); - }, None => {} + assert_eq!(expected_next_node, node.node.get_our_node_id()); + if next_msgs.is_some() { + update_fulfill_dance!(node, prev_node, false); } - let events = node.get_and_clear_pending_events(); + let events = node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { - Event::SendFulfillHTLC { ref node_id, ref msg } => { + Event::SendFulfillHTLC { ref node_id, ref msg, ref commitment_msg } => { expected_next_node = node_id.clone(); - next_msg = Some(msg.clone()); + next_msgs = Some((msg.clone(), commitment_msg.clone())); }, _ => panic!("Unexpected event"), }; @@ -1914,10 +2365,10 @@ mod tests { prev_node = node; } - assert_eq!(expected_next_node, origin_node.get_our_node_id()); - origin_node.handle_update_fulfill_htlc(&expected_route.first().unwrap().get_our_node_id(), &next_msg.unwrap()).unwrap(); + assert_eq!(expected_next_node, origin_node.node.get_our_node_id()); + update_fulfill_dance!(origin_node, expected_route.first().unwrap(), true); - let events = origin_node.get_and_clear_pending_events(); + let events = origin_node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { Event::PaymentSent { payment_preimage } => { @@ -1927,21 +2378,23 @@ mod tests { } } - fn route_payment(origin_node: &ChannelManager, origin_router: &Router, expected_route: &[&ChannelManager], recv_value: u64) -> ([u8; 32], [u8; 32]) { - let route = origin_router.get_route(&expected_route.last().unwrap().get_our_node_id(), &Vec::new(), recv_value, 142).unwrap(); + const TEST_FINAL_CLTV: u32 = 32; + + fn route_payment(origin_node: &Node, expected_route: &[&Node], recv_value: u64) -> ([u8; 32], [u8; 32]) { + let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap(); assert_eq!(route.hops.len(), expected_route.len()); for (node, hop) in expected_route.iter().zip(route.hops.iter()) { - assert_eq!(hop.pubkey, node.get_our_node_id()); + assert_eq!(hop.pubkey, node.node.get_our_node_id()); } send_along_route(origin_node, route, expected_route, recv_value) } - fn route_over_limit(origin_node: &ChannelManager, origin_router: &Router, expected_route: &[&ChannelManager], recv_value: u64) { - let route = origin_router.get_route(&expected_route.last().unwrap().get_our_node_id(), &Vec::new(), recv_value, 142).unwrap(); + fn route_over_limit(origin_node: &Node, expected_route: &[&Node], recv_value: u64) { + let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap(); assert_eq!(route.hops.len(), expected_route.len()); for (node, hop) in expected_route.iter().zip(route.hops.iter()) { - assert_eq!(hop.pubkey, node.get_our_node_id()); + assert_eq!(hop.pubkey, node.node.get_our_node_id()); } let our_payment_preimage = unsafe { [PAYMENT_COUNT; 32] }; @@ -1954,42 +2407,78 @@ mod tests { ret }; - let err = origin_node.send_payment(route, our_payment_hash).err().unwrap(); + let err = origin_node.node.send_payment(route, our_payment_hash).err().unwrap(); assert_eq!(err.err, "Cannot send value that would put us over our max HTLC value in flight"); } - fn send_payment(origin_node: &ChannelManager, origin_router: &Router, expected_route: &[&ChannelManager], recv_value: u64) { - let our_payment_preimage = route_payment(origin_node, origin_router, expected_route, recv_value).0; - claim_payment(origin_node, expected_route, our_payment_preimage); + fn send_payment(origin: &Node, expected_route: &[&Node], recv_value: u64) { + let our_payment_preimage = route_payment(&origin, expected_route, recv_value).0; + claim_payment(&origin, expected_route, our_payment_preimage); } - fn send_failed_payment(origin_node: &ChannelManager, origin_router: &Router, expected_route: &[&ChannelManager]) { - let route = origin_router.get_route(&expected_route.last().unwrap().get_our_node_id(), &Vec::new(), 1000000, 142).unwrap(); - assert_eq!(route.hops.len(), expected_route.len()); - for (node, hop) in expected_route.iter().zip(route.hops.iter()) { - assert_eq!(hop.pubkey, node.get_our_node_id()); + fn fail_payment(origin_node: &Node, expected_route: &[&Node], our_payment_hash: [u8; 32]) { + assert!(expected_route.last().unwrap().node.fail_htlc_backwards(&our_payment_hash)); + { + let mut added_monitors = expected_route.last().unwrap().chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); } - let our_payment_hash = send_along_route(origin_node, route, expected_route, 1000000).1; - assert!(expected_route.last().unwrap().fail_htlc_backwards(&our_payment_hash)); + let mut next_msgs: Option<(msgs::UpdateFailHTLC, msgs::CommitmentSigned)> = None; + macro_rules! update_fail_dance { + ($node: expr, $prev_node: expr, $last_node: expr) => { + { + $node.node.handle_update_fail_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0).unwrap(); + let revoke_and_commit = $node.node.handle_commitment_signed(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().1).unwrap(); + + { + let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + assert!($prev_node.node.handle_revoke_and_ack(&$node.node.get_our_node_id(), &revoke_and_commit.0).unwrap().is_none()); + { + let mut added_monitors = $prev_node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + let revoke_and_ack = $prev_node.node.handle_commitment_signed(&$node.node.get_our_node_id(), &revoke_and_commit.1.unwrap()).unwrap(); + { + let mut added_monitors = $prev_node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + assert!(revoke_and_ack.1.is_none()); + assert!($node.node.get_and_clear_pending_events().is_empty()); + assert!($node.node.handle_revoke_and_ack(&$prev_node.node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + { + let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap(); + if $last_node { + assert_eq!(added_monitors.len(), 1); + } else { + assert_eq!(added_monitors.len(), 2); + assert!(added_monitors[0].0 != added_monitors[1].0); + } + added_monitors.clear(); + } + } + } + } - let mut expected_next_node = expected_route.last().unwrap().get_our_node_id(); + let mut expected_next_node = expected_route.last().unwrap().node.get_our_node_id(); let mut prev_node = expected_route.last().unwrap(); - let mut next_msg = None; for node in expected_route.iter().rev() { - assert_eq!(expected_next_node, node.get_our_node_id()); - match next_msg { - Some(msg) => { - node.handle_update_fail_htlc(&prev_node.get_our_node_id(), &msg).unwrap(); - }, None => {} + assert_eq!(expected_next_node, node.node.get_our_node_id()); + if next_msgs.is_some() { + update_fail_dance!(node, prev_node, false); } - let events = node.get_and_clear_pending_events(); + let events = node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { - Event::SendFailHTLC { ref node_id, ref msg } => { + Event::SendFailHTLC { ref node_id, ref msg, ref commitment_msg } => { expected_next_node = node_id.clone(); - next_msg = Some(msg.clone()); + next_msgs = Some((msg.clone(), commitment_msg.clone())); }, _ => panic!("Unexpected event"), }; @@ -1997,10 +2486,10 @@ mod tests { prev_node = node; } - assert_eq!(expected_next_node, origin_node.get_our_node_id()); - origin_node.handle_update_fail_htlc(&expected_route.first().unwrap().get_our_node_id(), &next_msg.unwrap()).unwrap(); + assert_eq!(expected_next_node, origin_node.node.get_our_node_id()); + update_fail_dance!(origin_node, expected_route.first().unwrap(), true); - let events = origin_node.get_and_clear_pending_events(); + let events = origin_node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { Event::PaymentFailed { payment_hash } => { @@ -2010,193 +2499,401 @@ mod tests { } } + fn create_network(node_count: usize) -> Vec { + let mut nodes = Vec::new(); + let mut rng = thread_rng(); + let secp_ctx = Secp256k1::new(); + + for _ in 0..node_count { + let feeest = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 }); + let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new()); + let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())}); + let chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone())); + let node_id = { + let mut key_slice = [0; 32]; + rng.fill_bytes(&mut key_slice); + SecretKey::from_slice(&secp_ctx, &key_slice).unwrap() + }; + let node = ChannelManager::new(node_id.clone(), 0, true, Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone()).unwrap(); + let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id).unwrap()); + nodes.push(Node { feeest, chain_monitor, tx_broadcaster, chan_monitor, node_id, node, router }); + } + + nodes + } + #[test] fn fake_network_test() { // Simple test which builds a network of ChannelManagers, connects them to each other, and // tests that payments get routed and transactions broadcast in semi-reasonable ways. - let mut rng = thread_rng(); - let secp_ctx = Secp256k1::new(); - - let feeest_1 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 }); - let chain_monitor_1 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new()); - let chan_monitor_1 = Arc::new(test_utils::TestChannelMonitor{}); - let tx_broadcaster_1 = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())}); - let node_id_1 = { - let mut key_slice = [0; 32]; - rng.fill_bytes(&mut key_slice); - SecretKey::from_slice(&secp_ctx, &key_slice).unwrap() - }; - let node_1 = ChannelManager::new(node_id_1.clone(), 0, true, Network::Testnet, feeest_1.clone(), chan_monitor_1.clone(), chain_monitor_1.clone(), tx_broadcaster_1.clone()).unwrap(); - let router_1 = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id_1).unwrap()); - - let feeest_2 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 }); - let chain_monitor_2 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new()); - let chan_monitor_2 = Arc::new(test_utils::TestChannelMonitor{}); - let tx_broadcaster_2 = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())}); - let node_id_2 = { - let mut key_slice = [0; 32]; - rng.fill_bytes(&mut key_slice); - SecretKey::from_slice(&secp_ctx, &key_slice).unwrap() - }; - let node_2 = ChannelManager::new(node_id_2.clone(), 0, true, Network::Testnet, feeest_2.clone(), chan_monitor_2.clone(), chain_monitor_2.clone(), tx_broadcaster_2.clone()).unwrap(); - let router_2 = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id_2).unwrap()); - - let feeest_3 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 }); - let chain_monitor_3 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new()); - let chan_monitor_3 = Arc::new(test_utils::TestChannelMonitor{}); - let tx_broadcaster_3 = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())}); - let node_id_3 = { - let mut key_slice = [0; 32]; - rng.fill_bytes(&mut key_slice); - SecretKey::from_slice(&secp_ctx, &key_slice).unwrap() - }; - let node_3 = ChannelManager::new(node_id_3.clone(), 0, true, Network::Testnet, feeest_3.clone(), chan_monitor_3.clone(), chain_monitor_3.clone(), tx_broadcaster_3.clone()).unwrap(); - let router_3 = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id_3).unwrap()); - - let feeest_4 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 }); - let chain_monitor_4 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new()); - let chan_monitor_4 = Arc::new(test_utils::TestChannelMonitor{}); - let tx_broadcaster_4 = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())}); - let node_id_4 = { - let mut key_slice = [0; 32]; - rng.fill_bytes(&mut key_slice); - SecretKey::from_slice(&secp_ctx, &key_slice).unwrap() - }; - let node_4 = ChannelManager::new(node_id_4.clone(), 0, true, Network::Testnet, feeest_4.clone(), chan_monitor_4.clone(), chain_monitor_4.clone(), tx_broadcaster_4.clone()).unwrap(); - let router_4 = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id_4).unwrap()); + let nodes = create_network(4); // Create some initial channels - let chan_announcement_1 = create_chan_between_nodes(&node_1, &chain_monitor_1, &node_2, &chain_monitor_2); - for router in vec!(&router_1, &router_2, &router_3, &router_4) { - assert!(router.handle_channel_announcement(&chan_announcement_1.0).unwrap()); - router.handle_channel_update(&chan_announcement_1.1).unwrap(); - router.handle_channel_update(&chan_announcement_1.2).unwrap(); - } - let chan_announcement_2 = create_chan_between_nodes(&node_2, &chain_monitor_2, &node_3, &chain_monitor_3); - for router in vec!(&router_1, &router_2, &router_3, &router_4) { - assert!(router.handle_channel_announcement(&chan_announcement_2.0).unwrap()); - router.handle_channel_update(&chan_announcement_2.1).unwrap(); - router.handle_channel_update(&chan_announcement_2.2).unwrap(); - } - let chan_announcement_3 = create_chan_between_nodes(&node_3, &chain_monitor_3, &node_4, &chain_monitor_4); - for router in vec!(&router_1, &router_2, &router_3, &router_4) { - assert!(router.handle_channel_announcement(&chan_announcement_3.0).unwrap()); - router.handle_channel_update(&chan_announcement_3.1).unwrap(); - router.handle_channel_update(&chan_announcement_3.2).unwrap(); - } + let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); + let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); + let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3); // Rebalance the network a bit by relaying one payment through all the channels... - send_payment(&node_1, &router_1, &vec!(&*node_2, &*node_3, &*node_4)[..], 8000000); - send_payment(&node_1, &router_1, &vec!(&*node_2, &*node_3, &*node_4)[..], 8000000); - send_payment(&node_1, &router_1, &vec!(&*node_2, &*node_3, &*node_4)[..], 8000000); - send_payment(&node_1, &router_1, &vec!(&*node_2, &*node_3, &*node_4)[..], 8000000); - send_payment(&node_1, &router_1, &vec!(&*node_2, &*node_3, &*node_4)[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000); // Send some more payments - send_payment(&node_2, &router_2, &vec!(&*node_3, &*node_4)[..], 1000000); - send_payment(&node_4, &router_4, &vec!(&*node_3, &*node_2, &*node_1)[..], 1000000); - send_payment(&node_4, &router_4, &vec!(&*node_3, &*node_2)[..], 1000000); + send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000); + send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000); + send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000); // Test failure packets - send_failed_payment(&node_1, &router_1, &vec!(&*node_2, &*node_3, &*node_4)[..]); + let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1; + fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], payment_hash_1); // Add a new channel that skips 3 - let chan_announcement_4 = create_chan_between_nodes(&node_2, &chain_monitor_2, &node_4, &chain_monitor_4); - for router in vec!(&router_1, &router_2, &router_3, &router_4) { - assert!(router.handle_channel_announcement(&chan_announcement_4.0).unwrap()); - router.handle_channel_update(&chan_announcement_4.1).unwrap(); - router.handle_channel_update(&chan_announcement_4.2).unwrap(); - } + let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3); - send_payment(&node_1, &router_1, &vec!(&*node_2, &*node_4)[..], 1000000); - send_payment(&node_3, &router_3, &vec!(&*node_4)[..], 1000000); - send_payment(&node_2, &router_2, &vec!(&*node_4)[..], 8000000); - send_payment(&node_2, &router_2, &vec!(&*node_4)[..], 8000000); - send_payment(&node_2, &router_2, &vec!(&*node_4)[..], 8000000); - send_payment(&node_2, &router_2, &vec!(&*node_4)[..], 8000000); - send_payment(&node_2, &router_2, &vec!(&*node_4)[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000); + send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); // Do some rebalance loop payments, simultaneously let mut hops = Vec::with_capacity(3); hops.push(RouteHop { - pubkey: node_3.get_our_node_id(), - short_channel_id: chan_announcement_2.1.contents.short_channel_id, + pubkey: nodes[2].node.get_our_node_id(), + short_channel_id: chan_2.0.contents.short_channel_id, fee_msat: 0, - cltv_expiry_delta: chan_announcement_3.1.contents.cltv_expiry_delta as u32 + cltv_expiry_delta: chan_3.0.contents.cltv_expiry_delta as u32 }); hops.push(RouteHop { - pubkey: node_4.get_our_node_id(), - short_channel_id: chan_announcement_3.1.contents.short_channel_id, + pubkey: nodes[3].node.get_our_node_id(), + short_channel_id: chan_3.0.contents.short_channel_id, fee_msat: 0, - cltv_expiry_delta: chan_announcement_4.2.contents.cltv_expiry_delta as u32 + cltv_expiry_delta: chan_4.1.contents.cltv_expiry_delta as u32 }); hops.push(RouteHop { - pubkey: node_2.get_our_node_id(), - short_channel_id: chan_announcement_4.1.contents.short_channel_id, + pubkey: nodes[1].node.get_our_node_id(), + short_channel_id: chan_4.0.contents.short_channel_id, fee_msat: 1000000, - cltv_expiry_delta: 142, + cltv_expiry_delta: TEST_FINAL_CLTV, }); - hops[1].fee_msat = chan_announcement_4.2.contents.fee_base_msat as u64 + chan_announcement_4.2.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000; - hops[0].fee_msat = chan_announcement_3.1.contents.fee_base_msat as u64 + chan_announcement_3.1.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000; - let payment_preimage_1 = send_along_route(&node_2, Route { hops }, &vec!(&*node_3, &*node_4, &*node_2)[..], 1000000).0; + hops[1].fee_msat = chan_4.1.contents.fee_base_msat as u64 + chan_4.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000; + hops[0].fee_msat = chan_3.0.contents.fee_base_msat as u64 + chan_3.0.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000; + let payment_preimage_1 = send_along_route(&nodes[1], Route { hops }, &vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0; let mut hops = Vec::with_capacity(3); hops.push(RouteHop { - pubkey: node_4.get_our_node_id(), - short_channel_id: chan_announcement_4.1.contents.short_channel_id, + pubkey: nodes[3].node.get_our_node_id(), + short_channel_id: chan_4.0.contents.short_channel_id, fee_msat: 0, - cltv_expiry_delta: chan_announcement_3.2.contents.cltv_expiry_delta as u32 + cltv_expiry_delta: chan_3.1.contents.cltv_expiry_delta as u32 }); hops.push(RouteHop { - pubkey: node_3.get_our_node_id(), - short_channel_id: chan_announcement_3.1.contents.short_channel_id, + pubkey: nodes[2].node.get_our_node_id(), + short_channel_id: chan_3.0.contents.short_channel_id, fee_msat: 0, - cltv_expiry_delta: chan_announcement_2.2.contents.cltv_expiry_delta as u32 + cltv_expiry_delta: chan_2.1.contents.cltv_expiry_delta as u32 }); hops.push(RouteHop { - pubkey: node_2.get_our_node_id(), - short_channel_id: chan_announcement_2.1.contents.short_channel_id, + pubkey: nodes[1].node.get_our_node_id(), + short_channel_id: chan_2.0.contents.short_channel_id, fee_msat: 1000000, - cltv_expiry_delta: 142, + cltv_expiry_delta: TEST_FINAL_CLTV, }); - hops[1].fee_msat = chan_announcement_2.2.contents.fee_base_msat as u64 + chan_announcement_2.2.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000; - hops[0].fee_msat = chan_announcement_3.2.contents.fee_base_msat as u64 + chan_announcement_3.2.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000; - let payment_preimage_2 = send_along_route(&node_2, Route { hops }, &vec!(&*node_4, &*node_3, &*node_2)[..], 1000000).0; + hops[1].fee_msat = chan_2.1.contents.fee_base_msat as u64 + chan_2.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000; + hops[0].fee_msat = chan_3.1.contents.fee_base_msat as u64 + chan_3.1.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000; + let payment_hash_2 = send_along_route(&nodes[1], Route { hops }, &vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).1; // Claim the rebalances... - claim_payment(&node_2, &vec!(&*node_4, &*node_3, &*node_2)[..], payment_preimage_2); - claim_payment(&node_2, &vec!(&*node_3, &*node_4, &*node_2)[..], payment_preimage_1); + fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2); + claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1); // Add a duplicate new channel from 2 to 4 - let chan_announcement_5 = create_chan_between_nodes(&node_2, &chain_monitor_2, &node_4, &chain_monitor_4); - for router in vec!(&router_1, &router_2, &router_3, &router_4) { - assert!(router.handle_channel_announcement(&chan_announcement_5.0).unwrap()); - router.handle_channel_update(&chan_announcement_5.1).unwrap(); - router.handle_channel_update(&chan_announcement_5.2).unwrap(); - } + let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3); // Send some payments across both channels - let payment_preimage_3 = route_payment(&node_1, &router_1, &vec!(&*node_2, &*node_4)[..], 3000000).0; - let payment_preimage_4 = route_payment(&node_1, &router_1, &vec!(&*node_2, &*node_4)[..], 3000000).0; - let payment_preimage_5 = route_payment(&node_1, &router_1, &vec!(&*node_2, &*node_4)[..], 3000000).0; + let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0; + let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0; + let payment_preimage_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0; - route_over_limit(&node_1, &router_1, &vec!(&*node_2, &*node_4)[..], 3000000); + route_over_limit(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000); //TODO: Test that routes work again here as we've been notified that the channel is full - claim_payment(&node_1, &vec!(&*node_2, &*node_4)[..], payment_preimage_3); - claim_payment(&node_1, &vec!(&*node_2, &*node_4)[..], payment_preimage_4); - claim_payment(&node_1, &vec!(&*node_2, &*node_4)[..], payment_preimage_5); + claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3); + claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4); + claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5); // Close down the channels... - close_channel(&node_1, &tx_broadcaster_1, &node_2, &tx_broadcaster_2, &chan_announcement_1.3, true); - close_channel(&node_2, &tx_broadcaster_2, &node_3, &tx_broadcaster_3, &chan_announcement_2.3, false); - close_channel(&node_3, &tx_broadcaster_3, &node_4, &tx_broadcaster_4, &chan_announcement_3.3, true); - close_channel(&node_2, &tx_broadcaster_2, &node_4, &tx_broadcaster_4, &chan_announcement_4.3, false); + close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true); + close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, false); + close_channel(&nodes[2], &nodes[3], &chan_3.2, chan_3.3, true); + close_channel(&nodes[1], &nodes[3], &chan_4.2, chan_4.3, false); + close_channel(&nodes[1], &nodes[3], &chan_5.2, chan_5.3, false); + + // Check that we processed all pending events + for node in nodes { + assert_eq!(node.node.get_and_clear_pending_events().len(), 0); + assert_eq!(node.chan_monitor.added_monitors.lock().unwrap().len(), 0); + } + } + + #[derive(PartialEq)] + enum HTLCType { NONE, TIMEOUT, SUCCESS } + fn test_txn_broadcast(node: &Node, chan: &(msgs::ChannelUpdate, msgs::ChannelUpdate, Uint256, Transaction), commitment_tx: Option, has_htlc_tx: HTLCType) -> Vec { + let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap(); + assert!(node_txn.len() >= if commitment_tx.is_some() { 0 } else { 1 } + if has_htlc_tx == HTLCType::NONE { 0 } else { 1 }); + + let mut res = Vec::with_capacity(2); + + if let Some(explicit_tx) = commitment_tx { + res.push(explicit_tx.clone()); + } else { + for tx in node_txn.iter() { + if tx.input.len() == 1 && tx.input[0].prev_hash == chan.3.txid() { + let mut funding_tx_map = HashMap::new(); + funding_tx_map.insert(chan.3.txid(), chan.3.clone()); + tx.verify(&funding_tx_map).unwrap(); + res.push(tx.clone()); + } + } + } + assert_eq!(res.len(), 1); + + if has_htlc_tx != HTLCType::NONE { + for tx in node_txn.iter() { + if tx.input.len() == 1 && tx.input[0].prev_hash == res[0].txid() { + let mut funding_tx_map = HashMap::new(); + funding_tx_map.insert(res[0].txid(), res[0].clone()); + tx.verify(&funding_tx_map).unwrap(); + if has_htlc_tx == HTLCType::TIMEOUT { + assert!(tx.lock_time != 0); + } else { + assert!(tx.lock_time == 0); + } + res.push(tx.clone()); + break; + } + } + assert_eq!(res.len(), 2); + } + node_txn.clear(); + res + } + + fn check_preimage_claim(node: &Node, prev_txn: &Vec) -> Vec { + let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap(); + + assert!(node_txn.len() >= 1); + assert_eq!(node_txn[0].input.len(), 1); + let mut found_prev = false; + + for tx in prev_txn { + if node_txn[0].input[0].prev_hash == tx.txid() { + let mut funding_tx_map = HashMap::new(); + funding_tx_map.insert(tx.txid(), tx.clone()); + node_txn[0].verify(&funding_tx_map).unwrap(); + + assert!(node_txn[0].input[0].witness[2].len() > 106); // must spend an htlc output + assert_eq!(tx.input.len(), 1); // must spend a commitment tx + + found_prev = true; + break; + } + } + assert!(found_prev); + + let mut res = Vec::new(); + mem::swap(&mut *node_txn, &mut res); + res + } + + fn get_announce_close_broadcast_events(nodes: &Vec, a: usize, b: usize) { + let events_1 = nodes[a].node.get_and_clear_pending_events(); + assert_eq!(events_1.len(), 1); + let as_update = match events_1[0] { + Event::BroadcastChannelUpdate { ref msg } => { + msg.clone() + }, + _ => panic!("Unexpected event"), + }; + + let events_2 = nodes[b].node.get_and_clear_pending_events(); + assert_eq!(events_2.len(), 1); + let bs_update = match events_2[0] { + Event::BroadcastChannelUpdate { ref msg } => { + msg.clone() + }, + _ => panic!("Unexpected event"), + }; + + for node in nodes { + node.router.handle_channel_update(&as_update).unwrap(); + node.router.handle_channel_update(&bs_update).unwrap(); + } + } + + #[test] + fn channel_monitor_network_test() { + // Simple test which builds a network of ChannelManagers, connects them to each other, and + // tests that ChannelMonitor is able to recover from various states. + let nodes = create_network(5); + + // Create some initial channels + let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); + let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); + let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3); + let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4); + + // Rebalance the network a bit by relaying one payment through all the channels... + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000); + + // Simple case with no pending HTLCs: + nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true); + { + let node_txn = test_txn_broadcast(&nodes[1], &chan_1, None, HTLCType::NONE); + let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[0].chain_monitor.block_connected_checked(&header, 1, &[&node_txn[0]; 1], &[4; 1]); + assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 0); + } + get_announce_close_broadcast_events(&nodes, 0, 1); + assert_eq!(nodes[0].node.list_channels().len(), 0); + assert_eq!(nodes[1].node.list_channels().len(), 1); + + // One pending HTLC is discarded by the force-close: + let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 3000000).0; + + // Simple case of one pending HTLC to HTLC-Timeout + nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), true); + { + let node_txn = test_txn_broadcast(&nodes[1], &chan_2, None, HTLCType::TIMEOUT); + let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[2].chain_monitor.block_connected_checked(&header, 1, &[&node_txn[0]; 1], &[4; 1]); + assert_eq!(nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 0); + } + get_announce_close_broadcast_events(&nodes, 1, 2); + assert_eq!(nodes[1].node.list_channels().len(), 0); + assert_eq!(nodes[2].node.list_channels().len(), 1); + + macro_rules! claim_funds { + ($node: expr, $prev_node: expr, $preimage: expr) => { + { + assert!($node.node.claim_funds($preimage)); + { + let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + + let events = $node.node.get_and_clear_pending_events(); + assert_eq!(events.len(), 1); + match events[0] { + Event::SendFulfillHTLC { ref node_id, .. } => { + assert_eq!(*node_id, $prev_node.node.get_our_node_id()); + }, + _ => panic!("Unexpected event"), + }; + } + } + } + + // nodes[3] gets the preimage, but nodes[2] already disconnected, resulting in a nodes[2] + // HTLC-Timeout and a nodes[3] claim against it (+ its own announces) + nodes[2].node.peer_disconnected(&nodes[3].node.get_our_node_id(), true); + { + let node_txn = test_txn_broadcast(&nodes[2], &chan_3, None, HTLCType::TIMEOUT); + + // Claim the payment on nodes[3], giving it knowledge of the preimage + claim_funds!(nodes[3], nodes[2], payment_preimage_1); + + let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[3].chain_monitor.block_connected_checked(&header, 1, &[&node_txn[0]; 1], &[4; 1]); + + check_preimage_claim(&nodes[3], &node_txn); + } + get_announce_close_broadcast_events(&nodes, 2, 3); + assert_eq!(nodes[2].node.list_channels().len(), 0); + assert_eq!(nodes[3].node.list_channels().len(), 1); + + // One pending HTLC to time out: + let payment_preimage_2 = route_payment(&nodes[3], &vec!(&nodes[4])[..], 3000000).0; + + { + let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[3].chain_monitor.block_connected_checked(&header, 1, &Vec::new()[..], &[0; 0]); + for i in 2..TEST_FINAL_CLTV - 5 { + header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[3].chain_monitor.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]); + } + + let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT); + + // Claim the payment on nodes[3], giving it knowledge of the preimage + claim_funds!(nodes[4], nodes[3], payment_preimage_2); + + header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[4].chain_monitor.block_connected_checked(&header, 1, &Vec::new()[..], &[0; 0]); + for i in 2..TEST_FINAL_CLTV - 5 { + header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[4].chain_monitor.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]); + } + + test_txn_broadcast(&nodes[4], &chan_4, None, HTLCType::SUCCESS); + + header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[4].chain_monitor.block_connected_checked(&header, TEST_FINAL_CLTV - 5, &[&node_txn[0]; 1], &[4; 1]); + + check_preimage_claim(&nodes[4], &node_txn); + } + get_announce_close_broadcast_events(&nodes, 3, 4); + assert_eq!(nodes[3].node.list_channels().len(), 0); + assert_eq!(nodes[4].node.list_channels().len(), 0); + + // Create some new channels: + let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1); + + // A pending HTLC which will be revoked: + let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0; + // Get the will-be-revoked local txn from nodes[0] + let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.iter().next().unwrap().1.last_local_commitment_txn.clone(); + // Revoke the old state + claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3); + + { + let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[1].chain_monitor.block_connected_checked(&header, 1, &vec![&revoked_local_txn[0]; 1], &[4; 1]); + { + let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); + assert_eq!(node_txn.len(), 1); + assert_eq!(node_txn[0].input.len(), 1); + + let mut funding_tx_map = HashMap::new(); + funding_tx_map.insert(revoked_local_txn[0].txid(), revoked_local_txn[0].clone()); + node_txn[0].verify(&funding_tx_map).unwrap(); + node_txn.clear(); + } + + nodes[0].chain_monitor.block_connected_checked(&header, 1, &vec![&revoked_local_txn[0]; 1], &[4; 0]); + let node_txn = test_txn_broadcast(&nodes[0], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::TIMEOUT); + header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[1].chain_monitor.block_connected_checked(&header, 1, &[&node_txn[1]; 1], &[4; 1]); + + //TODO: At this point nodes[1] should claim the revoked HTLC-Timeout output, but that's + //not yet implemented in ChannelMonitor + } + get_announce_close_broadcast_events(&nodes, 0, 1); + assert_eq!(nodes[0].node.list_channels().len(), 0); + assert_eq!(nodes[1].node.list_channels().len(), 0); // Check that we processed all pending events - for node in vec!(&node_1, &node_2, &node_3, &node_4) { - assert_eq!(node.get_and_clear_pending_events().len(), 0); + for node in nodes { + assert_eq!(node.node.get_and_clear_pending_events().len(), 0); + assert_eq!(node.chan_monitor.added_monitors.lock().unwrap().len(), 0); } } }