+ 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.node.get_and_clear_pending_events();
+ assert_eq!(events.len(), 1);
+ match events[0] {
+ Event::PaymentSent { payment_preimage } => {
+ assert_eq!(payment_preimage, our_payment_preimage);
+ },
+ _ => panic!("Unexpected event"),
+ }
+ }
+
+ 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.node.get_our_node_id());
+ }
+
+ send_along_route(origin_node, route, expected_route, recv_value)
+ }
+
+ 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.node.get_our_node_id());
+ }
+
+ let our_payment_preimage = unsafe { [PAYMENT_COUNT; 32] };
+ unsafe { PAYMENT_COUNT += 1 };
+ let our_payment_hash = {
+ let mut sha = Sha256::new();
+ sha.input(&our_payment_preimage[..]);
+ let mut ret = [0; 32];
+ sha.result(&mut ret);
+ ret
+ };
+
+ 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, 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: &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.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.node.get_and_clear_pending_events();
+ assert_eq!(events.len(), 1);
+ match events[0] {
+ Event::SendFailHTLC { ref node_id, ref msg, ref commitment_msg } => {
+ expected_next_node = node_id.clone();
+ next_msgs = Some((msg.clone(), commitment_msg.clone()));
+ },
+ _ => panic!("Unexpected event"),
+ };
+
+ prev_node = node;
+ }
+
+ 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.node.get_and_clear_pending_events();
+ assert_eq!(events.len(), 1);
+ match events[0] {
+ Event::PaymentFailed { payment_hash } => {
+ assert_eq!(payment_hash, our_payment_hash);
+ },
+ _ => panic!("Unexpected event"),
+ }
+ }
+
+ fn create_network(node_count: usize) -> Vec<Node> {
+ 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