X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannelmanager.rs;h=dff6cb19e953ecd6abf93d64c9116b2ebefb2ea3;hb=e9f9cda986a37a6d7d84f9f5856d06b477a2374f;hp=3d70b1d379a4391461b3c5a756e126716d8d701d;hpb=ab56b81acd9da3a697dfc37fc4cb43cd8fbb1a2c;p=rust-lightning diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs index 3d70b1d3..dff6cb19 100644 --- a/src/ln/channelmanager.rs +++ b/src/ln/channelmanager.rs @@ -11,7 +11,7 @@ use secp256k1::{Secp256k1,Message}; use secp256k1::ecdh::SharedSecret; use secp256k1; -use chain::chaininterface::{ChainListener,ChainWatchInterface,FeeEstimator}; +use chain::chaininterface::{BroadcasterInterface,ChainListener,ChainWatchInterface,FeeEstimator}; use ln::channel::Channel; use ln::channelmonitor::ManyChannelMonitor; use ln::router::Route; @@ -26,22 +26,63 @@ use crypto::digest::Digest; use crypto::symmetriccipher::SynchronousStreamCipher; use crypto::chacha20::ChaCha20; -use std::sync::{Mutex,Arc}; +use std::sync::{Mutex,MutexGuard,Arc}; use std::collections::HashMap; use std::collections::hash_map; -use std::ptr; -use std::mem; +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, +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 { @@ -59,15 +100,6 @@ enum PendingOutboundHTLC { } } -enum HTLCFailReason<'a> { - ErrorPacket { - err: &'a msgs::OnionErrorPacket, - }, - Reason { - failure_code: u16, - } -} - /// We hold back HTLCs we intend to relay for a random interval in the range (this, 5*this). This /// provides some limited amount of privacy. Ideally this would range from somewhere like 1 second /// to 30 seconds, but people expect lightning to be, you know, kinda fast, sadly. We could @@ -112,6 +144,7 @@ pub struct ChannelManager { fee_estimator: Arc, monitor: Arc, chain_monitor: Arc, + tx_broadcaster: Arc, announce_channels_publicly: bool, fee_proportional_millionths: u32, @@ -145,24 +178,40 @@ struct OnionKeys { mu: [u8; 32], } +pub struct ChannelDetails { + /// The channel's ID (prior to funding transaction generation, this is a random 32 bytes, + /// thereafter this is the txid of the funding transaction xor the funding transaction output). + /// Note that this means this value is *not* persistent - it can change once during the + /// lifetime of the channel. + pub channel_id: Uint256, + /// The position of the funding transaction in the chain. None if the funding transaction has + /// not yet been confirmed and the channel fully opened. + pub short_channel_id: Option, + pub remote_network_id: PublicKey, + pub channel_value_satoshis: u64, + /// The user_id passed in to create_channel, or 0 if the channel was inbound. + pub user_id: u64, +} + impl ChannelManager { /// Constructs a new ChannelManager to hold several channels and route between them. This is /// 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)! - pub fn new(our_network_key: SecretKey, fee_proportional_millionths: u32, announce_channels_publicly: bool, network: Network, feeest: Arc, monitor: Arc, chain_monitor: Arc) -> Result, secp256k1::Error> { + 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(); let res = Arc::new(ChannelManager { genesis_hash: genesis_block(network).header.bitcoin_hash(), fee_estimator: feeest.clone(), monitor: monitor.clone(), - chain_monitor: chain_monitor, + chain_monitor, + tx_broadcaster, - announce_channels_publicly: announce_channels_publicly, - fee_proportional_millionths: fee_proportional_millionths, - secp_ctx: secp_ctx, + announce_channels_publicly, + fee_proportional_millionths, + secp_ctx, channel_state: Mutex::new(ChannelHolder{ by_id: HashMap::new(), @@ -171,7 +220,7 @@ impl ChannelManager { forward_htlcs: HashMap::new(), claimable_htlcs: HashMap::new(), }), - our_network_key: our_network_key, + our_network_key, pending_events: Mutex::new(Vec::new()), }); @@ -190,6 +239,47 @@ impl ChannelManager { } } + /// Gets the list of open channels, in random order. See ChannelDetail field documentation for + /// more information. + pub fn list_channels(&self) -> Vec { + let channel_state = self.channel_state.lock().unwrap(); + let mut res = Vec::with_capacity(channel_state.by_id.len()); + for (channel_id, channel) in channel_state.by_id.iter() { + res.push(ChannelDetails { + channel_id: (*channel_id).clone(), + short_channel_id: channel.get_short_channel_id(), + remote_network_id: channel.get_their_node_id(), + channel_value_satoshis: channel.get_value_satoshis(), + user_id: channel.get_user_id(), + }); + } + res + } + + /// Begins the process of closing a channel. After this call (plus some timeout), no new HTLCs + /// 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(); + 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 + }, + 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: Vec::new() }); + } + Ok(res.0) + } + #[inline] fn gen_rho_mu_from_shared_secret(shared_secret: &SharedSecret) -> ([u8; 32], [u8; 32]) { ({ @@ -558,11 +648,12 @@ impl ChannelManager { pub fn process_pending_htlc_forward(&self) { let mut new_events = Vec::new(); + let mut failed_forwards = Vec::new(); { 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; } @@ -571,6 +662,10 @@ impl ChannelManager { let forward_chan_id = match channel_state.short_to_id.get(&short_chan_id) { Some(chan_id) => chan_id.clone(), None => { + failed_forwards.reserve(pending_forwards.len()); + 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; } @@ -581,7 +676,8 @@ impl ChannelManager { for forward_info in pending_forwards { 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) => { - // TODO: Send a failure packet back + let chan_update = self.get_channel_update(forward_chan).unwrap(); + failed_forwards.push((forward_info.payment_hash, 0x4000 | 7, Some(chan_update))); continue; }, Ok(update_add) => { @@ -626,6 +722,13 @@ 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() }), + }; + } + if new_events.is_empty() { return } let mut events = self.pending_events.lock().unwrap(); @@ -637,11 +740,10 @@ impl ChannelManager { /// 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(payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 15 }) + 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, payment_hash: &[u8; 32], onion_error: HTLCFailReason) -> bool { - let mut channel_state = self.channel_state.lock().unwrap(); + fn fail_htlc_backwards_internal(&self, mut channel_state: MutexGuard, payment_hash: &[u8; 32], onion_error: HTLCFailReason) -> bool { let mut pending_htlc = { match channel_state.claimable_htlcs.remove(payment_hash) { Some(pending_htlc) => pending_htlc, @@ -660,6 +762,7 @@ impl ChannelManager { 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() @@ -668,8 +771,8 @@ impl ChannelManager { }, PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, incoming_packet_shared_secret } => { let err_packet = match onion_error { - HTLCFailReason::Reason { failure_code } => { - let packet = ChannelManager::build_failure_packet(&incoming_packet_shared_secret, failure_code, &[0; 0]).encode(); + HTLCFailReason::Reason { failure_code, data } => { + 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 } => { @@ -677,14 +780,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? @@ -693,11 +796,18 @@ impl ChannelManager { } }; - let mut pending_events = self.pending_events.lock().unwrap(); - pending_events.push(events::Event::SendFailHTLC { - node_id, - msg: fail_msg - }); + match fail_msgs { + Some(msgs) => { + mem::drop(channel_state); + let mut pending_events = self.pending_events.lock().unwrap(); + pending_events.push(events::Event::SendFailHTLC { + node_id, + msg: msgs.0, + commitment_msg: msgs.1, + }); + }, + None => {}, + } true }, @@ -707,6 +817,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) } @@ -744,6 +855,7 @@ impl ChannelManager { if from_user { panic!("Called claim_funds with a preimage for an outgoing payment. There is nothing we can do with this, and something is seriously wrong if you knew this..."); } + mem::drop(channel_state); let mut pending_events = self.pending_events.lock().unwrap(); pending_events.push(events::Event::PaymentSent { payment_preimage @@ -751,15 +863,15 @@ impl ChannelManager { false }, PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, .. } => { - let (node_id, fulfill_msg) = { + let (node_id, fulfill_msgs, monitor) = { 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) { - Ok(msg) => (chan.get_their_node_id(), msg), + 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 }), Err(_e) => { //TODO: Do something with e? return false; @@ -767,13 +879,27 @@ impl ChannelManager { } }; - let mut pending_events = self.pending_events.lock().unwrap(); - pending_events.push(events::Event::SendFulfillHTLC { - node_id: node_id, - msg: fulfill_msg - }); + mem::drop(channel_state); + match fulfill_msgs { + Some(msgs) => { + 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, + }); + }, + None => {}, + } - true + //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 } }, } } @@ -818,6 +944,7 @@ impl ChainListener for ChannelManager { }, None => {} } + //TODO: Check if channel was closed (or disabled) here } for to_insert in short_to_ids_to_insert { channel_state.short_to_id.insert(to_insert.0, to_insert.1); @@ -948,12 +1075,57 @@ impl ChannelMessageHandler for ChannelManager { }; } - fn handle_shutdown(&self, _their_node_id: &PublicKey, _msg: &msgs::Shutdown) -> Result<(), HandleError> { - unimplemented!() + 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(); + + 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}) + } + let res = chan_entry.get_mut().shutdown(&*self.fee_estimator, &msg)?; + if chan_entry.get().is_shutdown() { + chan_entry.remove_entry(); + } + res + }, + 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: Vec::new() }); + } + Ok((res.0, res.1)) } - fn handle_closing_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::ClosingSigned) -> Result<(), HandleError> { - unimplemented!() + 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(); + 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}) + } + let res = chan_entry.get_mut().closing_signed(&*self.fee_estimator, &msg)?; + if res.1.is_some() { + // We're done with this channel, we've got a signed closing transaction and + // will send the closing_signed back to the remote peer upon return. This + // 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 + }, + hash_map::Entry::Vacant(_) => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + } + }; + if let Some(broadcast_tx) = res.1 { + self.tx_broadcaster.broadcast_transaction(&broadcast_tx); + } + Ok(res.0) } fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateAddHTLC) -> Result<(), msgs::HandleError> { @@ -971,6 +1143,33 @@ impl ChannelMessageHandler for ChannelManager { let associated_data = Vec::new(); //TODO: What to put here? + macro_rules! get_onion_hash { + () => { + { + let mut sha = Sha256::new(); + sha.input(&msg.onion_routing_packet.hop_data); + let mut onion_hash = [0; 32]; + sha.result(&mut onion_hash); + onion_hash + } + } + } + + macro_rules! return_err { + ($msg: expr, $err_code: expr, $data: expr) => { + return Err(msgs::HandleError { + err: $msg, + msg: Some(msgs::ErrorAction::UpdateFailHTLC { + msg: msgs::UpdateFailHTLC { + channel_id: msg.channel_id, + htlc_id: msg.htlc_id, + reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, $err_code, $data), + } + }), + }); + } + } + if msg.onion_routing_packet.version != 0 { //TODO: Spec doesn't indicate if we should only hash hop_data here (and in other //sha256_of_onion error data packets), or the entire onion_routing_packet. Either way, @@ -978,39 +1177,14 @@ impl ChannelMessageHandler for ChannelManager { //receiving node would have to brute force to figure out which version was put in the //packet by the node that send us the message, in the case of hashing the hop_data, the //node knows the HMAC matched, so they already know what is there... - let mut sha = Sha256::new(); - sha.input(&msg.onion_routing_packet.hop_data); - let mut onion_hash = [0; 32]; - sha.result(&mut onion_hash); - return Err(msgs::HandleError { - err: "Unknown onion packet version", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 0x8000 | 0x4000 | 4, &onion_hash), - } - }), - }); + return_err!("Unknown onion packet version", 0x8000 | 0x4000 | 4, &get_onion_hash!()); } let mut hmac = Hmac::new(Sha256::new(), &mu); hmac.input(&msg.onion_routing_packet.hop_data); hmac.input(&associated_data[..]); if hmac.result() != MacResult::new(&msg.onion_routing_packet.hmac) { - let mut sha = Sha256::new(); - sha.input(&msg.onion_routing_packet.hop_data); - let mut onion_hash = [0; 32]; - sha.result(&mut onion_hash); - return Err(HandleError{err: "HMAC Check failed", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 0x8000 | 0x4000 | 5, &onion_hash), - } - }), - }); + return_err!("HMAC Check failed", 0x8000 | 0x4000 | 5, &get_onion_hash!()); } let mut chacha = ChaCha20::new(&rho, &[0u8; 8]); @@ -1023,15 +1197,7 @@ impl ChannelMessageHandler for ChannelManager { msgs::DecodeError::UnknownRealmByte => 0x4000 | 1, _ => 0x2000 | 2, // Should never happen }; - return Err(HandleError{err: "Unable to decode our hop data", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, error_code, &[0;0]), - } - }), - }); + return_err!("Unable to decode our hop data", error_code, &[0;0]); }, Ok(msg) => msg } @@ -1040,26 +1206,10 @@ impl ChannelMessageHandler for ChannelManager { let mut pending_forward_info = if next_hop_data.hmac == [0; 32] { // OUR PAYMENT! if next_hop_data.data.amt_to_forward != msg.amount_msat { - return Err(HandleError{err: "Upstream node sent less than we were supposed to receive in payment", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 19, &byte_utils::be64_to_array(msg.amount_msat)), - } - }), - }); + return_err!("Upstream node sent less than we were supposed to receive in payment", 19, &byte_utils::be64_to_array(msg.amount_msat)); } if next_hop_data.data.outgoing_cltv_value != msg.cltv_expiry { - return Err(HandleError{err: "Upstream node set CLTV to the wrong value", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 18, &byte_utils::be32_to_array(msg.cltv_expiry)), - } - }), - }); + return_err!("Upstream node set CLTV to the wrong value", 18, &byte_utils::be32_to_array(msg.cltv_expiry)); } // Note that we could obviously respond immediately with an update_fulfill_htlc @@ -1092,15 +1242,7 @@ impl ChannelMessageHandler for ChannelManager { Err(_) => { // Return temporary node failure as its technically our issue, not the // channel's issue. - return Err(HandleError{err: "Blinding factor is an invalid private key", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 0x2000 | 2, &[0;0]), - } - }), - }); + return_err!("Blinding factor is an invalid private key", 0x2000 | 2, &[0;0]); }, Ok(key) => key } @@ -1110,15 +1252,7 @@ impl ChannelMessageHandler for ChannelManager { Err(_) => { // Return temporary node failure as its technically our issue, not the // channel's issue. - return Err(HandleError{err: "New blinding factor is an invalid private key", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 0x2000 | 2, &[0;0]), - } - }), - }); + return_err!("New blinding factor is an invalid private key", 0x2000 | 2, &[0;0]); }, Ok(_) => {} }; @@ -1148,30 +1282,14 @@ impl ChannelMessageHandler for ChannelManager { if pending_forward_info.onion_packet.is_some() { // If short_channel_id is 0 here, we'll reject them in the body here let forwarding_id = match channel_state.short_to_id.get(&pending_forward_info.short_channel_id) { None => { - return Err(HandleError{err: "Don't have available channel for forwarding as requested.", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 0x4000 | 10, &[0;0]), - } - }), - }); + return_err!("Don't have available channel for forwarding as requested.", 0x4000 | 10, &[0;0]); }, Some(id) => id.clone(), }; 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(HandleError{err: "Forwarding channel is not in a ready state.", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 0x4000 | 10, &chan_update.encode()[..]), - } - }), - }); + return_err!("Forwarding channel is not in a ready state.", 0x4000 | 10, &chan_update.encode()[..]); } } @@ -1191,15 +1309,7 @@ impl ChannelMessageHandler for ChannelManager { _ => {}, } if !acceptable_cycle { - return Err(HandleError{err: "Payment looped through us twice", - msg: Some(msgs::ErrorMessage::UpdateFailHTLC { - msg: msgs::UpdateFailHTLC { - channel_id: msg.channel_id, - htlc_id: msg.htlc_id, - reason: ChannelManager::build_first_hop_failure_packet(&shared_secret, 0x4000 | 0x2000|2, &[0;0]), - } - }), - }); + return_err!("Payment looped through us twice", 0x4000 | 0x2000 | 2, &[0;0]); } }, _ => {}, @@ -1222,7 +1332,7 @@ impl ChannelMessageHandler for ChannelManager { match claimable_htlcs_entry { hash_map::Entry::Occupied(mut e) => { - let mut outbound_route = e.get_mut(); + let outbound_route = e.get_mut(); let route = match outbound_route { &mut PendingOutboundHTLC::OutboundRoute { ref route } => { route.clone() @@ -1246,78 +1356,100 @@ impl ChannelMessageHandler for ChannelManager { Ok(res) } - fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFulfillHTLC) -> Result, msgs::CommitmentSigned)>, HandleError> { - let res = { + 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)?; + chan.channel_monitor() }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) } }; - //TODO: Delay the claimed_funds relaying just like we do outbound relay! - self.claim_funds_internal(msg.payment_preimage.clone(), false); - res + self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; + Ok(()) } - fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailHTLC) -> Result, msgs::CommitmentSigned)>, HandleError> { - let res = { + 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) { + 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, HTLCFailReason::ErrorPacket { err: msg.reason.clone() }) + }, + None => return Err(HandleError{err: "Failed to find corresponding channel", msg: 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(); + 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, HTLCFailReason::Reason { failure_code: msg.failure_code, data: Vec::new() }) + }, + None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) + } + } + + fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &msgs::CommitmentSigned) -> Result<(msgs::RevokeAndACK, Option), 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.update_fail_htlc(&msg)? + (chan.commitment_signed(&msg)?, chan.channel_monitor()) }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) } }; - self.fail_htlc_backwards_internal(&res.0, HTLCFailReason::ErrorPacket { err: &msg.reason }); - Ok(res.1) + //TODO: Only if we store HTLC sigs + self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; + + Ok(res) } - fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailMalformedHTLC) -> Result, msgs::CommitmentSigned)>, HandleError> { - let res = { + 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 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_fail_malformed_htlc(&msg)? + (chan.revoke_and_ack(&msg)?, chan.channel_monitor()) }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) } }; - self.fail_htlc_backwards_internal(&res.0, HTLCFailReason::Reason { failure_code: msg.failure_code }); - Ok(res.1) - } + self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; + for failure in pending_failures.drain(..) { + self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failure.0, failure.1); + } - fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &msgs::CommitmentSigned) -> Result { let mut forward_event = None; - let (res, monitor) = { + if !pending_forwards.is_empty() { let mut channel_state = self.channel_state.lock().unwrap(); - - let ((res, mut forwarding_infos), monitor) = 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()) - }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - }; - 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); @@ -1327,12 +1459,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(); @@ -1346,24 +1473,6 @@ impl ChannelMessageHandler for ChannelManager { Ok(res) } - fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &msgs::RevokeAndACK) -> Result<(), HandleError> { - 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.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(()) - } - 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) { @@ -1414,6 +1523,37 @@ 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 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) => { + short_to_id.remove(&short_id); + }, + None => {}, + } + //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. + } + } + } + } } #[cfg(test)] @@ -1428,8 +1568,9 @@ mod tests { use bitcoin::util::misc::hex_bytes; 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; @@ -1442,8 +1583,9 @@ mod tests { use rand::{thread_rng,Rng}; - use std::sync::Arc; + use std::collections::HashMap; use std::default::Default; + use std::sync::{Arc, Mutex}; use std::time::Instant; fn build_test_onion_keys() -> Vec { @@ -1596,35 +1738,42 @@ 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) { - let open_chan = node_a.create_channel(node_b.get_our_node_id(), (1 << 24) - 1, 42).unwrap(); + static mut CHAN_COUNT: u32 = 0; + fn create_chan_between_nodes(node_a: &ChannelManager, chain_a: &chaininterface::ChainWatchInterfaceUtil, monitor_a: &test_utils::TestChannelMonitor, node_b: &ChannelManager, chain_b: &chaininterface::ChainWatchInterfaceUtil, monitor_b: &test_utils::TestChannelMonitor) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, Uint256, Transaction) { + 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(); let chan_id = unsafe { CHAN_COUNT }; - let tx = Transaction { version: chan_id as u32, lock_time: 0, input: Vec::new(), output: Vec::new(), witness: 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(); 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 } => { - assert_eq!(*channel_value_satoshis, (1 << 24) - 1); + 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); + 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); + node_a.funding_transaction_generated(&temporary_channel_id, funding_output.clone()); - //TODO: Check that we got added to chan_monitor_a! + let mut added_monitors = monitor_a.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + assert_eq!(added_monitors[0].0, funding_output); + added_monitors.clear(); }, _ => panic!("Unexpected event"), } @@ -1634,8 +1783,12 @@ mod tests { 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! + let res = node_b.handle_funding_created(&node_a.get_our_node_id(), msg).unwrap(); + let mut added_monitors = monitor_b.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"), }; @@ -1652,7 +1805,7 @@ mod tests { _ => panic!("Unexpected event"), }; - confirm_transaction(&chain_a, &tx); + confirm_transaction(&chain_a, &tx, chan_id); let events_4 = node_a.get_and_clear_pending_events(); assert_eq!(events_4.len(), 1); match events_4[0] { @@ -1664,12 +1817,15 @@ mod tests { _ => panic!("Unexpected event"), }; - confirm_transaction(&chain_b, &tx); + let channel_id; + + confirm_transaction(&chain_b, &tx, chan_id); let events_5 = node_b.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()); + 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(); as_announcement_sigs @@ -1701,7 +1857,45 @@ mod tests { CHAN_COUNT += 1; } - ((*announcement).clone(), (*as_update).clone(), (*bs_update).clone()) + ((*announcement).clone(), (*as_update).clone(), (*bs_update).clone(), channel_id, tx) + } + + fn close_channel(outbound_node: &ChannelManager, outbound_broadcaster: &test_utils::TestBroadcaster, inbound_node: &ChannelManager, inbound_broadcaster: &test_utils::TestBroadcaster, channel_id: &Uint256, funding_tx: Transaction, 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) }; + let (tx_a, tx_b); + + let shutdown_a = node_a.close_channel(channel_id).unwrap(); + let (shutdown_b, mut closing_signed_b) = node_b.handle_shutdown(&node_a.get_our_node_id(), &shutdown_a).unwrap(); + if !close_inbound_first { + assert!(closing_signed_b.is_none()); + } + let (empty_a, mut closing_signed_a) = node_a.handle_shutdown(&node_b.get_our_node_id(), &shutdown_b.unwrap()).unwrap(); + assert!(empty_a.is_none()); + if close_inbound_first { + assert!(closing_signed_a.is_none()); + closing_signed_a = node_a.handle_closing_signed(&node_b.get_our_node_id(), &closing_signed_b.unwrap()).unwrap(); + assert_eq!(broadcaster_a.txn_broadcasted.lock().unwrap().len(), 1); + tx_a = broadcaster_a.txn_broadcasted.lock().unwrap().remove(0); + + let empty_b = node_b.handle_closing_signed(&node_a.get_our_node_id(), &closing_signed_a.unwrap()).unwrap(); + assert!(empty_b.is_none()); + assert_eq!(broadcaster_b.txn_broadcasted.lock().unwrap().len(), 1); + tx_b = broadcaster_b.txn_broadcasted.lock().unwrap().remove(0); + } else { + closing_signed_b = node_b.handle_closing_signed(&node_a.get_our_node_id(), &closing_signed_a.unwrap()).unwrap(); + assert_eq!(broadcaster_b.txn_broadcasted.lock().unwrap().len(), 1); + tx_b = broadcaster_b.txn_broadcasted.lock().unwrap().remove(0); + + let empty_a2 = node_a.handle_closing_signed(&node_b.get_our_node_id(), &closing_signed_b.unwrap()).unwrap(); + assert!(empty_a2.is_none()); + assert_eq!(broadcaster_a.txn_broadcasted.lock().unwrap().len(), 1); + 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(); } struct SendEvent { @@ -1712,7 +1906,7 @@ mod tests { impl SendEvent { fn from_event(event: Event) -> SendEvent { match event { - Event::SendHTLCs{ node_id, msgs, commitment_msg } => { + Event::SendHTLCs { node_id, msgs, commitment_msg } => { SendEvent { node_id: node_id, msgs: msgs, commitment_msg: commitment_msg } }, _ => panic!("Unexpected event type!"), @@ -1721,7 +1915,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: &ChannelManager, origin_monitor: &test_utils::TestChannelMonitor, route: Route, expected_route: &[(&ChannelManager, &test_utils::TestChannelMonitor)], recv_value: u64) -> ([u8; 32], [u8; 32]) { let our_payment_preimage = unsafe { [PAYMENT_COUNT; 32] }; unsafe { PAYMENT_COUNT += 1 }; let our_payment_hash = { @@ -1735,19 +1929,42 @@ 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(), + node_id: expected_route[0].0.get_our_node_id(), msgs: vec!(msgs.0), commitment_msg: msgs.1, } }; - let mut prev_node = origin_node; + let mut prev_node = (origin_node, origin_monitor); - for (idx, node) in expected_route.iter().enumerate() { + for (idx, &(node, monitor)) in expected_route.iter().enumerate() { assert_eq!(node.get_our_node_id(), payment_event.node_id); - 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(); - prev_node.handle_revoke_and_ack(&node.get_our_node_id(), &revoke_and_ack).unwrap(); + node.handle_update_add_htlc(&prev_node.0.get_our_node_id(), &payment_event.msgs[0]).unwrap(); + { + let added_monitors = monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 0); + } + + let revoke_and_ack = node.handle_commitment_signed(&prev_node.0.get_our_node_id(), &payment_event.commitment_msg).unwrap(); + { + let mut added_monitors = monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + assert!(prev_node.0.handle_revoke_and_ack(&node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + let prev_revoke_and_ack = prev_node.0.handle_commitment_signed(&node.get_our_node_id(), &revoke_and_ack.1.unwrap()).unwrap(); + { + let mut added_monitors = prev_node.1.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!(node.handle_revoke_and_ack(&prev_node.0.get_our_node_id(), &prev_revoke_and_ack.0).unwrap().is_none()); + assert!(prev_revoke_and_ack.1.is_none()); + { + let mut added_monitors = monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } let events_1 = node.get_and_clear_pending_events(); assert_eq!(events_1.len(), 1); @@ -1776,49 +1993,72 @@ mod tests { assert_eq!(payment_event.msgs.len(), 1); } - prev_node = node; + prev_node = (node, monitor); } (our_payment_preimage, our_payment_hash) } - fn send_payment(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(); - 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 claim_payment(origin_node: &ChannelManager, origin_monitor: &test_utils::TestChannelMonitor, expected_route: &[(&ChannelManager, &test_utils::TestChannelMonitor)], our_payment_preimage: [u8; 32]) { + assert!(expected_route.last().unwrap().0.claim_funds(our_payment_preimage)); + { + let mut added_monitors = expected_route.last().unwrap().1.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); } - let our_payment_preimage = send_along_route(origin_node, route, expected_route, recv_value).0; - - assert!(expected_route.last().unwrap().claim_funds(our_payment_preimage)); + let mut next_msgs: Option<(msgs::UpdateFulfillHTLC, msgs::CommitmentSigned)> = None; + macro_rules! update_fulfill_dance { + ($node: expr, $monitor: expr, $prev_node: expr, $prev_monitor: expr) => { + { + $node.handle_update_fulfill_htlc(&$prev_node.get_our_node_id(), &next_msgs.as_ref().unwrap().0).unwrap(); + let revoke_and_commit = $node.handle_commitment_signed(&$prev_node.get_our_node_id(), &next_msgs.as_ref().unwrap().1).unwrap(); + { + let mut added_monitors = $monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!($prev_node.handle_revoke_and_ack(&$node.get_our_node_id(), &revoke_and_commit.0).unwrap().is_none()); + let revoke_and_ack = $prev_node.handle_commitment_signed(&$node.get_our_node_id(), &revoke_and_commit.1.unwrap()).unwrap(); + assert!(revoke_and_ack.1.is_none()); + { + let mut added_monitors = $prev_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!($node.handle_revoke_and_ack(&$prev_node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + { + let mut added_monitors = $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 prev_node = expected_route.last().unwrap(); - let mut next_msg = None; - for node in expected_route.iter().rev() { + let mut expected_next_node = expected_route.last().unwrap().0.get_our_node_id(); + let mut prev_node = (expected_route.last().unwrap().0, expected_route.last().unwrap().1); + for &(node, monitor) in expected_route.iter().rev() { assert_eq!(expected_next_node, node.get_our_node_id()); - match next_msg { - Some(msg) => { - assert!(node.handle_update_fulfill_htlc(&prev_node.get_our_node_id(), &msg).unwrap().is_none()); - }, None => {} + if next_msgs.is_some() { + update_fulfill_dance!(node, monitor, prev_node.0, prev_node.1); } let events = 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"), }; - prev_node = node; + prev_node = (node, monitor); } assert_eq!(expected_next_node, origin_node.get_our_node_id()); - assert!(origin_node.handle_update_fulfill_htlc(&expected_route.first().unwrap().get_our_node_id(), &next_msg.unwrap()).unwrap().is_none()); + update_fulfill_dance!(origin_node, origin_monitor, expected_route.first().unwrap().0, expected_route.first().unwrap().1); let events = origin_node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); @@ -1830,42 +2070,104 @@ mod tests { } } - 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(); + fn route_payment(origin_node: &ChannelManager, origin_monitor: &test_utils::TestChannelMonitor, origin_router: &Router, expected_route: &[(&ChannelManager, &test_utils::TestChannelMonitor)], recv_value: u64) -> ([u8; 32], [u8; 32]) { + let route = origin_router.get_route(&expected_route.last().unwrap().0.get_our_node_id(), &Vec::new(), recv_value, 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()); + } + + send_along_route(origin_node, origin_monitor, 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(); 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()); } - 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 our_payment_preimage = unsafe { [PAYMENT_COUNT; 32] }; + unsafe { PAYMENT_COUNT += 1 }; + let our_payment_hash = { + let mut sha = Sha256::new(); + sha.input(&our_payment_preimage[..]); + let mut ret = [0; 32]; + sha.result(&mut ret); + ret + }; - let mut expected_next_node = expected_route.last().unwrap().get_our_node_id(); - let mut prev_node = expected_route.last().unwrap(); - let mut next_msg = None; - for node in expected_route.iter().rev() { + let err = origin_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_monitor: &test_utils::TestChannelMonitor, origin_router: &Router, expected_route: &[(&ChannelManager, &test_utils::TestChannelMonitor)], recv_value: u64) { + let our_payment_preimage = route_payment(origin_node, origin_monitor, origin_router, expected_route, recv_value).0; + claim_payment(origin_node, origin_monitor, expected_route, our_payment_preimage); + } + + fn send_failed_payment(origin_node: &ChannelManager, origin_monitor: &test_utils::TestChannelMonitor, origin_router: &Router, expected_route: &[(&ChannelManager, &test_utils::TestChannelMonitor)]) { + let route = origin_router.get_route(&expected_route.last().unwrap().0.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()); + } + let our_payment_hash = send_along_route(origin_node, origin_monitor, route, expected_route, 1000000).1; + + assert!(expected_route.last().unwrap().0.fail_htlc_backwards(&our_payment_hash)); + + let mut next_msgs: Option<(msgs::UpdateFailHTLC, msgs::CommitmentSigned)> = None; + macro_rules! update_fail_dance { + ($node: expr, $monitor: expr, $prev_node: expr, $prev_monitor: expr) => { + { + $node.handle_update_fail_htlc(&$prev_node.get_our_node_id(), &next_msgs.as_ref().unwrap().0).unwrap(); + let revoke_and_commit = $node.handle_commitment_signed(&$prev_node.get_our_node_id(), &next_msgs.as_ref().unwrap().1).unwrap(); + { + let mut added_monitors = $monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + assert!($prev_node.handle_revoke_and_ack(&$node.get_our_node_id(), &revoke_and_commit.0).unwrap().is_none()); + let revoke_and_ack = $prev_node.handle_commitment_signed(&$node.get_our_node_id(), &revoke_and_commit.1.unwrap()).unwrap(); + assert!(revoke_and_ack.1.is_none()); + { + let mut added_monitors = $prev_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!($node.handle_revoke_and_ack(&$prev_node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + { + let mut added_monitors = $monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + } + } + } + + let mut expected_next_node = expected_route.last().unwrap().0.get_our_node_id(); + let mut prev_node = (expected_route.last().unwrap().0, expected_route.last().unwrap().1); + for &(node, monitor) in expected_route.iter().rev() { assert_eq!(expected_next_node, node.get_our_node_id()); - match next_msg { - Some(msg) => { - assert!(node.handle_update_fail_htlc(&prev_node.get_our_node_id(), &msg).unwrap().is_none()); - }, None => {} + if next_msgs.is_some() { + update_fail_dance!(node, monitor, prev_node.0, prev_node.1); } let events = 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"), }; - prev_node = node; + prev_node = (node, monitor); } assert_eq!(expected_next_node, origin_node.get_our_node_id()); - assert!(origin_node.handle_update_fail_htlc(&expected_route.first().unwrap().get_our_node_id(), &next_msg.unwrap()).unwrap().is_none()); + update_fail_dance!(origin_node, origin_monitor, expected_route.first().unwrap().0, expected_route.first().unwrap().1); let events = origin_node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); @@ -1886,88 +2188,104 @@ mod tests { 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 chan_monitor_1 = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor_1.clone(), tx_broadcaster_1.clone())); 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()).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 chan_monitor_2 = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor_2.clone(), tx_broadcaster_2.clone())); 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()).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 chan_monitor_3 = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor_3.clone(), tx_broadcaster_3.clone())); 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()).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 chan_monitor_4 = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor_4.clone(), tx_broadcaster_4.clone())); 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()).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()); // Create some initial channels - let chan_announcement_1 = create_chan_between_nodes(&node_1, &chain_monitor_1, &node_2, &chain_monitor_2); + let chan_announcement_1 = create_chan_between_nodes(&node_1, &chain_monitor_1, &chan_monitor_1, &node_2, &chain_monitor_2, &chan_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); + let chan_announcement_2 = create_chan_between_nodes(&node_2, &chain_monitor_2, &chan_monitor_2, &node_3, &chain_monitor_3, &chan_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); + let chan_announcement_3 = create_chan_between_nodes(&node_3, &chain_monitor_3, &chan_monitor_3, &node_4, &chain_monitor_4, &chan_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(); } - // Send some payments - send_payment(&node_1, &router_1, &vec!(&*node_2, &*node_3, &*node_4)[..], 1000000); - 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)[..], 250000); + // Rebalance the network a bit by relaying one payment through all the channels... + send_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4))[..], 8000000); + send_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4))[..], 8000000); + send_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4))[..], 8000000); + send_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4))[..], 8000000); + send_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4))[..], 8000000); + + // Send some more payments + send_payment(&node_2, &chan_monitor_2, &router_2, &vec!((&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4))[..], 1000000); + send_payment(&node_4, &chan_monitor_4, &router_4, &vec!((&*node_3, &*chan_monitor_3), (&*node_2, &*chan_monitor_2), (&*node_1, &*chan_monitor_1))[..], 1000000); + send_payment(&node_4, &chan_monitor_4, &router_4, &vec!((&*node_3, &*chan_monitor_3), (&*node_2, &*chan_monitor_2))[..], 1000000); // Test failure packets - send_failed_payment(&node_1, &router_1, &vec!(&*node_2, &*node_3, &*node_4)[..]); + send_failed_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4))[..]); // 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); + let chan_announcement_4 = create_chan_between_nodes(&node_2, &chain_monitor_2, &chan_monitor_2, &node_4, &chain_monitor_4, &chan_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(); } - send_payment(&node_1, &router_1, &vec!(&*node_2, &*node_4)[..], 1000000); + send_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_4, &*chan_monitor_4))[..], 1000000); + send_payment(&node_3, &chan_monitor_3, &router_3, &vec!((&*node_4, &*chan_monitor_4))[..], 1000000); + send_payment(&node_2, &chan_monitor_2, &router_2, &vec!((&*node_4, &*chan_monitor_4))[..], 8000000); + send_payment(&node_2, &chan_monitor_2, &router_2, &vec!((&*node_4, &*chan_monitor_4))[..], 8000000); + send_payment(&node_2, &chan_monitor_2, &router_2, &vec!((&*node_4, &*chan_monitor_4))[..], 8000000); + send_payment(&node_2, &chan_monitor_2, &router_2, &vec!((&*node_4, &*chan_monitor_4))[..], 8000000); + send_payment(&node_2, &chan_monitor_2, &router_2, &vec!((&*node_4, &*chan_monitor_4))[..], 8000000); - // Rebalance a bit + // Do some rebalance loop payments, simultaneously let mut hops = Vec::with_capacity(3); hops.push(RouteHop { pubkey: node_3.get_our_node_id(), @@ -1984,16 +2302,73 @@ mod tests { hops.push(RouteHop { pubkey: node_2.get_our_node_id(), short_channel_id: chan_announcement_4.1.contents.short_channel_id, - fee_msat: 250000, + fee_msat: 1000000, cltv_expiry_delta: 142, }); 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; - send_along_route(&node_2, Route { hops }, &vec!(&*node_3, &*node_4, &*node_2)[..], 250000); + let payment_preimage_1 = send_along_route(&node_2, &chan_monitor_2, Route { hops }, &vec!((&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4), (&*node_2, &*chan_monitor_2))[..], 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, + fee_msat: 0, + cltv_expiry_delta: chan_announcement_3.2.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, + fee_msat: 0, + cltv_expiry_delta: chan_announcement_2.2.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, + fee_msat: 1000000, + cltv_expiry_delta: 142, + }); + 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, &chan_monitor_2, Route { hops }, &vec!((&*node_4, &*chan_monitor_4), (&*node_3, &*chan_monitor_3), (&*node_2, &*chan_monitor_2))[..], 1000000).0; + + // Claim the rebalances... + claim_payment(&node_2, &chan_monitor_2, &vec!((&*node_4, &*chan_monitor_4), (&*node_3, &*chan_monitor_3), (&*node_2, &*chan_monitor_2))[..], payment_preimage_2); + claim_payment(&node_2, &chan_monitor_2, &vec!((&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4), (&*node_2, &*chan_monitor_2))[..], 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, &chan_monitor_2, &node_4, &chain_monitor_4, &chan_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(); + } + + // Send some payments across both channels + let payment_preimage_3 = route_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_4, &*chan_monitor_4))[..], 3000000).0; + let payment_preimage_4 = route_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_4, &*chan_monitor_4))[..], 3000000).0; + let payment_preimage_5 = route_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_4, &*chan_monitor_4))[..], 3000000).0; + + route_over_limit(&node_1, &router_1, &vec!(&*node_2, &*node_4)[..], 3000000); + + //TODO: Test that routes work again here as we've been notified that the channel is full + + claim_payment(&node_1, &chan_monitor_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_4, &*chan_monitor_4))[..], payment_preimage_3); + claim_payment(&node_1, &chan_monitor_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_4, &*chan_monitor_4))[..], payment_preimage_4); + claim_payment(&node_1, &chan_monitor_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_4, &*chan_monitor_4))[..], payment_preimage_5); + + // Close down the channels... + close_channel(&node_1, &tx_broadcaster_1, &node_2, &tx_broadcaster_2, &chan_announcement_1.3, chan_announcement_1.4, true); + close_channel(&node_2, &tx_broadcaster_2, &node_3, &tx_broadcaster_3, &chan_announcement_2.3, chan_announcement_2.4, false); + close_channel(&node_3, &tx_broadcaster_3, &node_4, &tx_broadcaster_4, &chan_announcement_3.3, chan_announcement_3.4, true); + close_channel(&node_2, &tx_broadcaster_2, &node_4, &tx_broadcaster_4, &chan_announcement_4.3, chan_announcement_4.4, false); // 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 chan_monitor in vec!(&chan_monitor_1, &chan_monitor_2, &chan_monitor_3, &chan_monitor_4) { + assert_eq!(chan_monitor.added_monitors.lock().unwrap().len(), 0); + } } }