+ struct Node {
+ chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
+ tx_broadcaster: Arc<test_utils::TestBroadcaster>,
+ chan_monitor: Arc<test_utils::TestChannelMonitor>,
+ node: Arc<ChannelManager>,
+ router: Router,
+ network_payment_count: Rc<RefCell<u8>>,
+ network_chan_count: Rc<RefCell<u32>>,
+ }
+ impl Drop for Node {
+ fn drop(&mut self) {
+ if !::std::thread::panicking() {
+ // Check that we processed all pending events
+ assert_eq!(self.node.get_and_clear_pending_events().len(), 0);
+ assert_eq!(self.chan_monitor.added_monitors.lock().unwrap().len(), 0);
+ }
+ }
+ }
+
+ fn create_chan_between_nodes(node_a: &Node, node_b: &Node) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
+ create_chan_between_nodes_with_value(node_a, node_b, 100000, 10001)
+ }
+
+ fn create_chan_between_nodes_with_value(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
+ let (funding_locked, channel_id, tx) = create_chan_between_nodes_with_value_a(node_a, node_b, channel_value, push_msat);
+ let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(node_a, node_b, &funding_locked);
+ (announcement, as_update, bs_update, channel_id, tx)
+ }
+
+ fn create_chan_between_nodes_with_value_init(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64) -> Transaction {
+ node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42).unwrap();
+
+ let events_1 = node_a.node.get_and_clear_pending_events();
+ assert_eq!(events_1.len(), 1);
+ let accept_chan = match events_1[0] {
+ Event::SendOpenChannel { ref node_id, ref msg } => {
+ assert_eq!(*node_id, node_b.node.get_our_node_id());
+ node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), msg).unwrap()
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), &accept_chan).unwrap();
+
+ let chan_id = *node_a.network_chan_count.borrow();
+ let tx;
+ let funding_output;
+
+ let events_2 = node_a.node.get_and_clear_pending_events();
+ assert_eq!(events_2.len(), 1);
+ match events_2[0] {
+ Event::FundingGenerationReady { ref temporary_channel_id, ref channel_value_satoshis, ref output_script, user_channel_id } => {
+ assert_eq!(*channel_value_satoshis, channel_value);
+ 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 = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0);
+
+ node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output);
+ 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();
+ },
+ _ => panic!("Unexpected event"),
+ }
+
+ let events_3 = node_a.node.get_and_clear_pending_events();
+ assert_eq!(events_3.len(), 1);
+ let funding_signed = match events_3[0] {
+ Event::SendFundingCreated { ref node_id, ref msg } => {
+ 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();
+ res
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ node_a.node.handle_funding_signed(&node_b.node.get_our_node_id(), &funding_signed).unwrap();
+ {
+ 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();
+ }
+
+ let events_4 = node_a.node.get_and_clear_pending_events();
+ assert_eq!(events_4.len(), 1);
+ match events_4[0] {
+ Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
+ assert_eq!(user_channel_id, 42);
+ assert_eq!(*funding_txo, funding_output);
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ tx
+ }
+
+ fn create_chan_between_nodes_with_value_confirm(node_a: &Node, node_b: &Node, tx: &Transaction) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32]) {
+ confirm_transaction(&node_b.chain_monitor, &tx, tx.version);
+ let events_5 = node_b.node.get_and_clear_pending_events();
+ assert_eq!(events_5.len(), 1);
+ match events_5[0] {
+ Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => {
+ assert_eq!(*node_id, node_a.node.get_our_node_id());
+ assert!(announcement_sigs.is_none());
+ node_a.node.handle_funding_locked(&node_b.node.get_our_node_id(), msg).unwrap()
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ let channel_id;
+
+ confirm_transaction(&node_a.chain_monitor, &tx, tx.version);
+ let events_6 = node_a.node.get_and_clear_pending_events();
+ assert_eq!(events_6.len(), 1);
+ (match events_6[0] {
+ Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => {
+ channel_id = msg.channel_id.clone();
+ assert_eq!(*node_id, node_b.node.get_our_node_id());
+ (msg.clone(), announcement_sigs.clone().unwrap())
+ },
+ _ => panic!("Unexpected event"),
+ }, channel_id)
+ }
+
+ fn create_chan_between_nodes_with_value_a(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32], Transaction) {
+ let tx = create_chan_between_nodes_with_value_init(node_a, node_b, channel_value, push_msat);
+ let (msgs, chan_id) = create_chan_between_nodes_with_value_confirm(node_a, node_b, &tx);
+ (msgs, chan_id, tx)
+ }
+
+ fn create_chan_between_nodes_with_value_b(node_a: &Node, node_b: &Node, as_funding_msgs: &(msgs::FundingLocked, msgs::AnnouncementSignatures)) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) {
+ let bs_announcement_sigs = {
+ let bs_announcement_sigs = node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), &as_funding_msgs.0).unwrap().unwrap();
+ node_b.node.handle_announcement_signatures(&node_a.node.get_our_node_id(), &as_funding_msgs.1).unwrap();
+ bs_announcement_sigs
+ };
+
+ let events_7 = node_b.node.get_and_clear_pending_events();
+ assert_eq!(events_7.len(), 1);
+ let (announcement, bs_update) = match events_7[0] {
+ Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
+ (msg, update_msg)
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ node_a.node.handle_announcement_signatures(&node_b.node.get_our_node_id(), &bs_announcement_sigs).unwrap();
+ let events_8 = node_a.node.get_and_clear_pending_events();
+ assert_eq!(events_8.len(), 1);
+ let as_update = match events_8[0] {
+ Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
+ assert!(*announcement == *msg);
+ update_msg
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ *node_a.network_chan_count.borrow_mut() += 1;
+
+ ((*announcement).clone(), (*as_update).clone(), (*bs_update).clone())
+ }
+
+ fn create_announced_chan_between_nodes(nodes: &Vec<Node>, a: usize, b: usize) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
+ create_announced_chan_between_nodes_with_value(nodes, a, b, 100000, 10001)
+ }
+
+ fn create_announced_chan_between_nodes_with_value(nodes: &Vec<Node>, a: usize, b: usize, channel_value: u64, push_msat: u64) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
+ let chan_announcement = create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat);
+ 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)
+ }
+
+ macro_rules! check_spends {
+ ($tx: expr, $spends_tx: expr) => {
+ {
+ let mut funding_tx_map = HashMap::new();
+ let spends_tx = $spends_tx;
+ funding_tx_map.insert(spends_tx.txid(), spends_tx);
+ $tx.verify(&funding_tx_map).unwrap();
+ }
+ }
+ }
+
+ fn close_channel(outbound_node: &Node, inbound_node: &Node, channel_id: &[u8; 32], funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate) {
+ 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);
+
+ node_a.close_channel(channel_id).unwrap();
+ let events_1 = node_a.get_and_clear_pending_events();
+ assert_eq!(events_1.len(), 1);
+ let shutdown_a = match events_1[0] {
+ Event::SendShutdown { ref node_id, ref msg } => {
+ assert_eq!(node_id, &node_b.get_our_node_id());
+ msg.clone()
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ 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);
+ check_spends!(tx_a, funding_tx);
+
+ let events_2 = node_a.get_and_clear_pending_events();
+ assert_eq!(events_2.len(), 1);
+ let as_update = match events_2[0] {
+ Event::BroadcastChannelUpdate { ref msg } => {
+ msg.clone()
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ let events_3 = node_b.get_and_clear_pending_events();
+ assert_eq!(events_3.len(), 1);
+ let bs_update = match events_3[0] {
+ Event::BroadcastChannelUpdate { ref msg } => {
+ msg.clone()
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ (as_update, bs_update)
+ }
+
+ struct SendEvent {
+ node_id: PublicKey,
+ msgs: Vec<msgs::UpdateAddHTLC>,
+ commitment_msg: msgs::CommitmentSigned,
+ }
+ impl SendEvent {
+ fn from_event(event: Event) -> SendEvent {
+ match event {
+ Event::UpdateHTLCs { node_id, updates: msgs::CommitmentUpdate { update_add_htlcs, update_fulfill_htlcs, update_fail_htlcs, update_fail_malformed_htlcs, update_fee, commitment_signed } } => {
+ assert!(update_fulfill_htlcs.is_empty());
+ assert!(update_fail_htlcs.is_empty());
+ assert!(update_fail_malformed_htlcs.is_empty());
+ assert!(update_fee.is_none());
+ SendEvent { node_id: node_id, msgs: update_add_htlcs, commitment_msg: commitment_signed }
+ },
+ _ => panic!("Unexpected event type!"),
+ }
+ }
+ }
+
+ macro_rules! check_added_monitors {
+ ($node: expr, $count: expr) => {
+ {
+ let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap();
+ assert_eq!(added_monitors.len(), $count);
+ added_monitors.clear();
+ }
+ }
+ }
+
+ macro_rules! commitment_signed_dance {
+ ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr) => {
+ {
+ check_added_monitors!($node_a, 0);
+ let (as_revoke_and_ack, as_commitment_signed) = $node_a.node.handle_commitment_signed(&$node_b.node.get_our_node_id(), &$commitment_signed).unwrap();
+ check_added_monitors!($node_a, 1);
+ check_added_monitors!($node_b, 0);
+ assert!($node_b.node.handle_revoke_and_ack(&$node_a.node.get_our_node_id(), &as_revoke_and_ack).unwrap().is_none());
+ check_added_monitors!($node_b, 1);
+ let (bs_revoke_and_ack, bs_none) = $node_b.node.handle_commitment_signed(&$node_a.node.get_our_node_id(), &as_commitment_signed.unwrap()).unwrap();
+ assert!(bs_none.is_none());
+ check_added_monitors!($node_b, 1);
+ if $fail_backwards {
+ assert!($node_a.node.get_and_clear_pending_events().is_empty());
+ }
+ assert!($node_a.node.handle_revoke_and_ack(&$node_b.node.get_our_node_id(), &bs_revoke_and_ack).unwrap().is_none());
+ {
+ let mut added_monitors = $node_a.chan_monitor.added_monitors.lock().unwrap();
+ if $fail_backwards {
+ assert_eq!(added_monitors.len(), 2);
+ assert!(added_monitors[0].0 != added_monitors[1].0);
+ } else {
+ assert_eq!(added_monitors.len(), 1);
+ }
+ added_monitors.clear();
+ }
+ }
+ }
+ }
+
+ macro_rules! get_payment_preimage_hash {
+ ($node: expr) => {
+ {
+ let payment_preimage = [*$node.network_payment_count.borrow(); 32];
+ *$node.network_payment_count.borrow_mut() += 1;
+ let mut payment_hash = [0; 32];
+ let mut sha = Sha256::new();
+ sha.input(&payment_preimage[..]);
+ sha.result(&mut payment_hash);
+ (payment_preimage, payment_hash)
+ }
+ }
+ }