f - Move RouteHint to lightning crate

Author: jkczyz

fuzz/src/router.rs

@@ -16,7 +16,7 @@ use lightning::chain::transaction::OutPoint;
 use lightning::ln::channelmanager::ChannelDetails;
 use lightning::ln::features::InitFeatures;
 use lightning::ln::msgs;
-use lightning::routing::router::{get_route, RouteHintHop};
+use lightning::routing::router::{get_route, RouteHint, RouteHintHop};
 use lightning::util::logger::Logger;
 use lightning::util::ser::Readable;
 use lightning::routing::network_graph::{NetworkGraph, RoutingFees};
@@ -225,13 +225,13 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 						Some(&first_hops_vec[..])
 					},
 				};
-				let mut last_hops_vec = Vec::new();
+				let mut last_hops = Vec::new();
 				{
 					let count = get_slice!(1)[0];
 					for _ in 0..count {
 						scid += 1;
 						let rnid = node_pks.iter().skip(slice_to_be16(get_slice!(2))as usize % node_pks.len()).next().unwrap();
-						last_hops_vec.push(RouteHintHop {
+						last_hops.push(RouteHint(vec![RouteHintHop {
 							src_node_id: *rnid,
 							short_channel_id: scid,
 							fees: RoutingFees {
@@ -241,13 +241,12 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 							cltv_expiry_delta: slice_to_be16(get_slice!(2)),
 							htlc_minimum_msat: Some(slice_to_be64(get_slice!(8))),
 							htlc_maximum_msat: None,
-						});
+						}]));
 					}
 				}
-				let last_hops = &last_hops_vec[..];
 				for target in node_pks.iter() {
 					let _ = get_route(&our_pubkey, &net_graph, target, None, first_hops,
-						last_hops.iter().map(|hop| std::slice::from_ref(hop)).collect::<Vec<_>>(),
+						last_hops.iter().collect::<Vec<_>>(),
 						slice_to_be64(get_slice!(8)), slice_to_be32(get_slice!(4)), Arc::clone(&logger));
 				}
 			},

lightning-invoice/src/de.rs

@@ -12,7 +12,7 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256;
 use lightning::ln::PaymentSecret;
 use lightning::routing::network_graph::RoutingFees;
-use lightning::routing::router::RouteHintHop;
+use lightning::routing::router::{RouteHint, RouteHintHop};
 
 use num_traits::{CheckedAdd, CheckedMul};
 
@@ -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, RouteHint, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice, constants, SignedRawInvoice,
+	SemanticError, Route, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice, constants, SignedRawInvoice,
 	RawDataPart, CreationError, InvoiceFeatures};
 
 use self::hrp_sm::parse_hrp;
@@ -434,7 +434,7 @@ impl FromBase32 for TaggedField {
 			constants::TAG_FALLBACK =>
 				Ok(TaggedField::Fallback(Fallback::from_base32(field_data)?)),
 			constants::TAG_ROUTE =>
-				Ok(TaggedField::Route(RouteHint::from_base32(field_data)?)),
+				Ok(TaggedField::Route(Route::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 RouteHint {
+impl FromBase32 for Route {
 	type Err = ParseError;
 
-	fn from_base32(field_data: &[u5]) -> Result<RouteHint, ParseError> {
+	fn from_base32(field_data: &[u5]) -> Result<Route, ParseError> {
 		let bytes = Vec::<u8>::from_base32(field_data)?;
 
 		if bytes.len() % 51 != 0 {
@@ -593,7 +593,7 @@ impl FromBase32 for RouteHint {
 			route_hops.push(hop);
 		}
 
-		Ok(RouteHint(route_hops))
+		Ok(Route(RouteHint(route_hops)))
 	}
 }
 
@@ -930,8 +930,8 @@ mod test {
 	#[test]
 	fn test_parse_route() {
 		use lightning::routing::network_graph::RoutingFees;
-		use lightning::routing::router::RouteHintHop;
-		use ::RouteHint;
+		use lightning::routing::router::{RouteHint, RouteHintHop};
+		use ::Route;
 		use bech32::FromBase32;
 		use de::parse_int_be;
 
@@ -976,10 +976,10 @@ mod test {
 			htlc_maximum_msat: None
 		});
 
-		assert_eq!(RouteHint::from_base32(&input), Ok(RouteHint(expected)));
+		assert_eq!(Route::from_base32(&input), Ok(Route(RouteHint(expected))));
 
 		assert_eq!(
-			RouteHint::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]),
+			Route::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]),
 			Err(ParseError::UnexpectedEndOfTaggedFields)
 		);
 	}

lightning-invoice/src/lib.rs

@@ -30,7 +30,7 @@ use lightning::ln::PaymentSecret;
 use lightning::ln::features::InvoiceFeatures;
 #[cfg(any(doc, test))]
 use lightning::routing::network_graph::RoutingFees;
-use lightning::routing::router::RouteHintHop;
+use lightning::routing::router::RouteHint;
 
 use secp256k1::key::PublicKey;
 use secp256k1::{Message, Secp256k1};
@@ -362,7 +362,7 @@ pub enum TaggedField {
 	ExpiryTime(ExpiryTime),
 	MinFinalCltvExpiry(MinFinalCltvExpiry),
 	Fallback(Fallback),
-	Route(RouteHint),
+	Route(Route),
 	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 RouteHint(Vec<RouteHintHop>);
+pub struct Route(RouteHint);
 
 /// Tag constants as specified in BOLT11
 #[allow(missing_docs)]
@@ -509,8 +509,8 @@ 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: Vec<RouteHintHop>) -> Self {
-		match RouteHint::new(route) {
+	pub fn route(mut self, route: RouteHint) -> Self {
+		match Route::new(route) {
 			Ok(r) => self.tagged_fields.push(TaggedField::Route(r)),
 			Err(e) => self.error = Some(e),
 		}
@@ -892,11 +892,11 @@ impl RawInvoice {
 		}).collect::<Vec<&Fallback>>()
 	}
 
-	pub fn routes(&self) -> Vec<&RouteHint> {
+	pub fn routes(&self) -> Vec<&Route> {
 		self.known_tagged_fields().filter_map(|tf| match tf {
 			&TaggedField::Route(ref r) => Some(r),
 			_ => None,
-		}).collect::<Vec<&RouteHint>>()
+		}).collect::<Vec<&Route>>()
 	}
 
 	pub fn amount_pico_btc(&self) -> Option<u64> {
@@ -1145,10 +1145,15 @@ impl Invoice {
 	}
 
 	/// Returns a list of all routes included in the invoice
-	pub fn routes(&self) -> Vec<&RouteHint> {
+	pub fn routes(&self) -> Vec<&Route> {
 		self.signed_invoice.routes()
 	}
 
+	/// Returns a list of all routes included in the invoice as the underlying type
+	pub fn route_hints(&self) -> Vec<&RouteHint> {
+		self.routes().into_iter().map(|route| &**route).collect()
+	}
+
 	/// Returns the currency for which the invoice was issued
 	pub fn currency(&self) -> Currency {
 		self.signed_invoice.currency()
@@ -1268,32 +1273,32 @@ impl ExpiryTime {
 	}
 }
 
-impl RouteHint {
+impl Route {
 	/// Create a new (partial) route from a list of hops
-	pub fn new(hops: Vec<RouteHintHop>) -> Result<RouteHint, CreationError> {
-		if hops.len() <= 12 {
-			Ok(RouteHint(hops))
+	pub fn new(hops: RouteHint) -> Result<Route, CreationError> {
+		if hops.0.len() <= 12 {
+			Ok(Route(hops))
 		} else {
 			Err(CreationError::RouteTooLong)
 		}
 	}
 
 	/// Returrn the underlying vector of hops
-	pub fn into_inner(self) -> Vec<RouteHintHop> {
+	pub fn into_inner(self) -> RouteHint {
 		self.0
 	}
 }
 
-impl Into<Vec<RouteHintHop>> for RouteHint {
-	fn into(self) -> Vec<RouteHintHop> {
+impl Into<RouteHint> for Route {
+	fn into(self) -> RouteHint {
 		self.into_inner()
 	}
 }
 
-impl Deref for RouteHint {
-	type Target = Vec<RouteHintHop>;
+impl Deref for Route {
+	type Target = RouteHint;
 
-	fn deref(&self) -> &Vec<RouteHintHop> {
+	fn deref(&self) -> &RouteHint {
 		&self.0
 	}
 }
@@ -1652,6 +1657,7 @@ mod test {
 	#[test]
 	fn test_builder_fail() {
 		use ::*;
+		use lightning::routing::router::RouteHintHop;
 		use std::iter::FromIterator;
 		use secp256k1::key::PublicKey;
 
@@ -1686,7 +1692,7 @@ mod test {
 			htlc_minimum_msat: None,
 			htlc_maximum_msat: None,
 		};
-		let too_long_route = vec![route_hop; 13];
+		let too_long_route = RouteHint(vec![route_hop; 13]);
 		let long_route_res = builder.clone()
 			.description("Test".into())
 			.route(too_long_route)
@@ -1704,6 +1710,7 @@ mod test {
 	#[test]
 	fn test_builder_ok() {
 		use ::*;
+		use lightning::routing::router::RouteHintHop;
 		use secp256k1::Secp256k1;
 		use secp256k1::key::{SecretKey, PublicKey};
 		use std::time::{UNIX_EPOCH, Duration};
@@ -1719,7 +1726,7 @@ mod test {
 		).unwrap();
 		let public_key = PublicKey::from_secret_key(&secp_ctx, &private_key);
 
-		let route_1 = vec![
+		let route_1 = RouteHint(vec![
 			RouteHintHop {
 				src_node_id: public_key.clone(),
 				short_channel_id: de::parse_int_be(&[123; 8], 256).expect("short chan ID slice too big?"),
@@ -1742,9 +1749,9 @@ mod test {
 				htlc_minimum_msat: None,
 				htlc_maximum_msat: None,
 			}
-		];
+		]);
 
-		let route_2 = vec![
+		let route_2 = RouteHint(vec![
 			RouteHintHop {
 				src_node_id: public_key.clone(),
 				short_channel_id: 0,
@@ -1767,7 +1774,7 @@ mod test {
 				htlc_minimum_msat: None,
 				htlc_maximum_msat: None,
 			}
-		];
+		]);
 
 		let builder = InvoiceBuilder::new(Currency::BitcoinTestnet)
 			.amount_pico_btc(123)
@@ -1800,7 +1807,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![&RouteHint(route_1), &RouteHint(route_2)]);
+		assert_eq!(invoice.routes(), vec![&Route(route_1), &Route(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,
-	RouteHint, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawInvoice, RawDataPart};
+	Route, 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,11 +356,11 @@ impl Base32Len for Fallback {
 	}
 }
 
-impl ToBase32 for RouteHint {
+impl ToBase32 for Route {
 	fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
 		let mut converter = BytesToBase32::new(writer);
 
-		for hop in self.iter() {
+		for hop in self.0.0.iter() {
 			converter.append(&hop.src_node_id.serialize()[..])?;
 			let short_channel_id = try_stretch(
 				encode_int_be_base256(hop.short_channel_id),
@@ -392,9 +392,9 @@ impl ToBase32 for RouteHint {
 	}
 }
 
-impl Base32Len for RouteHint {
+impl Base32Len for Route {
 	fn base32_len(&self) -> usize {
-		bytes_size_to_base32_size(self.0.len() * 51)
+		bytes_size_to_base32_size(self.0.0.len() * 51)
 	}
 }
 

lightning-invoice/src/utils.rs

@@ -7,7 +7,7 @@ use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
 use lightning::chain::keysinterface::{Sign, KeysInterface};
 use lightning::ln::channelmanager::{ChannelManager, MIN_FINAL_CLTV_EXPIRY};
 use lightning::routing::network_graph::RoutingFees;
-use lightning::routing::router::RouteHintHop;
+use lightning::routing::router::{RouteHint, RouteHintHop};
 use lightning::util::logger::Logger;
 use std::convert::TryInto;
 use std::ops::Deref;
@@ -40,7 +40,7 @@ where
 			Some(info) => info,
 			None => continue,
 		};
-		route_hints.push(vec![RouteHintHop {
+		route_hints.push(RouteHint(vec![RouteHintHop {
 			src_node_id: channel.remote_network_id,
 			short_channel_id,
 			fees: RoutingFees {
@@ -50,7 +50,7 @@ where
 			cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
 			htlc_minimum_msat: None,
 			htlc_maximum_msat: None,
-		}]);
+		}]));
 	}
 
 	let (payment_hash, payment_secret) = channelmanager.create_inbound_payment(
@@ -114,7 +114,7 @@ mod test {
 
 		let amt_msat = invoice.amount_pico_btc().unwrap() / 10;
 		let first_hops = nodes[0].node.list_usable_channels();
-		let last_hops = invoice.routes().into_iter().map(|route| &(**route)[..]).collect();
+		let last_hops = invoice.route_hints();
 		let network_graph = nodes[0].net_graph_msg_handler.network_graph.read().unwrap();
 		let logger = test_utils::TestLogger::new();
 		let route = router::get_route(