/// A value of 0 will allow payments up to and including a channel's total announced usable
/// capacity, a value of one will only use up to half its capacity, two 1/4, etc.
///
- /// Default value: 1
+ /// Default value: 2
pub max_channel_saturation_power_of_half: u8,
/// A list of SCIDs which this payment was previously attempted over and which caused the
(2, features, option),
(3, max_path_count, (default_value, DEFAULT_MAX_PATH_COUNT)),
(4, route_hints, vec_type),
- (5, max_channel_saturation_power_of_half, (default_value, 1)),
+ (5, max_channel_saturation_power_of_half, (default_value, 2)),
(6, expiry_time, option),
(7, previously_failed_channels, vec_type),
});
expiry_time: None,
max_total_cltv_expiry_delta: DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA,
max_path_count: DEFAULT_MAX_PATH_COUNT,
- max_channel_saturation_power_of_half: 1,
+ max_channel_saturation_power_of_half: 2,
previously_failed_channels: Vec::new(),
}
}
pub(crate) fn get_route<L: Deref, S: Score>(
our_node_pubkey: &PublicKey, payment_params: &PaymentParameters, network_graph: &ReadOnlyNetworkGraph,
first_hops: Option<&[&ChannelDetails]>, final_value_msat: u64, final_cltv_expiry_delta: u32,
- logger: L, scorer: &S, random_seed_bytes: &[u8; 32]
+ logger: L, scorer: &S, _random_seed_bytes: &[u8; 32]
) -> Result<Route, LightningError>
where L::Target: Logger {
let payee_node_id = NodeId::from_pubkey(&payment_params.payee_pubkey);
// 4. See if we managed to collect paths which aggregately are able to transfer target value
// (not recommended value).
// 5. If yes, proceed. If not, fail routing.
- // 6. Randomly combine paths into routes having enough to fulfill the payment. (TODO: knapsack)
- // 7. Of all the found paths, select only those with the lowest total fee.
- // 8. The last path in every selected route is likely to be more than we need.
- // Reduce its value-to-transfer and recompute fees.
- // 9. Choose the best route by the lowest total fee.
+ // 6. Select the paths which have the lowest cost (fee plus scorer penalty) per amount
+ // transferred up to the transfer target value.
+ // 7. Reduce the value of the last path until we are sending only the target value.
+ // 8. If our maximum channel saturation limit caused us to pick two identical paths, combine
+ // them so that we're not sending two HTLCs along the same path.
// As for the actual search algorithm,
// we do a payee-to-payer pseudo-Dijkstra's sorting by each node's distance from the payee
lowest_fee_to_peer_through_node: total_fee_msat,
lowest_fee_to_node: $next_hops_fee_msat as u64 + hop_use_fee_msat,
total_cltv_delta: hop_total_cltv_delta,
- value_contribution_msat: value_contribution_msat,
+ value_contribution_msat,
path_htlc_minimum_msat,
path_penalty_msat,
path_length_to_node,
// Both these cases (and other cases except reaching recommended_value_msat) mean that
// paths_collection will be stopped because found_new_path==false.
// This is not necessarily a routing failure.
- 'path_construction: while let Some(RouteGraphNode { node_id, lowest_fee_to_node, total_cltv_delta, value_contribution_msat, path_htlc_minimum_msat, path_penalty_msat, path_length_to_node, .. }) = targets.pop() {
+ 'path_construction: while let Some(RouteGraphNode { node_id, lowest_fee_to_node, total_cltv_delta, mut value_contribution_msat, path_htlc_minimum_msat, path_penalty_msat, path_length_to_node, .. }) = targets.pop() {
// Since we're going payee-to-payer, hitting our node as a target means we should stop
// traversing the graph and arrange the path out of what we found.
// on some channels we already passed (assuming dest->source direction). Here, we
// recompute the fees again, so that if that's the case, we match the currently
// underpaid htlc_minimum_msat with fees.
- payment_path.update_value_and_recompute_fees(cmp::min(value_contribution_msat, final_value_msat));
+ debug_assert_eq!(payment_path.get_value_msat(), value_contribution_msat);
+ value_contribution_msat = cmp::min(value_contribution_msat, final_value_msat);
+ payment_path.update_value_and_recompute_fees(value_contribution_msat);
// Since a path allows to transfer as much value as
// the smallest channel it has ("bottleneck"), we should recompute
return Err(LightningError{err: "Failed to find a sufficient route to the given destination".to_owned(), action: ErrorAction::IgnoreError});
}
- // Sort by total fees and take the best paths.
- payment_paths.sort_unstable_by_key(|path| path.get_total_fee_paid_msat());
- if payment_paths.len() > 50 {
- payment_paths.truncate(50);
- }
+ // Step (6).
+ let mut selected_route = payment_paths;
+
+ debug_assert_eq!(selected_route.iter().map(|p| p.get_value_msat()).sum::<u64>(), already_collected_value_msat);
+ let mut overpaid_value_msat = already_collected_value_msat - final_value_msat;
- // Draw multiple sufficient routes by randomly combining the selected paths.
- let mut drawn_routes = Vec::new();
- let mut prng = ChaCha20::new(random_seed_bytes, &[0u8; 12]);
- let mut random_index_bytes = [0u8; ::core::mem::size_of::<usize>()];
-
- let num_permutations = payment_paths.len();
- for _ in 0..num_permutations {
- let mut cur_route = Vec::<PaymentPath>::new();
- let mut aggregate_route_value_msat = 0;
-
- // Step (6).
- // Do a Fisher-Yates shuffle to create a random permutation of the payment paths
- for cur_index in (1..payment_paths.len()).rev() {
- prng.process_in_place(&mut random_index_bytes);
- let random_index = usize::from_be_bytes(random_index_bytes).wrapping_rem(cur_index+1);
- payment_paths.swap(cur_index, random_index);
+ // First, sort by the cost-per-value of the path, dropping the paths that cost the most for
+ // the value they contribute towards the payment amount.
+ // We sort in descending order as we will remove from the front in `retain`, next.
+ selected_route.sort_unstable_by(|a, b|
+ (((b.get_cost_msat() as u128) << 64) / (b.get_value_msat() as u128))
+ .cmp(&(((a.get_cost_msat() as u128) << 64) / (a.get_value_msat() as u128)))
+ );
+
+ // We should make sure that at least 1 path left.
+ let mut paths_left = selected_route.len();
+ selected_route.retain(|path| {
+ if paths_left == 1 {
+ return true
+ }
+ let path_value_msat = path.get_value_msat();
+ if path_value_msat <= overpaid_value_msat {
+ overpaid_value_msat -= path_value_msat;
+ paths_left -= 1;
+ return false;
}
+ true
+ });
+ debug_assert!(selected_route.len() > 0);
+ if overpaid_value_msat != 0 {
// Step (7).
- for payment_path in &payment_paths {
- cur_route.push(payment_path.clone());
- aggregate_route_value_msat += payment_path.get_value_msat();
- if aggregate_route_value_msat > final_value_msat {
- // Last path likely overpaid. Substract it from the most expensive
- // (in terms of proportional fee) path in this route and recompute fees.
- // This might be not the most economically efficient way, but fewer paths
- // also makes routing more reliable.
- let mut overpaid_value_msat = aggregate_route_value_msat - final_value_msat;
-
- // First, we drop some expensive low-value paths entirely if possible, since fewer
- // paths is better: the payment is less likely to fail. In order to do so, we sort
- // by value and fall back to total fees paid, i.e., in case of equal values we
- // prefer lower cost paths.
- cur_route.sort_unstable_by(|a, b| {
- a.get_value_msat().cmp(&b.get_value_msat())
- // Reverse ordering for cost, so we drop higher-cost paths first
- .then_with(|| b.get_cost_msat().cmp(&a.get_cost_msat()))
- });
-
- // We should make sure that at least 1 path left.
- let mut paths_left = cur_route.len();
- cur_route.retain(|path| {
- if paths_left == 1 {
- return true
- }
- let mut keep = true;
- let path_value_msat = path.get_value_msat();
- if path_value_msat <= overpaid_value_msat {
- keep = false;
- overpaid_value_msat -= path_value_msat;
- paths_left -= 1;
- }
- keep
- });
-
- if overpaid_value_msat == 0 {
- break;
- }
+ // Now, subtract the remaining overpaid value from the most-expensive path.
+ // TODO: this could also be optimized by also sorting by feerate_per_sat_routed,
+ // so that the sender pays less fees overall. And also htlc_minimum_msat.
+ selected_route.sort_unstable_by(|a, b| {
+ let a_f = a.hops.iter().map(|hop| hop.0.candidate.fees().proportional_millionths as u64).sum::<u64>();
+ let b_f = b.hops.iter().map(|hop| hop.0.candidate.fees().proportional_millionths as u64).sum::<u64>();
+ a_f.cmp(&b_f).then_with(|| b.get_cost_msat().cmp(&a.get_cost_msat()))
+ });
+ let expensive_payment_path = selected_route.first_mut().unwrap();
- assert!(cur_route.len() > 0);
-
- // Step (8).
- // Now, subtract the overpaid value from the most-expensive path.
- // TODO: this could also be optimized by also sorting by feerate_per_sat_routed,
- // so that the sender pays less fees overall. And also htlc_minimum_msat.
- cur_route.sort_unstable_by_key(|path| { path.hops.iter().map(|hop| hop.0.candidate.fees().proportional_millionths as u64).sum::<u64>() });
- let expensive_payment_path = cur_route.first_mut().unwrap();
-
- // We already dropped all the small value paths above, meaning all the
- // remaining paths are larger than remaining overpaid_value_msat.
- // Thus, this can't be negative.
- let expensive_path_new_value_msat = expensive_payment_path.get_value_msat() - overpaid_value_msat;
- expensive_payment_path.update_value_and_recompute_fees(expensive_path_new_value_msat);
- break;
- }
- }
- drawn_routes.push(cur_route);
+ // We already dropped all the paths with value below `overpaid_value_msat` above, thus this
+ // can't go negative.
+ let expensive_path_new_value_msat = expensive_payment_path.get_value_msat() - overpaid_value_msat;
+ expensive_payment_path.update_value_and_recompute_fees(expensive_path_new_value_msat);
}
- // Step (9).
- // Select the best route by lowest total cost.
- drawn_routes.sort_unstable_by_key(|paths| paths.iter().map(|path| path.get_cost_msat()).sum::<u64>());
- let selected_route = drawn_routes.first_mut().unwrap();
-
+ // Step (8).
// Sort by the path itself and combine redundant paths.
// Note that we sort by SCIDs alone as its simpler but when combining we have to ensure we
// compare both SCIDs and NodeIds as individual nodes may use random aliases causing collisions
PaymentParameters, Route, RouteHint, RouteHintHop, RouteHop, RoutingFees,
DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE};
use routing::scoring::{ChannelUsage, Score, ProbabilisticScorer, ProbabilisticScoringParameters};
+ use routing::test_utils::{add_channel, add_or_update_node, build_graph, build_line_graph, id_to_feature_flags, get_nodes, update_channel};
use chain::transaction::OutPoint;
use chain::keysinterface::KeysInterface;
- use ln::features::{ChannelFeatures, InitFeatures, InvoiceFeatures, NodeFeatures};
- use ln::msgs::{ErrorAction, LightningError, OptionalField, UnsignedChannelAnnouncement, ChannelAnnouncement, RoutingMessageHandler,
- NodeAnnouncement, UnsignedNodeAnnouncement, ChannelUpdate, UnsignedChannelUpdate};
+ use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
+ use ln::msgs::{ErrorAction, LightningError, UnsignedChannelUpdate, MAX_VALUE_MSAT};
use ln::channelmanager;
- use util::test_utils;
+ use util::test_utils as ln_test_utils;
use util::chacha20::ChaCha20;
- use util::ser::Writeable;
#[cfg(c_bindings)]
- use util::ser::Writer;
+ use util::ser::{Writeable, Writer};
- use bitcoin::hashes::sha256d::Hash as Sha256dHash;
use bitcoin::hashes::Hash;
use bitcoin::network::constants::Network;
use bitcoin::blockdata::constants::genesis_block;
use hex;
use bitcoin::secp256k1::{PublicKey,SecretKey};
- use bitcoin::secp256k1::{Secp256k1, All};
+ use bitcoin::secp256k1::Secp256k1;
use prelude::*;
- use sync::{self, Arc};
+ use sync::Arc;
use core::convert::TryInto;
}
}
- // Using the same keys for LN and BTC ids
- fn add_channel(
- gossip_sync: &P2PGossipSync<Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>,
- secp_ctx: &Secp256k1<All>, node_1_privkey: &SecretKey, node_2_privkey: &SecretKey, features: ChannelFeatures, short_channel_id: u64
- ) {
- let node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_1_privkey);
- let node_id_2 = PublicKey::from_secret_key(&secp_ctx, node_2_privkey);
-
- let unsigned_announcement = UnsignedChannelAnnouncement {
- features,
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id,
- node_id_1,
- node_id_2,
- bitcoin_key_1: node_id_1,
- bitcoin_key_2: node_id_2,
- excess_data: Vec::new(),
- };
-
- let msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
- let valid_announcement = ChannelAnnouncement {
- node_signature_1: secp_ctx.sign_ecdsa(&msghash, node_1_privkey),
- node_signature_2: secp_ctx.sign_ecdsa(&msghash, node_2_privkey),
- bitcoin_signature_1: secp_ctx.sign_ecdsa(&msghash, node_1_privkey),
- bitcoin_signature_2: secp_ctx.sign_ecdsa(&msghash, node_2_privkey),
- contents: unsigned_announcement.clone(),
- };
- match gossip_sync.handle_channel_announcement(&valid_announcement) {
- Ok(res) => assert!(res),
- _ => panic!()
- };
- }
-
- fn update_channel(
- gossip_sync: &P2PGossipSync<Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>,
- secp_ctx: &Secp256k1<All>, node_privkey: &SecretKey, update: UnsignedChannelUpdate
- ) {
- let msghash = hash_to_message!(&Sha256dHash::hash(&update.encode()[..])[..]);
- let valid_channel_update = ChannelUpdate {
- signature: secp_ctx.sign_ecdsa(&msghash, node_privkey),
- contents: update.clone()
- };
-
- match gossip_sync.handle_channel_update(&valid_channel_update) {
- Ok(res) => assert!(res),
- Err(_) => panic!()
- };
- }
-
- fn add_or_update_node(
- gossip_sync: &P2PGossipSync<Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestChainSource>, Arc<test_utils::TestLogger>>,
- secp_ctx: &Secp256k1<All>, node_privkey: &SecretKey, features: NodeFeatures, timestamp: u32
- ) {
- let node_id = PublicKey::from_secret_key(&secp_ctx, node_privkey);
- let unsigned_announcement = UnsignedNodeAnnouncement {
- features,
- timestamp,
- node_id,
- rgb: [0; 3],
- alias: [0; 32],
- addresses: Vec::new(),
- excess_address_data: Vec::new(),
- excess_data: Vec::new(),
- };
- let msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
- let valid_announcement = NodeAnnouncement {
- signature: secp_ctx.sign_ecdsa(&msghash, node_privkey),
- contents: unsigned_announcement.clone()
- };
-
- match gossip_sync.handle_node_announcement(&valid_announcement) {
- Ok(_) => (),
- Err(_) => panic!()
- };
- }
-
- fn get_nodes(secp_ctx: &Secp256k1<All>) -> (SecretKey, PublicKey, Vec<SecretKey>, Vec<PublicKey>) {
- let privkeys: Vec<SecretKey> = (2..22).map(|i| {
- SecretKey::from_slice(&hex::decode(format!("{:02x}", i).repeat(32)).unwrap()[..]).unwrap()
- }).collect();
-
- let pubkeys = privkeys.iter().map(|secret| PublicKey::from_secret_key(&secp_ctx, secret)).collect();
-
- let our_privkey = SecretKey::from_slice(&hex::decode("01".repeat(32)).unwrap()[..]).unwrap();
- let our_id = PublicKey::from_secret_key(&secp_ctx, &our_privkey);
-
- (our_privkey, our_id, privkeys, pubkeys)
- }
-
- fn id_to_feature_flags(id: u8) -> Vec<u8> {
- // Set the feature flags to the id'th odd (ie non-required) feature bit so that we can
- // test for it later.
- let idx = (id - 1) * 2 + 1;
- if idx > 8*3 {
- vec![1 << (idx - 8*3), 0, 0, 0]
- } else if idx > 8*2 {
- vec![1 << (idx - 8*2), 0, 0]
- } else if idx > 8*1 {
- vec![1 << (idx - 8*1), 0]
- } else {
- vec![1 << idx]
- }
- }
-
- fn build_line_graph() -> (
- Secp256k1<All>, sync::Arc<NetworkGraph<Arc<test_utils::TestLogger>>>,
- P2PGossipSync<sync::Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, sync::Arc<test_utils::TestChainSource>, sync::Arc<test_utils::TestLogger>>,
- sync::Arc<test_utils::TestChainSource>, sync::Arc<test_utils::TestLogger>,
- ) {
- let secp_ctx = Secp256k1::new();
- let logger = Arc::new(test_utils::TestLogger::new());
- let chain_monitor = Arc::new(test_utils::TestChainSource::new(Network::Testnet));
- let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
- let network_graph = Arc::new(NetworkGraph::new(genesis_hash, Arc::clone(&logger)));
- let gossip_sync = P2PGossipSync::new(Arc::clone(&network_graph), None, Arc::clone(&logger));
-
- // Build network from our_id to node 19:
- // our_id -1(1)2- node0 -1(2)2- node1 - ... - node19
- let (our_privkey, _, privkeys, _) = get_nodes(&secp_ctx);
-
- for (idx, (cur_privkey, next_privkey)) in core::iter::once(&our_privkey)
- .chain(privkeys.iter()).zip(privkeys.iter()).enumerate() {
- let cur_short_channel_id = (idx as u64) + 1;
- add_channel(&gossip_sync, &secp_ctx, &cur_privkey, &next_privkey,
- ChannelFeatures::from_le_bytes(id_to_feature_flags(1)), cur_short_channel_id);
- update_channel(&gossip_sync, &secp_ctx, &cur_privkey, UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: cur_short_channel_id,
- timestamp: idx as u32,
- flags: 0,
- cltv_expiry_delta: 0,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &next_privkey, UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: cur_short_channel_id,
- timestamp: (idx as u32)+1,
- flags: 1,
- cltv_expiry_delta: 0,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
- add_or_update_node(&gossip_sync, &secp_ctx, next_privkey,
- NodeFeatures::from_le_bytes(id_to_feature_flags(1)), 0);
- }
-
- (secp_ctx, network_graph, gossip_sync, chain_monitor, logger)
- }
-
- fn build_graph() -> (
- Secp256k1<All>,
- sync::Arc<NetworkGraph<Arc<test_utils::TestLogger>>>,
- P2PGossipSync<sync::Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, sync::Arc<test_utils::TestChainSource>, sync::Arc<test_utils::TestLogger>>,
- sync::Arc<test_utils::TestChainSource>,
- sync::Arc<test_utils::TestLogger>,
- ) {
- let secp_ctx = Secp256k1::new();
- let logger = Arc::new(test_utils::TestLogger::new());
- let chain_monitor = Arc::new(test_utils::TestChainSource::new(Network::Testnet));
- let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
- let network_graph = Arc::new(NetworkGraph::new(genesis_hash, Arc::clone(&logger)));
- let gossip_sync = P2PGossipSync::new(Arc::clone(&network_graph), None, Arc::clone(&logger));
- // Build network from our_id to node6:
- //
- // -1(1)2- node0 -1(3)2-
- // / \
- // our_id -1(12)2- node7 -1(13)2--- node2
- // \ /
- // -1(2)2- node1 -1(4)2-
- //
- //
- // chan1 1-to-2: disabled
- // chan1 2-to-1: enabled, 0 fee
- //
- // chan2 1-to-2: enabled, ignored fee
- // chan2 2-to-1: enabled, 0 fee
- //
- // chan3 1-to-2: enabled, 0 fee
- // chan3 2-to-1: enabled, 100 msat fee
- //
- // chan4 1-to-2: enabled, 100% fee
- // chan4 2-to-1: enabled, 0 fee
- //
- // chan12 1-to-2: enabled, ignored fee
- // chan12 2-to-1: enabled, 0 fee
- //
- // chan13 1-to-2: enabled, 200% fee
- // chan13 2-to-1: enabled, 0 fee
- //
- //
- // -1(5)2- node3 -1(8)2--
- // | 2 |
- // | (11) |
- // / 1 \
- // node2--1(6)2- node4 -1(9)2--- node6 (not in global route map)
- // \ /
- // -1(7)2- node5 -1(10)2-
- //
- // Channels 5, 8, 9 and 10 are private channels.
- //
- // chan5 1-to-2: enabled, 100 msat fee
- // chan5 2-to-1: enabled, 0 fee
- //
- // chan6 1-to-2: enabled, 0 fee
- // chan6 2-to-1: enabled, 0 fee
- //
- // chan7 1-to-2: enabled, 100% fee
- // chan7 2-to-1: enabled, 0 fee
- //
- // chan8 1-to-2: enabled, variable fee (0 then 1000 msat)
- // chan8 2-to-1: enabled, 0 fee
- //
- // chan9 1-to-2: enabled, 1001 msat fee
- // chan9 2-to-1: enabled, 0 fee
- //
- // chan10 1-to-2: enabled, 0 fee
- // chan10 2-to-1: enabled, 0 fee
- //
- // chan11 1-to-2: enabled, 0 fee
- // chan11 2-to-1: enabled, 0 fee
-
- let (our_privkey, _, privkeys, _) = get_nodes(&secp_ctx);
-
- add_channel(&gossip_sync, &secp_ctx, &our_privkey, &privkeys[0], ChannelFeatures::from_le_bytes(id_to_feature_flags(1)), 1);
- update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 1,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: 0,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
-
- add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[0], NodeFeatures::from_le_bytes(id_to_feature_flags(1)), 0);
-
- add_channel(&gossip_sync, &secp_ctx, &our_privkey, &privkeys[1], ChannelFeatures::from_le_bytes(id_to_feature_flags(2)), 2);
- update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 2,
- timestamp: 1,
- flags: 0,
- cltv_expiry_delta: (5 << 4) | 3,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: u32::max_value(),
- fee_proportional_millionths: u32::max_value(),
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 2,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: 0,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
-
- add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[1], NodeFeatures::from_le_bytes(id_to_feature_flags(2)), 0);
-
- add_channel(&gossip_sync, &secp_ctx, &our_privkey, &privkeys[7], ChannelFeatures::from_le_bytes(id_to_feature_flags(12)), 12);
- update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 12,
- timestamp: 1,
- flags: 0,
- cltv_expiry_delta: (5 << 4) | 3,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: u32::max_value(),
- fee_proportional_millionths: u32::max_value(),
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 12,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: 0,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
-
- add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[7], NodeFeatures::from_le_bytes(id_to_feature_flags(8)), 0);
-
- add_channel(&gossip_sync, &secp_ctx, &privkeys[0], &privkeys[2], ChannelFeatures::from_le_bytes(id_to_feature_flags(3)), 3);
- update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 3,
- timestamp: 1,
- flags: 0,
- cltv_expiry_delta: (3 << 4) | 1,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 3,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: (3 << 4) | 2,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 100,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
-
- add_channel(&gossip_sync, &secp_ctx, &privkeys[1], &privkeys[2], ChannelFeatures::from_le_bytes(id_to_feature_flags(4)), 4);
- update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 4,
- timestamp: 1,
- flags: 0,
- cltv_expiry_delta: (4 << 4) | 1,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 1000000,
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 4,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: (4 << 4) | 2,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
-
- add_channel(&gossip_sync, &secp_ctx, &privkeys[7], &privkeys[2], ChannelFeatures::from_le_bytes(id_to_feature_flags(13)), 13);
- update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 13,
- timestamp: 1,
- flags: 0,
- cltv_expiry_delta: (13 << 4) | 1,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 2000000,
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 13,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: (13 << 4) | 2,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
-
- add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[2], NodeFeatures::from_le_bytes(id_to_feature_flags(3)), 0);
-
- add_channel(&gossip_sync, &secp_ctx, &privkeys[2], &privkeys[4], ChannelFeatures::from_le_bytes(id_to_feature_flags(6)), 6);
- update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 6,
- timestamp: 1,
- flags: 0,
- cltv_expiry_delta: (6 << 4) | 1,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &privkeys[4], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 6,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: (6 << 4) | 2,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new(),
- });
-
- add_channel(&gossip_sync, &secp_ctx, &privkeys[4], &privkeys[3], ChannelFeatures::from_le_bytes(id_to_feature_flags(11)), 11);
- update_channel(&gossip_sync, &secp_ctx, &privkeys[4], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 11,
- timestamp: 1,
- flags: 0,
- cltv_expiry_delta: (11 << 4) | 1,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &privkeys[3], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 11,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: (11 << 4) | 2,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
-
- add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[4], NodeFeatures::from_le_bytes(id_to_feature_flags(5)), 0);
-
- add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[3], NodeFeatures::from_le_bytes(id_to_feature_flags(4)), 0);
-
- add_channel(&gossip_sync, &secp_ctx, &privkeys[2], &privkeys[5], ChannelFeatures::from_le_bytes(id_to_feature_flags(7)), 7);
- update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 7,
- timestamp: 1,
- flags: 0,
- cltv_expiry_delta: (7 << 4) | 1,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 1000000,
- excess_data: Vec::new()
- });
- update_channel(&gossip_sync, &secp_ctx, &privkeys[5], UnsignedChannelUpdate {
- chain_hash: genesis_block(Network::Testnet).header.block_hash(),
- short_channel_id: 7,
- timestamp: 1,
- flags: 1,
- cltv_expiry_delta: (7 << 4) | 2,
- htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
- fee_base_msat: 0,
- fee_proportional_millionths: 0,
- excess_data: Vec::new()
- });
-
- add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[5], NodeFeatures::from_le_bytes(id_to_feature_flags(6)), 0);
-
- (secp_ctx, network_graph, gossip_sync, chain_monitor, logger)
- }
-
#[test]
fn simple_route_test() {
let (secp_ctx, network_graph, _, _, logger) = build_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let payment_params = PaymentParameters::from_node_id(nodes[2]);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Simple route to 2 via 1
let (secp_ctx, network_graph, _, _, logger) = build_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let payment_params = PaymentParameters::from_node_id(nodes[2]);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Simple route to 2 via 1
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
let payment_params = PaymentParameters::from_node_id(nodes[2]);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Simple route to 2 via 1
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 200_000_000,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(199_999_999),
+ htlc_maximum_msat: 199_999_999,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
fn htlc_minimum_overpay_test() {
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(InvoiceFeatures::known());
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(channelmanager::provided_invoice_features());
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// A route to node#2 via two paths.
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 35_000,
- htlc_maximum_msat: OptionalField::Present(40_000),
+ htlc_maximum_msat: 40_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 35_000,
- htlc_maximum_msat: OptionalField::Present(40_000),
+ htlc_maximum_msat: 40_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 65_000,
- htlc_maximum_msat: OptionalField::Present(80_000),
+ htlc_maximum_msat: 80_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 100_000,
excess_data: Vec::new()
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
let payment_params = PaymentParameters::from_node_id(nodes[2]);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// // Disable channels 4 and 12 by flags=2
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (_, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
let payment_params = PaymentParameters::from_node_id(nodes[2]);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Disable nodes 1, 2, and 8 by requiring unknown feature bits
- let mut unknown_features = NodeFeatures::known();
+ let mut unknown_features = NodeFeatures::empty();
unknown_features.set_unknown_feature_required();
add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[0], unknown_features.clone(), 1);
add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[1], unknown_features.clone(), 1);
fn our_chans_test() {
let (secp_ctx, network_graph, _, _, logger) = build_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Route to 1 via 2 and 3 because our channel to 1 is disabled
fn partial_route_hint_test() {
let (secp_ctx, network_graph, _, _, logger) = build_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Simple test across 2, 3, 5, and 4 via a last_hop channel
let (secp_ctx, network_graph, _, _, logger) = build_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let payment_params = PaymentParameters::from_node_id(nodes[6]).with_route_hints(empty_last_hop(&nodes));
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Test handling of an empty RouteHint passed in Invoice.
let (_, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
let last_hops = multi_hop_last_hops_hint([nodes[2], nodes[3]]);
let payment_params = PaymentParameters::from_node_id(nodes[6]).with_route_hints(last_hops.clone());
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Test through channels 2, 3, 0xff00, 0xff01.
// Test shows that multiple hop hints are considered.
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
let last_hops = multi_hop_last_hops_hint([nodes[2], non_announced_pubkey]);
let payment_params = PaymentParameters::from_node_id(nodes[6]).with_route_hints(last_hops.clone());
- let scorer = test_utils::TestScorer::with_penalty(0);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
// Test through channels 2, 3, 0xff00, 0xff01.
// Test shows that multiple hop hints are considered.
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2, // to disable
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
let (secp_ctx, network_graph, _, _, logger) = build_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let payment_params = PaymentParameters::from_node_id(nodes[6]).with_route_hints(last_hops_with_public_channel(&nodes));
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// This test shows that public routes can be present in the invoice
// which would be handled in the same manner.
fn our_chans_last_hop_connect_test() {
let (secp_ctx, network_graph, _, _, logger) = build_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// Simple test with outbound channel to 4 to test that last_hops and first_hops connect
}]);
let payment_params = PaymentParameters::from_node_id(target_node_id).with_route_hints(vec![last_hops]);
let our_chans = vec![get_channel_details(Some(42), middle_node_id, InitFeatures::from_le_bytes(vec![0b11]), outbound_capacity_msat)];
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
- let logger = test_utils::TestLogger::new();
+ let logger = ln_test_utils::TestLogger::new();
let network_graph = NetworkGraph::new(genesis_hash, &logger);
let route = get_route(&source_node_id, &payment_params, &network_graph.read_only(),
Some(&our_chans.iter().collect::<Vec<_>>()), route_val, 42, &logger, &scorer, &random_seed_bytes);
let (secp_ctx, network_graph, mut gossip_sync, chain_monitor, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(InvoiceFeatures::known());
+ let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(channelmanager::provided_invoice_features());
// We will use a simple single-path route from
// our node to node2 via node0: channels {1, 3}.
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(1_000_000_000),
+ htlc_maximum_msat: 1_000_000_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: 250_000_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(1_000_000_000),
+ htlc_maximum_msat: 1_000_000_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(1_000_000_000),
+ htlc_maximum_msat: 1_000_000_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(15_000),
+ htlc_maximum_msat: 15_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (3 << 4) | 1,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: 15_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 1,
cltv_expiry_delta: (3 << 4) | 2,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: 15_000,
fee_base_msat: 100,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(10_000),
+ htlc_maximum_msat: 10_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
// one of the latter hops is limited.
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- let payment_params = PaymentParameters::from_node_id(nodes[3]).with_features(InvoiceFeatures::known());
+ let payment_params = PaymentParameters::from_node_id(nodes[3]).with_features(channelmanager::provided_invoice_features());
// Path via {node7, node2, node4} is channels {12, 13, 6, 11}.
// {12, 13, 11} have the capacities of 100, {6} has a capacity of 50.
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(50_000),
+ htlc_maximum_msat: 50_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
fn ignore_fee_first_hop_test() {
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let payment_params = PaymentParameters::from_node_id(nodes[2]);
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 1_000_000,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(50_000),
+ htlc_maximum_msat: 50_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
fn simple_mpp_route_test() {
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let payment_params = PaymentParameters::from_node_id(nodes[2])
- .with_features(InvoiceFeatures::known());
+ .with_features(channelmanager::provided_invoice_features());
// We need a route consisting of 3 paths:
// From our node to node2 via node0, node7, node1 (three paths one hop each).
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(50_000),
+ htlc_maximum_msat: 50_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(60_000),
+ htlc_maximum_msat: 60_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(60_000),
+ htlc_maximum_msat: 60_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000),
+ htlc_maximum_msat: 200_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(180_000),
+ htlc_maximum_msat: 180_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
fn long_mpp_route_test() {
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- let payment_params = PaymentParameters::from_node_id(nodes[3]).with_features(InvoiceFeatures::known());
+ let payment_params = PaymentParameters::from_node_id(nodes[3]).with_features(channelmanager::provided_invoice_features());
// We need a route consisting of 3 paths:
// From our node to node3 via {node0, node2}, {node7, node2, node4} and {node7, node2}.
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000),
+ htlc_maximum_msat: 200_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000),
+ htlc_maximum_msat: 200_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000),
+ htlc_maximum_msat: 200_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
fn mpp_cheaper_route_test() {
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- let payment_params = PaymentParameters::from_node_id(nodes[3]).with_features(InvoiceFeatures::known());
+ let payment_params = PaymentParameters::from_node_id(nodes[3]).with_features(channelmanager::provided_invoice_features());
// This test checks that if we have two cheaper paths and one more expensive path,
// so that liquidity-wise any 2 of 3 combination is sufficient,
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000),
+ htlc_maximum_msat: 200_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000),
+ htlc_maximum_msat: 200_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000),
+ htlc_maximum_msat: 200_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 1_000,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
// if the fee is not properly accounted for, the behavior is different.
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- let payment_params = PaymentParameters::from_node_id(nodes[3]).with_features(InvoiceFeatures::known());
+ let payment_params = PaymentParameters::from_node_id(nodes[3]).with_features(channelmanager::provided_invoice_features());
// We need a route consisting of 2 paths:
// From our node to node3 via {node0, node2} and {node7, node2, node4}.
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 2,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(250_000),
+ htlc_maximum_msat: 250_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 150_000,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
// This bug appeared in production in some specific channel configurations.
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- let payment_params = PaymentParameters::from_node_id(PublicKey::from_slice(&[02; 33]).unwrap()).with_features(InvoiceFeatures::known())
+ let payment_params = PaymentParameters::from_node_id(PublicKey::from_slice(&[02; 33]).unwrap()).with_features(channelmanager::provided_invoice_features())
.with_route_hints(vec![RouteHint(vec![RouteHintHop {
src_node_id: nodes[2],
short_channel_id: 42,
cltv_expiry_delta: 42,
htlc_minimum_msat: None,
htlc_maximum_msat: None,
- }])]);
+ }])]).with_max_channel_saturation_power_of_half(0);
// Keep only two paths from us to nodes[2], both with a 99sat HTLC maximum, with one with
// no fee and one with a 1msat fee. Previously, trying to route 100 sats to nodes[2] here
flags: 0,
cltv_expiry_delta: (5 << 4) | 5,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(99_000),
+ htlc_maximum_msat: 99_000,
fee_base_msat: u32::max_value(),
fee_proportional_millionths: u32::max_value(),
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (5 << 4) | 3,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(99_000),
+ htlc_maximum_msat: 99_000,
fee_base_msat: u32::max_value(),
fee_proportional_millionths: u32::max_value(),
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (4 << 4) | 1,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 1,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0|2, // Channel disabled
cltv_expiry_delta: (13 << 4) | 1,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 2000000,
excess_data: Vec::new()
// path finding we realize that we found more capacity than we need.
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(InvoiceFeatures::known())
+ let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(channelmanager::provided_invoice_features())
.with_max_channel_saturation_power_of_half(0);
// We need a route consisting of 3 paths:
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(100_000),
+ htlc_maximum_msat: 100_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(50_000),
+ htlc_maximum_msat: 50_000,
fee_base_msat: 100,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(60_000),
+ htlc_maximum_msat: 60_000,
fee_base_msat: 100,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(60_000),
+ htlc_maximum_msat: 60_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(20_000),
+ htlc_maximum_msat: 20_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(20_000),
+ htlc_maximum_msat: 20_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
// "previous hop" being set to node 3, creating a loop in the path.
let secp_ctx = Secp256k1::new();
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
- let logger = Arc::new(test_utils::TestLogger::new());
+ let logger = Arc::new(ln_test_utils::TestLogger::new());
let network = Arc::new(NetworkGraph::new(genesis_hash, Arc::clone(&logger)));
let gossip_sync = P2PGossipSync::new(Arc::clone(&network), None, Arc::clone(&logger));
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let payment_params = PaymentParameters::from_node_id(nodes[6]);
flags: 0,
cltv_expiry_delta: (6 << 4) | 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (5 << 4) | 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 100,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (4 << 4) | 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (3 << 4) | 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (2 << 4) | 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (1 << 4) | 0,
htlc_minimum_msat: 100,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
// we calculated fees on a higher value, resulting in us ignoring such paths.
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, _, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let payment_params = PaymentParameters::from_node_id(nodes[2]);
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(85_000),
+ htlc_maximum_msat: 85_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (4 << 4) | 1,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(270_000),
+ htlc_maximum_msat: 270_000,
fee_base_msat: 0,
fee_proportional_millionths: 1000000,
excess_data: Vec::new()
// resulting in us thinking there is no possible path, even if other paths exist.
let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph();
let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(InvoiceFeatures::known());
+ let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(channelmanager::provided_invoice_features());
// We modify the graph to set the htlc_minimum of channel 2 and 4 as needed - channel 2
// gets an htlc_maximum_msat of 80_000 and channel 4 an htlc_minimum_msat of 90_000. We
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(80_000),
+ htlc_maximum_msat: 80_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (4 << 4) | 1,
htlc_minimum_msat: 90_000,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
assert_eq!(route.paths[0][1].short_channel_id, 13);
assert_eq!(route.paths[0][1].fee_msat, 90_000);
assert_eq!(route.paths[0][1].cltv_expiry_delta, 42);
- assert_eq!(route.paths[0][1].node_features.le_flags(), InvoiceFeatures::known().le_flags());
+ assert_eq!(route.paths[0][1].node_features.le_flags(), channelmanager::provided_invoice_features().le_flags());
assert_eq!(route.paths[0][1].channel_features.le_flags(), &id_to_feature_flags(13));
}
}
let secp_ctx = Secp256k1::new();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
- let logger = Arc::new(test_utils::TestLogger::new());
+ let logger = Arc::new(ln_test_utils::TestLogger::new());
let network_graph = NetworkGraph::new(genesis_hash, Arc::clone(&logger));
- let scorer = test_utils::TestScorer::with_penalty(0);
- let payment_params = PaymentParameters::from_node_id(nodes[0]).with_features(InvoiceFeatures::known());
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let payment_params = PaymentParameters::from_node_id(nodes[0]).with_features(channelmanager::provided_invoice_features());
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
{
let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&[
- &get_channel_details(Some(3), nodes[0], InitFeatures::known(), 200_000),
- &get_channel_details(Some(2), nodes[0], InitFeatures::known(), 10_000),
+ &get_channel_details(Some(3), nodes[0], channelmanager::provided_init_features(), 200_000),
+ &get_channel_details(Some(2), nodes[0], channelmanager::provided_init_features(), 10_000),
]), 100_000, 42, Arc::clone(&logger), &scorer, &random_seed_bytes).unwrap();
assert_eq!(route.paths.len(), 1);
assert_eq!(route.paths[0].len(), 1);
}
{
let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&[
- &get_channel_details(Some(3), nodes[0], InitFeatures::known(), 50_000),
- &get_channel_details(Some(2), nodes[0], InitFeatures::known(), 50_000),
+ &get_channel_details(Some(3), nodes[0], channelmanager::provided_init_features(), 50_000),
+ &get_channel_details(Some(2), nodes[0], channelmanager::provided_init_features(), 50_000),
]), 100_000, 42, Arc::clone(&logger), &scorer, &random_seed_bytes).unwrap();
assert_eq!(route.paths.len(), 2);
assert_eq!(route.paths[0].len(), 1);
// smallest of them, avoiding further fragmenting our available outbound balance to
// this node.
let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&[
- &get_channel_details(Some(2), nodes[0], InitFeatures::known(), 50_000),
- &get_channel_details(Some(3), nodes[0], InitFeatures::known(), 50_000),
- &get_channel_details(Some(5), nodes[0], InitFeatures::known(), 50_000),
- &get_channel_details(Some(6), nodes[0], InitFeatures::known(), 300_000),
- &get_channel_details(Some(7), nodes[0], InitFeatures::known(), 50_000),
- &get_channel_details(Some(8), nodes[0], InitFeatures::known(), 50_000),
- &get_channel_details(Some(9), nodes[0], InitFeatures::known(), 50_000),
- &get_channel_details(Some(4), nodes[0], InitFeatures::known(), 1_000_000),
+ &get_channel_details(Some(2), nodes[0], channelmanager::provided_init_features(), 50_000),
+ &get_channel_details(Some(3), nodes[0], channelmanager::provided_init_features(), 50_000),
+ &get_channel_details(Some(5), nodes[0], channelmanager::provided_init_features(), 50_000),
+ &get_channel_details(Some(6), nodes[0], channelmanager::provided_init_features(), 300_000),
+ &get_channel_details(Some(7), nodes[0], channelmanager::provided_init_features(), 50_000),
+ &get_channel_details(Some(8), nodes[0], channelmanager::provided_init_features(), 50_000),
+ &get_channel_details(Some(9), nodes[0], channelmanager::provided_init_features(), 50_000),
+ &get_channel_details(Some(4), nodes[0], channelmanager::provided_init_features(), 1_000_000),
]), 100_000, 42, Arc::clone(&logger), &scorer, &random_seed_bytes).unwrap();
assert_eq!(route.paths.len(), 1);
assert_eq!(route.paths[0].len(), 1);
let payment_params = PaymentParameters::from_node_id(nodes[6]).with_route_hints(last_hops(&nodes));
// Without penalizing each hop 100 msats, a longer path with lower fees is chosen.
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let route = get_route(
&our_id, &payment_params, &network_graph.read_only(), None, 100, 42,
// Applying a 100 msat penalty to each hop results in taking channels 7 and 10 to nodes[6]
// from nodes[2] rather than channel 6, 11, and 8, even though the longer path is cheaper.
- let scorer = test_utils::TestScorer::with_penalty(100);
+ let scorer = ln_test_utils::TestScorer::with_penalty(100);
let route = get_route(
&our_id, &payment_params, &network_graph.read_only(), None, 100, 42,
Arc::clone(&logger), &scorer, &random_seed_bytes
let network_graph = network.read_only();
// A path to nodes[6] exists when no penalties are applied to any channel.
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let route = get_route(
&our_id, &payment_params, &network_graph, None, 100, 42,
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let network_graph = network.read_only();
- let scorer = test_utils::TestScorer::with_penalty(0);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
// Make sure that generally there is at least one route available
let feasible_max_total_cltv_delta = 1008;
let feasible_payment_params = PaymentParameters::from_node_id(nodes[6]).with_route_hints(last_hops(&nodes))
.with_max_total_cltv_expiry_delta(feasible_max_total_cltv_delta);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let route = get_route(&our_id, &feasible_payment_params, &network_graph, None, 100, 0, Arc::clone(&logger), &scorer, &random_seed_bytes).unwrap();
let path = route.paths[0].iter().map(|hop| hop.short_channel_id).collect::<Vec<_>>();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let network_graph = network.read_only();
- let scorer = test_utils::TestScorer::with_penalty(0);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
let mut payment_params = PaymentParameters::from_node_id(nodes[6]).with_route_hints(last_hops(&nodes))
.with_max_path_count(1);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// We should be able to find a route initially, and then after we fail a few random
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let network_graph = network.read_only();
- let scorer = test_utils::TestScorer::with_penalty(0);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// First check we can actually create a long route on this graph.
let (secp_ctx, network_graph, _, _, logger) = build_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
- let scorer = test_utils::TestScorer::with_penalty(0);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
let payment_params = PaymentParameters::from_node_id(nodes[6]).with_route_hints(last_hops(&nodes));
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, 42, Arc::clone(&logger), &scorer, &random_seed_bytes).unwrap();
assert_eq!(route.paths.len(), 1);
let network_graph = network.read_only();
let network_nodes = network_graph.nodes();
let network_channels = network_graph.channels();
- let scorer = test_utils::TestScorer::with_penalty(0);
+ let scorer = ln_test_utils::TestScorer::with_penalty(0);
let payment_params = PaymentParameters::from_node_id(nodes[3]);
- let keys_manager = test_utils::TestKeysInterface::new(&[4u8; 32], Network::Testnet);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[4u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let mut route = get_route(&our_id, &payment_params, &network_graph, None, 100, 0,
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
let network_graph = network.read_only();
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let payment_params = PaymentParameters::from_node_id(nodes[3]);
flags: 0,
cltv_expiry_delta: (4 << 4) | 1,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000_000),
+ htlc_maximum_msat: 250_000_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
flags: 0,
cltv_expiry_delta: (13 << 4) | 1,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Present(200_000_000),
+ htlc_maximum_msat: 250_000_000,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: Vec::new()
});
- let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(InvoiceFeatures::known());
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let payment_params = PaymentParameters::from_node_id(nodes[2]).with_features(channelmanager::provided_invoice_features());
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
- // 150,000 sat is less than the available liquidity on each channel, set above.
- let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 150_000_000, 42, Arc::clone(&logger), &scorer, &random_seed_bytes).unwrap();
+ // 100,000 sats is less than the available liquidity on each channel, set above.
+ let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100_000_000, 42, Arc::clone(&logger), &scorer, &random_seed_bytes).unwrap();
assert_eq!(route.paths.len(), 2);
assert!((route.paths[0][1].short_channel_id == 4 && route.paths[1][1].short_channel_id == 13) ||
(route.paths[1][1].short_channel_id == 4 && route.paths[0][1].short_channel_id == 13));
fn generate_routes() {
use routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters};
- let mut d = match super::test_utils::get_route_file() {
+ let mut d = match super::bench_utils::get_route_file() {
Ok(f) => f,
Err(e) => {
eprintln!("{}", e);
return;
},
};
- let logger = test_utils::TestLogger::new();
+ let logger = ln_test_utils::TestLogger::new();
let graph = NetworkGraph::read(&mut d, &logger).unwrap();
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// First, get 100 (source, destination) pairs for which route-getting actually succeeds...
fn generate_routes_mpp() {
use routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters};
- let mut d = match super::test_utils::get_route_file() {
+ let mut d = match super::bench_utils::get_route_file() {
Ok(f) => f,
Err(e) => {
eprintln!("{}", e);
return;
},
};
- let logger = test_utils::TestLogger::new();
+ let logger = ln_test_utils::TestLogger::new();
let graph = NetworkGraph::read(&mut d, &logger).unwrap();
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
// First, get 100 (source, destination) pairs for which route-getting actually succeeds...
let src = &PublicKey::from_slice(nodes.keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap();
seed = seed.overflowing_mul(0xdeadbeef).0;
let dst = PublicKey::from_slice(nodes.keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap();
- let payment_params = PaymentParameters::from_node_id(dst).with_features(InvoiceFeatures::known());
+ let payment_params = PaymentParameters::from_node_id(dst).with_features(channelmanager::provided_invoice_features());
let amt = seed as u64 % 200_000_000;
let params = ProbabilisticScoringParameters::default();
let scorer = ProbabilisticScorer::new(params, &graph, &logger);
let (secp_ctx, network_graph, _, _, logger) = build_line_graph();
let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
- let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
let random_seed_bytes = keys_manager.get_secure_random_bytes();
let scorer_params = ProbabilisticScoringParameters::default();
}
#[cfg(all(test, not(feature = "no-std")))]
-pub(crate) mod test_utils {
+pub(crate) mod bench_utils {
use std::fs::File;
/// Tries to open a network graph file, or panics with a URL to fetch it.
pub(crate) fn get_route_file() -> Result<std::fs::File, &'static str> {
use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
use chain::transaction::OutPoint;
use chain::keysinterface::{KeysManager,KeysInterface};
- use ln::channelmanager::{ChannelCounterparty, ChannelDetails};
+ use ln::channelmanager::{self, ChannelCounterparty, ChannelDetails};
use ln::features::{InitFeatures, InvoiceFeatures};
use routing::gossip::NetworkGraph;
use routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringParameters};
}
fn read_network_graph(logger: &DummyLogger) -> NetworkGraph<&DummyLogger> {
- let mut d = test_utils::get_route_file().unwrap();
+ let mut d = bench_utils::get_route_file().unwrap();
NetworkGraph::read(&mut d, logger).unwrap()
}
ChannelDetails {
channel_id: [0; 32],
counterparty: ChannelCounterparty {
- features: InitFeatures::known(),
+ features: channelmanager::provided_init_features(),
node_id,
unspendable_punishment_reserve: 0,
forwarding_info: None,
let logger = DummyLogger {};
let network_graph = read_network_graph(&logger);
let scorer = FixedPenaltyScorer::with_penalty(0);
- generate_routes(bench, &network_graph, scorer, InvoiceFeatures::known());
+ generate_routes(bench, &network_graph, scorer, channelmanager::provided_invoice_features());
}
#[bench]
let network_graph = read_network_graph(&logger);
let params = ProbabilisticScoringParameters::default();
let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
- generate_routes(bench, &network_graph, scorer, InvoiceFeatures::known());
+ generate_routes(bench, &network_graph, scorer, channelmanager::provided_invoice_features());
}
fn generate_routes<S: Score>(
projects / rust-lightning / blobdiff