1 #[cfg(feature = "std")]
3 use core::convert::TryFrom;
5 use core::fmt::{Display, Formatter};
6 use core::num::ParseIntError;
8 use core::str::FromStr;
11 use bech32::{u5, FromBase32};
13 use bitcoin::{PubkeyHash, ScriptHash};
14 use bitcoin::util::address::WitnessVersion;
15 use bitcoin_hashes::Hash;
16 use bitcoin_hashes::sha256;
17 use crate::prelude::*;
18 use lightning::ln::PaymentSecret;
19 use lightning::routing::gossip::RoutingFees;
20 use lightning::routing::router::{RouteHint, RouteHintHop};
22 use num_traits::{CheckedAdd, CheckedMul};
25 use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
26 use secp256k1::PublicKey;
28 use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
29 SemanticError, PrivateRoute, ParseError, ParseOrSemanticError, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice,
30 constants, SignedRawInvoice, RawDataPart, InvoiceFeatures};
32 use self::hrp_sm::parse_hrp;
34 /// State machine to parse the hrp
38 #[derive(PartialEq, Eq, Debug)]
49 fn next_state(&self, read_symbol: char) -> Result<States, super::ParseError> {
52 if read_symbol == 'l' {
55 Err(super::ParseError::MalformedHRP)
59 if read_symbol == 'n' {
62 Err(super::ParseError::MalformedHRP)
66 if !read_symbol.is_numeric() {
67 Ok(States::ParseCurrencyPrefix)
69 Ok(States::ParseAmountNumber)
72 States::ParseCurrencyPrefix => {
73 if !read_symbol.is_numeric() {
74 Ok(States::ParseCurrencyPrefix)
76 Ok(States::ParseAmountNumber)
79 States::ParseAmountNumber => {
80 if read_symbol.is_numeric() {
81 Ok(States::ParseAmountNumber)
82 } else if ['m', 'u', 'n', 'p'].contains(&read_symbol) {
83 Ok(States::ParseAmountSiPrefix)
85 Err(super::ParseError::UnknownSiPrefix)
88 States::ParseAmountSiPrefix => Err(super::ParseError::MalformedHRP),
92 fn is_final(&self) -> bool {
93 !(*self == States::ParseL || *self == States::ParseN)
101 currency_prefix: Option<Range<usize>>,
102 amount_number: Option<Range<usize>>,
103 amount_si_prefix: Option<Range<usize>>,
107 fn new() -> StateMachine {
109 state: States::Start,
111 currency_prefix: None,
113 amount_si_prefix: None,
117 fn update_range(range: &mut Option<Range<usize>>, position: usize) {
118 let new_range = match *range {
119 None => Range {start: position, end: position + 1},
120 Some(ref r) => Range {start: r.start, end: r.end + 1},
122 *range = Some(new_range);
125 fn step(&mut self, c: char) -> Result<(), super::ParseError> {
126 let next_state = self.state.next_state(c)?;
128 States::ParseCurrencyPrefix => {
129 StateMachine::update_range(&mut self.currency_prefix, self.position)
131 States::ParseAmountNumber => {
132 StateMachine::update_range(&mut self.amount_number, self.position)
134 States::ParseAmountSiPrefix => {
135 StateMachine::update_range(&mut self.amount_si_prefix, self.position)
141 self.state = next_state;
145 fn is_final(&self) -> bool {
146 self.state.is_final()
149 fn currency_prefix(&self) -> &Option<Range<usize>> {
150 &self.currency_prefix
153 fn amount_number(&self) -> &Option<Range<usize>> {
157 fn amount_si_prefix(&self) -> &Option<Range<usize>> {
158 &self.amount_si_prefix
162 pub fn parse_hrp(input: &str) -> Result<(&str, &str, &str), super::ParseError> {
163 let mut sm = StateMachine::new();
164 for c in input.chars() {
169 return Err(super::ParseError::MalformedHRP);
172 let currency = sm.currency_prefix().clone()
173 .map(|r| &input[r]).unwrap_or("");
174 let amount = sm.amount_number().clone()
175 .map(|r| &input[r]).unwrap_or("");
176 let si = sm.amount_si_prefix().clone()
177 .map(|r| &input[r]).unwrap_or("");
179 Ok((currency, amount, si))
184 impl FromStr for super::Currency {
185 type Err = ParseError;
187 fn from_str(currency_prefix: &str) -> Result<Self, ParseError> {
188 match currency_prefix {
189 "bc" => Ok(Currency::Bitcoin),
190 "tb" => Ok(Currency::BitcoinTestnet),
191 "bcrt" => Ok(Currency::Regtest),
192 "sb" => Ok(Currency::Simnet),
193 "tbs" => Ok(Currency::Signet),
194 _ => Err(ParseError::UnknownCurrency)
199 impl FromStr for SiPrefix {
200 type Err = ParseError;
202 fn from_str(currency_prefix: &str) -> Result<Self, ParseError> {
203 use crate::SiPrefix::*;
204 match currency_prefix {
209 _ => Err(ParseError::UnknownSiPrefix)
215 /// use lightning_invoice::Invoice;
218 /// let invoice = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\
219 /// h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\
220 /// 5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\
221 /// h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\
222 /// j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\
223 /// ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\
224 /// guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\
225 /// ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\
226 /// p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\
227 /// 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\
228 /// j5r6drg6k6zcqj0fcwg";
230 /// assert!(invoice.parse::<Invoice>().is_ok());
232 impl FromStr for Invoice {
233 type Err = ParseOrSemanticError;
235 fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err> {
236 let signed = s.parse::<SignedRawInvoice>()?;
237 Ok(Invoice::from_signed(signed)?)
242 /// use lightning_invoice::*;
244 /// let invoice = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\
245 /// h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\
246 /// 5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\
247 /// h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\
248 /// j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\
249 /// ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\
250 /// guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\
251 /// ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\
252 /// p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\
253 /// 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\
254 /// j5r6drg6k6zcqj0fcwg";
256 /// let parsed_1 = invoice.parse::<Invoice>();
258 /// let parsed_2 = match invoice.parse::<SignedRawInvoice>() {
259 /// Ok(signed) => match Invoice::from_signed(signed) {
260 /// Ok(invoice) => Ok(invoice),
261 /// Err(e) => Err(ParseOrSemanticError::SemanticError(e)),
263 /// Err(e) => Err(ParseOrSemanticError::ParseError(e)),
266 /// assert!(parsed_1.is_ok());
267 /// assert_eq!(parsed_1, parsed_2);
269 impl FromStr for SignedRawInvoice {
270 type Err = ParseError;
272 fn from_str(s: &str) -> Result<Self, Self::Err> {
273 let (hrp, data, var) = bech32::decode(s)?;
275 if var == bech32::Variant::Bech32m {
276 // Consider Bech32m addresses to be "Invalid Checksum", since that is what we'd get if
277 // we didn't support Bech32m (which lightning does not use).
278 return Err(ParseError::Bech32Error(bech32::Error::InvalidChecksum));
281 if data.len() < 104 {
282 return Err(ParseError::TooShortDataPart);
285 let raw_hrp: RawHrp = hrp.parse()?;
286 let data_part = RawDataPart::from_base32(&data[..data.len()-104])?;
288 Ok(SignedRawInvoice {
289 raw_invoice: RawInvoice {
293 hash: RawInvoice::hash_from_parts(
295 &data[..data.len()-104]
297 signature: InvoiceSignature::from_base32(&data[data.len()-104..])?,
302 impl FromStr for RawHrp {
303 type Err = ParseError;
305 fn from_str(hrp: &str) -> Result<Self, <Self as FromStr>::Err> {
306 let parts = parse_hrp(hrp)?;
308 let currency = parts.0.parse::<Currency>()?;
310 let amount = if !parts.1.is_empty() {
311 Some(parts.1.parse::<u64>()?)
316 let si_prefix: Option<SiPrefix> = if parts.2.is_empty() {
319 let si: SiPrefix = parts.2.parse()?;
320 if let Some(amt) = amount {
321 if amt.checked_mul(si.multiplier()).is_none() {
322 return Err(ParseError::IntegerOverflowError);
331 si_prefix: si_prefix,
336 impl FromBase32 for RawDataPart {
337 type Err = ParseError;
339 fn from_base32(data: &[u5]) -> Result<Self, Self::Err> {
340 if data.len() < 7 { // timestamp length
341 return Err(ParseError::TooShortDataPart);
344 let timestamp = PositiveTimestamp::from_base32(&data[0..7])?;
345 let tagged = parse_tagged_parts(&data[7..])?;
348 timestamp: timestamp,
349 tagged_fields: tagged,
354 impl FromBase32 for PositiveTimestamp {
355 type Err = ParseError;
357 fn from_base32(b32: &[u5]) -> Result<Self, Self::Err> {
359 return Err(ParseError::InvalidSliceLength("PositiveTimestamp::from_base32()".into()));
361 let timestamp: u64 = parse_int_be(b32, 32)
362 .expect("7*5bit < 64bit, no overflow possible");
363 match PositiveTimestamp::from_unix_timestamp(timestamp) {
365 Err(_) => unreachable!(),
370 impl FromBase32 for InvoiceSignature {
371 type Err = ParseError;
372 fn from_base32(signature: &[u5]) -> Result<Self, Self::Err> {
373 if signature.len() != 104 {
374 return Err(ParseError::InvalidSliceLength("InvoiceSignature::from_base32()".into()));
376 let recoverable_signature_bytes = Vec::<u8>::from_base32(signature)?;
377 let signature = &recoverable_signature_bytes[0..64];
378 let recovery_id = RecoveryId::from_i32(recoverable_signature_bytes[64] as i32)?;
380 Ok(InvoiceSignature(RecoverableSignature::from_compact(
387 pub(crate) fn parse_int_be<T, U>(digits: &[U], base: T) -> Option<T>
388 where T: CheckedAdd + CheckedMul + From<u8> + Default,
391 digits.iter().fold(Some(Default::default()), |acc, b|
393 .and_then(|x| x.checked_mul(&base))
394 .and_then(|x| x.checked_add(&(Into::<u8>::into(*b)).into()))
398 fn parse_tagged_parts(data: &[u5]) -> Result<Vec<RawTaggedField>, ParseError> {
399 let mut parts = Vec::<RawTaggedField>::new();
402 while !data.is_empty() {
404 return Err(ParseError::UnexpectedEndOfTaggedFields);
407 // Ignore tag at data[0], it will be handled in the TaggedField parsers and
408 // parse the length to find the end of the tagged field's data
409 let len = parse_int_be(&data[1..3], 32).expect("can't overflow");
410 let last_element = 3 + len;
412 if data.len() < last_element {
413 return Err(ParseError::UnexpectedEndOfTaggedFields);
416 // Get the tagged field's data slice
417 let field = &data[0..last_element];
419 // Set data slice to remaining data
420 data = &data[last_element..];
422 match TaggedField::from_base32(field) {
424 parts.push(RawTaggedField::KnownSemantics(field))
426 Err(ParseError::Skip)|Err(ParseError::Bech32Error(bech32::Error::InvalidLength)) => {
427 parts.push(RawTaggedField::UnknownSemantics(field.into()))
429 Err(e) => {return Err(e)}
435 impl FromBase32 for TaggedField {
436 type Err = ParseError;
438 fn from_base32(field: &[u5]) -> Result<TaggedField, ParseError> {
440 return Err(ParseError::UnexpectedEndOfTaggedFields);
444 let field_data = &field[3..];
447 constants::TAG_PAYMENT_HASH =>
448 Ok(TaggedField::PaymentHash(Sha256::from_base32(field_data)?)),
449 constants::TAG_DESCRIPTION =>
450 Ok(TaggedField::Description(Description::from_base32(field_data)?)),
451 constants::TAG_PAYEE_PUB_KEY =>
452 Ok(TaggedField::PayeePubKey(PayeePubKey::from_base32(field_data)?)),
453 constants::TAG_DESCRIPTION_HASH =>
454 Ok(TaggedField::DescriptionHash(Sha256::from_base32(field_data)?)),
455 constants::TAG_EXPIRY_TIME =>
456 Ok(TaggedField::ExpiryTime(ExpiryTime::from_base32(field_data)?)),
457 constants::TAG_MIN_FINAL_CLTV_EXPIRY_DELTA =>
458 Ok(TaggedField::MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta::from_base32(field_data)?)),
459 constants::TAG_FALLBACK =>
460 Ok(TaggedField::Fallback(Fallback::from_base32(field_data)?)),
461 constants::TAG_PRIVATE_ROUTE =>
462 Ok(TaggedField::PrivateRoute(PrivateRoute::from_base32(field_data)?)),
463 constants::TAG_PAYMENT_SECRET =>
464 Ok(TaggedField::PaymentSecret(PaymentSecret::from_base32(field_data)?)),
465 constants::TAG_FEATURES =>
466 Ok(TaggedField::Features(InvoiceFeatures::from_base32(field_data)?)),
468 // "A reader MUST skip over unknown fields"
469 Err(ParseError::Skip)
475 impl FromBase32 for Sha256 {
476 type Err = ParseError;
478 fn from_base32(field_data: &[u5]) -> Result<Sha256, ParseError> {
479 if field_data.len() != 52 {
480 // "A reader MUST skip over […] a p, [or] h […] field that does not have data_length 52 […]."
481 Err(ParseError::Skip)
483 Ok(Sha256(sha256::Hash::from_slice(&Vec::<u8>::from_base32(field_data)?)
484 .expect("length was checked before (52 u5 -> 32 u8)")))
489 impl FromBase32 for Description {
490 type Err = ParseError;
492 fn from_base32(field_data: &[u5]) -> Result<Description, ParseError> {
493 let bytes = Vec::<u8>::from_base32(field_data)?;
494 let description = String::from(str::from_utf8(&bytes)?);
495 Ok(Description::new(description).expect(
496 "Max len is 639=floor(1023*5/8) since the len field is only 10bits long"
501 impl FromBase32 for PayeePubKey {
502 type Err = ParseError;
504 fn from_base32(field_data: &[u5]) -> Result<PayeePubKey, ParseError> {
505 if field_data.len() != 53 {
506 // "A reader MUST skip over […] a n […] field that does not have data_length 53 […]."
507 Err(ParseError::Skip)
509 let data_bytes = Vec::<u8>::from_base32(field_data)?;
510 let pub_key = PublicKey::from_slice(&data_bytes)?;
516 impl FromBase32 for ExpiryTime {
517 type Err = ParseError;
519 fn from_base32(field_data: &[u5]) -> Result<ExpiryTime, ParseError> {
520 match parse_int_be::<u64, u5>(field_data, 32)
521 .map(|t| ExpiryTime::from_seconds(t))
524 None => Err(ParseError::IntegerOverflowError),
529 impl FromBase32 for MinFinalCltvExpiryDelta {
530 type Err = ParseError;
532 fn from_base32(field_data: &[u5]) -> Result<MinFinalCltvExpiryDelta, ParseError> {
533 let expiry = parse_int_be::<u64, u5>(field_data, 32);
534 if let Some(expiry) = expiry {
535 Ok(MinFinalCltvExpiryDelta(expiry))
537 Err(ParseError::IntegerOverflowError)
542 impl FromBase32 for Fallback {
543 type Err = ParseError;
545 fn from_base32(field_data: &[u5]) -> Result<Fallback, ParseError> {
546 if field_data.len() < 1 {
547 return Err(ParseError::UnexpectedEndOfTaggedFields);
550 let version = field_data[0];
551 let bytes = Vec::<u8>::from_base32(&field_data[1..])?;
553 match version.to_u8() {
555 if bytes.len() < 2 || bytes.len() > 40 {
556 return Err(ParseError::InvalidSegWitProgramLength);
558 let version = WitnessVersion::try_from(version).expect("0 through 16 are valid SegWit versions");
559 Ok(Fallback::SegWitProgram {
565 let pkh = match PubkeyHash::from_slice(&bytes) {
567 Err(bitcoin_hashes::Error::InvalidLength(_, _)) => return Err(ParseError::InvalidPubKeyHashLength),
569 Ok(Fallback::PubKeyHash(pkh))
572 let sh = match ScriptHash::from_slice(&bytes) {
574 Err(bitcoin_hashes::Error::InvalidLength(_, _)) => return Err(ParseError::InvalidScriptHashLength),
576 Ok(Fallback::ScriptHash(sh))
578 _ => Err(ParseError::Skip)
583 impl FromBase32 for PrivateRoute {
584 type Err = ParseError;
586 fn from_base32(field_data: &[u5]) -> Result<PrivateRoute, ParseError> {
587 let bytes = Vec::<u8>::from_base32(field_data)?;
589 if bytes.len() % 51 != 0 {
590 return Err(ParseError::UnexpectedEndOfTaggedFields);
593 let mut route_hops = Vec::<RouteHintHop>::new();
595 let mut bytes = bytes.as_slice();
596 while !bytes.is_empty() {
597 let hop_bytes = &bytes[0..51];
598 bytes = &bytes[51..];
600 let mut channel_id: [u8; 8] = Default::default();
601 channel_id.copy_from_slice(&hop_bytes[33..41]);
603 let hop = RouteHintHop {
604 src_node_id: PublicKey::from_slice(&hop_bytes[0..33])?,
605 short_channel_id: parse_int_be(&channel_id, 256).expect("short chan ID slice too big?"),
607 base_msat: parse_int_be(&hop_bytes[41..45], 256).expect("slice too big?"),
608 proportional_millionths: parse_int_be(&hop_bytes[45..49], 256).expect("slice too big?"),
610 cltv_expiry_delta: parse_int_be(&hop_bytes[49..51], 256).expect("slice too big?"),
611 htlc_minimum_msat: None,
612 htlc_maximum_msat: None,
615 route_hops.push(hop);
618 Ok(PrivateRoute(RouteHint(route_hops)))
622 impl Display for ParseError {
623 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
625 // TODO: find a way to combine the first three arms (e as error::Error?)
626 ParseError::Bech32Error(ref e) => {
627 write!(f, "Invalid bech32: {}", e)
629 ParseError::ParseAmountError(ref e) => {
630 write!(f, "Invalid amount in hrp ({})", e)
632 ParseError::MalformedSignature(ref e) => {
633 write!(f, "Invalid secp256k1 signature: {}", e)
635 ParseError::DescriptionDecodeError(ref e) => {
636 write!(f, "Description is not a valid utf-8 string: {}", e)
638 ParseError::InvalidSliceLength(ref function) => {
639 write!(f, "Slice in function {} had the wrong length", function)
641 ParseError::BadPrefix => f.write_str("did not begin with 'ln'"),
642 ParseError::UnknownCurrency => f.write_str("currency code unknown"),
643 ParseError::UnknownSiPrefix => f.write_str("unknown SI prefix"),
644 ParseError::MalformedHRP => f.write_str("malformed human readable part"),
645 ParseError::TooShortDataPart => {
646 f.write_str("data part too short (should be at least 111 bech32 chars long)")
648 ParseError::UnexpectedEndOfTaggedFields => {
649 f.write_str("tagged fields part ended unexpectedly")
651 ParseError::PaddingError => f.write_str("some data field had bad padding"),
652 ParseError::IntegerOverflowError => {
653 f.write_str("parsed integer doesn't fit into receiving type")
655 ParseError::InvalidSegWitProgramLength => {
656 f.write_str("fallback SegWit program is too long or too short")
658 ParseError::InvalidPubKeyHashLength => {
659 f.write_str("fallback public key hash has a length unequal 20 bytes")
661 ParseError::InvalidScriptHashLength => {
662 f.write_str("fallback script hash has a length unequal 32 bytes")
664 ParseError::InvalidRecoveryId => {
665 f.write_str("recovery id is out of range (should be in [0,3])")
667 ParseError::Skip => {
668 f.write_str("the tagged field has to be skipped because of an unexpected, but allowed property")
674 impl Display for ParseOrSemanticError {
675 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
677 ParseOrSemanticError::ParseError(err) => err.fmt(f),
678 ParseOrSemanticError::SemanticError(err) => err.fmt(f),
683 #[cfg(feature = "std")]
684 impl error::Error for ParseError {}
686 #[cfg(feature = "std")]
687 impl error::Error for ParseOrSemanticError {}
689 macro_rules! from_error {
690 ($my_error:expr, $extern_error:ty) => {
691 impl From<$extern_error> for ParseError {
692 fn from(e: $extern_error) -> Self {
699 from_error!(ParseError::MalformedSignature, secp256k1::Error);
700 from_error!(ParseError::ParseAmountError, ParseIntError);
701 from_error!(ParseError::DescriptionDecodeError, str::Utf8Error);
703 impl From<bech32::Error> for ParseError {
704 fn from(e: bech32::Error) -> Self {
706 bech32::Error::InvalidPadding => ParseError::PaddingError,
707 _ => ParseError::Bech32Error(e)
712 impl From<ParseError> for ParseOrSemanticError {
713 fn from(e: ParseError) -> Self {
714 ParseOrSemanticError::ParseError(e)
718 impl From<crate::SemanticError> for ParseOrSemanticError {
719 fn from(e: SemanticError) -> Self {
720 ParseOrSemanticError::SemanticError(e)
726 use crate::de::ParseError;
727 use secp256k1::PublicKey;
729 use bitcoin_hashes::hex::FromHex;
730 use bitcoin_hashes::sha256;
732 const CHARSET_REV: [i8; 128] = [
733 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
734 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
735 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
736 15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1,
737 -1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
738 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1,
739 -1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
740 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1
743 fn from_bech32(bytes_5b: &[u8]) -> Vec<u5> {
746 .map(|c| u5::try_from_u8(CHARSET_REV[*c as usize] as u8).unwrap())
751 fn test_parse_currency_prefix() {
754 assert_eq!("bc".parse::<Currency>(), Ok(Currency::Bitcoin));
755 assert_eq!("tb".parse::<Currency>(), Ok(Currency::BitcoinTestnet));
756 assert_eq!("bcrt".parse::<Currency>(), Ok(Currency::Regtest));
757 assert_eq!("sb".parse::<Currency>(), Ok(Currency::Simnet));
758 assert_eq!("tbs".parse::<Currency>(), Ok(Currency::Signet));
759 assert_eq!("something_else".parse::<Currency>(), Err(ParseError::UnknownCurrency))
763 fn test_parse_int_from_bytes_be() {
764 use crate::de::parse_int_be;
766 assert_eq!(parse_int_be::<u32, u8>(&[1, 2, 3, 4], 256), Some(16909060));
767 assert_eq!(parse_int_be::<u32, u8>(&[1, 3], 32), Some(35));
768 assert_eq!(parse_int_be::<u32, u8>(&[255, 255, 255, 255], 256), Some(4294967295));
769 assert_eq!(parse_int_be::<u32, u8>(&[1, 0, 0, 0, 0], 256), None);
773 fn test_parse_sha256_hash() {
775 use bech32::FromBase32;
777 let input = from_bech32(
778 "qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypq".as_bytes()
781 let hash = sha256::Hash::from_hex(
782 "0001020304050607080900010203040506070809000102030405060708090102"
784 let expected = Ok(Sha256(hash));
786 assert_eq!(Sha256::from_base32(&input), expected);
788 // make sure hashes of unknown length get skipped
789 let input_unexpected_length = from_bech32(
790 "qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypyq".as_bytes()
792 assert_eq!(Sha256::from_base32(&input_unexpected_length), Err(ParseError::Skip));
796 fn test_parse_description() {
797 use crate::Description;
798 use bech32::FromBase32;
800 let input = from_bech32("xysxxatsyp3k7enxv4js".as_bytes());
801 let expected = Ok(Description::new("1 cup coffee".to_owned()).unwrap());
802 assert_eq!(Description::from_base32(&input), expected);
806 fn test_parse_payee_pub_key() {
807 use crate::PayeePubKey;
808 use bech32::FromBase32;
810 let input = from_bech32("q0n326hr8v9zprg8gsvezcch06gfaqqhde2aj730yg0durunfhv66".as_bytes());
812 0x03, 0xe7, 0x15, 0x6a, 0xe3, 0x3b, 0x0a, 0x20, 0x8d, 0x07, 0x44, 0x19, 0x91, 0x63,
813 0x17, 0x7e, 0x90, 0x9e, 0x80, 0x17, 0x6e, 0x55, 0xd9, 0x7a, 0x2f, 0x22, 0x1e, 0xde,
814 0x0f, 0x93, 0x4d, 0xd9, 0xad
816 let expected = Ok(PayeePubKey(
817 PublicKey::from_slice(&pk_bytes[..]).unwrap()
820 assert_eq!(PayeePubKey::from_base32(&input), expected);
823 let input_unexpected_length = from_bech32(
824 "q0n326hr8v9zprg8gsvezcch06gfaqqhde2aj730yg0durunfhvq".as_bytes()
826 assert_eq!(PayeePubKey::from_base32(&input_unexpected_length), Err(ParseError::Skip));
830 fn test_parse_expiry_time() {
831 use crate::ExpiryTime;
832 use bech32::FromBase32;
834 let input = from_bech32("pu".as_bytes());
835 let expected = Ok(ExpiryTime::from_seconds(60));
836 assert_eq!(ExpiryTime::from_base32(&input), expected);
838 let input_too_large = from_bech32("sqqqqqqqqqqqq".as_bytes());
839 assert_eq!(ExpiryTime::from_base32(&input_too_large), Err(ParseError::IntegerOverflowError));
843 fn test_parse_min_final_cltv_expiry_delta() {
844 use crate::MinFinalCltvExpiryDelta;
845 use bech32::FromBase32;
847 let input = from_bech32("pr".as_bytes());
848 let expected = Ok(MinFinalCltvExpiryDelta(35));
850 assert_eq!(MinFinalCltvExpiryDelta::from_base32(&input), expected);
854 fn test_parse_fallback() {
856 use bech32::FromBase32;
857 use bitcoin::{PubkeyHash, ScriptHash};
858 use bitcoin::util::address::WitnessVersion;
859 use bitcoin_hashes::Hash;
863 from_bech32("3x9et2e20v6pu37c5d9vax37wxq72un98".as_bytes()),
864 Ok(Fallback::PubKeyHash(PubkeyHash::from_slice(&[
865 0x31, 0x72, 0xb5, 0x65, 0x4f, 0x66, 0x83, 0xc8, 0xfb, 0x14, 0x69, 0x59, 0xd3,
866 0x47, 0xce, 0x30, 0x3c, 0xae, 0x4c, 0xa7
870 from_bech32("j3a24vwu6r8ejrss3axul8rxldph2q7z9".as_bytes()),
871 Ok(Fallback::ScriptHash(ScriptHash::from_slice(&[
872 0x8f, 0x55, 0x56, 0x3b, 0x9a, 0x19, 0xf3, 0x21, 0xc2, 0x11, 0xe9, 0xb9, 0xf3,
873 0x8c, 0xdf, 0x68, 0x6e, 0xa0, 0x78, 0x45
877 from_bech32("qw508d6qejxtdg4y5r3zarvary0c5xw7k".as_bytes()),
878 Ok(Fallback::SegWitProgram {
879 version: WitnessVersion::V0,
880 program: Vec::from(&[
881 0x75u8, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54, 0x94, 0x1c, 0x45,
882 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
887 vec![u5::try_from_u8(21).unwrap(); 41],
888 Err(ParseError::Skip)
892 Err(ParseError::UnexpectedEndOfTaggedFields)
895 vec![u5::try_from_u8(1).unwrap(); 81],
896 Err(ParseError::InvalidSegWitProgramLength)
899 vec![u5::try_from_u8(17).unwrap(); 1],
900 Err(ParseError::InvalidPubKeyHashLength)
903 vec![u5::try_from_u8(18).unwrap(); 1],
904 Err(ParseError::InvalidScriptHashLength)
908 for (input, expected) in cases.into_iter() {
909 assert_eq!(Fallback::from_base32(&input), expected);
914 fn test_parse_route() {
915 use lightning::routing::gossip::RoutingFees;
916 use lightning::routing::router::{RouteHint, RouteHintHop};
917 use crate::PrivateRoute;
918 use bech32::FromBase32;
919 use crate::de::parse_int_be;
921 let input = from_bech32(
922 "q20q82gphp2nflc7jtzrcazrra7wwgzxqc8u7754cdlpfrmccae92qgzqvzq2ps8pqqqqqqpqqqqq9qqqvpeuqa\
923 fqxu92d8lr6fvg0r5gv0heeeqgcrqlnm6jhphu9y00rrhy4grqszsvpcgpy9qqqqqqgqqqqq7qqzq".as_bytes()
926 let mut expected = Vec::<RouteHintHop>::new();
927 expected.push(RouteHintHop {
928 src_node_id: PublicKey::from_slice(
930 0x02u8, 0x9e, 0x03, 0xa9, 0x01, 0xb8, 0x55, 0x34, 0xff, 0x1e, 0x92, 0xc4, 0x3c,
931 0x74, 0x43, 0x1f, 0x7c, 0xe7, 0x20, 0x46, 0x06, 0x0f, 0xcf, 0x7a, 0x95, 0xc3,
932 0x7e, 0x14, 0x8f, 0x78, 0xc7, 0x72, 0x55
935 short_channel_id: parse_int_be(&[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08], 256).expect("short chan ID slice too big?"),
938 proportional_millionths: 20,
940 cltv_expiry_delta: 3,
941 htlc_minimum_msat: None,
942 htlc_maximum_msat: None
944 expected.push(RouteHintHop {
945 src_node_id: PublicKey::from_slice(
947 0x03u8, 0x9e, 0x03, 0xa9, 0x01, 0xb8, 0x55, 0x34, 0xff, 0x1e, 0x92, 0xc4, 0x3c,
948 0x74, 0x43, 0x1f, 0x7c, 0xe7, 0x20, 0x46, 0x06, 0x0f, 0xcf, 0x7a, 0x95, 0xc3,
949 0x7e, 0x14, 0x8f, 0x78, 0xc7, 0x72, 0x55
952 short_channel_id: parse_int_be(&[0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a], 256).expect("short chan ID slice too big?"),
955 proportional_millionths: 30,
957 cltv_expiry_delta: 4,
958 htlc_minimum_msat: None,
959 htlc_maximum_msat: None
962 assert_eq!(PrivateRoute::from_base32(&input), Ok(PrivateRoute(RouteHint(expected))));
965 PrivateRoute::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]),
966 Err(ParseError::UnexpectedEndOfTaggedFields)
971 fn test_payment_secret_and_features_de_and_ser() {
972 use lightning::ln::features::InvoiceFeatures;
973 use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
974 use crate::TaggedField::*;
975 use crate::{SiPrefix, SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart,
976 Currency, Sha256, PositiveTimestamp};
978 // Feature bits 9, 15, and 99 are set.
979 let expected_features = InvoiceFeatures::from_le_bytes(vec![0, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8]);
980 let invoice_str = "lnbc25m1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdq5vdhkven9v5sxyetpdeessp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygs9q5sqqqqqqqqqqqqqqqpqsq67gye39hfg3zd8rgc80k32tvy9xk2xunwm5lzexnvpx6fd77en8qaq424dxgt56cag2dpt359k3ssyhetktkpqh24jqnjyw6uqd08sgptq44qu";
981 let invoice = SignedRawInvoice {
982 raw_invoice: RawInvoice {
984 currency: Currency::Bitcoin,
985 raw_amount: Some(25),
986 si_prefix: Some(SiPrefix::Milli)
989 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
990 tagged_fields: vec ! [
991 PaymentHash(Sha256(sha256::Hash::from_hex(
992 "0001020304050607080900010203040506070809000102030405060708090102"
994 Description(crate::Description::new("coffee beans".to_owned()).unwrap()).into(),
995 PaymentSecret(crate::PaymentSecret([17; 32])).into(),
996 Features(expected_features).into()]}
998 hash: [0xb1, 0x96, 0x46, 0xc3, 0xbc, 0x56, 0x76, 0x1d, 0x20, 0x65, 0x6e, 0x0e, 0x32,
999 0xec, 0xd2, 0x69, 0x27, 0xb7, 0x62, 0x6e, 0x2a, 0x8b, 0xe6, 0x97, 0x71, 0x9f,
1000 0xf8, 0x7e, 0x44, 0x54, 0x55, 0xb9],
1001 signature: InvoiceSignature(RecoverableSignature::from_compact(
1002 &[0xd7, 0x90, 0x4c, 0xc4, 0xb7, 0x4a, 0x22, 0x26, 0x9c, 0x68, 0xc1, 0xdf, 0x68,
1003 0xa9, 0x6c, 0x21, 0x4d, 0x65, 0x1b, 0x93, 0x76, 0xe9, 0xf1, 0x64, 0xd3, 0x60,
1004 0x4d, 0xa4, 0xb7, 0xde, 0xcc, 0xce, 0x0e, 0x82, 0xaa, 0xab, 0x4c, 0x85, 0xd3,
1005 0x58, 0xea, 0x14, 0xd0, 0xae, 0x34, 0x2d, 0xa3, 0x08, 0x12, 0xf9, 0x5d, 0x97,
1006 0x60, 0x82, 0xea, 0xac, 0x81, 0x39, 0x11, 0xda, 0xe0, 0x1a, 0xf3, 0xc1],
1007 RecoveryId::from_i32(1).unwrap()
1010 assert_eq!(invoice_str, invoice.to_string());
1012 invoice_str.parse(),
1018 fn test_raw_signed_invoice_deserialization() {
1019 use crate::TaggedField::*;
1020 use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
1021 use crate::{SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256,
1025 "lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmw\
1026 wd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d73gafnh3cax9rn449d9p5uxz9\
1027 ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ecky03ylcqca784w".parse(),
1028 Ok(SignedRawInvoice {
1029 raw_invoice: RawInvoice {
1031 currency: Currency::Bitcoin,
1036 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1037 tagged_fields: vec ! [
1038 PaymentHash(Sha256(sha256::Hash::from_hex(
1039 "0001020304050607080900010203040506070809000102030405060708090102"
1040 ).unwrap())).into(),
1042 crate::Description::new(
1043 "Please consider supporting this project".to_owned()
1050 0xc3, 0xd4, 0xe8, 0x3f, 0x64, 0x6f, 0xa7, 0x9a, 0x39, 0x3d, 0x75, 0x27,
1051 0x7b, 0x1d, 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7,
1052 0x83, 0x5d, 0xb2, 0xec, 0xd5, 0x18, 0xe1, 0xc9
1054 signature: InvoiceSignature(RecoverableSignature::from_compact(
1056 0x38u8, 0xec, 0x68, 0x91, 0x34, 0x5e, 0x20, 0x41, 0x45, 0xbe, 0x8a,
1057 0x3a, 0x99, 0xde, 0x38, 0xe9, 0x8a, 0x39, 0xd6, 0xa5, 0x69, 0x43,
1058 0x4e, 0x18, 0x45, 0xc8, 0xaf, 0x72, 0x05, 0xaf, 0xcf, 0xcc, 0x7f,
1059 0x42, 0x5f, 0xcd, 0x14, 0x63, 0xe9, 0x3c, 0x32, 0x88, 0x1e, 0xad,
1060 0x0d, 0x6e, 0x35, 0x6d, 0x46, 0x7e, 0xc8, 0xc0, 0x25, 0x53, 0xf9,
1061 0xaa, 0xb1, 0x5e, 0x57, 0x38, 0xb1, 0x1f, 0x12, 0x7f
1063 RecoveryId::from_i32(0).unwrap()