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};
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;
"tb" => Ok(Currency::BitcoinTestnet),
"bcrt" => Ok(Currency::Regtest),
"sb" => Ok(Currency::Simnet),
+ "tbs" => Ok(Currency::Signet),
_ => Err(ParseError::UnknownCurrency)
}
}
type Err = ParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
- let (hrp, data) = bech32::decode(s)?;
+ let (hrp, data, var) = bech32::decode(s)?;
+
+ if var == bech32::Variant::Bech32m {
+ // Consider Bech32m addresses to be "Invalid Checksum", since that is what we'd get if
+ // we didn't support Bech32m (which lightning does not use).
+ return Err(ParseError::Bech32Error(bech32::Error::InvalidChecksum));
+ }
if data.len() < 104 {
return Err(ParseError::TooShortDataPart);
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 =>
}
}
-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;
}
}
-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 {
route_hops.push(hop);
}
- Ok(RouteHint(route_hops))
+ Ok(PrivateRoute(RouteHint(route_hops)))
}
}
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))
}
#[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;
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)
);
}