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) {
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