Merge pull request #2555 from tnull/2023-08-have-get-route-take-params

Have `get_route` and `Route` take `RouteParameters`

Author: TheBlueMatt

fuzz/src/chanmon_consistency.rs

@@ -376,7 +376,7 @@ fn send_payment(source: &ChanMan, dest: &ChanMan, dest_chan_id: u64, amt: u64, p
 			fee_msat: amt,
 			cltv_expiry_delta: 200,
 		}], blinded_tail: None }],
-		payment_params: None,
+		route_params: None,
 	}, payment_hash, RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_id)) {
 		check_payment_err(err, amt > max_value_sendable || amt < min_value_sendable);
 		false
@@ -409,15 +409,15 @@ fn send_hop_payment(source: &ChanMan, middle: &ChanMan, middle_chan_id: u64, des
 			channel_features: middle.channel_features(),
 			fee_msat: first_hop_fee,
 			cltv_expiry_delta: 100,
-		},RouteHop {
+		}, RouteHop {
 			pubkey: dest.get_our_node_id(),
 			node_features: dest.node_features(),
 			short_channel_id: dest_chan_id,
 			channel_features: dest.channel_features(),
 			fee_msat: amt,
 			cltv_expiry_delta: 200,
 		}], blinded_tail: None }],
-		payment_params: None,
+		route_params: None,
 	}, payment_hash, RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_id)) {
 		let sent_amt = amt + first_hop_fee;
 		check_payment_err(err, sent_amt < min_value_sendable || sent_amt > max_value_sendable);

fuzz/src/full_stack.rs

@@ -527,10 +527,8 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 			4 => {
 				let final_value_msat = slice_to_be24(get_slice!(3)) as u64;
 				let payment_params = PaymentParameters::from_node_id(get_pubkey!(), 42);
-				let params = RouteParameters {
-					payment_params,
-					final_value_msat,
-				};
+				let params = RouteParameters::from_payment_params_and_value(
+					payment_params, final_value_msat);
 				let mut payment_hash = PaymentHash([0; 32]);
 				payment_hash.0[0..8].copy_from_slice(&be64_to_array(payments_sent));
 				let mut sha = Sha256::engine();
@@ -548,10 +546,8 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 			15 => {
 				let final_value_msat = slice_to_be24(get_slice!(3)) as u64;
 				let payment_params = PaymentParameters::from_node_id(get_pubkey!(), 42);
-				let params = RouteParameters {
-					payment_params,
-					final_value_msat,
-				};
+				let params = RouteParameters::from_payment_params_and_value(
+					payment_params, final_value_msat);
 				let mut payment_hash = PaymentHash([0; 32]);
 				payment_hash.0[0..8].copy_from_slice(&be64_to_array(payments_sent));
 				let mut sha = Sha256::engine();

fuzz/src/router.rs

@@ -326,11 +326,10 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 				let mut last_hops = Vec::new();
 				last_hops!(last_hops);
 				find_routes!(first_hops, node_pks.iter(), |final_amt, final_delta, target: &PublicKey| {
-					RouteParameters {
-						payment_params: PaymentParameters::from_node_id(*target, final_delta)
+					RouteParameters::from_payment_params_and_value(
+						PaymentParameters::from_node_id(*target, final_delta)
 							.with_route_hints(last_hops.clone()).unwrap(),
-						final_value_msat: final_amt,
-					}
+						final_amt)
 				});
 			},
 			x => {
@@ -366,11 +365,9 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 				let mut features = Bolt12InvoiceFeatures::empty();
 				features.set_basic_mpp_optional();
 				find_routes!(first_hops, vec![dummy_pk].iter(), |final_amt, _, _| {
-					RouteParameters {
-						payment_params: PaymentParameters::blinded(last_hops.clone())
-							.with_bolt12_features(features.clone()).unwrap(),
-						final_value_msat: final_amt,
-					}
+					RouteParameters::from_payment_params_and_value(PaymentParameters::blinded(last_hops.clone())
+						.with_bolt12_features(features.clone()).unwrap(),
+					final_amt)
 				});
 			}
 		}

lightning-invoice/src/utils.rs

@@ -869,10 +869,8 @@ mod test {
 				invoice.min_final_cltv_expiry_delta() as u32)
 			.with_bolt11_features(invoice.features().unwrap().clone()).unwrap()
 			.with_route_hints(invoice.route_hints()).unwrap();
-		let route_params = RouteParameters {
-			payment_params,
-			final_value_msat: invoice.amount_milli_satoshis().unwrap(),
-		};
+		let route_params = RouteParameters::from_payment_params_and_value(
+			payment_params, invoice.amount_milli_satoshis().unwrap());
 		let payment_event = {
 			let mut payment_hash = PaymentHash([0; 32]);
 			payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]);
@@ -1326,10 +1324,8 @@ mod test {
 				invoice.min_final_cltv_expiry_delta() as u32)
 			.with_bolt11_features(invoice.features().unwrap().clone()).unwrap()
 			.with_route_hints(invoice.route_hints()).unwrap();
-		let params = RouteParameters {
-			payment_params,
-			final_value_msat: invoice.amount_milli_satoshis().unwrap(),
-		};
+		let params = RouteParameters::from_payment_params_and_value(
+			payment_params, invoice.amount_milli_satoshis().unwrap());
 		let (payment_event, fwd_idx) = {
 			let mut payment_hash = PaymentHash([0; 32]);
 			payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]);

lightning/src/ln/channelmanager.rs

@@ -9655,10 +9655,9 @@ mod tests {
 		let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &expected_route, 100_000);
 
 		// Next, attempt a keysend payment and make sure it fails.
-		let route_params = RouteParameters {
-			payment_params: PaymentParameters::for_keysend(expected_route.last().unwrap().node.get_our_node_id(), TEST_FINAL_CLTV, false),
-			final_value_msat: 100_000,
-		};
+		let route_params = RouteParameters::from_payment_params_and_value(
+			PaymentParameters::for_keysend(expected_route.last().unwrap().node.get_our_node_id(),
+			TEST_FINAL_CLTV, false), 100_000);
 		let route = find_route(
 			&nodes[0].node.get_our_node_id(), &route_params, &nodes[0].network_graph,
 			None, nodes[0].logger, &scorer, &(), &random_seed_bytes
@@ -9746,10 +9745,10 @@ mod tests {
 		pass_along_path(&nodes[0], &path, 100_000, payment_hash, None, event, true, Some(payment_preimage));
 
 		// Next, attempt a keysend payment and make sure it fails.
-		let route_params = RouteParameters {
-			payment_params: PaymentParameters::for_keysend(expected_route.last().unwrap().node.get_our_node_id(), TEST_FINAL_CLTV, false),
-			final_value_msat: 100_000,
-		};
+		let route_params = RouteParameters::from_payment_params_and_value(
+			PaymentParameters::for_keysend(expected_route.last().unwrap().node.get_our_node_id(), TEST_FINAL_CLTV, false),
+			100_000
+		);
 		let route = find_route(
 			&nodes[0].node.get_our_node_id(), &route_params, &nodes[0].network_graph,
 			None, nodes[0].logger, &scorer, &(), &random_seed_bytes
@@ -9795,10 +9794,8 @@ mod tests {
 		let payee_pubkey = nodes[1].node.get_our_node_id();
 
 		let _chan = create_chan_between_nodes(&nodes[0], &nodes[1]);
-		let route_params = RouteParameters {
-			payment_params: PaymentParameters::for_keysend(payee_pubkey, 40, false),
-			final_value_msat: 10_000,
-		};
+		let route_params = RouteParameters::from_payment_params_and_value(
+			PaymentParameters::for_keysend(payee_pubkey, 40, false), 10_000);
 		let network_graph = nodes[0].network_graph.clone();
 		let first_hops = nodes[0].node.list_usable_channels();
 		let scorer = test_utils::TestScorer::new();
@@ -9842,10 +9839,8 @@ mod tests {
 		let payee_pubkey = nodes[1].node.get_our_node_id();
 
 		let _chan = create_chan_between_nodes(&nodes[0], &nodes[1]);
-		let route_params = RouteParameters {
-			payment_params: PaymentParameters::for_keysend(payee_pubkey, 40, false),
-			final_value_msat: 10_000,
-		};
+		let route_params = RouteParameters::from_payment_params_and_value(
+			PaymentParameters::for_keysend(payee_pubkey, 40, false), 10_000);
 		let network_graph = nodes[0].network_graph.clone();
 		let first_hops = nodes[0].node.list_usable_channels();
 		let scorer = test_utils::TestScorer::new();
@@ -10742,9 +10737,9 @@ pub mod bench {
 				let payment_secret = $node_b.create_inbound_payment_for_hash(payment_hash, None, 7200, None).unwrap();
 
 				$node_a.send_payment(payment_hash, RecipientOnionFields::secret_only(payment_secret),
-					PaymentId(payment_hash.0), RouteParameters {
-						payment_params, final_value_msat: 10_000,
-					}, Retry::Attempts(0)).unwrap();
+					PaymentId(payment_hash.0),
+					RouteParameters::from_payment_params_and_value(payment_params, 10_000),
+					Retry::Attempts(0)).unwrap();
 				let payment_event = SendEvent::from_event($node_a.get_and_clear_pending_msg_events().pop().unwrap());
 				$node_b.handle_update_add_htlc(&$node_a.get_our_node_id(), &payment_event.msgs[0]);
 				$node_b.handle_commitment_signed(&$node_a.get_our_node_id(), &payment_event.commitment_msg);

lightning/src/ln/functional_test_utils.rs

@@ -19,7 +19,7 @@ use crate::events::bump_transaction::{BumpTransactionEventHandler, Wallet, Walle
 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
 use crate::ln::channelmanager::{self, AChannelManager, ChainParameters, ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentSendFailure, RecipientOnionFields, PaymentId, MIN_CLTV_EXPIRY_DELTA};
 use crate::routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate};
-use crate::routing::router::{self, PaymentParameters, Route};
+use crate::routing::router::{self, PaymentParameters, Route, RouteParameters};
 use crate::ln::features::InitFeatures;
 use crate::ln::msgs;
 use crate::ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
@@ -1864,14 +1864,14 @@ macro_rules! get_payment_preimage_hash {
 }
 
 /// Gets a route from the given sender to the node described in `payment_params`.
-pub fn get_route(send_node: &Node, payment_params: &PaymentParameters, recv_value: u64) -> Result<Route, msgs::LightningError> {
+pub fn get_route(send_node: &Node, route_params: &RouteParameters) -> Result<Route, msgs::LightningError> {
 	let scorer = TestScorer::new();
 	let keys_manager = TestKeysInterface::new(&[0u8; 32], bitcoin::network::constants::Network::Testnet);
 	let random_seed_bytes = keys_manager.get_secure_random_bytes();
 	router::get_route(
-		&send_node.node.get_our_node_id(), payment_params, &send_node.network_graph.read_only(),
+		&send_node.node.get_our_node_id(), route_params, &send_node.network_graph.read_only(),
 		Some(&send_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
-		recv_value, send_node.logger, &scorer, &(), &random_seed_bytes
+		send_node.logger, &scorer, &(), &random_seed_bytes
 	)
 }
 
@@ -1880,9 +1880,10 @@ pub fn get_route(send_node: &Node, payment_params: &PaymentParameters, recv_valu
 /// Don't use this, use the identically-named function instead.
 #[macro_export]
 macro_rules! get_route {
-	($send_node: expr, $payment_params: expr, $recv_value: expr) => {
-		$crate::ln::functional_test_utils::get_route(&$send_node, &$payment_params, $recv_value)
-	}
+	($send_node: expr, $payment_params: expr, $recv_value: expr) => {{
+		let route_params = $crate::routing::router::RouteParameters::from_payment_params_and_value($payment_params, $recv_value);
+		$crate::ln::functional_test_utils::get_route(&$send_node, &route_params)
+	}}
 }
 
 #[cfg(test)]
@@ -1894,9 +1895,10 @@ macro_rules! get_route_and_payment_hash {
 		$crate::get_route_and_payment_hash!($send_node, $recv_node, payment_params, $recv_value)
 	}};
 	($send_node: expr, $recv_node: expr, $payment_params: expr, $recv_value: expr) => {{
+		let route_params = $crate::routing::router::RouteParameters::from_payment_params_and_value($payment_params, $recv_value);
 		let (payment_preimage, payment_hash, payment_secret) =
 			$crate::ln::functional_test_utils::get_payment_preimage_hash(&$recv_node, Some($recv_value), None);
-		let route = $crate::ln::functional_test_utils::get_route(&$send_node, &$payment_params, $recv_value);
+		let route = $crate::ln::functional_test_utils::get_route(&$send_node, &route_params);
 		(route.unwrap(), payment_hash, payment_preimage, payment_secret)
 	}}
 }
@@ -2490,7 +2492,8 @@ pub const TEST_FINAL_CLTV: u32 = 70;
 pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret) {
 	let payment_params = PaymentParameters::from_node_id(expected_route.last().unwrap().node.get_our_node_id(), TEST_FINAL_CLTV)
 		.with_bolt11_features(expected_route.last().unwrap().node.invoice_features()).unwrap();
-	let route = get_route(origin_node, &payment_params, recv_value).unwrap();
+	let route_params = RouteParameters::from_payment_params_and_value(payment_params, recv_value);
+	let route = get_route(origin_node, &route_params).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].hops.len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].hops.iter()) {
@@ -2504,14 +2507,14 @@ pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route:
 pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64)  {
 	let payment_params = PaymentParameters::from_node_id(expected_route.last().unwrap().node.get_our_node_id(), TEST_FINAL_CLTV)
 		.with_bolt11_features(expected_route.last().unwrap().node.invoice_features()).unwrap();
+	let route_params = RouteParameters::from_payment_params_and_value(payment_params, recv_value);
 	let network_graph = origin_node.network_graph.read_only();
 	let scorer = test_utils::TestScorer::new();
 	let seed = [0u8; 32];
 	let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
 	let random_seed_bytes = keys_manager.get_secure_random_bytes();
-	let route = router::get_route(
-		&origin_node.node.get_our_node_id(), &payment_params, &network_graph,
-		None, recv_value, origin_node.logger, &scorer, &(), &random_seed_bytes).unwrap();
+	let route = router::get_route(&origin_node.node.get_our_node_id(), &route_params, &network_graph,
+		None, origin_node.logger, &scorer, &(), &random_seed_bytes).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].hops.len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].hops.iter()) {

lightning/src/ln/functional_tests.rs

@@ -26,7 +26,7 @@ use crate::ln::channel::{DISCONNECT_PEER_AWAITING_RESPONSE_TICKS, ChannelError};
 use crate::ln::{chan_utils, onion_utils};
 use crate::ln::chan_utils::{OFFERED_HTLC_SCRIPT_WEIGHT, htlc_success_tx_weight, htlc_timeout_tx_weight, HTLCOutputInCommitment};
 use crate::routing::gossip::{NetworkGraph, NetworkUpdate};
-use crate::routing::router::{Path, PaymentParameters, Route, RouteHop, get_route};
+use crate::routing::router::{Path, PaymentParameters, Route, RouteHop, get_route, RouteParameters};
 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, NodeFeatures};
 use crate::ln::msgs;
 use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, ErrorAction};
@@ -1049,7 +1049,9 @@ fn fake_network_test() {
 	});
 	hops[1].fee_msat = chan_4.1.contents.fee_base_msat as u64 + chan_4.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000;
 	hops[0].fee_msat = chan_3.0.contents.fee_base_msat as u64 + chan_3.0.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000;
-	let payment_preimage_1 = send_along_route(&nodes[1], Route { paths: vec![Path { hops, blinded_tail: None }], payment_params: None }, &vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0;
+	let payment_preimage_1 = send_along_route(&nodes[1],
+		Route { paths: vec![Path { hops, blinded_tail: None }], route_params: None },
+			&vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0;
 
 	let mut hops = Vec::with_capacity(3);
 	hops.push(RouteHop {
@@ -1078,7 +1080,9 @@ fn fake_network_test() {
 	});
 	hops[1].fee_msat = chan_2.1.contents.fee_base_msat as u64 + chan_2.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000;
 	hops[0].fee_msat = chan_3.1.contents.fee_base_msat as u64 + chan_3.1.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000;
-	let payment_hash_2 = send_along_route(&nodes[1], Route { paths: vec![Path { hops, blinded_tail: None }], payment_params: None }, &vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).1;
+	let payment_hash_2 = send_along_route(&nodes[1],
+		Route { paths: vec![Path { hops, blinded_tail: None }], route_params: None },
+			&vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).1;
 
 	// Claim the rebalances...
 	fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2);
@@ -7137,8 +7141,11 @@ fn test_check_htlc_underpaying() {
 
 	let scorer = test_utils::TestScorer::new();
 	let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes();
-	let payment_params = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), TEST_FINAL_CLTV).with_bolt11_features(nodes[1].node.invoice_features()).unwrap();
-	let route = get_route(&nodes[0].node.get_our_node_id(), &payment_params, &nodes[0].network_graph.read_only(), None, 10_000, nodes[0].logger, &scorer, &(), &random_seed_bytes).unwrap();
+	let payment_params = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(),
+		TEST_FINAL_CLTV).with_bolt11_features(nodes[1].node.invoice_features()).unwrap();
+	let route_params = RouteParameters::from_payment_params_and_value(payment_params, 10_000);
+	let route = get_route(&nodes[0].node.get_our_node_id(), &route_params, &nodes[0].network_graph.read_only(),
+		None, nodes[0].logger, &scorer, &(), &random_seed_bytes).unwrap();
 	let (_, our_payment_hash, _) = get_payment_preimage_hash!(nodes[0]);
 	let our_payment_secret = nodes[1].node.create_inbound_payment_for_hash(our_payment_hash, Some(100_000), 7200, None).unwrap();
 	nodes[0].node.send_payment_with_route(&route, our_payment_hash,
@@ -7394,12 +7401,14 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
 	let payment_params = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), 50).with_bolt11_features(nodes[1].node.invoice_features()).unwrap();
 	let scorer = test_utils::TestScorer::new();
 	let random_seed_bytes = chanmon_cfgs[1].keys_manager.get_secure_random_bytes();
-	let route = get_route(&nodes[0].node.get_our_node_id(), &payment_params, &nodes[0].network_graph.read_only(), None,
-		3_000_000, nodes[0].logger, &scorer, &(), &random_seed_bytes).unwrap();
+	let route_params = RouteParameters::from_payment_params_and_value(payment_params, 3_000_000);
+	let route = get_route(&nodes[0].node.get_our_node_id(), &route_params, &nodes[0].network_graph.read_only(), None,
+		nodes[0].logger, &scorer, &(), &random_seed_bytes).unwrap();
 	let payment_preimage = send_along_route(&nodes[0], route, &[&nodes[1]], 3_000_000).0;
 	let payment_params = PaymentParameters::from_node_id(nodes[0].node.get_our_node_id(), 50).with_bolt11_features(nodes[0].node.invoice_features()).unwrap();
-	let route = get_route(&nodes[1].node.get_our_node_id(), &payment_params, &nodes[1].network_graph.read_only(), None,
-		3_000_000, nodes[0].logger, &scorer, &(), &random_seed_bytes).unwrap();
+	let route_params = RouteParameters::from_payment_params_and_value(payment_params, 3_000_000);
+	let route = get_route(&nodes[1].node.get_our_node_id(), &route_params, &nodes[1].network_graph.read_only(), None,
+		nodes[0].logger, &scorer, &(), &random_seed_bytes).unwrap();
 	send_along_route(&nodes[1], route, &[&nodes[0]], 3_000_000);
 
 	let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan.2);