X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpayment_tests.rs;h=adc611e7e190833fc8a8f87346f2ba2009bab730;hb=a1c92820b0800881e7f4289e3e77dae44f0a0cad;hp=c8a2c45f96f8ff5938ca0c8f86411aa0b15d4c27;hpb=3f416bc24e0e804e0cae1c8c5650b19500122b6d;p=rust-lightning diff --git a/lightning/src/ln/payment_tests.rs b/lightning/src/ln/payment_tests.rs index c8a2c45f..adc611e7 100644 --- a/lightning/src/ln/payment_tests.rs +++ b/lightning/src/ln/payment_tests.rs @@ -19,8 +19,9 @@ use crate::events::{ClosureReason, Event, HTLCDestination, MessageSendEvent, Mes use crate::ln::channel::{EXPIRE_PREV_CONFIG_TICKS, commit_tx_fee_msat, get_holder_selected_channel_reserve_satoshis, ANCHOR_OUTPUT_VALUE_SATOSHI}; use crate::ln::channelmanager::{BREAKDOWN_TIMEOUT, MPP_TIMEOUT_TICKS, MIN_CLTV_EXPIRY_DELTA, PaymentId, PaymentSendFailure, RecentPaymentDetails, RecipientOnionFields, HTLCForwardInfo, PendingHTLCRouting, PendingAddHTLCInfo}; use crate::ln::features::{Bolt11InvoiceFeatures, ChannelTypeFeatures}; -use crate::ln::{msgs, ChannelId, PaymentSecret, PaymentPreimage}; +use crate::ln::{msgs, ChannelId, PaymentHash, PaymentSecret, PaymentPreimage}; use crate::ln::msgs::ChannelMessageHandler; +use crate::ln::onion_utils; use crate::ln::outbound_payment::{IDEMPOTENCY_TIMEOUT_TICKS, Retry}; use crate::routing::gossip::{EffectiveCapacity, RoutingFees}; use crate::routing::router::{get_route, Path, PaymentParameters, Route, Router, RouteHint, RouteHintHop, RouteHop, RouteParameters, find_route}; @@ -31,10 +32,14 @@ use crate::util::errors::APIError; use crate::util::ser::Writeable; use crate::util::string::UntrustedString; +use bitcoin::hashes::Hash; +use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::network::constants::Network; +use bitcoin::secp256k1::{Secp256k1, SecretKey}; use crate::prelude::*; +use crate::ln::functional_test_utils; use crate::ln::functional_test_utils::*; use crate::routing::gossip::NodeId; #[cfg(feature = "std")] @@ -377,7 +382,7 @@ fn do_test_keysend_payments(public_node: bool, with_retry: bool) { let route_params = RouteParameters::from_payment_params_and_value( PaymentParameters::for_keysend(payee_pubkey, 40, false), 10000); - let network_graph = nodes[0].network_graph.clone(); + let network_graph = nodes[0].network_graph; let channels = nodes[0].node.list_usable_channels(); let first_hops = channels.iter().collect::>(); let first_hops = if public_node { None } else { Some(first_hops.as_slice()) }; @@ -429,7 +434,7 @@ fn test_mpp_keysend() { create_announced_chan_between_nodes(&nodes, 0, 2); create_announced_chan_between_nodes(&nodes, 1, 3); create_announced_chan_between_nodes(&nodes, 2, 3); - let network_graph = nodes[0].network_graph.clone(); + let network_graph = nodes[0].network_graph; let payer_pubkey = nodes[0].node.get_our_node_id(); let payee_pubkey = nodes[3].node.get_our_node_id(); @@ -1278,48 +1283,17 @@ fn successful_probe_yields_event() { create_announced_chan_between_nodes(&nodes, 0, 1); create_announced_chan_between_nodes(&nodes, 1, 2); - let (route, _, _, _) = get_route_and_payment_hash!(&nodes[0], nodes[2], 100_000); + let recv_value = 100_000; + let (route, _, _, _) = get_route_and_payment_hash!(&nodes[0], nodes[2], recv_value); - let (payment_hash, payment_id) = nodes[0].node.send_probe(route.paths[0].clone()).unwrap(); + let res = nodes[0].node.send_probe(route.paths[0].clone()).unwrap(); - // node[0] -- update_add_htlcs -> node[1] - check_added_monitors!(nodes[0], 1); - let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); - let probe_event = SendEvent::from_commitment_update(nodes[1].node.get_our_node_id(), updates); - nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &probe_event.msgs[0]); - check_added_monitors!(nodes[1], 0); - commitment_signed_dance!(nodes[1], nodes[0], probe_event.commitment_msg, false); - expect_pending_htlcs_forwardable!(nodes[1]); - - // node[1] -- update_add_htlcs -> node[2] - check_added_monitors!(nodes[1], 1); - let updates = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id()); - let probe_event = SendEvent::from_commitment_update(nodes[1].node.get_our_node_id(), updates); - nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &probe_event.msgs[0]); - check_added_monitors!(nodes[2], 0); - commitment_signed_dance!(nodes[2], nodes[1], probe_event.commitment_msg, true, true); + let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[2]]]; - // node[1] <- update_fail_htlcs -- node[2] - let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); - nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]); - check_added_monitors!(nodes[1], 0); - commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, true); + send_probe_along_route(&nodes[0], expected_route); - // node[0] <- update_fail_htlcs -- node[1] - let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); - check_added_monitors!(nodes[0], 0); - commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false); + expect_probe_successful_events(&nodes[0], vec![res]); - let mut events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events.drain(..).next().unwrap() { - crate::events::Event::ProbeSuccessful { payment_id: ev_pid, payment_hash: ev_ph, .. } => { - assert_eq!(payment_id, ev_pid); - assert_eq!(payment_hash, ev_ph); - }, - _ => panic!(), - }; assert!(!nodes[0].node.has_pending_payments()); } @@ -1424,6 +1398,94 @@ fn onchain_failed_probe_yields_event() { assert!(!nodes[0].node.has_pending_payments()); } +#[test] +fn preflight_probes_yield_event_skip_private_hop() { + let chanmon_cfgs = create_chanmon_cfgs(5); + let node_cfgs = create_node_cfgs(5, &chanmon_cfgs); + + // We alleviate the HTLC max-in-flight limit, as otherwise we'd always be limited through that. + let mut no_htlc_limit_config = test_default_channel_config(); + no_htlc_limit_config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 100; + + let user_configs = std::iter::repeat(no_htlc_limit_config).take(5).map(|c| Some(c)).collect::>>(); + let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &user_configs); + let nodes = create_network(5, &node_cfgs, &node_chanmgrs); + + // Setup channel topology: + // N0 -(1M:0)- N1 -(1M:0)- N2 -(70k:0)- N3 -(50k:0)- N4 + + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0); + create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 70_000, 0); + create_unannounced_chan_between_nodes_with_value(&nodes, 3, 4, 50_000, 0); + + let mut invoice_features = Bolt11InvoiceFeatures::empty(); + invoice_features.set_basic_mpp_optional(); + + let payment_params = PaymentParameters::from_node_id(nodes[3].node.get_our_node_id(), TEST_FINAL_CLTV) + .with_bolt11_features(invoice_features).unwrap(); + + let recv_value = 50_000_000; + let route_params = RouteParameters::from_payment_params_and_value(payment_params, recv_value); + let res = nodes[0].node.send_preflight_probes(route_params, None).unwrap(); + + let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[2], &nodes[3]]]; + + assert_eq!(res.len(), expected_route.len()); + + send_probe_along_route(&nodes[0], expected_route); + + expect_probe_successful_events(&nodes[0], res.clone()); + + assert!(!nodes[0].node.has_pending_payments()); +} + +#[test] +fn preflight_probes_yield_event() { + let chanmon_cfgs = create_chanmon_cfgs(4); + let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); + + // We alleviate the HTLC max-in-flight limit, as otherwise we'd always be limited through that. + let mut no_htlc_limit_config = test_default_channel_config(); + no_htlc_limit_config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 100; + + let user_configs = std::iter::repeat(no_htlc_limit_config).take(4).map(|c| Some(c)).collect::>>(); + let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &user_configs); + let nodes = create_network(4, &node_cfgs, &node_chanmgrs); + + // Setup channel topology: + // (1M:0)- N1 -(30k:0) + // / \ + // N0 N4 + // \ / + // (1M:0)- N2 -(70k:0) + // + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0); + create_announced_chan_between_nodes_with_value(&nodes, 1, 3, 30_000, 0); + create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 70_000, 0); + + let mut invoice_features = Bolt11InvoiceFeatures::empty(); + invoice_features.set_basic_mpp_optional(); + + let payment_params = PaymentParameters::from_node_id(nodes[3].node.get_our_node_id(), TEST_FINAL_CLTV) + .with_bolt11_features(invoice_features).unwrap(); + + let recv_value = 50_000_000; + let route_params = RouteParameters::from_payment_params_and_value(payment_params, recv_value); + let res = nodes[0].node.send_preflight_probes(route_params, None).unwrap(); + + let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]]; + + assert_eq!(res.len(), expected_route.len()); + + send_probe_along_route(&nodes[0], expected_route); + + expect_probe_successful_events(&nodes[0], res.clone()); + + assert!(!nodes[0].node.has_pending_payments()); +} + #[test] fn preflight_probes_yield_event_and_skip() { let chanmon_cfgs = create_chanmon_cfgs(5); @@ -1444,7 +1506,7 @@ fn preflight_probes_yield_event_and_skip() { // \ / // (70k:0)- N3 -(1M:0) // - let first_chan_update = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0).0; + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0); create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 30_000, 0); create_announced_chan_between_nodes_with_value(&nodes, 1, 3, 70_000, 0); create_announced_chan_between_nodes_with_value(&nodes, 2, 4, 1_000_000, 0); @@ -1453,70 +1515,22 @@ fn preflight_probes_yield_event_and_skip() { let mut invoice_features = Bolt11InvoiceFeatures::empty(); invoice_features.set_basic_mpp_optional(); - let mut payment_params = PaymentParameters::from_node_id(nodes[4].node.get_our_node_id(), TEST_FINAL_CLTV) + let payment_params = PaymentParameters::from_node_id(nodes[4].node.get_our_node_id(), TEST_FINAL_CLTV) .with_bolt11_features(invoice_features).unwrap(); - let route_params = RouteParameters::from_payment_params_and_value(payment_params, 80_000_000); + let recv_value = 80_000_000; + let route_params = RouteParameters::from_payment_params_and_value(payment_params, recv_value); let res = nodes[0].node.send_preflight_probes(route_params, None).unwrap(); + let expected_route : &[&[&Node]] = &[&[&nodes[1], &nodes[2], &nodes[4]]]; + // We check that only one probe was sent, the other one was skipped due to limited liquidity. assert_eq!(res.len(), 1); - let log_msg = format!("Skipped sending payment probe to avoid putting channel {} under the liquidity limit.", - first_chan_update.contents.short_channel_id); - node_cfgs[0].logger.assert_log_contains("lightning::ln::channelmanager", &log_msg, 1); - - let (payment_hash, payment_id) = res.first().unwrap(); - - // node[0] -- update_add_htlcs -> node[1] - check_added_monitors!(nodes[0], 1); - let probe_event = SendEvent::from_node(&nodes[0]); - nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &probe_event.msgs[0]); - check_added_monitors!(nodes[1], 0); - commitment_signed_dance!(nodes[1], nodes[0], probe_event.commitment_msg, false); - expect_pending_htlcs_forwardable!(nodes[1]); - - // node[1] -- update_add_htlcs -> node[2] - check_added_monitors!(nodes[1], 1); - let probe_event = SendEvent::from_node(&nodes[1]); - nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &probe_event.msgs[0]); - check_added_monitors!(nodes[2], 0); - commitment_signed_dance!(nodes[2], nodes[1], probe_event.commitment_msg, false); - expect_pending_htlcs_forwardable!(nodes[2]); - // node[2] -- update_add_htlcs -> node[4] - check_added_monitors!(nodes[2], 1); - let probe_event = SendEvent::from_node(&nodes[2]); - nodes[4].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &probe_event.msgs[0]); - check_added_monitors!(nodes[4], 0); - commitment_signed_dance!(nodes[4], nodes[2], probe_event.commitment_msg, true, true); - - // node[2] <- update_fail_htlcs -- node[4] - let updates = get_htlc_update_msgs!(nodes[4], nodes[2].node.get_our_node_id()); - nodes[2].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &updates.update_fail_htlcs[0]); - check_added_monitors!(nodes[2], 0); - commitment_signed_dance!(nodes[2], nodes[4], updates.commitment_signed, true); - - // node[1] <- update_fail_htlcs -- node[2] - let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); - nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]); - check_added_monitors!(nodes[1], 0); - commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, true); + send_probe_along_route(&nodes[0], expected_route); - // node[0] <- update_fail_htlcs -- node[1] - let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); - check_added_monitors!(nodes[0], 0); - commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false); + expect_probe_successful_events(&nodes[0], res.clone()); - let mut events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events.drain(..).next().unwrap() { - crate::events::Event::ProbeSuccessful { payment_id: ev_pid, payment_hash: ev_ph, .. } => { - assert_eq!(*payment_id, ev_pid); - assert_eq!(*payment_hash, ev_ph); - }, - _ => panic!(), - }; assert!(!nodes[0].node.has_pending_payments()); } @@ -1931,7 +1945,7 @@ fn do_test_intercepted_payment(test: InterceptTest) { expect_payment_failed_conditions(&nodes[0], payment_hash, false, fail_conditions); } else if test == InterceptTest::Forward { // Check that we'll fail as expected when sending to a channel that isn't in `ChannelReady` yet. - let temp_chan_id = nodes[1].node.create_channel(nodes[2].node.get_our_node_id(), 100_000, 0, 42, None).unwrap(); + let temp_chan_id = nodes[1].node.create_channel(nodes[2].node.get_our_node_id(), 100_000, 0, 42, None, None).unwrap(); let unusable_chan_err = nodes[1].node.forward_intercepted_htlc(intercept_id, &temp_chan_id, nodes[2].node.get_our_node_id(), expected_outbound_amount_msat).unwrap_err(); assert_eq!(unusable_chan_err , APIError::ChannelUnavailable { err: format!("Channel with id {} for the passed counterparty node_id {} is still opening.", @@ -3325,6 +3339,7 @@ fn test_threaded_payment_retries() { // We really want std::thread::scope, but its not stable until 1.63. Until then, we get unsafe. let node_ref = NodePtr::from_node(&nodes[0]); move || { + let _ = &node_ref; let node_a = unsafe { &*node_ref.0 }; while Instant::now() < end_time { node_a.node.get_and_clear_pending_events(); // wipe the PendingHTLCsForwardable @@ -4185,3 +4200,59 @@ fn test_htlc_forward_considers_anchor_outputs_value() { check_closed_broadcast(&nodes[2], 1, true); check_added_monitors(&nodes[2], 1); } + +#[test] +fn peel_payment_onion_custom_tlvs() { + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + create_announced_chan_between_nodes(&nodes, 0, 1); + let secp_ctx = Secp256k1::new(); + + let amt_msat = 1000; + let payment_params = PaymentParameters::for_keysend(nodes[1].node.get_our_node_id(), + TEST_FINAL_CLTV, false); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, amt_msat); + let route = functional_test_utils::get_route(&nodes[0], &route_params).unwrap(); + let mut recipient_onion = RecipientOnionFields::spontaneous_empty() + .with_custom_tlvs(vec![(414141, vec![42; 1200])]).unwrap(); + let prng_seed = chanmon_cfgs[0].keys_manager.get_secure_random_bytes(); + let session_priv = SecretKey::from_slice(&prng_seed[..]).expect("RNG is busted"); + let keysend_preimage = PaymentPreimage([42; 32]); + let payment_hash = PaymentHash(Sha256::hash(&keysend_preimage.0).to_byte_array()); + + let (onion_routing_packet, first_hop_msat, cltv_expiry) = onion_utils::create_payment_onion( + &secp_ctx, &route.paths[0], &session_priv, amt_msat, recipient_onion.clone(), + nodes[0].best_block_info().1, &payment_hash, &Some(keysend_preimage), prng_seed + ).unwrap(); + + let update_add = msgs::UpdateAddHTLC { + channel_id: ChannelId([0; 32]), + htlc_id: 42, + amount_msat: first_hop_msat, + payment_hash, + cltv_expiry, + skimmed_fee_msat: None, + onion_routing_packet, + blinding_point: None, + }; + let peeled_onion = crate::ln::onion_payment::peel_payment_onion( + &update_add, &&chanmon_cfgs[1].keys_manager, &&chanmon_cfgs[1].logger, &secp_ctx, + nodes[1].best_block_info().1, true, false + ).unwrap(); + assert_eq!(peeled_onion.incoming_amt_msat, Some(amt_msat)); + match peeled_onion.routing { + PendingHTLCRouting::ReceiveKeysend { + payment_data, payment_metadata, custom_tlvs, .. + } => { + #[cfg(not(c_bindings))] + assert_eq!(&custom_tlvs, recipient_onion.custom_tlvs()); + #[cfg(c_bindings)] + assert_eq!(custom_tlvs, recipient_onion.custom_tlvs()); + assert!(payment_metadata.is_none()); + assert!(payment_data.is_none()); + }, + _ => panic!() + } +}