Accept multi-hop route hints in get_route

[rust-lightning] / lightning-invoice / src / de.rs

diff --git a/lightning-invoice/src/de.rs b/lightning-invoice/src/de.rs
index c06281e4b4db86c00b95812ad4794b57dffe9112..9c5120e4ad67cb2e9ccdc492b0757a8479c380f0 100644 (file)
--- a/lightning-invoice/src/de.rs
+++ b/lightning-invoice/src/de.rs
@@ -10,8 +10,9 @@ use bech32::{u5, FromBase32};
 
 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};
 
@@ -19,7 +20,9 @@ use secp256k1;
 use secp256k1::recovery::{RecoveryId, RecoverableSignature};
 use secp256k1::key::PublicKey;
 
-use super::*;
+use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiry, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
+       SemanticError, PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice, constants, SignedRawInvoice,
+       RawDataPart, CreationError, InvoiceFeatures};
 
 use self::hrp_sm::parse_hrp;
 
@@ -182,6 +185,7 @@ impl FromStr for super::Currency {
                        "tb" => Ok(Currency::BitcoinTestnet),
                        "bcrt" => Ok(Currency::Regtest),
                        "sb" => Ok(Currency::Simnet),
+                       "tbs" => Ok(Currency::Signet),
                        _ => Err(ParseError::UnknownCurrency)
                }
        }
@@ -264,7 +268,7 @@ impl FromStr for SignedRawInvoice {
                                hrp.as_bytes(),
                                &data[..data.len()-104]
                        ),
-                       signature: Signature::from_base32(&data[data.len()-104..])?,
+                       signature: InvoiceSignature::from_base32(&data[data.len()-104..])?,
                })
        }
 }
@@ -338,17 +342,17 @@ impl FromBase32 for PositiveTimestamp {
        }
 }
 
-impl FromBase32 for Signature {
+impl FromBase32 for InvoiceSignature {
        type Err = ParseError;
        fn from_base32(signature: &[u5]) -> Result<Self, Self::Err> {
                if signature.len() != 104 {
-                       return Err(ParseError::InvalidSliceLength("Signature::from_base32()".into()));
+                       return Err(ParseError::InvalidSliceLength("InvoiceSignature::from_base32()".into()));
                }
                let recoverable_signature_bytes = Vec::<u8>::from_base32(signature)?;
                let signature = &recoverable_signature_bytes[0..64];
                let recovery_id = RecoveryId::from_i32(recoverable_signature_bytes[64] as i32)?;
 
-               Ok(Signature(RecoverableSignature::from_compact(
+               Ok(InvoiceSignature(RecoverableSignature::from_compact(
                        signature,
                        recovery_id
                )?))
@@ -429,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(RouteHint::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 =>
@@ -484,21 +488,6 @@ impl FromBase32 for PayeePubKey {
        }
 }
 
-impl FromBase32 for PaymentSecret {
-       type Err = ParseError;
-
-       fn from_base32(field_data: &[u5]) -> Result<PaymentSecret, ParseError> {
-               if field_data.len() != 52 {
-                       Err(ParseError::Skip)
-               } else {
-                       let data_bytes = Vec::<u8>::from_base32(field_data)?;
-                       let mut payment_secret = [0; 32];
-                       payment_secret.copy_from_slice(&data_bytes);
-                       Ok(PaymentSecret(payment_secret))
-               }
-       }
-}
-
 impl FromBase32 for ExpiryTime {
        type Err = ParseError;
 
@@ -569,10 +558,10 @@ impl FromBase32 for Fallback {
        }
 }
 
-impl FromBase32 for RouteHint {
+impl FromBase32 for PrivateRoute {
        type Err = ParseError;
 
-       fn from_base32(field_data: &[u5]) -> Result<RouteHint, ParseError> {
+       fn from_base32(field_data: &[u5]) -> Result<PrivateRoute, ParseError> {
                let bytes = Vec::<u8>::from_base32(field_data)?;
 
                if bytes.len() % 51 != 0 {
@@ -604,7 +593,7 @@ impl FromBase32 for RouteHint {
                        route_hops.push(hop);
                }
 
-               Ok(RouteHint(route_hops))
+               Ok(PrivateRoute(RouteHint(route_hops)))
        }
 }
 
@@ -786,6 +775,7 @@ mod test {
                assert_eq!("tb".parse::<Currency>(), Ok(Currency::BitcoinTestnet));
                assert_eq!("bcrt".parse::<Currency>(), Ok(Currency::Regtest));
                assert_eq!("sb".parse::<Currency>(), Ok(Currency::Simnet));
+               assert_eq!("tbs".parse::<Currency>(), Ok(Currency::Signet));
                assert_eq!("something_else".parse::<Currency>(), Err(ParseError::UnknownCurrency))
        }
 
@@ -940,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 ::PrivateRoute;
                use bech32::FromBase32;
                use de::parse_int_be;
 
@@ -986,10 +976,10 @@ mod test {
                        htlc_maximum_msat: None
                });
 
-               assert_eq!(RouteHint::from_base32(&input), Ok(RouteHint(expected)));
+               assert_eq!(PrivateRoute::from_base32(&input), Ok(PrivateRoute(RouteHint(expected))));
 
                assert_eq!(
-                       RouteHint::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]),
+                       PrivateRoute::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]),
                        Err(ParseError::UnexpectedEndOfTaggedFields)
                );
        }
@@ -999,7 +989,7 @@ mod test {
                use lightning::ln::features::InvoiceFeatures;
                use secp256k1::recovery::{RecoveryId, RecoverableSignature};
                use TaggedField::*;
-               use {SiPrefix, SignedRawInvoice, Signature, RawInvoice, RawHrp, RawDataPart,
+               use {SiPrefix, SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart,
                                 Currency, Sha256, PositiveTimestamp};
 
                // Feature bits 9, 15, and 99 are set.
@@ -1025,7 +1015,7 @@ mod test {
                                        hash: [0xb1, 0x96, 0x46, 0xc3, 0xbc, 0x56, 0x76, 0x1d, 0x20, 0x65, 0x6e, 0x0e, 0x32,
                                                                        0xec, 0xd2, 0x69, 0x27, 0xb7, 0x62, 0x6e, 0x2a, 0x8b, 0xe6, 0x97, 0x71, 0x9f,
                                                                        0xf8, 0x7e, 0x44, 0x54, 0x55, 0xb9],
-                                       signature: Signature(RecoverableSignature::from_compact(
+                                       signature: InvoiceSignature(RecoverableSignature::from_compact(
                                                                                &[0xd7, 0x90, 0x4c, 0xc4, 0xb7, 0x4a, 0x22, 0x26, 0x9c, 0x68, 0xc1, 0xdf, 0x68,
                                                                                        0xa9, 0x6c, 0x21, 0x4d, 0x65, 0x1b, 0x93, 0x76, 0xe9, 0xf1, 0x64, 0xd3, 0x60,
                                                                                        0x4d, 0xa4, 0xb7, 0xde, 0xcc, 0xce, 0x0e, 0x82, 0xaa, 0xab, 0x4c, 0x85, 0xd3,
@@ -1045,7 +1035,7 @@ mod test {
        fn test_raw_signed_invoice_deserialization() {
                use TaggedField::*;
                use secp256k1::recovery::{RecoveryId, RecoverableSignature};
-               use {SignedRawInvoice, Signature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256,
+               use {SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256,
                         PositiveTimestamp};
 
                assert_eq!(
@@ -1078,7 +1068,7 @@ mod test {
                                        0x7b, 0x1d, 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7,
                                        0x83, 0x5d, 0xb2, 0xec, 0xd5, 0x18, 0xe1, 0xc9
                                ],
-                               signature: Signature(RecoverableSignature::from_compact(
+                               signature: InvoiceSignature(RecoverableSignature::from_compact(
                                        & [
                                                0x38u8, 0xec, 0x68, 0x91, 0x34, 0x5e, 0x20, 0x41, 0x45, 0xbe, 0x8a,
                                                0x3a, 0x99, 0xde, 0x38, 0xe9, 0x8a, 0x39, 0xd6, 0xa5, 0x69, 0x43,