Rename Payee to PaymentParameters

fuzz/src/chanmon_consistency.rs

@@ -308,7 +308,7 @@ fn send_payment(source: &ChanMan, dest: &ChanMan, dest_chan_id: u64, amt: u64, p
 			fee_msat: amt,
 			cltv_expiry_delta: 200,
 		}]],
-		payee: None,
+		payment_params: None,
 	}, payment_hash, &Some(payment_secret)) {
 		check_payment_err(err);
 		false
@@ -334,7 +334,7 @@ fn send_hop_payment(source: &ChanMan, middle: &ChanMan, middle_chan_id: u64, des
 			fee_msat: amt,
 			cltv_expiry_delta: 200,
 		}]],
-		payee: None,
+		payment_params: None,
 	}, payment_hash, &Some(payment_secret)) {
 		check_payment_err(err);
 		false

fuzz/src/full_stack.rs

@@ -38,7 +38,7 @@ use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor,Ig
 use lightning::ln::msgs::DecodeError;
 use lightning::ln::script::ShutdownScript;
 use lightning::routing::network_graph::{NetGraphMsgHandler, NetworkGraph};
-use lightning::routing::router::{find_route, Payee, RouteParameters};
+use lightning::routing::router::{find_route, PaymentParameters, RouteParameters};
 use lightning::routing::scoring::Scorer;
 use lightning::util::config::UserConfig;
 use lightning::util::errors::APIError;
@@ -446,9 +446,9 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 			},
 			4 => {
 				let final_value_msat = slice_to_be24(get_slice!(3)) as u64;
-				let payee = Payee::from_node_id(get_pubkey!());
+				let payment_params = PaymentParameters::from_node_id(get_pubkey!());
 				let params = RouteParameters {
-					payee,
+					payment_params,
 					final_value_msat,
 					final_cltv_expiry_delta: 42,
 				};
@@ -469,9 +469,9 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 			},
 			15 => {
 				let final_value_msat = slice_to_be24(get_slice!(3)) as u64;
-				let payee = Payee::from_node_id(get_pubkey!());
+				let payment_params = PaymentParameters::from_node_id(get_pubkey!());
 				let params = RouteParameters {
-					payee,
+					payment_params,
 					final_value_msat,
 					final_cltv_expiry_delta: 42,
 				};

fuzz/src/router.rs

@@ -16,7 +16,7 @@ use lightning::chain::transaction::OutPoint;
 use lightning::ln::channelmanager::{ChannelDetails, ChannelCounterparty};
 use lightning::ln::features::InitFeatures;
 use lightning::ln::msgs;
-use lightning::routing::router::{find_route, Payee, RouteHint, RouteHintHop, RouteParameters};
+use lightning::routing::router::{find_route, PaymentParameters, RouteHint, RouteHintHop, RouteParameters};
 use lightning::routing::scoring::Scorer;
 use lightning::util::logger::Logger;
 use lightning::util::ser::Readable;
@@ -251,12 +251,12 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 				}
 				let scorer = Scorer::with_fixed_penalty(0);
 				for target in node_pks.iter() {
-					let params = RouteParameters {
-						payee: Payee::from_node_id(*target).with_route_hints(last_hops.clone()),
+					let route_params = RouteParameters {
+						payment_params: PaymentParameters::from_node_id(*target).with_route_hints(last_hops.clone()),
 						final_value_msat: slice_to_be64(get_slice!(8)),
 						final_cltv_expiry_delta: slice_to_be32(get_slice!(4)),
 					};
-					let _ = find_route(&our_pubkey, &params, &net_graph,
+					let _ = find_route(&our_pubkey, &route_params, &net_graph,
 						first_hops.map(|c| c.iter().collect::<Vec<_>>()).as_ref().map(|a| a.as_slice()),
 						Arc::clone(&logger), &scorer);
 				}

lightning-invoice/src/payment.rs

@@ -143,7 +143,7 @@ use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::scoring::{LockableScore, Score};
-use lightning::routing::router::{Payee, Route, RouteParameters};
+use lightning::routing::router::{PaymentParameters, Route, RouteParameters};
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
 use crate::sync::Mutex;
@@ -206,7 +206,7 @@ pub trait Payer {
 pub trait Router<S: Score> {
 	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
 	fn find_route(
-		&self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+		&self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
 		first_hops: Option<&[&ChannelDetails]>, scorer: &S
 	) -> Result<Route, LightningError>;
 }
@@ -296,22 +296,22 @@ where
 		};
 
 		let payment_secret = Some(invoice.payment_secret().clone());
-		let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key())
+		let mut payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key())
 			.with_expiry_time(expiry_time_from_unix_epoch(&invoice).as_secs())
 			.with_route_hints(invoice.route_hints());
 		if let Some(features) = invoice.features() {
-			payee = payee.with_features(features.clone());
+			payment_params = payment_params.with_features(features.clone());
 		}
-		let params = RouteParameters {
-			payee,
+		let route_params = RouteParameters {
+			payment_params,
 			final_value_msat: invoice.amount_milli_satoshis().or(amount_msats).unwrap(),
 			final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
 		};
 
 		let send_payment = |route: &Route| {
 			self.payer.send_payment(route, payment_hash, &payment_secret)
 		};
-		self.pay_internal(&params, payment_hash, send_payment)
+		self.pay_internal(&route_params, payment_hash, send_payment)
 			.map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e })
 	}
 
@@ -330,16 +330,16 @@ where
 			hash_map::Entry::Vacant(entry) => entry.insert(0),
 		};
 
-		let params = RouteParameters {
-			payee: Payee::for_keysend(pubkey),
+		let route_params = RouteParameters {
+			payment_params: PaymentParameters::for_keysend(pubkey),
 			final_value_msat: amount_msats,
 			final_cltv_expiry_delta,
 		};
 
 		let send_payment = |route: &Route| {
 			self.payer.send_spontaneous_payment(route, payment_preimage)
 		};
-		self.pay_internal(&params, payment_hash, send_payment)
+		self.pay_internal(&route_params, payment_hash, send_payment)
 			.map_err(|e| { self.payment_cache.lock().unwrap().remove(&payment_hash); e })
 	}
 
@@ -462,8 +462,8 @@ fn expiry_time_from_unix_epoch(invoice: &Invoice) -> Duration {
 }
 
 #[cfg(feature = "std")]
-fn has_expired(params: &RouteParameters) -> bool {
-	if let Some(expiry_time) = params.payee.expiry_time {
+fn has_expired(route_params: &RouteParameters) -> bool {
+	if let Some(expiry_time) = route_params.payment_params.expiry_time {
 		Invoice::is_expired_from_epoch(&SystemTime::UNIX_EPOCH, Duration::from_secs(expiry_time))
 	} else { false }
 }
@@ -533,7 +533,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::network_graph::NodeId;
-	use lightning::routing::router::{Payee, Route, RouteHop};
+	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
 	use lightning::util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
@@ -882,7 +882,7 @@ mod tests {
 		assert_eq!(*payer.attempts.borrow(), 1);
 
 		let mut retry_data = TestRouter::retry_for_invoice(&invoice);
-		retry_data.payee.expiry_time = Some(SystemTime::now()
+		retry_data.payment_params.expiry_time = Some(SystemTime::now()
 			.checked_sub(Duration::from_secs(2)).unwrap()
 			.duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs());
 		let event = Event::PaymentPathFailed {
@@ -1136,7 +1136,7 @@ mod tests {
 		assert_eq!(*payer.attempts.borrow(), 1);
 
 		let retry = RouteParameters {
-			payee: Payee::for_keysend(pubkey),
+			payment_params: PaymentParameters::for_keysend(pubkey),
 			final_value_msat,
 			final_cltv_expiry_delta,
 		};
@@ -1251,7 +1251,7 @@ mod tests {
 						short_channel_id: 1, fee_msat: final_value_msat / 2, cltv_expiry_delta: 144
 					}],
 				],
-				payee: None,
+				payment_params: None,
 			}
 		}
 
@@ -1260,15 +1260,15 @@ mod tests {
 		}
 
 		fn retry_for_invoice(invoice: &Invoice) -> RouteParameters {
-			let mut payee = Payee::from_node_id(invoice.recover_payee_pub_key())
+			let mut payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key())
 				.with_expiry_time(expiry_time_from_unix_epoch(invoice).as_secs())
 				.with_route_hints(invoice.route_hints());
 			if let Some(features) = invoice.features() {
-				payee = payee.with_features(features.clone());
+				payment_params = payment_params.with_features(features.clone());
 			}
 			let final_value_msat = invoice.amount_milli_satoshis().unwrap() / 2;
 			RouteParameters {
-				payee,
+				payment_params,
 				final_value_msat,
 				final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
 			}
@@ -1277,11 +1277,11 @@ mod tests {
 
 	impl<S: Score> Router<S> for TestRouter {
 		fn find_route(
-			&self, _payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
+			&self, _payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
 			_first_hops: Option<&[&ChannelDetails]>, _scorer: &S
 		) -> Result<Route, LightningError> {
 			Ok(Route {
-				payee: Some(params.payee.clone()), ..Self::route_for_value(params.final_value_msat)
+				payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
 			})
 		}
 	}
@@ -1543,7 +1543,7 @@ mod tests {
 					cltv_expiry_delta: 100,
 				}],
 			],
-			payee: Some(Payee::from_node_id(nodes[1].node.get_our_node_id())),
+			payment_params: Some(PaymentParameters::from_node_id(nodes[1].node.get_our_node_id())),
 		};
 		let router = ManualRouter(RefCell::new(VecDeque::new()));
 		router.expect_find_route(Ok(route.clone()));
@@ -1587,7 +1587,7 @@ mod tests {
 					cltv_expiry_delta: 100,
 				}],
 			],
-			payee: Some(Payee::from_node_id(nodes[1].node.get_our_node_id())),
+			payment_params: Some(PaymentParameters::from_node_id(nodes[1].node.get_our_node_id())),
 		};
 		let router = ManualRouter(RefCell::new(VecDeque::new()));
 		router.expect_find_route(Ok(route.clone()));
@@ -1668,7 +1668,7 @@ mod tests {
 					cltv_expiry_delta: 100,
 				}]
 			],
-			payee: Some(Payee::from_node_id(nodes[2].node.get_our_node_id())),
+			payment_params: Some(PaymentParameters::from_node_id(nodes[2].node.get_our_node_id())),
 		};
 		let router = ManualRouter(RefCell::new(VecDeque::new()));
 		router.expect_find_route(Ok(route.clone()));

lightning-invoice/src/utils.rs

@@ -198,7 +198,7 @@ mod test {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::features::InitFeatures;
 	use lightning::ln::msgs::ChannelMessageHandler;
-	use lightning::routing::router::{Payee, RouteParameters, find_route};
+	use lightning::routing::router::{PaymentParameters, RouteParameters, find_route};
 	use lightning::util::events::MessageSendEventsProvider;
 	use lightning::util::test_utils;
 	use utils::create_invoice_from_channelmanager_and_duration_since_epoch;
@@ -217,11 +217,11 @@ mod test {
 		assert_eq!(invoice.min_final_cltv_expiry(), MIN_FINAL_CLTV_EXPIRY as u64);
 		assert_eq!(invoice.description(), InvoiceDescription::Direct(&Description("test".to_string())));
 
-		let payee = Payee::from_node_id(invoice.recover_payee_pub_key())
+		let payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key())
 			.with_features(invoice.features().unwrap().clone())
 			.with_route_hints(invoice.route_hints());
-		let params = RouteParameters {
-			payee,
+		let route_params = RouteParameters {
+			payment_params,
 			final_value_msat: invoice.amount_milli_satoshis().unwrap(),
 			final_cltv_expiry_delta: invoice.min_final_cltv_expiry() as u32,
 		};
@@ -230,7 +230,7 @@ mod test {
 		let logger = test_utils::TestLogger::new();
 		let scorer = test_utils::TestScorer::with_fixed_penalty(0);
 		let route = find_route(
-			&nodes[0].node.get_our_node_id(), &params, network_graph,
+			&nodes[0].node.get_our_node_id(), &route_params, network_graph,
 			Some(&first_hops.iter().collect::<Vec<_>>()), &logger, &scorer,
 		).unwrap();
 

lightning/src/ln/channel.rs

@@ -5992,7 +5992,7 @@ mod tests {
 				first_hop_htlc_msat: 548,
 				payment_id: PaymentId([42; 32]),
 				payment_secret: None,
-				payee: None,
+				payment_params: None,
 			}
 		});