use chain::chaininterface;
use chain::transaction::OutPoint;
-use chain::keysinterface::KeysInterface;
use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure};
use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor};
-use ln::router::{Route, Router, RouterReadArgs};
+use routing::router::{Route, get_route};
+use routing::network_graph::{NetGraphMsgHandler, NetworkGraph};
use ln::features::InitFeatures;
use ln::msgs;
use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
use util::errors::APIError;
use util::logger::Logger;
use util::config::UserConfig;
-use util::ser::{ReadableArgs, Writeable};
+use util::ser::{ReadableArgs, Writeable, Readable};
use bitcoin::util::hash::BitcoinHash;
use bitcoin::blockdata::block::BlockHeader;
use bitcoin::blockdata::transaction::{Transaction, TxOut};
use bitcoin::network::constants::Network;
-use bitcoin_hashes::sha256::Hash as Sha256;
-use bitcoin_hashes::sha256d::Hash as Sha256d;
-use bitcoin_hashes::Hash;
+use bitcoin::hashes::sha256::Hash as Sha256;
+use bitcoin::hashes::Hash;
+use bitcoin::hash_types::BlockHash;
-use secp256k1::Secp256k1;
-use secp256k1::key::PublicKey;
+use bitcoin::secp256k1::key::PublicKey;
use rand::{thread_rng,Rng};
use std::cell::RefCell;
use std::rc::Rc;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, RwLock};
use std::mem;
use std::collections::HashMap;
}
}
-pub fn connect_blocks<'a, 'b>(notifier: &'a chaininterface::BlockNotifierRef<'b>, depth: u32, height: u32, parent: bool, prev_blockhash: Sha256d) -> Sha256d {
+pub fn connect_blocks<'a, 'b>(notifier: &'a chaininterface::BlockNotifierRef<'b>, depth: u32, height: u32, parent: bool, prev_blockhash: BlockHash) -> BlockHash {
let mut header = BlockHeader { version: 0x2000000, prev_blockhash: if parent { prev_blockhash } else { Default::default() }, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
notifier.block_connected_checked(&header, height + 1, &Vec::new(), &Vec::new());
for i in 2..depth + 1 {
pub chan_monitor: &'b test_utils::TestChannelMonitor<'c>,
pub keys_manager: &'b test_utils::TestKeysInterface,
pub node: &'a ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator>,
- pub router: Router,
+ pub net_graph_msg_handler: NetGraphMsgHandler,
pub node_seed: [u8; 32],
pub network_payment_count: Rc<RefCell<u8>>,
pub network_chan_count: Rc<RefCell<u32>>,
// Check that if we serialize the Router, we can deserialize it again.
{
let mut w = test_utils::TestVecWriter(Vec::new());
- self.router.write(&mut w).unwrap();
- let deserialized_router = Router::read(&mut ::std::io::Cursor::new(&w.0), RouterReadArgs {
- chain_monitor: Arc::clone(&self.chain_monitor) as Arc<chaininterface::ChainWatchInterface>,
- logger: Arc::clone(&self.logger) as Arc<Logger>
- }).unwrap();
+ let network_graph_ser = self.net_graph_msg_handler.network_graph.read().unwrap();
+ network_graph_ser.write(&mut w).unwrap();
+ let network_graph_deser = <NetworkGraph>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap();
+ assert!(network_graph_deser == *self.net_graph_msg_handler.network_graph.read().unwrap());
+ let net_graph_msg_handler = NetGraphMsgHandler::from_net_graph(
+ Arc::clone(&self.chain_monitor) as Arc<chaininterface::ChainWatchInterface>,
+ Arc::clone(&self.logger) as Arc<Logger>, RwLock::new(network_graph_deser)
+ );
let mut chan_progress = 0;
loop {
- let orig_announcements = self.router.get_next_channel_announcements(chan_progress, 255);
- let deserialized_announcements = deserialized_router.get_next_channel_announcements(chan_progress, 255);
+ let orig_announcements = self.net_graph_msg_handler.get_next_channel_announcements(chan_progress, 255);
+ let deserialized_announcements = net_graph_msg_handler.get_next_channel_announcements(chan_progress, 255);
assert!(orig_announcements == deserialized_announcements);
chan_progress = match orig_announcements.last() {
Some(announcement) => announcement.0.contents.short_channel_id + 1,
}
let mut node_progress = None;
loop {
- let orig_announcements = self.router.get_next_node_announcements(node_progress.as_ref(), 255);
- let deserialized_announcements = deserialized_router.get_next_node_announcements(node_progress.as_ref(), 255);
+ let orig_announcements = self.net_graph_msg_handler.get_next_node_announcements(node_progress.as_ref(), 255);
+ let deserialized_announcements = net_graph_msg_handler.get_next_node_announcements(node_progress.as_ref(), 255);
assert!(orig_announcements == deserialized_announcements);
node_progress = match orig_announcements.last() {
Some(announcement) => Some(announcement.contents.node_id),
for (_, old_monitor) in old_monitors.iter() {
let mut w = test_utils::TestVecWriter(Vec::new());
old_monitor.write_for_disk(&mut w).unwrap();
- let (_, deserialized_monitor) = <(Sha256d, ChannelMonitor<EnforcingChannelKeys>)>::read(
+ let (_, deserialized_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(
&mut ::std::io::Cursor::new(&w.0), Arc::clone(&self.logger) as Arc<Logger>).unwrap();
deserialized_monitors.push(deserialized_monitor);
}
let mut w = test_utils::TestVecWriter(Vec::new());
self.node.write(&mut w).unwrap();
- <(Sha256d, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut ::std::io::Cursor::new(w.0), ChannelManagerReadArgs {
+ <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut ::std::io::Cursor::new(w.0), ChannelManagerReadArgs {
default_config: UserConfig::default(),
keys_manager: self.keys_manager,
fee_estimator: &test_utils::TestFeeEstimator { sat_per_kw: 253 },
};
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();
- node.router.handle_node_announcement(&a_node_announcement).unwrap();
- node.router.handle_node_announcement(&b_node_announcement).unwrap();
+ assert!(node.net_graph_msg_handler.handle_channel_announcement(&chan_announcement.0).unwrap());
+ node.net_graph_msg_handler.handle_channel_update(&chan_announcement.1).unwrap();
+ node.net_graph_msg_handler.handle_channel_update(&chan_announcement.2).unwrap();
+ node.net_graph_msg_handler.handle_node_announcement(&a_node_announcement).unwrap();
+ node.net_graph_msg_handler.handle_node_announcement(&b_node_announcement).unwrap();
}
(chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
}
pub fn send_along_route_with_secret<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, route: Route, expected_paths: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<PaymentSecret>) {
origin_node.node.send_payment(&route, our_payment_hash, &our_payment_secret).unwrap();
check_added_monitors!(origin_node, expected_paths.len());
+ pass_along_route(origin_node, expected_paths, recv_value, our_payment_hash, our_payment_secret);
+}
- let mut events = origin_node.node.get_and_clear_pending_msg_events();
- assert_eq!(events.len(), expected_paths.len());
- for (path_idx, (ev, expected_route)) in events.drain(..).zip(expected_paths.iter()).enumerate() {
- let mut payment_event = SendEvent::from_event(ev);
- let mut prev_node = origin_node;
-
- for (idx, &node) in expected_route.iter().enumerate() {
- assert_eq!(node.node.get_our_node_id(), payment_event.node_id);
-
- node.node.handle_update_add_htlc(&prev_node.node.get_our_node_id(), &payment_event.msgs[0]);
- check_added_monitors!(node, 0);
- commitment_signed_dance!(node, prev_node, payment_event.commitment_msg, false);
-
- expect_pending_htlcs_forwardable!(node);
-
- if idx == expected_route.len() - 1 {
- let events_2 = node.node.get_and_clear_pending_events();
- // Once we've gotten through all the HTLCs, the last one should result in a
- // PaymentReceived (but each previous one should not!).
- if path_idx == expected_paths.len() - 1 {
- assert_eq!(events_2.len(), 1);
- match events_2[0] {
- Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
- assert_eq!(our_payment_hash, *payment_hash);
- assert_eq!(our_payment_secret, *payment_secret);
- assert_eq!(amt, recv_value);
- },
- _ => panic!("Unexpected event"),
- }
- } else {
- assert!(events_2.is_empty());
+pub fn pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path: &[&Node<'a, 'b, 'c>], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<PaymentSecret>, ev: MessageSendEvent, payment_received_expected: bool) {
+ let mut payment_event = SendEvent::from_event(ev);
+ let mut prev_node = origin_node;
+
+ for (idx, &node) in expected_path.iter().enumerate() {
+ assert_eq!(node.node.get_our_node_id(), payment_event.node_id);
+
+ node.node.handle_update_add_htlc(&prev_node.node.get_our_node_id(), &payment_event.msgs[0]);
+ check_added_monitors!(node, 0);
+ commitment_signed_dance!(node, prev_node, payment_event.commitment_msg, false);
+
+ expect_pending_htlcs_forwardable!(node);
+
+ if idx == expected_path.len() - 1 {
+ let events_2 = node.node.get_and_clear_pending_events();
+ if payment_received_expected {
+ assert_eq!(events_2.len(), 1);
+ match events_2[0] {
+ Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
+ assert_eq!(our_payment_hash, *payment_hash);
+ assert_eq!(our_payment_secret, *payment_secret);
+ assert_eq!(amt, recv_value);
+ },
+ _ => panic!("Unexpected event"),
}
} else {
- let mut events_2 = node.node.get_and_clear_pending_msg_events();
- assert_eq!(events_2.len(), 1);
- check_added_monitors!(node, 1);
- payment_event = SendEvent::from_event(events_2.remove(0));
- assert_eq!(payment_event.msgs.len(), 1);
+ assert!(events_2.is_empty());
}
-
- prev_node = node;
+ } else {
+ let mut events_2 = node.node.get_and_clear_pending_msg_events();
+ assert_eq!(events_2.len(), 1);
+ check_added_monitors!(node, 1);
+ payment_event = SendEvent::from_event(events_2.remove(0));
+ assert_eq!(payment_event.msgs.len(), 1);
}
+
+ prev_node = node;
+ }
+}
+
+pub fn pass_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&[&Node<'a, 'b, 'c>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<PaymentSecret>) {
+ let mut events = origin_node.node.get_and_clear_pending_msg_events();
+ assert_eq!(events.len(), expected_route.len());
+ for (path_idx, (ev, expected_path)) in events.drain(..).zip(expected_route.iter()).enumerate() {
+ // Once we've gotten through all the HTLCs, the last one should result in a
+ // PaymentReceived (but each previous one should not!), .
+ let expect_payment = path_idx == expected_route.len() - 1;
+ pass_along_path(origin_node, expected_path, recv_value, our_payment_hash.clone(), our_payment_secret, ev, expect_payment);
}
}
pub const TEST_FINAL_CLTV: u32 = 32;
pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
- let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
+ let net_graph_msg_handler = &origin_node.net_graph_msg_handler;
+ let logger = Arc::new(test_utils::TestLogger::new());
+ let route = get_route(&origin_node.node.get_our_node_id(), net_graph_msg_handler, &expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV, logger.clone()).unwrap();
assert_eq!(route.paths.len(), 1);
assert_eq!(route.paths[0].len(), expected_route.len());
for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
}
pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) {
- let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
+ let logger = Arc::new(test_utils::TestLogger::new());
+ let net_graph_msg_handler = &origin_node.net_graph_msg_handler;
+ let route = get_route(&origin_node.node.get_our_node_id(), net_graph_msg_handler, &expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV, logger.clone()).unwrap();
assert_eq!(route.paths.len(), 1);
assert_eq!(route.paths[0].len(), expected_route.len());
for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
}
pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeCfg<'c>>, chan_mgrs: &'a Vec<ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator>>) -> Vec<Node<'a, 'b, 'c>> {
- let secp_ctx = Secp256k1::new();
let mut nodes = Vec::new();
let chan_count = Rc::new(RefCell::new(0));
let payment_count = Rc::new(RefCell::new(0));
let block_notifier = chaininterface::BlockNotifier::new(cfgs[i].chain_monitor.clone());
block_notifier.register_listener(&cfgs[i].chan_monitor.simple_monitor as &chaininterface::ChainListener);
block_notifier.register_listener(&chan_mgrs[i] as &chaininterface::ChainListener);
- let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &cfgs[i].keys_manager.get_node_secret()), cfgs[i].chain_monitor.clone(), cfgs[i].logger.clone() as Arc<Logger>);
+ let net_graph_msg_handler = NetGraphMsgHandler::new(cfgs[i].chain_monitor.clone(), cfgs[i].logger.clone() as Arc<Logger>);
nodes.push(Node{ chain_monitor: cfgs[i].chain_monitor.clone(), block_notifier,
- tx_broadcaster: cfgs[i].tx_broadcaster, chan_monitor: &cfgs[i].chan_monitor,
- keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i], router,
- node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
- network_payment_count: payment_count.clone(), logger: cfgs[i].logger.clone(),
+ tx_broadcaster: cfgs[i].tx_broadcaster, chan_monitor: &cfgs[i].chan_monitor,
+ keys_manager: &cfgs[i].keys_manager, node: &chan_mgrs[i], net_graph_msg_handler,
+ node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
+ network_payment_count: payment_count.clone(), logger: cfgs[i].logger.clone(),
})
}
};
for node in nodes {
- node.router.handle_channel_update(&as_update).unwrap();
- node.router.handle_channel_update(&bs_update).unwrap();
+ node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
+ node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
}
}