use chain::keysinterface::KeysInterface;
use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash};
use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor};
-use ln::router::{Route, Router};
+use ln::router::{Route, Router, RouterReadArgs};
use ln::features::InitFeatures;
use ln::msgs;
use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
use std::rc::Rc;
use std::sync::{Arc, Mutex};
use std::mem;
-use std::collections::{HashSet, HashMap};
+use std::collections::HashMap;
pub const CHAN_CONFIRM_DEPTH: u32 = 100;
pub fn confirm_transaction<'a, 'b: 'a>(notifier: &'a chaininterface::BlockNotifierRef<'b>, chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction, chan_id: u32) {
assert!(self.node.get_and_clear_pending_events().is_empty());
assert!(self.chan_monitor.added_monitors.lock().unwrap().is_empty());
+ // 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 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);
+ assert!(orig_announcements == deserialized_announcements);
+ chan_progress = match orig_announcements.last() {
+ Some(announcement) => announcement.0.contents.short_channel_id + 1,
+ None => break,
+ };
+ }
+ 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);
+ assert!(orig_announcements == deserialized_announcements);
+ node_progress = match orig_announcements.last() {
+ Some(announcement) => Some(announcement.contents.node_id),
+ None => break,
+ };
+ }
+ }
+
// Check that if we serialize and then deserialize all our channel monitors we get the
// same set of outputs to watch for on chain as we have now. Note that if we write
// tests that fully close channels and remove the monitors at some point this may break.
pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c, 'd>(nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
let chan_announcement = create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat, a_flags, b_flags);
+
+ nodes[a].node.broadcast_node_announcement([0, 0, 0], [0; 32], Vec::new());
+ let a_events = nodes[a].node.get_and_clear_pending_msg_events();
+ assert_eq!(a_events.len(), 1);
+ let a_node_announcement = match a_events[0] {
+ MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => {
+ (*msg).clone()
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ nodes[b].node.broadcast_node_announcement([1, 1, 1], [1; 32], Vec::new());
+ let b_events = nodes[b].node.get_and_clear_pending_msg_events();
+ assert_eq!(b_events.len(), 1);
+ let b_node_announcement = match b_events[0] {
+ MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => {
+ (*msg).clone()
+ },
+ _ => panic!("Unexpected event"),
+ };
+
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();
}
(chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
}
macro_rules! check_spends {
- ($tx: expr, $spends_tx: expr) => {
+ ($tx: expr, $($spends_txn: expr),*) => {
{
$tx.verify(|out_point| {
- if out_point.txid == $spends_tx.txid() {
- $spends_tx.output.get(out_point.vout as usize).cloned()
- } else {
- None
- }
+ $(
+ if out_point.txid == $spends_txn.txid() {
+ return $spends_txn.output.get(out_point.vout as usize).cloned()
+ }
+ )*
+ None
}).unwrap();
}
}
pub fn create_chanmon_cfgs(node_count: usize) -> Vec<TestChanMonCfg> {
let mut chan_mon_cfgs = Vec::new();
for _ in 0..node_count {
- let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), broadcasted_txn: Mutex::new(HashSet::new())};
+ let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())};
let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
chan_mon_cfgs.push(TestChanMonCfg{ tx_broadcaster, fee_estimator });
}
let mut default_config = UserConfig::default();
default_config.channel_options.announced_channel = true;
default_config.peer_channel_config_limits.force_announced_channel_preference = false;
+ default_config.own_channel_config.our_htlc_minimum_msat = 1000; // sanitization being done by the sender, to exerce receiver logic we need to lift of limit
let node = ChannelManager::new(Network::Testnet, cfgs[i].fee_estimator, &cfgs[i].chan_monitor, cfgs[i].tx_broadcaster, cfgs[i].logger.clone(), &cfgs[i].keys_manager, if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, 0).unwrap();
chanmgrs.push(node);
}
let mut res = Vec::with_capacity(2);
node_txn.retain(|tx| {
if tx.input.len() == 1 && tx.input[0].previous_output.txid == chan.3.txid() {
- check_spends!(tx, chan.3.clone());
+ check_spends!(tx, chan.3);
if commitment_tx.is_none() {
res.push(tx.clone());
}
if has_htlc_tx != HTLCType::NONE {
node_txn.retain(|tx| {
if tx.input.len() == 1 && tx.input[0].previous_output.txid == res[0].txid() {
- check_spends!(tx, res[0].clone());
+ check_spends!(tx, res[0]);
if has_htlc_tx == HTLCType::TIMEOUT {
assert!(tx.lock_time != 0);
} else {
for tx in prev_txn {
if node_txn[0].input[0].previous_output.txid == tx.txid() {
- check_spends!(node_txn[0], tx.clone());
+ check_spends!(node_txn[0], tx);
assert!(node_txn[0].input[0].witness[2].len() > 106); // must spend an htlc output
assert_eq!(tx.input.len(), 1); // must spend a commitment tx
projects / rust-lightning / blobdiff