X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannelmanager.rs;h=68cfed8fd0d422cce1f17550bdefde7d129dbae1;hb=4fbe0c90b8d535e407bd8a3021a80ab0bf0dc06e;hp=b35387ba8314b7921e92a818f36a94a4e1260215;hpb=e2b1b1be78384ab7a5d63dd3ef5e54eb7eb6e662;p=rust-lightning diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs index b35387ba..68cfed8f 100644 --- a/src/ln/channelmanager.rs +++ b/src/ln/channelmanager.rs @@ -37,12 +37,12 @@ mod channel_held_info { /// 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, + 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")] @@ -59,6 +59,7 @@ mod channel_held_info { } } + #[derive(Clone)] // See Channel::revoke_and_ack for why, tl;dr: Rust bug pub enum HTLCFailReason { ErrorPacket { err: msgs::OnionErrorPacket, @@ -68,6 +69,15 @@ mod channel_held_info { 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::*; @@ -297,6 +307,7 @@ impl ChannelManager { res } + #[inline] fn gen_ammag_from_shared_secret(shared_secret: &SharedSecret) -> [u8; 32] { let mut hmac = Hmac::new(Sha256::new(), &[0x61, 0x6d, 0x6d, 0x61, 0x67]); // ammag hmac.input(&shared_secret[..]); @@ -495,6 +506,7 @@ impl ChannelManager { packet } + #[inline] fn build_first_hop_failure_packet(shared_secret: &SharedSecret, failure_type: u16, failure_data: &[u8]) -> msgs::OnionErrorPacket { let failure_packet = ChannelManager::build_failure_packet(shared_secret, failure_type, failure_data); ChannelManager::encrypt_failure_packet(shared_secret, &failure_packet.encode()[..]) @@ -770,14 +782,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? @@ -786,12 +798,18 @@ impl ChannelManager { } }; - mem::drop(channel_state); - let mut pending_events = self.pending_events.lock().unwrap(); - pending_events.push(events::Event::SendFailHTLC { - node_id, - msg: fail_msg - }); + match fail_msgs { + Some(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 }, @@ -847,14 +865,14 @@ impl ChannelManager { false }, PendingOutboundHTLC::IntermediaryHopData { source_short_channel_id, .. } => { - let (node_id, fulfill_msg, monitor) = { + 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) { + 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? @@ -863,13 +881,17 @@ impl ChannelManager { } }; - { - mem::drop(channel_state); - let mut pending_events = self.pending_events.lock().unwrap(); - pending_events.push(events::Event::SendFulfillHTLC { - node_id: node_id, - msg: fulfill_msg - }); + 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 => {}, } //TODO: It may not be possible to handle add_update_monitor fails gracefully, maybe @@ -1361,40 +1383,34 @@ impl ChannelMessageHandler for ChannelManager { fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailHTLC) -> Result<(), HandleError> { let mut channel_state = self.channel_state.lock().unwrap(); - let payment_hash = match channel_state.by_id.get_mut(&msg.channel_id) { + match channel_state.by_id.get_mut(&msg.channel_id) { Some(chan) => { if chan.get_their_node_id() != *their_node_id { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) } - chan.update_fail_htlc(&msg)? + chan.update_fail_htlc(&msg, HTLCFailReason::ErrorPacket { err: msg.reason.clone() }) }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - }; - self.fail_htlc_backwards_internal(channel_state, &payment_hash, HTLCFailReason::ErrorPacket { err: msg.reason.clone() }); - Ok(()) + } } fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailMalformedHTLC) -> Result<(), HandleError> { let mut channel_state = self.channel_state.lock().unwrap(); - let payment_hash = match channel_state.by_id.get_mut(&msg.channel_id) { + match channel_state.by_id.get_mut(&msg.channel_id) { Some(chan) => { if chan.get_their_node_id() != *their_node_id { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) } - chan.update_fail_malformed_htlc(&msg)? + chan.update_fail_malformed_htlc(&msg, HTLCFailReason::Reason { failure_code: msg.failure_code, data: Vec::new() }) }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - }; - self.fail_htlc_backwards_internal(channel_state, &payment_hash, HTLCFailReason::Reason { failure_code: msg.failure_code, data: Vec::new() }); - Ok(()) + } } - fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &msgs::CommitmentSigned) -> Result { - let mut forward_event = 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(); - - let ((res, mut forwarding_infos), monitor) = match channel_state.by_id.get_mut(&msg.channel_id) { + match channel_state.by_id.get_mut(&msg.channel_id) { Some(chan) => { if chan.get_their_node_id() != *their_node_id { return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) @@ -1402,13 +1418,40 @@ impl ChannelMessageHandler for ChannelManager { (chan.commitment_signed(&msg)?, chan.channel_monitor()) }, None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - }; + } + }; + //TODO: Only if we store HTLC sigs + self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; + + Ok(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.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)?; + for failure in pending_failures.drain(..) { + self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), &failure.0, failure.1); + } + let mut forward_event = None; + if !pending_forwards.is_empty() { + let mut channel_state = self.channel_state.lock().unwrap(); if channel_state.forward_htlcs.is_empty() { forward_event = Some(Instant::now() + Duration::from_millis(((rng::rand_f32() * 4.0 + 1.0) * MIN_HTLC_RELAY_HOLDING_CELL_MILLIS as f32) as u64)); channel_state.next_forward = forward_event.unwrap(); } - for forward_info in forwarding_infos.drain(..) { + for forward_info in pending_forwards.drain(..) { match channel_state.forward_htlcs.entry(forward_info.short_channel_id) { hash_map::Entry::Occupied(mut entry) => { entry.get_mut().push(forward_info); @@ -1418,12 +1461,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(); @@ -1437,23 +1475,6 @@ impl ChannelMessageHandler for ChannelManager { Ok(res) } - fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &msgs::RevokeAndACK) -> Result, msgs::CommitmentSigned)>, HandleError> { - let (res, monitor) = { - let mut channel_state = self.channel_state.lock().unwrap(); - match channel_state.by_id.get_mut(&msg.channel_id) { - Some(chan) => { - if chan.get_their_node_id() != *their_node_id { - return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None}) - } - (chan.revoke_and_ack(&msg)?, chan.channel_monitor()) - }, - None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None}) - } - }; - self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?; - Ok(res) - } - fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFee) -> Result<(), HandleError> { let mut channel_state = self.channel_state.lock().unwrap(); match channel_state.by_id.get_mut(&msg.channel_id) { @@ -1564,8 +1585,9 @@ mod tests { use rand::{thread_rng,Rng}; - use std::sync::{Arc, Mutex}; + use std::collections::HashMap; use std::default::Default; + use std::sync::{Arc, Mutex}; use std::time::Instant; fn build_test_onion_keys() -> Vec { @@ -1727,17 +1749,27 @@ mod tests { } } + struct Node { + feeest: Arc, + chain_monitor: Arc, + tx_broadcaster: Arc, + chan_monitor: Arc, + node_id: SecretKey, + node: Arc, + router: Router, + } + static mut CHAN_COUNT: u32 = 0; - fn create_chan_between_nodes(node_a: &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(); + fn create_chan_between_nodes(node_a: &Node, node_b: &Node) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, Uint256, Transaction) { + let open_chan = node_a.node.create_channel(node_b.node.get_our_node_id(), 100000, 42).unwrap(); + let accept_chan = node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), &open_chan).unwrap(); + node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), &accept_chan).unwrap(); let chan_id = unsafe { CHAN_COUNT }; let tx; let funding_output; - let events_1 = node_a.get_and_clear_pending_events(); + let events_1 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_1.len(), 1); match events_1[0] { Event::FundingGenerationReady { ref temporary_channel_id, ref channel_value_satoshis, ref output_script, user_channel_id } => { @@ -1749,8 +1781,8 @@ mod tests { }]}; funding_output = (Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0); - node_a.funding_transaction_generated(&temporary_channel_id, funding_output.clone()); - let mut added_monitors = monitor_a.added_monitors.lock().unwrap(); + node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output.clone()); + 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(); @@ -1758,13 +1790,13 @@ mod tests { _ => panic!("Unexpected event"), } - let events_2 = node_a.get_and_clear_pending_events(); + let events_2 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_2.len(), 1); let funding_signed = match events_2[0] { Event::SendFundingCreated { ref node_id, ref msg } => { - assert_eq!(*node_id, node_b.get_our_node_id()); - 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!(*node_id, node_b.node.get_our_node_id()); + let res = node_b.node.handle_funding_created(&node_a.node.get_our_node_id(), msg).unwrap(); + let mut added_monitors = node_b.chan_monitor.added_monitors.lock().unwrap(); assert_eq!(added_monitors.len(), 1); assert_eq!(added_monitors[0].0, funding_output); added_monitors.clear(); @@ -1773,9 +1805,9 @@ mod tests { _ => panic!("Unexpected event"), }; - node_a.handle_funding_signed(&node_b.get_our_node_id(), &funding_signed).unwrap(); + node_a.node.handle_funding_signed(&node_b.node.get_our_node_id(), &funding_signed).unwrap(); - let events_3 = node_a.get_and_clear_pending_events(); + let events_3 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_3.len(), 1); match events_3[0] { Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => { @@ -1785,35 +1817,35 @@ mod tests { _ => panic!("Unexpected event"), }; - confirm_transaction(&chain_a, &tx, chan_id); - let events_4 = node_a.get_and_clear_pending_events(); + confirm_transaction(&node_a.chain_monitor, &tx, chan_id); + let events_4 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_4.len(), 1); match events_4[0] { Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => { - assert_eq!(*node_id, node_b.get_our_node_id()); + assert_eq!(*node_id, node_b.node.get_our_node_id()); assert!(announcement_sigs.is_none()); - node_b.handle_funding_locked(&node_a.get_our_node_id(), msg).unwrap() + node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), msg).unwrap() }, _ => panic!("Unexpected event"), }; let channel_id; - confirm_transaction(&chain_b, &tx, chan_id); - let events_5 = node_b.get_and_clear_pending_events(); + confirm_transaction(&node_b.chain_monitor, &tx, chan_id); + let events_5 = node_b.node.get_and_clear_pending_events(); assert_eq!(events_5.len(), 1); let as_announcement_sigs = match events_5[0] { Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => { - assert_eq!(*node_id, node_a.get_our_node_id()); + assert_eq!(*node_id, node_a.node.get_our_node_id()); channel_id = msg.channel_id.clone(); - let as_announcement_sigs = node_a.handle_funding_locked(&node_b.get_our_node_id(), msg).unwrap().unwrap(); - node_a.handle_announcement_signatures(&node_b.get_our_node_id(), &(*announcement_sigs).clone().unwrap()).unwrap(); + let as_announcement_sigs = node_a.node.handle_funding_locked(&node_b.node.get_our_node_id(), msg).unwrap().unwrap(); + node_a.node.handle_announcement_signatures(&node_b.node.get_our_node_id(), &(*announcement_sigs).clone().unwrap()).unwrap(); as_announcement_sigs }, _ => panic!("Unexpected event"), }; - let events_6 = node_a.get_and_clear_pending_events(); + let events_6 = node_a.node.get_and_clear_pending_events(); assert_eq!(events_6.len(), 1); let (announcement, as_update) = match events_6[0] { Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { @@ -1822,8 +1854,8 @@ mod tests { _ => panic!("Unexpected event"), }; - node_b.handle_announcement_signatures(&node_a.get_our_node_id(), &as_announcement_sigs).unwrap(); - let events_7 = node_b.get_and_clear_pending_events(); + node_b.node.handle_announcement_signatures(&node_a.node.get_our_node_id(), &as_announcement_sigs).unwrap(); + let events_7 = node_b.node.get_and_clear_pending_events(); assert_eq!(events_7.len(), 1); let bs_update = match events_7[0] { Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { @@ -1840,9 +1872,19 @@ mod tests { ((*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) }; + fn create_announced_chan_between_nodes(nodes: &Vec, a: usize, b: usize) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, Uint256, Transaction) { + let chan_announcement = create_chan_between_nodes(&nodes[a], &nodes[b]); + for node in nodes { + assert!(node.router.handle_channel_announcement(&chan_announcement.0).unwrap()); + node.router.handle_channel_update(&chan_announcement.1).unwrap(); + node.router.handle_channel_update(&chan_announcement.2).unwrap(); + } + (chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4) + } + + fn close_channel(outbound_node: &Node, inbound_node: &Node, channel_id: &Uint256, funding_tx: Transaction, close_inbound_first: bool) { + let (node_a, broadcaster_a) = if close_inbound_first { (&inbound_node.node, &inbound_node.tx_broadcaster) } else { (&outbound_node.node, &outbound_node.tx_broadcaster) }; + let (node_b, broadcaster_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster) } else { (&inbound_node.node, &inbound_node.tx_broadcaster) }; let (tx_a, tx_b); let shutdown_a = node_a.close_channel(channel_id).unwrap(); @@ -1895,7 +1937,7 @@ mod tests { } static mut PAYMENT_COUNT: u8 = 0; - 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]) { + fn send_along_route(origin_node: &Node, route: Route, expected_route: &[&Node], recv_value: u64) -> ([u8; 32], [u8; 32]) { let our_payment_preimage = unsafe { [PAYMENT_COUNT; 32] }; unsafe { PAYMENT_COUNT += 1 }; let our_payment_hash = { @@ -1907,48 +1949,56 @@ mod tests { }; let mut payment_event = { - let msgs = origin_node.send_payment(route, our_payment_hash).unwrap().unwrap(); + let msgs = origin_node.node.send_payment(route, our_payment_hash).unwrap().unwrap(); SendEvent { - node_id: expected_route[0].0.get_our_node_id(), + node_id: expected_route[0].node.get_our_node_id(), msgs: vec!(msgs.0), commitment_msg: msgs.1, } }; - let mut prev_node = (origin_node, origin_monitor); + let mut prev_node = origin_node; - for (idx, &(node, monitor)) in expected_route.iter().enumerate() { - assert_eq!(node.get_our_node_id(), payment_event.node_id); + for (idx, &node) in expected_route.iter().enumerate() { + assert_eq!(node.node.get_our_node_id(), payment_event.node_id); - node.handle_update_add_htlc(&prev_node.0.get_our_node_id(), &payment_event.msgs[0]).unwrap(); + node.node.handle_update_add_htlc(&prev_node.node.get_our_node_id(), &payment_event.msgs[0]).unwrap(); { - let added_monitors = monitor.added_monitors.lock().unwrap(); + let added_monitors = node.chan_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 revoke_and_ack = node.node.handle_commitment_signed(&prev_node.node.get_our_node_id(), &payment_event.commitment_msg).unwrap(); { - let mut added_monitors = monitor.added_monitors.lock().unwrap(); + let mut added_monitors = node.chan_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).unwrap().is_none()); + assert!(prev_node.node.handle_revoke_and_ack(&node.node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + let prev_revoke_and_ack = prev_node.node.handle_commitment_signed(&node.node.get_our_node_id(), &revoke_and_ack.1.unwrap()).unwrap(); { - let mut added_monitors = prev_node.1.added_monitors.lock().unwrap(); + let mut added_monitors = prev_node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!(node.node.handle_revoke_and_ack(&prev_node.node.get_our_node_id(), &prev_revoke_and_ack.0).unwrap().is_none()); + assert!(prev_revoke_and_ack.1.is_none()); + { + let mut added_monitors = node.chan_monitor.added_monitors.lock().unwrap(); assert_eq!(added_monitors.len(), 1); added_monitors.clear(); } - let events_1 = node.get_and_clear_pending_events(); + let events_1 = node.node.get_and_clear_pending_events(); assert_eq!(events_1.len(), 1); match events_1[0] { Event::PendingHTLCsForwardable { .. } => { }, _ => panic!("Unexpected event"), }; - node.channel_state.lock().unwrap().next_forward = Instant::now(); - node.process_pending_htlc_forward(); + node.node.channel_state.lock().unwrap().next_forward = Instant::now(); + node.node.process_pending_htlc_forward(); - let mut events_2 = node.get_and_clear_pending_events(); + let mut events_2 = node.node.get_and_clear_pending_events(); assert_eq!(events_2.len(), 1); if idx == expected_route.len() - 1 { match events_2[0] { @@ -1965,42 +2015,63 @@ mod tests { assert_eq!(payment_event.msgs.len(), 1); } - prev_node = (node, monitor); + prev_node = node; } (our_payment_preimage, our_payment_hash) } - 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)); + fn claim_payment(origin_node: &Node, expected_route: &[&Node], our_payment_preimage: [u8; 32]) { + assert!(expected_route.last().unwrap().node.claim_funds(our_payment_preimage)); { - let mut added_monitors = expected_route.last().unwrap().1.added_monitors.lock().unwrap(); + 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 expected_next_node = expected_route.last().unwrap().0.get_our_node_id(); - let mut prev_node = expected_route.last().unwrap().0; - let mut next_msg = None; - for &(node, monitor) in expected_route.iter().rev() { - assert_eq!(expected_next_node, node.get_our_node_id()); - match next_msg { - Some(msg) => { - node.handle_update_fulfill_htlc(&prev_node.get_our_node_id(), &msg).unwrap(); + let mut next_msgs: Option<(msgs::UpdateFulfillHTLC, msgs::CommitmentSigned)> = None; + macro_rules! update_fulfill_dance { + ($node: expr, $prev_node: expr) => { + { + $node.node.handle_update_fulfill_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(), 2); + added_monitors.clear(); + } + assert!($prev_node.node.handle_revoke_and_ack(&$node.node.get_our_node_id(), &revoke_and_commit.0).unwrap().is_none()); + let revoke_and_ack = $prev_node.node.handle_commitment_signed(&$node.node.get_our_node_id(), &revoke_and_commit.1.unwrap()).unwrap(); + assert!(revoke_and_ack.1.is_none()); { - let mut added_monitors = monitor.added_monitors.lock().unwrap(); + let mut added_monitors = $prev_node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!($node.node.handle_revoke_and_ack(&$prev_node.node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + { + let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap(); assert_eq!(added_monitors.len(), 1); added_monitors.clear(); } - }, None => {} + } } + } - let events = node.get_and_clear_pending_events(); + let mut expected_next_node = expected_route.last().unwrap().node.get_our_node_id(); + let mut prev_node = expected_route.last().unwrap(); + 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); + } + + let events = node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { - Event::SendFulfillHTLC { ref node_id, ref msg } => { + Event::SendFulfillHTLC { ref node_id, ref msg, ref commitment_msg } => { expected_next_node = node_id.clone(); - next_msg = Some(msg.clone()); + next_msgs = Some((msg.clone(), commitment_msg.clone())); }, _ => panic!("Unexpected event"), }; @@ -2008,15 +2079,10 @@ mod tests { prev_node = node; } - assert_eq!(expected_next_node, origin_node.get_our_node_id()); - origin_node.handle_update_fulfill_htlc(&expected_route.first().unwrap().0.get_our_node_id(), &next_msg.unwrap()).unwrap(); - { - let mut added_monitors = origin_monitor.added_monitors.lock().unwrap(); - assert_eq!(added_monitors.len(), 1); - added_monitors.clear(); - } + assert_eq!(expected_next_node, origin_node.node.get_our_node_id()); + update_fulfill_dance!(origin_node, expected_route.first().unwrap()); - let events = origin_node.get_and_clear_pending_events(); + let events = origin_node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { Event::PaymentSent { payment_preimage } => { @@ -2026,21 +2092,21 @@ mod tests { } } - 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(); + 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(); 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()); + for (node, hop) in expected_route.iter().zip(route.hops.iter()) { + assert_eq!(hop.pubkey, node.node.get_our_node_id()); } - send_along_route(origin_node, origin_monitor, route, expected_route, recv_value) + send_along_route(origin_node, route, expected_route, recv_value) } - fn route_over_limit(origin_node: &ChannelManager, origin_router: &Router, expected_route: &[&ChannelManager], recv_value: u64) { - let route = origin_router.get_route(&expected_route.last().unwrap().get_our_node_id(), &Vec::new(), recv_value, 142).unwrap(); + fn route_over_limit(origin_node: &Node, expected_route: &[&Node], recv_value: u64) { + let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), &Vec::new(), recv_value, 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()); + assert_eq!(hop.pubkey, node.node.get_our_node_id()); } let our_payment_preimage = unsafe { [PAYMENT_COUNT; 32] }; @@ -2053,42 +2119,68 @@ mod tests { ret }; - let err = origin_node.send_payment(route, our_payment_hash).err().unwrap(); + let err = origin_node.node.send_payment(route, our_payment_hash).err().unwrap(); assert_eq!(err.err, "Cannot send value that would put us over our max HTLC value in flight"); } - fn send_payment(origin_node: &ChannelManager, origin_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_payment(origin: &Node, expected_route: &[&Node], recv_value: u64) { + let our_payment_preimage = route_payment(&origin, expected_route, recv_value).0; + claim_payment(&origin, expected_route, our_payment_preimage); } - fn send_failed_payment(origin_node: &ChannelManager, origin_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(); + 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.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 expected_next_node = expected_route.last().unwrap().0.get_our_node_id(); - let mut prev_node = expected_route.last().unwrap().0; - let mut next_msg = None; - for &(node, _) in expected_route.iter().rev() { - assert_eq!(expected_next_node, node.get_our_node_id()); - match next_msg { - Some(msg) => { - node.handle_update_fail_htlc(&prev_node.get_our_node_id(), &msg).unwrap(); - }, None => {} + 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; + + assert!(expected_route.last().unwrap().node.fail_htlc_backwards(&our_payment_hash)); + + let mut next_msgs: Option<(msgs::UpdateFailHTLC, msgs::CommitmentSigned)> = None; + macro_rules! update_fail_dance { + ($node: expr, $prev_node: expr) => { + { + $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 revoke_and_ack = $prev_node.node.handle_commitment_signed(&$node.node.get_our_node_id(), &revoke_and_commit.1.unwrap()).unwrap(); + assert!(revoke_and_ack.1.is_none()); + { + let mut added_monitors = $prev_node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 2); + added_monitors.clear(); + } + assert!($node.node.handle_revoke_and_ack(&$prev_node.node.get_our_node_id(), &revoke_and_ack.0).unwrap().is_none()); + { + let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap(); + assert_eq!(added_monitors.len(), 1); + added_monitors.clear(); + } + } + } + } + + let mut expected_next_node = expected_route.last().unwrap().node.get_our_node_id(); + let mut prev_node = expected_route.last().unwrap(); + 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); } - let events = node.get_and_clear_pending_events(); + let events = node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { - Event::SendFailHTLC { ref node_id, ref msg } => { + Event::SendFailHTLC { ref node_id, ref msg, ref commitment_msg } => { expected_next_node = node_id.clone(); - next_msg = Some(msg.clone()); + next_msgs = Some((msg.clone(), commitment_msg.clone())); }, _ => panic!("Unexpected event"), }; @@ -2096,10 +2188,10 @@ mod tests { prev_node = node; } - assert_eq!(expected_next_node, origin_node.get_our_node_id()); - origin_node.handle_update_fail_htlc(&expected_route.first().unwrap().0.get_our_node_id(), &next_msg.unwrap()).unwrap(); + assert_eq!(expected_next_node, origin_node.node.get_our_node_id()); + update_fail_dance!(origin_node, expected_route.first().unwrap()); - let events = origin_node.get_and_clear_pending_events(); + let events = origin_node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { Event::PaymentFailed { payment_hash } => { @@ -2109,196 +2201,143 @@ mod tests { } } + fn create_network(node_count: usize) -> Vec { + let mut nodes = Vec::new(); + let mut rng = thread_rng(); + let secp_ctx = Secp256k1::new(); + + for _ in 0..node_count { + let feeest = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 }); + let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new()); + let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())}); + let chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone())); + let node_id = { + let mut key_slice = [0; 32]; + rng.fill_bytes(&mut key_slice); + SecretKey::from_slice(&secp_ctx, &key_slice).unwrap() + }; + let node = ChannelManager::new(node_id.clone(), 0, true, Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone()).unwrap(); + let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id).unwrap()); + nodes.push(Node { feeest, chain_monitor, tx_broadcaster, chan_monitor, node_id, node, router }); + } + + nodes + } + #[test] fn fake_network_test() { // Simple test which builds a network of ChannelManagers, connects them to each other, and // tests that payments get routed and transactions broadcast in semi-reasonable ways. - let mut rng = thread_rng(); - let secp_ctx = Secp256k1::new(); - - let feeest_1 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 }); - let chain_monitor_1 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new()); - let 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(), 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 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(), 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 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(), 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 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(), tx_broadcaster_4.clone()).unwrap(); - let router_4 = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id_4).unwrap()); + let nodes = create_network(4); // Create some initial channels - let chan_announcement_1 = create_chan_between_nodes(&node_1, &chain_monitor_1, &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, &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, &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(); - } + let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); + let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); + let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3); // Rebalance the network a bit by relaying one payment through all the channels... - send_payment(&node_1, &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_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000); // Send some more payments - send_payment(&node_2, &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); + send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000); + send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000); + send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000); // Test failure packets - send_failed_payment(&node_1, &chan_monitor_1, &router_1, &vec!((&*node_2, &*chan_monitor_2), (&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4))[..]); + send_failed_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..]); // Add a new channel that skips 3 - 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(); - } + let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3); - 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); + send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000); + send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); + send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000); // Do some rebalance loop payments, simultaneously let mut hops = Vec::with_capacity(3); hops.push(RouteHop { - pubkey: node_3.get_our_node_id(), - short_channel_id: chan_announcement_2.1.contents.short_channel_id, + pubkey: nodes[2].node.get_our_node_id(), + short_channel_id: chan_2.0.contents.short_channel_id, fee_msat: 0, - cltv_expiry_delta: chan_announcement_3.1.contents.cltv_expiry_delta as u32 + cltv_expiry_delta: chan_3.0.contents.cltv_expiry_delta as u32 }); hops.push(RouteHop { - pubkey: node_4.get_our_node_id(), - short_channel_id: chan_announcement_3.1.contents.short_channel_id, + pubkey: nodes[3].node.get_our_node_id(), + short_channel_id: chan_3.0.contents.short_channel_id, fee_msat: 0, - cltv_expiry_delta: chan_announcement_4.2.contents.cltv_expiry_delta as u32 + cltv_expiry_delta: chan_4.1.contents.cltv_expiry_delta as u32 }); hops.push(RouteHop { - pubkey: node_2.get_our_node_id(), - short_channel_id: chan_announcement_4.1.contents.short_channel_id, + pubkey: nodes[1].node.get_our_node_id(), + short_channel_id: chan_4.0.contents.short_channel_id, fee_msat: 1000000, cltv_expiry_delta: 142, }); - hops[1].fee_msat = chan_announcement_4.2.contents.fee_base_msat as u64 + chan_announcement_4.2.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000; - hops[0].fee_msat = chan_announcement_3.1.contents.fee_base_msat as u64 + chan_announcement_3.1.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000; - let payment_preimage_1 = send_along_route(&node_2, &chan_monitor_2, Route { hops }, &vec!((&*node_3, &*chan_monitor_3), (&*node_4, &*chan_monitor_4), (&*node_2, &*chan_monitor_2))[..], 1000000).0; + hops[1].fee_msat = chan_4.1.contents.fee_base_msat as u64 + chan_4.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000; + hops[0].fee_msat = chan_3.0.contents.fee_base_msat as u64 + chan_3.0.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000; + let payment_preimage_1 = send_along_route(&nodes[1], Route { hops }, &vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0; let mut hops = Vec::with_capacity(3); hops.push(RouteHop { - pubkey: node_4.get_our_node_id(), - short_channel_id: chan_announcement_4.1.contents.short_channel_id, + pubkey: nodes[3].node.get_our_node_id(), + short_channel_id: chan_4.0.contents.short_channel_id, fee_msat: 0, - cltv_expiry_delta: chan_announcement_3.2.contents.cltv_expiry_delta as u32 + cltv_expiry_delta: chan_3.1.contents.cltv_expiry_delta as u32 }); hops.push(RouteHop { - pubkey: node_3.get_our_node_id(), - short_channel_id: chan_announcement_3.1.contents.short_channel_id, + pubkey: nodes[2].node.get_our_node_id(), + short_channel_id: chan_3.0.contents.short_channel_id, fee_msat: 0, - cltv_expiry_delta: chan_announcement_2.2.contents.cltv_expiry_delta as u32 + cltv_expiry_delta: chan_2.1.contents.cltv_expiry_delta as u32 }); hops.push(RouteHop { - pubkey: node_2.get_our_node_id(), - short_channel_id: chan_announcement_2.1.contents.short_channel_id, + pubkey: nodes[1].node.get_our_node_id(), + short_channel_id: chan_2.0.contents.short_channel_id, fee_msat: 1000000, cltv_expiry_delta: 142, }); - 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; + 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; // 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); + claim_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_preimage_2); + claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1); // Add a duplicate new channel from 2 to 4 - let chan_announcement_5 = create_chan_between_nodes(&node_2, &chain_monitor_2, &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(); - } + let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3); // Send some payments across both channels - let payment_preimage_3 = route_payment(&node_1, &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; + let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0; + let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0; + let payment_preimage_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0; - route_over_limit(&node_1, &router_1, &vec!(&*node_2, &*node_4)[..], 3000000); + route_over_limit(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000); //TODO: Test that routes work again here as we've been notified that the channel is full - claim_payment(&node_1, &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); + claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3); + claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4); + claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5); // Close down the channels... - close_channel(&node_1, &tx_broadcaster_1, &node_2, &tx_broadcaster_2, &chan_announcement_1.3, 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); + close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true); + close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, false); + close_channel(&nodes[2], &nodes[3], &chan_3.2, chan_3.3, true); + close_channel(&nodes[1], &nodes[3], &chan_4.2, chan_4.3, false); + close_channel(&nodes[1], &nodes[3], &chan_5.2, chan_5.3, false); // Check that we processed all pending events - for node in 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); + 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); } } }