X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannelmanager.rs;h=83ff021a7e9164b121f1503b599cd62d07d852c8;hb=fd141bbed2a900070cbecf7ef9f22e377e1f353f;hp=68cfed8fd0d422cce1f17550bdefde7d129dbae1;hpb=4d75d4c099cd6875f7ba95050012de340367278a;p=rust-lightning diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs index 68cfed8f..83ff021a 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; @@ -91,12 +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, + session_priv: SecretKey, } } @@ -163,7 +167,7 @@ macro_rules! secp_call { match $res { Ok(key) => key, //TODO: Make the err a parameter! - Err(_) => return Err(HandleError{err: "Key error", msg: None}) + Err(_) => return Err(HandleError{err: "Key error", action: None}) } }; } @@ -198,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(); @@ -229,14 +233,48 @@ impl ChannelManager { Ok(res) } - 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); + /// Creates a new outbound channel to the given remote node and with the given value. + /// user_id will be provided back as user_channel_id in FundingGenerationReady and + /// FundingBroadcastSafe events to allow tracking of which events correspond with which + /// create_channel call. Note that user_channel_id defaults to 0 for inbound channels, so you + /// may wish to avoid using 0 for user_id here. + /// If successful, will generate a SendOpenChannel event, so you should probably poll + /// PeerManager::process_events afterwards. + pub fn create_channel(&self, their_network_key: PublicKey, channel_value_satoshis: u64, user_id: u64) -> Result<(), HandleError> { + 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) { Some(_) => panic!("RNG is bad???"), - None => Ok(res) + None => {} } + + let mut events = self.pending_events.lock().unwrap(); + events.push(events::Event::SendOpenChannel { + node_id: their_network_key, + msg: res, + }); + Ok(()) } /// Gets the list of open channels, in random order. See ChannelDetail field documentation for @@ -260,23 +298,34 @@ 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}) + hash_map::Entry::Vacant(_) => return Err(HandleError{err: "No such channel", action: 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: 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) } @@ -316,8 +365,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; @@ -340,18 +390,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) } @@ -382,11 +443,11 @@ impl ChannelManager { }; cur_value_msat += hop.fee_msat; if cur_value_msat >= 21000000 * 100000000 * 1000 { - return Err(HandleError{err: "Channel fees overflowed?!", msg: None}); + return Err(HandleError{err: "Channel fees overflowed?!", action: None}); } cur_cltv += hop.cltv_expiry_delta as u32; if cur_cltv >= 500000000 { - return Err(HandleError{err: "Channel CLTV overflowed?!", msg: None}); + return Err(HandleError{err: "Channel CLTV overflowed?!", action: None}); } last_short_channel_id = hop.short_channel_id; } @@ -513,9 +574,9 @@ impl ChannelManager { } /// 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}), + None => return Err(HandleError{err: "Channel not yet established", action: None}), Some(id) => id, }; @@ -541,18 +602,19 @@ 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}); + return Err(HandleError{err: "Route didn't go anywhere/had bogus size", action: None}); } let our_node_id = self.get_our_node_id(); for (idx, hop) in route.hops.iter().enumerate() { if idx != route.hops.len() - 1 && hop.pubkey == our_node_id { - return Err(HandleError{err: "Route went through us but wasn't a simple rebalance loop to us", msg: None}); + return Err(HandleError{err: "Route went through us but wasn't a simple rebalance loop to us", action: None}); } } @@ -568,40 +630,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!", action: 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!", action: 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 @@ -612,15 +694,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 { @@ -668,7 +744,6 @@ impl ChannelManager { for forward_info in pending_forwards { failed_forwards.push((forward_info.payment_hash, 0x4000 | 10, None)); } - // TODO: Send a failure packet back on each pending_forward continue; } }; @@ -679,7 +754,7 @@ impl ChannelManager { match forward_chan.send_htlc(forward_info.amt_to_forward, forward_info.payment_hash, forward_info.outgoing_cltv_value, forward_info.onion_packet.unwrap()) { Err(_e) => { let chan_update = self.get_channel_update(forward_chan).unwrap(); - failed_forwards.push((forward_info.payment_hash, 0x4000 | 7, Some(chan_update))); + failed_forwards.push((forward_info.payment_hash, 0x1000 | 7, Some(chan_update))); continue; }, Ok(update_add) => { @@ -700,25 +775,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, - }); + })); } } } @@ -727,16 +802,25 @@ 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: 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() }), + 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); } } @@ -754,7 +838,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 }; }, _ => {} @@ -763,8 +851,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() @@ -799,13 +887,18 @@ impl ChannelManager { }; match fail_msgs { - Some(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: msgs.0, - commitment_msg: msgs.1, + msg: msg, + commitment_msg: commitment_msg, }); }, None => {}, @@ -838,13 +931,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 }); } }, @@ -865,7 +958,7 @@ impl ChannelManager { false }, PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, .. } => { - let (node_id, fulfill_msgs, monitor) = { + 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 @@ -873,7 +966,7 @@ impl ChannelManager { let chan = channel_state.by_id.get_mut(&chan_id).unwrap(); match chan.get_update_fulfill_htlc_and_commit(payment_preimage) { - Ok(msg) => (chan.get_their_node_id(), msg, if from_user { Some(chan.channel_monitor()) } else { None }), + Ok(msg) => (chan.get_their_node_id(), msg), Err(_e) => { //TODO: Do something with e? return false; @@ -883,25 +976,21 @@ impl ChannelManager { mem::drop(channel_state); match fulfill_msgs { - Some(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: msgs.0, - commitment_msg: msgs.1, + msg, + commitment_msg, }); }, None => {}, } - - //TODO: It may not be possible to handle add_update_monitor fails gracefully, maybe - //it should return no Err? Sadly, panic!()s instead doesn't help much :( - if from_user { - match self.monitor.add_update_monitor(monitor.as_ref().unwrap().get_funding_txo().unwrap(), monitor.unwrap()) { - Ok(()) => true, - Err(_) => true, - } - } else { true } + true }, } } @@ -910,6 +999,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 { @@ -923,37 +1019,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; } - //TODO: Check if channel was closed (or disabled) here + 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); } } @@ -972,13 +1099,34 @@ impl ChannelMessageHandler for ChannelManager { //TODO: Handle errors and close channel (or so) fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &msgs::OpenChannel) -> Result { if msg.chain_hash != self.genesis_hash { - return Err(HandleError{err: "Unknown genesis block hash", msg: None}); + return Err(HandleError{err: "Unknown genesis block hash", action: None}); } let mut channel_state = self.channel_state.lock().unwrap(); 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)?; + return Err(HandleError{err: "temporary_channel_id collision!", action: None}); + } + + 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) @@ -990,12 +1138,12 @@ impl ChannelMessageHandler for ChannelManager { match channel_state.by_id.get_mut(&msg.temporary_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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } chan.accept_channel(&msg)?; (chan.get_value_satoshis(), chan.get_funding_redeemscript().to_v0_p2wsh(), chan.get_user_id()) }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } }; let mut pending_events = self.pending_events.lock().unwrap(); @@ -1012,49 +1160,53 @@ 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) => { 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: 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); } } }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } }; // Release channel lock for install_watch_outpoint call, // 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: 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}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: 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, @@ -1068,47 +1220,59 @@ impl ChannelMessageHandler for ChannelManager { 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } chan.funding_locked(&msg)?; return Ok(self.get_announcement_sigs(chan)?); }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) }; } 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) => { if chan_entry.get().get_their_node_id() != *their_node_id { - return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } 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}) + hash_map::Entry::Vacant(_) => return Err(HandleError{err: "Failed to find corresponding channel", action: 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: 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 { - return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } let res = chan_entry.get_mut().closing_signed(&*self.fee_estimator, &msg)?; if res.1.is_some() { @@ -1117,16 +1281,26 @@ 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}) + hash_map::Entry::Vacant(_) => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } }; 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) } @@ -1161,7 +1335,7 @@ impl ChannelMessageHandler for ChannelManager { ($msg: expr, $err_code: expr, $data: expr) => { return Err(msgs::HandleError { err: $msg, - msg: Some(msgs::ErrorAction::UpdateFailHTLC { + action: Some(msgs::ErrorAction::UpdateFailHTLC { msg: msgs::UpdateFailHTLC { channel_id: msg.channel_id, htlc_id: msg.htlc_id, @@ -1291,7 +1465,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.", 0x1000 | 7, &chan_update.encode_with_len()[..]); } } @@ -1320,31 +1494,32 @@ impl ChannelMessageHandler for ChannelManager { let (source_short_channel_id, res) = 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } if !chan.is_usable() { - return Err(HandleError{err: "Channel not yet available for receiving HTLCs", msg: None}); + return Err(HandleError{err: "Channel not yet available for receiving HTLCs", action: None}); } let short_channel_id = chan.get_short_channel_id().unwrap(); pending_forward_info.prev_short_channel_id = short_channel_id; (short_channel_id, chan.update_add_htlc(&msg, pending_forward_info)?) }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}), //TODO: panic? + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}), //TODO: panic? }; 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) => { @@ -1369,28 +1544,91 @@ impl ChannelMessageHandler for ChannelManager { 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } - chan.update_fulfill_htlc(&msg)?; - chan.channel_monitor() + chan.update_fulfill_htlc(&msg)? }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } }; - self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; + if let Err(_e) = self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor) { + unimplemented!(); + } 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(); - match channel_state.by_id.get_mut(&msg.channel_id) { + 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } chan.update_fail_htlc(&msg, HTLCFailReason::ErrorPacket { err: msg.reason.clone() }) }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) + }?; + + 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) } } @@ -1399,47 +1637,50 @@ impl ChannelMessageHandler for ChannelManager { 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } 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}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } } fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &msgs::CommitmentSigned) -> Result<(msgs::RevokeAndACK, Option), HandleError> { - let (res, monitor) = { + 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } - (chan.commitment_signed(&msg)?, chan.channel_monitor()) + chan.commitment_signed(&msg)? }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } }; - //TODO: Only if we store HTLC sigs - self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; + if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) { + unimplemented!(); + } - Ok(res) + 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), monitor) = { + 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } - (chan.revoke_and_ack(&msg)?, chan.channel_monitor()) + chan.revoke_and_ack(&msg)? }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } }; - self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; + 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); } @@ -1480,11 +1721,11 @@ impl ChannelMessageHandler for ChannelManager { 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } chan.update_fee(&*self.fee_estimator, &msg) }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } } @@ -1494,10 +1735,10 @@ impl ChannelMessageHandler for ChannelManager { 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}) + return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None}) } if !chan.is_usable() { - return Err(HandleError{err: "Got an announcement_signatures before we were ready for it", msg: None }); + return Err(HandleError{err: "Got an announcement_signatures before we were ready for it", action: None }); } let our_node_id = self.get_our_node_id(); @@ -1518,7 +1759,7 @@ impl ChannelMessageHandler for ChannelManager { contents: announcement, }, self.get_channel_update(chan).unwrap()) // can only fail if we're not in a ready state }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}) } }; let mut pending_events = self.pending_events.lock().unwrap(); @@ -1527,40 +1768,54 @@ impl ChannelMessageHandler for ChannelManager { } fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool) { - 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(move |_, chan| { - if chan.get_their_node_id() == *their_node_id { - match chan.get_short_channel_id() { - Some(short_id) => { + 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); - }, - None => {}, + } + 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. } - //TODO: get the latest commitment tx, any HTLC txn built on top of it, etc out - //of the channel and throw those into the announcement blackhole. - 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; @@ -1589,6 +1844,7 @@ mod tests { 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 @@ -1761,17 +2017,27 @@ mod tests { 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.create_channel(node_b.node.get_our_node_id(), 100000, 42).unwrap(); + + let events_1 = node_a.node.get_and_clear_pending_events(); + assert_eq!(events_1.len(), 1); + let accept_chan = match events_1[0] { + Event::SendOpenChannel { ref node_id, ref msg } => { + assert_eq!(*node_id, node_b.node.get_our_node_id()); + node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), msg).unwrap() + }, + _ => panic!("Unexpected event"), + }; + node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), &accept_chan).unwrap(); let chan_id = unsafe { CHAN_COUNT }; let tx; let funding_output; - let events_1 = node_a.node.get_and_clear_pending_events(); - assert_eq!(events_1.len(), 1); - match events_1[0] { + let events_2 = node_a.node.get_and_clear_pending_events(); + assert_eq!(events_2.len(), 1); + match events_2[0] { 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); @@ -1779,9 +2045,9 @@ mod tests { 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 = (Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); + funding_output = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); - node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output.clone()); + 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); @@ -1790,9 +2056,9 @@ mod tests { _ => panic!("Unexpected event"), } - let events_2 = node_a.node.get_and_clear_pending_events(); - assert_eq!(events_2.len(), 1); - let funding_signed = match events_2[0] { + let events_3 = node_a.node.get_and_clear_pending_events(); + assert_eq!(events_3.len(), 1); + let funding_signed = match events_3[0] { Event::SendFundingCreated { ref node_id, ref msg } => { 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(); @@ -1806,10 +2072,16 @@ mod tests { }; 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.node.get_and_clear_pending_events(); - assert_eq!(events_3.len(), 1); - match events_3[0] { + let events_4 = node_a.node.get_and_clear_pending_events(); + assert_eq!(events_4.len(), 1); + match events_4[0] { Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => { assert_eq!(user_channel_id, 42); assert_eq!(*funding_txo, funding_output); @@ -1818,9 +2090,9 @@ mod tests { }; 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] { + let events_5 = node_a.node.get_and_clear_pending_events(); + assert_eq!(events_5.len(), 1); + match events_5[0] { Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => { assert_eq!(*node_id, node_b.node.get_our_node_id()); assert!(announcement_sigs.is_none()); @@ -1832,9 +2104,9 @@ mod tests { let channel_id; 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] { + let events_6 = node_b.node.get_and_clear_pending_events(); + assert_eq!(events_6.len(), 1); + let as_announcement_sigs = match events_6[0] { Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => { assert_eq!(*node_id, node_a.node.get_our_node_id()); channel_id = msg.channel_id.clone(); @@ -1845,9 +2117,9 @@ mod tests { _ => panic!("Unexpected event"), }; - 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] { + let events_7 = node_a.node.get_and_clear_pending_events(); + assert_eq!(events_7.len(), 1); + let (announcement, as_update) = match events_7[0] { Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { (msg, update_msg) }, @@ -1855,9 +2127,9 @@ mod tests { }; 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] { + let events_8 = node_b.node.get_and_clear_pending_events(); + assert_eq!(events_8.len(), 1); + let bs_update = match events_8[0] { Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { assert!(*announcement == *msg); update_msg @@ -1882,7 +2154,7 @@ mod tests { (chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4) } - fn close_channel(outbound_node: &Node, inbound_node: &Node, channel_id: &Uint256, funding_tx: Transaction, close_inbound_first: bool) { + 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); @@ -1918,6 +2190,26 @@ mod tests { 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 { @@ -1949,12 +2241,16 @@ mod tests { }; let mut payment_event = { - let msgs = origin_node.node.send_payment(route, our_payment_hash).unwrap().unwrap(); - SendEvent { - node_id: expected_route[0].node.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; @@ -2009,9 +2305,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); } @@ -2031,13 +2330,23 @@ mod tests { let mut next_msgs: Option<(msgs::UpdateFulfillHTLC, msgs::CommitmentSigned)> = None; macro_rules! update_fulfill_dance { - ($node: expr, $prev_node: expr) => { + ($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(), 2); + 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()); @@ -2063,7 +2372,7 @@ mod tests { for node in expected_route.iter().rev() { assert_eq!(expected_next_node, node.node.get_our_node_id()); if next_msgs.is_some() { - update_fulfill_dance!(node, prev_node); + update_fulfill_dance!(node, prev_node, false); } let events = node.node.get_and_clear_pending_events(); @@ -2080,7 +2389,7 @@ mod tests { } assert_eq!(expected_next_node, origin_node.node.get_our_node_id()); - update_fulfill_dance!(origin_node, expected_route.first().unwrap()); + update_fulfill_dance!(origin_node, expected_route.first().unwrap(), true); let events = origin_node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); @@ -2092,8 +2401,10 @@ mod tests { } } + 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, 142).unwrap(); + 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.node.get_our_node_id()); @@ -2103,7 +2414,7 @@ mod tests { } 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, 142).unwrap(); + 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.node.get_our_node_id()); @@ -2128,39 +2439,49 @@ mod tests { claim_payment(&origin, expected_route, our_payment_preimage); } - fn send_failed_payment(origin_node: &Node, expected_route: &[&Node]) { - let route = origin_node.router.get_route(&expected_route.last().unwrap().node.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.node.get_our_node_id()); - } - let our_payment_hash = send_along_route(origin_node, route, expected_route, 1000000).1; - + 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 mut next_msgs: Option<(msgs::UpdateFailHTLC, msgs::CommitmentSigned)> = None; macro_rules! update_fail_dance { - ($node: expr, $prev_node: expr) => { + ($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(); - 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); + 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(); - assert_eq!(added_monitors.len(), 1); + 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(); } } @@ -2172,7 +2493,7 @@ mod tests { for node in expected_route.iter().rev() { assert_eq!(expected_next_node, node.node.get_our_node_id()); if next_msgs.is_some() { - update_fail_dance!(node, prev_node); + update_fail_dance!(node, prev_node, false); } let events = node.node.get_and_clear_pending_events(); @@ -2189,7 +2510,7 @@ mod tests { } assert_eq!(expected_next_node, origin_node.node.get_our_node_id()); - update_fail_dance!(origin_node, expected_route.first().unwrap()); + update_fail_dance!(origin_node, expected_route.first().unwrap(), true); let events = origin_node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); @@ -2247,7 +2568,8 @@ mod tests { send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000); // Test failure packets - send_failed_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..]); + 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_4 = create_announced_chan_between_nodes(&nodes, 1, 3); @@ -2278,7 +2600,7 @@ mod tests { 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_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; @@ -2301,14 +2623,14 @@ mod tests { 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_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_preimage_2 = send_along_route(&nodes[1], Route { hops }, &vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).0; + 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(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_preimage_2); + 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 @@ -2340,4 +2662,261 @@ mod tests { 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 nodes { + assert_eq!(node.node.get_and_clear_pending_events().len(), 0); + assert_eq!(node.chan_monitor.added_monitors.lock().unwrap().len(), 0); + } + } }