f - Rename Route to PrivateRoute in lightning-invoice

Author: jkczyz

lightning-invoice/src/de.rs

@@ -21,7 +21,7 @@ use secp256k1::recovery::{RecoveryId, RecoverableSignature};
 use secp256k1::key::PublicKey;
 
 use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiry, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
-	SemanticError, Route, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice, constants, SignedRawInvoice,
+	SemanticError, PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice, constants, SignedRawInvoice,
 	RawDataPart, CreationError, InvoiceFeatures};
 
 use self::hrp_sm::parse_hrp;
@@ -433,8 +433,8 @@ impl FromBase32 for TaggedField {
 				Ok(TaggedField::MinFinalCltvExpiry(MinFinalCltvExpiry::from_base32(field_data)?)),
 			constants::TAG_FALLBACK =>
 				Ok(TaggedField::Fallback(Fallback::from_base32(field_data)?)),
-			constants::TAG_ROUTE =>
-				Ok(TaggedField::Route(Route::from_base32(field_data)?)),
+			constants::TAG_PRIVATE_ROUTE =>
+				Ok(TaggedField::PrivateRoute(PrivateRoute::from_base32(field_data)?)),
 			constants::TAG_PAYMENT_SECRET =>
 				Ok(TaggedField::PaymentSecret(PaymentSecret::from_base32(field_data)?)),
 			constants::TAG_FEATURES =>
@@ -558,10 +558,10 @@ impl FromBase32 for Fallback {
 	}
 }
 
-impl FromBase32 for Route {
+impl FromBase32 for PrivateRoute {
 	type Err = ParseError;
 
-	fn from_base32(field_data: &[u5]) -> Result<Route, ParseError> {
+	fn from_base32(field_data: &[u5]) -> Result<PrivateRoute, ParseError> {
 		let bytes = Vec::<u8>::from_base32(field_data)?;
 
 		if bytes.len() % 51 != 0 {
@@ -593,7 +593,7 @@ impl FromBase32 for Route {
 			route_hops.push(hop);
 		}
 
-		Ok(Route(RouteHint(route_hops)))
+		Ok(PrivateRoute(RouteHint(route_hops)))
 	}
 }
 
@@ -931,7 +931,7 @@ mod test {
 	fn test_parse_route() {
 		use lightning::routing::network_graph::RoutingFees;
 		use lightning::routing::router::{RouteHint, RouteHintHop};
-		use ::Route;
+		use ::PrivateRoute;
 		use bech32::FromBase32;
 		use de::parse_int_be;
 
@@ -976,10 +976,10 @@ mod test {
 			htlc_maximum_msat: None
 		});
 
-		assert_eq!(Route::from_base32(&input), Ok(Route(RouteHint(expected))));
+		assert_eq!(PrivateRoute::from_base32(&input), Ok(PrivateRoute(RouteHint(expected))));
 
 		assert_eq!(
-			Route::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]),
+			PrivateRoute::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]),
 			Err(ParseError::UnexpectedEndOfTaggedFields)
 		);
 	}

lightning-invoice/src/lib.rs

@@ -362,7 +362,7 @@ pub enum TaggedField {
 	ExpiryTime(ExpiryTime),
 	MinFinalCltvExpiry(MinFinalCltvExpiry),
 	Fallback(Fallback),
-	Route(Route),
+	PrivateRoute(PrivateRoute),
 	PaymentSecret(PaymentSecret),
 	Features(InvoiceFeatures),
 }
@@ -419,7 +419,7 @@ pub struct InvoiceSignature(pub RecoverableSignature);
 /// The encoded route has to be <1024 5bit characters long (<=639 bytes or <=12 hops)
 ///
 #[derive(Eq, PartialEq, Debug, Clone)]
-pub struct Route(RouteHint);
+pub struct PrivateRoute(RouteHint);
 
 /// Tag constants as specified in BOLT11
 #[allow(missing_docs)]
@@ -431,7 +431,7 @@ pub mod constants {
 	pub const TAG_EXPIRY_TIME: u8 = 6;
 	pub const TAG_MIN_FINAL_CLTV_EXPIRY: u8 = 24;
 	pub const TAG_FALLBACK: u8 = 9;
-	pub const TAG_ROUTE: u8 = 3;
+	pub const TAG_PRIVATE_ROUTE: u8 = 3;
 	pub const TAG_PAYMENT_SECRET: u8 = 16;
 	pub const TAG_FEATURES: u8 = 5;
 }
@@ -509,9 +509,9 @@ impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBui
 	}
 
 	/// Adds a private route.
-	pub fn route(mut self, route: RouteHint) -> Self {
-		match Route::new(route) {
-			Ok(r) => self.tagged_fields.push(TaggedField::Route(r)),
+	pub fn private_route(mut self, hint: RouteHint) -> Self {
+		match PrivateRoute::new(hint) {
+			Ok(r) => self.tagged_fields.push(TaggedField::PrivateRoute(r)),
 			Err(e) => self.error = Some(e),
 		}
 		self
@@ -913,8 +913,8 @@ impl RawInvoice {
 		find_all_extract!(self.known_tagged_fields(), TaggedField::Fallback(ref x), x).collect()
 	}
 
-	pub fn routes(&self) -> Vec<&Route> {
-		find_all_extract!(self.known_tagged_fields(), TaggedField::Route(ref x), x).collect()
+	pub fn private_routes(&self) -> Vec<&PrivateRoute> {
+		find_all_extract!(self.known_tagged_fields(), TaggedField::PrivateRoute(ref x), x).collect()
 	}
 
 	pub fn amount_pico_btc(&self) -> Option<u64> {
@@ -1163,13 +1163,13 @@ impl Invoice {
 	}
 
 	/// Returns a list of all routes included in the invoice
-	pub fn routes(&self) -> Vec<&Route> {
-		self.signed_invoice.routes()
+	pub fn private_routes(&self) -> Vec<&PrivateRoute> {
+		self.signed_invoice.private_routes()
 	}
 
-	/// Returns a list of all routes included in the invoice as the underlying type
+	/// Returns a list of all routes included in the invoice as the underlying hints
 	pub fn route_hints(&self) -> Vec<&RouteHint> {
-		self.routes().into_iter().map(|route| &**route).collect()
+		self.private_routes().into_iter().map(|route| &**route).collect()
 	}
 
 	/// Returns the currency for which the invoice was issued
@@ -1200,7 +1200,7 @@ impl TaggedField {
 			TaggedField::ExpiryTime(_) => constants::TAG_EXPIRY_TIME,
 			TaggedField::MinFinalCltvExpiry(_) => constants::TAG_MIN_FINAL_CLTV_EXPIRY,
 			TaggedField::Fallback(_) => constants::TAG_FALLBACK,
-			TaggedField::Route(_) => constants::TAG_ROUTE,
+			TaggedField::PrivateRoute(_) => constants::TAG_PRIVATE_ROUTE,
 			TaggedField::PaymentSecret(_) => constants::TAG_PAYMENT_SECRET,
 			TaggedField::Features(_) => constants::TAG_FEATURES,
 		};
@@ -1291,11 +1291,11 @@ impl ExpiryTime {
 	}
 }
 
-impl Route {
+impl PrivateRoute {
 	/// Creates a new (partial) route from a list of hops
-	pub fn new(hops: RouteHint) -> Result<Route, CreationError> {
+	pub fn new(hops: RouteHint) -> Result<PrivateRoute, CreationError> {
 		if hops.0.len() <= 12 {
-			Ok(Route(hops))
+			Ok(PrivateRoute(hops))
 		} else {
 			Err(CreationError::RouteTooLong)
 		}
@@ -1307,13 +1307,13 @@ impl Route {
 	}
 }
 
-impl Into<RouteHint> for Route {
+impl Into<RouteHint> for PrivateRoute {
 	fn into(self) -> RouteHint {
 		self.into_inner()
 	}
 }
 
-impl Deref for Route {
+impl Deref for PrivateRoute {
 	type Target = RouteHint;
 
 	fn deref(&self) -> &RouteHint {
@@ -1713,7 +1713,7 @@ mod test {
 		let too_long_route = RouteHint(vec![route_hop; 13]);
 		let long_route_res = builder.clone()
 			.description("Test".into())
-			.route(too_long_route)
+			.private_route(too_long_route)
 			.build_raw();
 		assert_eq!(long_route_res, Err(CreationError::RouteTooLong));
 
@@ -1801,8 +1801,8 @@ mod test {
 			.expiry_time(Duration::from_secs(54321))
 			.min_final_cltv_expiry(144)
 			.fallback(Fallback::PubKeyHash([0;20]))
-			.route(route_1.clone())
-			.route(route_2.clone())
+			.private_route(route_1.clone())
+			.private_route(route_2.clone())
 			.description_hash(sha256::Hash::from_slice(&[3;32][..]).unwrap())
 			.payment_hash(sha256::Hash::from_slice(&[21;32][..]).unwrap())
 			.payment_secret(PaymentSecret([42; 32]))
@@ -1825,7 +1825,7 @@ mod test {
 		assert_eq!(invoice.expiry_time(), Duration::from_secs(54321));
 		assert_eq!(invoice.min_final_cltv_expiry(), 144);
 		assert_eq!(invoice.fallbacks(), vec![&Fallback::PubKeyHash([0;20])]);
-		assert_eq!(invoice.routes(), vec![&Route(route_1), &Route(route_2)]);
+		assert_eq!(invoice.private_routes(), vec![&PrivateRoute(route_1), &PrivateRoute(route_2)]);
 		assert_eq!(
 			invoice.description(),
 			InvoiceDescription::Hash(&Sha256(sha256::Hash::from_slice(&[3;32][..]).unwrap()))

lightning-invoice/src/ser.rs

@@ -3,7 +3,7 @@ use std::fmt::{Display, Formatter};
 use bech32::{ToBase32, u5, WriteBase32, Base32Len};
 
 use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiry, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
-	Route, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawInvoice, RawDataPart};
+	PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawInvoice, RawDataPart};
 
 /// Converts a stream of bytes written to it to base32. On finalization the according padding will
 /// be applied. That means the results of writing two data blocks with one or two `BytesToBase32`
@@ -356,7 +356,7 @@ impl Base32Len for Fallback {
 	}
 }
 
-impl ToBase32 for Route {
+impl ToBase32 for PrivateRoute {
 	fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
 		let mut converter = BytesToBase32::new(writer);
 
@@ -392,7 +392,7 @@ impl ToBase32 for Route {
 	}
 }
 
-impl Base32Len for Route {
+impl Base32Len for PrivateRoute {
 	fn base32_len(&self) -> usize {
 		bytes_size_to_base32_size((self.0).0.len() * 51)
 	}
@@ -439,8 +439,8 @@ impl ToBase32 for TaggedField {
 			TaggedField::Fallback(ref fallback_address) => {
 				write_tagged_field(writer, constants::TAG_FALLBACK, fallback_address)
 			},
-			TaggedField::Route(ref route_hops) => {
-				write_tagged_field(writer, constants::TAG_ROUTE, route_hops)
+			TaggedField::PrivateRoute(ref route_hops) => {
+				write_tagged_field(writer, constants::TAG_PRIVATE_ROUTE, route_hops)
 			},
 			TaggedField::PaymentSecret(ref payment_secret) => {
 				  write_tagged_field(writer, constants::TAG_PAYMENT_SECRET, payment_secret)

lightning-invoice/src/utils.rs

@@ -70,8 +70,8 @@ where
 	if let Some(amt) = amt_msat {
 		invoice = invoice.amount_pico_btc(amt * 10);
 	}
-	for hint in route_hints.drain(..) {
-		invoice = invoice.route(hint);
+	for hint in route_hints {
+		invoice = invoice.private_route(hint);
 	}
 
 	let raw_invoice = match invoice.build_raw() {