_ Git - rust-lightning/blob - lightning-invoice/src/lib.rs

   1 // Prefix these with `rustdoc::` when we update our MSRV to be >= 1.52 to remove warnings.
   2 #![deny(broken_intra_doc_links)]
   3 #![deny(private_intra_doc_links)]
   4
   5 #![deny(missing_docs)]
   6 #![deny(non_upper_case_globals)]
   7 #![deny(non_camel_case_types)]
   8 #![deny(non_snake_case)]
   9 #![deny(unused_mut)]
  10
  11 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
  12
  13 #![cfg_attr(feature = "strict", deny(warnings))]
  14 #![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
  15
  16 //! This crate provides data structures to represent
  17 //! [lightning BOLT11](https://github.com/lightning/bolts/blob/master/11-payment-encoding.md)
  18 //! invoices and functions to create, encode and decode these. If you just want to use the standard
  19 //! en-/decoding functionality this should get you started:
  20 //!
  21 //!   * For parsing use `str::parse::<Invoice>(&self)` (see [`Invoice::from_str`])
  22 //!   * For constructing invoices use the [`InvoiceBuilder`]
  23 //!   * For serializing invoices use the [`Display`]/[`ToString`] traits
  24 //!
  25 //! [`Invoice::from_str`]: crate::Invoice#impl-FromStr
  26
  27 #[cfg(not(any(feature = "std", feature = "no-std")))]
  28 compile_error!("at least one of the `std` or `no-std` features must be enabled");
  29
  30 pub mod payment;
  31 pub mod utils;
  32
  33 pub(crate) mod time_utils;
  34
  35 extern crate bech32;
  36 extern crate bitcoin_hashes;
  37 #[macro_use] extern crate lightning;
  38 extern crate num_traits;
  39 extern crate secp256k1;
  40 extern crate alloc;
  41 #[cfg(any(test, feature = "std"))]
  42 extern crate core;
  43 #[cfg(feature = "serde")]
  44 extern crate serde;
  45
  46 #[cfg(feature = "std")]
  47 use std::time::SystemTime;
  48
  49 use bech32::u5;
  50 use bitcoin::{Address, Network, PubkeyHash, ScriptHash};
  51 use bitcoin::util::address::{Payload, WitnessVersion};
  52 use bitcoin_hashes::{Hash, sha256};
  53 use lightning::ln::PaymentSecret;
  54 use lightning::ln::features::InvoiceFeatures;
  55 #[cfg(any(doc, test))]
  56 use lightning::routing::gossip::RoutingFees;
  57 use lightning::routing::router::RouteHint;
  58 use lightning::util::invoice::construct_invoice_preimage;
  59
  60 use secp256k1::PublicKey;
  61 use secp256k1::{Message, Secp256k1};
  62 use secp256k1::ecdsa::RecoverableSignature;
  63
  64 use core::fmt::{Display, Formatter, self};
  65 use core::iter::FilterMap;
  66 use core::num::ParseIntError;
  67 use core::ops::Deref;
  68 use core::slice::Iter;
  69 use core::time::Duration;
  70 use core::str;
  71
  72 #[cfg(feature = "serde")]
  73 use serde::{Deserialize, Deserializer,Serialize, Serializer, de::Error};
  74
  75 mod de;
  76 mod ser;
  77 mod tb;
  78
  79 mod prelude {
  80         #[cfg(feature = "hashbrown")]
  81         extern crate hashbrown;
  82
  83         pub use alloc::{vec, vec::Vec, string::String, collections::VecDeque, boxed::Box};
  84         #[cfg(not(feature = "hashbrown"))]
  85         pub use std::collections::{HashMap, HashSet, hash_map};
  86         #[cfg(feature = "hashbrown")]
  87         pub use self::hashbrown::{HashMap, HashSet, hash_map};
  88
  89         pub use alloc::string::ToString;
  90 }
  91
  92 use crate::prelude::*;
  93
  94 /// Sync compat for std/no_std
  95 #[cfg(feature = "std")]
  96 mod sync {
  97         pub use ::std::sync::{Mutex, MutexGuard};
  98 }
  99
 100 /// Sync compat for std/no_std
 101 #[cfg(not(feature = "std"))]
 102 mod sync;
 103
 104 /// Errors that indicate what is wrong with the invoice. They have some granularity for debug
 105 /// reasons, but should generally result in an "invalid BOLT11 invoice" message for the user.
 106 #[allow(missing_docs)]
 107 #[derive(PartialEq, Eq, Debug, Clone)]
 108 pub enum ParseError {
 109         Bech32Error(bech32::Error),
 110         ParseAmountError(ParseIntError),
 111         MalformedSignature(secp256k1::Error),
 112         BadPrefix,
 113         UnknownCurrency,
 114         UnknownSiPrefix,
 115         MalformedHRP,
 116         TooShortDataPart,
 117         UnexpectedEndOfTaggedFields,
 118         DescriptionDecodeError(str::Utf8Error),
 119         PaddingError,
 120         IntegerOverflowError,
 121         InvalidSegWitProgramLength,
 122         InvalidPubKeyHashLength,
 123         InvalidScriptHashLength,
 124         InvalidRecoveryId,
 125         InvalidSliceLength(String),
 126
 127         /// Not an error, but used internally to signal that a part of the invoice should be ignored
 128         /// according to BOLT11
 129         Skip,
 130 }
 131
 132 /// Indicates that something went wrong while parsing or validating the invoice. Parsing errors
 133 /// should be mostly seen as opaque and are only there for debugging reasons. Semantic errors
 134 /// like wrong signatures, missing fields etc. could mean that someone tampered with the invoice.
 135 #[derive(PartialEq, Eq, Debug, Clone)]
 136 pub enum ParseOrSemanticError {
 137         /// The invoice couldn't be decoded
 138         ParseError(ParseError),
 139
 140         /// The invoice could be decoded but violates the BOLT11 standard
 141         SemanticError(crate::SemanticError),
 142 }
 143
 144 /// The number of bits used to represent timestamps as defined in BOLT 11.
 145 const TIMESTAMP_BITS: usize = 35;
 146
 147 /// The maximum timestamp as [`Duration::as_secs`] since the Unix epoch allowed by [`BOLT 11`].
 148 ///
 149 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
 150 pub const MAX_TIMESTAMP: u64 = (1 << TIMESTAMP_BITS) - 1;
 151
 152 /// Default expiry time as defined by [BOLT 11].
 153 ///
 154 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
 155 pub const DEFAULT_EXPIRY_TIME: u64 = 3600;
 156
 157 /// Default minimum final CLTV expiry as defined by [BOLT 11].
 158 ///
 159 /// Note that this is *not* the same value as rust-lightning's minimum CLTV expiry, which is
 160 /// provided in [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
 161 ///
 162 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
 163 /// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
 164 pub const DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA: u64 = 18;
 165
 166 /// Builder for [`Invoice`]s. It's the most convenient and advised way to use this library. It ensures
 167 /// that only a semantically and syntactically correct Invoice can be built using it.
 168 ///
 169 /// ```
 170 /// extern crate secp256k1;
 171 /// extern crate lightning;
 172 /// extern crate lightning_invoice;
 173 /// extern crate bitcoin_hashes;
 174 ///
 175 /// use bitcoin_hashes::Hash;
 176 /// use bitcoin_hashes::sha256;
 177 ///
 178 /// use secp256k1::Secp256k1;
 179 /// use secp256k1::SecretKey;
 180 ///
 181 /// use lightning::ln::PaymentSecret;
 182 ///
 183 /// use lightning_invoice::{Currency, InvoiceBuilder};
 184 ///
 185 /// # #[cfg(not(feature = "std"))]
 186 /// # fn main() {}
 187 /// # #[cfg(feature = "std")]
 188 /// # fn main() {
 189 /// let private_key = SecretKey::from_slice(
 190 ///             &[
 191 ///                     0xe1, 0x26, 0xf6, 0x8f, 0x7e, 0xaf, 0xcc, 0x8b, 0x74, 0xf5, 0x4d, 0x26, 0x9f,
 192 ///                     0xe2, 0x06, 0xbe, 0x71, 0x50, 0x00, 0xf9, 0x4d, 0xac, 0x06, 0x7d, 0x1c, 0x04,
 193 ///             0xa8, 0xca, 0x3b, 0x2d, 0xb7, 0x34
 194 ///     ][..]
 195 ///     ).unwrap();
 196 ///
 197 /// let payment_hash = sha256::Hash::from_slice(&[0; 32][..]).unwrap();
 198 /// let payment_secret = PaymentSecret([42u8; 32]);
 199 ///
 200 /// let invoice = InvoiceBuilder::new(Currency::Bitcoin)
 201 ///     .description("Coins pls!".into())
 202 ///     .payment_hash(payment_hash)
 203 ///     .payment_secret(payment_secret)
 204 ///     .current_timestamp()
 205 ///     .min_final_cltv_expiry_delta(144)
 206 ///     .build_signed(|hash| {
 207 ///             Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)
 208 ///     })
 209 ///     .unwrap();
 210 ///
 211 /// assert!(invoice.to_string().starts_with("lnbc1"));
 212 /// # }
 213 /// ```
 214 ///
 215 /// # Type parameters
 216 /// The two parameters `D` and `H` signal if the builder already contains the correct amount of the
 217 /// given field:
 218 ///  * `D`: exactly one [`TaggedField::Description`] or [`TaggedField::DescriptionHash`]
 219 ///  * `H`: exactly one [`TaggedField::PaymentHash`]
 220 ///  * `T`: the timestamp is set
 221 ///
 222 /// This is not exported to bindings users as we likely need to manually select one set of boolean type parameters.
 223 #[derive(Eq, PartialEq, Debug, Clone)]
 224 pub struct InvoiceBuilder<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool> {
 225         currency: Currency,
 226         amount: Option<u64>,
 227         si_prefix: Option<SiPrefix>,
 228         timestamp: Option<PositiveTimestamp>,
 229         tagged_fields: Vec<TaggedField>,
 230         error: Option<CreationError>,
 231
 232         phantom_d: core::marker::PhantomData<D>,
 233         phantom_h: core::marker::PhantomData<H>,
 234         phantom_t: core::marker::PhantomData<T>,
 235         phantom_c: core::marker::PhantomData<C>,
 236         phantom_s: core::marker::PhantomData<S>,
 237 }
 238
 239 /// Represents a syntactically and semantically correct lightning BOLT11 invoice.
 240 ///
 241 /// There are three ways to construct an `Invoice`:
 242 ///  1. using [`InvoiceBuilder`]
 243 ///  2. using [`Invoice::from_signed`]
 244 ///  3. using `str::parse::<Invoice>(&str)` (see [`Invoice::from_str`])
 245 ///
 246 /// [`Invoice::from_str`]: crate::Invoice#impl-FromStr
 247 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 248 pub struct Invoice {
 249         signed_invoice: SignedRawInvoice,
 250 }
 251
 252 /// Represents the description of an invoice which has to be either a directly included string or
 253 /// a hash of a description provided out of band.
 254 ///
 255 /// This is not exported to bindings users as we don't have a good way to map the reference lifetimes making this
 256 /// practically impossible to use safely in languages like C.
 257 #[derive(Eq, PartialEq, Debug, Clone)]
 258 pub enum InvoiceDescription<'f> {
 259         /// Reference to the directly supplied description in the invoice
 260         Direct(&'f Description),
 261
 262         /// Reference to the description's hash included in the invoice
 263         Hash(&'f Sha256),
 264 }
 265
 266 /// Represents a signed [`RawInvoice`] with cached hash. The signature is not checked and may be
 267 /// invalid.
 268 ///
 269 /// # Invariants
 270 /// The hash has to be either from the deserialized invoice or from the serialized [`RawInvoice`].
 271 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 272 pub struct SignedRawInvoice {
 273         /// The rawInvoice that the signature belongs to
 274         raw_invoice: RawInvoice,
 275
 276         /// Hash of the [`RawInvoice`] that will be used to check the signature.
 277         ///
 278         /// * if the `SignedRawInvoice` was deserialized the hash is of from the original encoded form,
 279         /// since it's not guaranteed that encoding it again will lead to the same result since integers
 280         /// could have been encoded with leading zeroes etc.
 281         /// * if the `SignedRawInvoice` was constructed manually the hash will be the calculated hash
 282         /// from the [`RawInvoice`]
 283         hash: [u8; 32],
 284
 285         /// signature of the payment request
 286         signature: InvoiceSignature,
 287 }
 288
 289 /// Represents an syntactically correct [`Invoice`] for a payment on the lightning network,
 290 /// but without the signature information.
 291 /// Decoding and encoding should not lead to information loss but may lead to different hashes.
 292 ///
 293 /// For methods without docs see the corresponding methods in [`Invoice`].
 294 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 295 pub struct RawInvoice {
 296         /// human readable part
 297         pub hrp: RawHrp,
 298
 299         /// data part
 300         pub data: RawDataPart,
 301 }
 302
 303 /// Data of the [`RawInvoice`] that is encoded in the human readable part.
 304 ///
 305 /// This is not exported to bindings users as we don't yet support `Option<Enum>`
 306 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 307 pub struct RawHrp {
 308         /// The currency deferred from the 3rd and 4th character of the bech32 transaction
 309         pub currency: Currency,
 310
 311         /// The amount that, multiplied by the SI prefix, has to be payed
 312         pub raw_amount: Option<u64>,
 313
 314         /// SI prefix that gets multiplied with the `raw_amount`
 315         pub si_prefix: Option<SiPrefix>,
 316 }
 317
 318 /// Data of the [`RawInvoice`] that is encoded in the data part
 319 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 320 pub struct RawDataPart {
 321         /// generation time of the invoice
 322         pub timestamp: PositiveTimestamp,
 323
 324         /// tagged fields of the payment request
 325         pub tagged_fields: Vec<RawTaggedField>,
 326 }
 327
 328 /// A timestamp that refers to a date after 1 January 1970.
 329 ///
 330 /// # Invariants
 331 ///
 332 /// The Unix timestamp representing the stored time has to be positive and no greater than
 333 /// [`MAX_TIMESTAMP`].
 334 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
 335 pub struct PositiveTimestamp(Duration);
 336
 337 /// SI prefixes for the human readable part
 338 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
 339 pub enum SiPrefix {
 340         /// 10^-3
 341         Milli,
 342         /// 10^-6
 343         Micro,
 344         /// 10^-9
 345         Nano,
 346         /// 10^-12
 347         Pico,
 348 }
 349
 350 impl SiPrefix {
 351         /// Returns the multiplier to go from a BTC value to picoBTC implied by this SiPrefix.
 352         /// This is effectively 10^12 * the prefix multiplier
 353         pub fn multiplier(&self) -> u64 {
 354                 match *self {
 355                         SiPrefix::Milli => 1_000_000_000,
 356                         SiPrefix::Micro => 1_000_000,
 357                         SiPrefix::Nano => 1_000,
 358                         SiPrefix::Pico => 1,
 359                 }
 360         }
 361
 362         /// Returns all enum variants of `SiPrefix` sorted in descending order of their associated
 363         /// multiplier.
 364         ///
 365         /// This is not exported to bindings users as we don't yet support a slice of enums, and also because this function
 366         /// isn't the most critical to expose.
 367         pub fn values_desc() -> &'static [SiPrefix] {
 368                 use crate::SiPrefix::*;
 369                 static VALUES: [SiPrefix; 4] = [Milli, Micro, Nano, Pico];
 370                 &VALUES
 371         }
 372 }
 373
 374 /// Enum representing the crypto currencies (or networks) supported by this library
 375 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 376 pub enum Currency {
 377         /// Bitcoin mainnet
 378         Bitcoin,
 379
 380         /// Bitcoin testnet
 381         BitcoinTestnet,
 382
 383         /// Bitcoin regtest
 384         Regtest,
 385
 386         /// Bitcoin simnet
 387         Simnet,
 388
 389         /// Bitcoin signet
 390         Signet,
 391 }
 392
 393 /// Tagged field which may have an unknown tag
 394 ///
 395 /// This is not exported to bindings users as we don't currently support TaggedField
 396 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 397 pub enum RawTaggedField {
 398         /// Parsed tagged field with known tag
 399         KnownSemantics(TaggedField),
 400         /// tagged field which was not parsed due to an unknown tag or undefined field semantics
 401         UnknownSemantics(Vec<u5>),
 402 }
 403
 404 /// Tagged field with known tag
 405 ///
 406 /// For descriptions of the enum values please refer to the enclosed type's docs.
 407 ///
 408 /// This is not exported to bindings users as we don't yet support enum variants with the same name the struct contained
 409 /// in the variant.
 410 #[allow(missing_docs)]
 411 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 412 pub enum TaggedField {
 413         PaymentHash(Sha256),
 414         Description(Description),
 415         PayeePubKey(PayeePubKey),
 416         DescriptionHash(Sha256),
 417         ExpiryTime(ExpiryTime),
 418         MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta),
 419         Fallback(Fallback),
 420         PrivateRoute(PrivateRoute),
 421         PaymentSecret(PaymentSecret),
 422         PaymentMetadata(Vec<u8>),
 423         Features(InvoiceFeatures),
 424 }
 425
 426 /// SHA-256 hash
 427 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 428 pub struct Sha256(/// This is not exported to bindings users as the native hash types are not currently mapped
 429         pub sha256::Hash);
 430
 431 /// Description string
 432 ///
 433 /// # Invariants
 434 /// The description can be at most 639 __bytes__ long
 435 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 436 pub struct Description(String);
 437
 438 /// Payee public key
 439 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 440 pub struct PayeePubKey(pub PublicKey);
 441
 442 /// Positive duration that defines when (relatively to the timestamp) in the future the invoice
 443 /// expires
 444 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 445 pub struct ExpiryTime(Duration);
 446
 447 /// `min_final_cltv_expiry_delta` to use for the last HTLC in the route
 448 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 449 pub struct MinFinalCltvExpiryDelta(pub u64);
 450
 451 /// Fallback address in case no LN payment is possible
 452 #[allow(missing_docs)]
 453 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 454 pub enum Fallback {
 455         SegWitProgram {
 456                 version: WitnessVersion,
 457                 program: Vec<u8>,
 458         },
 459         PubKeyHash(PubkeyHash),
 460         ScriptHash(ScriptHash),
 461 }
 462
 463 /// Recoverable signature
 464 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 465 pub struct InvoiceSignature(pub RecoverableSignature);
 466
 467 /// Private routing information
 468 ///
 469 /// # Invariants
 470 /// The encoded route has to be <1024 5bit characters long (<=639 bytes or <=12 hops)
 471 ///
 472 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 473 pub struct PrivateRoute(RouteHint);
 474
 475 /// Tag constants as specified in BOLT11
 476 #[allow(missing_docs)]
 477 pub mod constants {
 478         pub const TAG_PAYMENT_HASH: u8 = 1;
 479         pub const TAG_DESCRIPTION: u8 = 13;
 480         pub const TAG_PAYEE_PUB_KEY: u8 = 19;
 481         pub const TAG_DESCRIPTION_HASH: u8 = 23;
 482         pub const TAG_EXPIRY_TIME: u8 = 6;
 483         pub const TAG_MIN_FINAL_CLTV_EXPIRY_DELTA: u8 = 24;
 484         pub const TAG_FALLBACK: u8 = 9;
 485         pub const TAG_PRIVATE_ROUTE: u8 = 3;
 486         pub const TAG_PAYMENT_SECRET: u8 = 16;
 487         pub const TAG_PAYMENT_METADATA: u8 = 27;
 488         pub const TAG_FEATURES: u8 = 5;
 489 }
 490
 491 impl InvoiceBuilder<tb::False, tb::False, tb::False, tb::False, tb::False> {
 492         /// Construct new, empty `InvoiceBuilder`. All necessary fields have to be filled first before
 493         /// `InvoiceBuilder::build(self)` becomes available.
 494         pub fn new(currrency: Currency) -> Self {
 495                 InvoiceBuilder {
 496                         currency: currrency,
 497                         amount: None,
 498                         si_prefix: None,
 499                         timestamp: None,
 500                         tagged_fields: Vec::new(),
 501                         error: None,
 502
 503                         phantom_d: core::marker::PhantomData,
 504                         phantom_h: core::marker::PhantomData,
 505                         phantom_t: core::marker::PhantomData,
 506                         phantom_c: core::marker::PhantomData,
 507                         phantom_s: core::marker::PhantomData,
 508                 }
 509         }
 510 }
 511
 512 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBuilder<D, H, T, C, S> {
 513         /// Helper function to set the completeness flags.
 514         fn set_flags<DN: tb::Bool, HN: tb::Bool, TN: tb::Bool, CN: tb::Bool, SN: tb::Bool>(self) -> InvoiceBuilder<DN, HN, TN, CN, SN> {
 515                 InvoiceBuilder::<DN, HN, TN, CN, SN> {
 516                         currency: self.currency,
 517                         amount: self.amount,
 518                         si_prefix: self.si_prefix,
 519                         timestamp: self.timestamp,
 520                         tagged_fields: self.tagged_fields,
 521                         error: self.error,
 522
 523                         phantom_d: core::marker::PhantomData,
 524                         phantom_h: core::marker::PhantomData,
 525                         phantom_t: core::marker::PhantomData,
 526                         phantom_c: core::marker::PhantomData,
 527                         phantom_s: core::marker::PhantomData,
 528                 }
 529         }
 530
 531         /// Sets the amount in millisatoshis. The optimal SI prefix is chosen automatically.
 532         pub fn amount_milli_satoshis(mut self, amount_msat: u64) -> Self {
 533                 let amount = amount_msat * 10; // Invoices are denominated in "pico BTC"
 534                 let biggest_possible_si_prefix = SiPrefix::values_desc()
 535                         .iter()
 536                         .find(|prefix| amount % prefix.multiplier() == 0)
 537                         .expect("Pico should always match");
 538                 self.amount = Some(amount / biggest_possible_si_prefix.multiplier());
 539                 self.si_prefix = Some(*biggest_possible_si_prefix);
 540                 self
 541         }
 542
 543         /// Sets the payee's public key.
 544         pub fn payee_pub_key(mut self, pub_key: PublicKey) -> Self {
 545                 self.tagged_fields.push(TaggedField::PayeePubKey(PayeePubKey(pub_key)));
 546                 self
 547         }
 548
 549         /// Sets the expiry time, dropping the subsecond part (which is not representable in BOLT 11
 550         /// invoices).
 551         pub fn expiry_time(mut self, expiry_time: Duration) -> Self {
 552                 self.tagged_fields.push(TaggedField::ExpiryTime(ExpiryTime::from_duration(expiry_time)));
 553                 self
 554         }
 555
 556         /// Adds a fallback address.
 557         pub fn fallback(mut self, fallback: Fallback) -> Self {
 558                 self.tagged_fields.push(TaggedField::Fallback(fallback));
 559                 self
 560         }
 561
 562         /// Adds a private route.
 563         pub fn private_route(mut self, hint: RouteHint) -> Self {
 564                 match PrivateRoute::new(hint) {
 565                         Ok(r) => self.tagged_fields.push(TaggedField::PrivateRoute(r)),
 566                         Err(e) => self.error = Some(e),
 567                 }
 568                 self
 569         }
 570 }
 571
 572 impl<D: tb::Bool, H: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBuilder<D, H, tb::True, C, S> {
 573         /// Builds a [`RawInvoice`] if no [`CreationError`] occurred while construction any of the
 574         /// fields.
 575         pub fn build_raw(self) -> Result<RawInvoice, CreationError> {
 576
 577                 // If an error occurred at any time before, return it now
 578                 if let Some(e) = self.error {
 579                         return Err(e);
 580                 }
 581
 582                 let hrp = RawHrp {
 583                         currency: self.currency,
 584                         raw_amount: self.amount,
 585                         si_prefix: self.si_prefix,
 586                 };
 587
 588                 let timestamp = self.timestamp.expect("ensured to be Some(t) by type T");
 589
 590                 let tagged_fields = self.tagged_fields.into_iter().map(|tf| {
 591                         RawTaggedField::KnownSemantics(tf)
 592                 }).collect::<Vec<_>>();
 593
 594                 let data = RawDataPart {
 595                         timestamp,
 596                         tagged_fields,
 597                 };
 598
 599                 Ok(RawInvoice {
 600                         hrp,
 601                         data,
 602                 })
 603         }
 604 }
 605
 606 impl<H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBuilder<tb::False, H, T, C, S> {
 607         /// Set the description. This function is only available if no description (hash) was set.
 608         pub fn description(mut self, description: String) -> InvoiceBuilder<tb::True, H, T, C, S> {
 609                 match Description::new(description) {
 610                         Ok(d) => self.tagged_fields.push(TaggedField::Description(d)),
 611                         Err(e) => self.error = Some(e),
 612                 }
 613                 self.set_flags()
 614         }
 615
 616         /// Set the description hash. This function is only available if no description (hash) was set.
 617         pub fn description_hash(mut self, description_hash: sha256::Hash) -> InvoiceBuilder<tb::True, H, T, C, S> {
 618                 self.tagged_fields.push(TaggedField::DescriptionHash(Sha256(description_hash)));
 619                 self.set_flags()
 620         }
 621
 622         /// Set the description or description hash. This function is only available if no description (hash) was set.
 623         pub fn invoice_description(self, description: InvoiceDescription) -> InvoiceBuilder<tb::True, H, T, C, S> {
 624                 match description {
 625                         InvoiceDescription::Direct(desc) => {
 626                                 self.description(desc.clone().into_inner())
 627                         }
 628                         InvoiceDescription::Hash(hash) => {
 629                                 self.description_hash(hash.0)
 630                         }
 631                 }
 632         }
 633 }
 634
 635 impl<D: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBuilder<D, tb::False, T, C, S> {
 636         /// Set the payment hash. This function is only available if no payment hash was set.
 637         pub fn payment_hash(mut self, hash: sha256::Hash) -> InvoiceBuilder<D, tb::True, T, C, S> {
 638                 self.tagged_fields.push(TaggedField::PaymentHash(Sha256(hash)));
 639                 self.set_flags()
 640         }
 641 }
 642
 643 impl<D: tb::Bool, H: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBuilder<D, H, tb::False, C, S> {
 644         /// Sets the timestamp to a specific [`SystemTime`].
 645         #[cfg(feature = "std")]
 646         pub fn timestamp(mut self, time: SystemTime) -> InvoiceBuilder<D, H, tb::True, C, S> {
 647                 match PositiveTimestamp::from_system_time(time) {
 648                         Ok(t) => self.timestamp = Some(t),
 649                         Err(e) => self.error = Some(e),
 650                 }
 651
 652                 self.set_flags()
 653         }
 654
 655         /// Sets the timestamp to a duration since the Unix epoch, dropping the subsecond part (which
 656         /// is not representable in BOLT 11 invoices).
 657         pub fn duration_since_epoch(mut self, time: Duration) -> InvoiceBuilder<D, H, tb::True, C, S> {
 658                 match PositiveTimestamp::from_duration_since_epoch(time) {
 659                         Ok(t) => self.timestamp = Some(t),
 660                         Err(e) => self.error = Some(e),
 661                 }
 662
 663                 self.set_flags()
 664         }
 665
 666         /// Sets the timestamp to the current system time.
 667         #[cfg(feature = "std")]
 668         pub fn current_timestamp(mut self) -> InvoiceBuilder<D, H, tb::True, C, S> {
 669                 let now = PositiveTimestamp::from_system_time(SystemTime::now());
 670                 self.timestamp = Some(now.expect("for the foreseeable future this shouldn't happen"));
 671                 self.set_flags()
 672         }
 673 }
 674
 675 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, S: tb::Bool> InvoiceBuilder<D, H, T, tb::False, S> {
 676         /// Sets `min_final_cltv_expiry_delta`.
 677         pub fn min_final_cltv_expiry_delta(mut self, min_final_cltv_expiry_delta: u64) -> InvoiceBuilder<D, H, T, tb::True, S> {
 678                 self.tagged_fields.push(TaggedField::MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta(min_final_cltv_expiry_delta)));
 679                 self.set_flags()
 680         }
 681 }
 682
 683 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool> InvoiceBuilder<D, H, T, C, tb::False> {
 684         /// Sets the payment secret and relevant features.
 685         pub fn payment_secret(mut self, payment_secret: PaymentSecret) -> InvoiceBuilder<D, H, T, C, tb::True> {
 686                 let mut features = InvoiceFeatures::empty();
 687                 features.set_variable_length_onion_required();
 688                 features.set_payment_secret_required();
 689                 self.tagged_fields.push(TaggedField::PaymentSecret(payment_secret));
 690                 self.tagged_fields.push(TaggedField::Features(features));
 691                 self.set_flags()
 692         }
 693 }
 694
 695 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool> InvoiceBuilder<D, H, T, C, tb::True> {
 696         /// Sets the `basic_mpp` feature as optional.
 697         pub fn basic_mpp(mut self) -> Self {
 698                 for field in self.tagged_fields.iter_mut() {
 699                         if let TaggedField::Features(f) = field {
 700                                 f.set_basic_mpp_optional();
 701                         }
 702                 }
 703                 self
 704         }
 705 }
 706
 707 impl InvoiceBuilder<tb::True, tb::True, tb::True, tb::True, tb::True> {
 708         /// Builds and signs an invoice using the supplied `sign_function`. This function MAY NOT fail
 709         /// and MUST produce a recoverable signature valid for the given hash and if applicable also for
 710         /// the included payee public key.
 711         pub fn build_signed<F>(self, sign_function: F) -> Result<Invoice, CreationError>
 712                 where F: FnOnce(&Message) -> RecoverableSignature
 713         {
 714                 let invoice = self.try_build_signed::<_, ()>(|hash| {
 715                         Ok(sign_function(hash))
 716                 });
 717
 718                 match invoice {
 719                         Ok(i) => Ok(i),
 720                         Err(SignOrCreationError::CreationError(e)) => Err(e),
 721                         Err(SignOrCreationError::SignError(())) => unreachable!(),
 722                 }
 723         }
 724
 725         /// Builds and signs an invoice using the supplied `sign_function`. This function MAY fail with
 726         /// an error of type `E` and MUST produce a recoverable signature valid for the given hash and
 727         /// if applicable also for the included payee public key.
 728         pub fn try_build_signed<F, E>(self, sign_function: F) -> Result<Invoice, SignOrCreationError<E>>
 729                 where F: FnOnce(&Message) -> Result<RecoverableSignature, E>
 730         {
 731                 let raw = match self.build_raw() {
 732                         Ok(r) => r,
 733                         Err(e) => return Err(SignOrCreationError::CreationError(e)),
 734                 };
 735
 736                 let signed = match raw.sign(sign_function) {
 737                         Ok(s) => s,
 738                         Err(e) => return Err(SignOrCreationError::SignError(e)),
 739                 };
 740
 741                 let invoice = Invoice {
 742                         signed_invoice: signed,
 743                 };
 744
 745                 invoice.check_field_counts().expect("should be ensured by type signature of builder");
 746                 invoice.check_feature_bits().expect("should be ensured by type signature of builder");
 747                 invoice.check_amount().expect("should be ensured by type signature of builder");
 748
 749                 Ok(invoice)
 750         }
 751 }
 752
 753
 754 impl SignedRawInvoice {
 755         /// Disassembles the `SignedRawInvoice` into its three parts:
 756         ///  1. raw invoice
 757         ///  2. hash of the raw invoice
 758         ///  3. signature
 759         pub fn into_parts(self) -> (RawInvoice, [u8; 32], InvoiceSignature) {
 760                 (self.raw_invoice, self.hash, self.signature)
 761         }
 762
 763         /// The [`RawInvoice`] which was signed.
 764         pub fn raw_invoice(&self) -> &RawInvoice {
 765                 &self.raw_invoice
 766         }
 767
 768         /// The hash of the [`RawInvoice`] that was signed.
 769         pub fn signable_hash(&self) -> &[u8; 32] {
 770                 &self.hash
 771         }
 772
 773         /// Signature for the invoice.
 774         pub fn signature(&self) -> &InvoiceSignature {
 775                 &self.signature
 776         }
 777
 778         /// Recovers the public key used for signing the invoice from the recoverable signature.
 779         pub fn recover_payee_pub_key(&self) -> Result<PayeePubKey, secp256k1::Error> {
 780                 let hash = Message::from_slice(&self.hash[..])
 781                         .expect("Hash is 32 bytes long, same as MESSAGE_SIZE");
 782
 783                 Ok(PayeePubKey(Secp256k1::new().recover_ecdsa(
 784                         &hash,
 785                         &self.signature
 786                 )?))
 787         }
 788
 789         /// Checks if the signature is valid for the included payee public key or if none exists if it's
 790         /// valid for the recovered signature (which should always be true?).
 791         pub fn check_signature(&self) -> bool {
 792                 let included_pub_key = self.raw_invoice.payee_pub_key();
 793
 794                 let mut recovered_pub_key = Option::None;
 795                 if recovered_pub_key.is_none() {
 796                         let recovered = match self.recover_payee_pub_key() {
 797                                 Ok(pk) => pk,
 798                                 Err(_) => return false,
 799                         };
 800                         recovered_pub_key = Some(recovered);
 801                 }
 802
 803                 let pub_key = included_pub_key.or(recovered_pub_key.as_ref())
 804                         .expect("One is always present");
 805
 806                 let hash = Message::from_slice(&self.hash[..])
 807                         .expect("Hash is 32 bytes long, same as MESSAGE_SIZE");
 808
 809                 let secp_context = Secp256k1::new();
 810                 let verification_result = secp_context.verify_ecdsa(
 811                         &hash,
 812                         &self.signature.to_standard(),
 813                         pub_key
 814                 );
 815
 816                 match verification_result {
 817                         Ok(()) => true,
 818                         Err(_) => false,
 819                 }
 820         }
 821 }
 822
 823 /// Finds the first element of an enum stream of a given variant and extracts one member of the
 824 /// variant. If no element was found `None` gets returned.
 825 ///
 826 /// The following example would extract the first B.
 827 ///
 828 /// ```ignore
 829 /// enum Enum {
 830 ///     A(u8),
 831 ///     B(u16)
 832 /// }
 833 ///
 834 /// let elements = vec![Enum::A(1), Enum::A(2), Enum::B(3), Enum::A(4)];
 835 ///
 836 /// assert_eq!(find_extract!(elements.iter(), Enum::B(x), x), Some(3u16));
 837 /// ```
 838 macro_rules! find_extract {
 839         ($iter:expr, $enm:pat, $enm_var:ident) => {
 840                 find_all_extract!($iter, $enm, $enm_var).next()
 841         };
 842 }
 843
 844 /// Finds the all elements of an enum stream of a given variant and extracts one member of the
 845 /// variant through an iterator.
 846 ///
 847 /// The following example would extract all A.
 848 ///
 849 /// ```ignore
 850 /// enum Enum {
 851 ///     A(u8),
 852 ///     B(u16)
 853 /// }
 854 ///
 855 /// let elements = vec![Enum::A(1), Enum::A(2), Enum::B(3), Enum::A(4)];
 856 ///
 857 /// assert_eq!(
 858 ///     find_all_extract!(elements.iter(), Enum::A(x), x).collect::<Vec<u8>>(),
 859 ///     vec![1u8, 2u8, 4u8]
 860 /// );
 861 /// ```
 862 macro_rules! find_all_extract {
 863         ($iter:expr, $enm:pat, $enm_var:ident) => {
 864                 $iter.filter_map(|tf| match *tf {
 865                         $enm => Some($enm_var),
 866                         _ => None,
 867                 })
 868         };
 869 }
 870
 871 #[allow(missing_docs)]
 872 impl RawInvoice {
 873         /// Hash the HRP as bytes and signatureless data part.
 874         fn hash_from_parts(hrp_bytes: &[u8], data_without_signature: &[u5]) -> [u8; 32] {
 875                 let preimage = construct_invoice_preimage(hrp_bytes, data_without_signature);
 876                 let mut hash: [u8; 32] = Default::default();
 877                 hash.copy_from_slice(&sha256::Hash::hash(&preimage)[..]);
 878                 hash
 879         }
 880
 881         /// Calculate the hash of the encoded `RawInvoice` which should be signed.
 882         pub fn signable_hash(&self) -> [u8; 32] {
 883                 use bech32::ToBase32;
 884
 885                 RawInvoice::hash_from_parts(
 886                         self.hrp.to_string().as_bytes(),
 887                         &self.data.to_base32()
 888                 )
 889         }
 890
 891         /// Signs the invoice using the supplied `sign_method`. This function MAY fail with an error of
 892         /// type `E`. Since the signature of a [`SignedRawInvoice`] is not required to be valid there
 893         /// are no constraints regarding the validity of the produced signature.
 894         ///
 895         /// This is not exported to bindings users as we don't currently support passing function pointers into methods
 896         /// explicitly.
 897         pub fn sign<F, E>(self, sign_method: F) -> Result<SignedRawInvoice, E>
 898                 where F: FnOnce(&Message) -> Result<RecoverableSignature, E>
 899         {
 900                 let raw_hash = self.signable_hash();
 901                 let hash = Message::from_slice(&raw_hash[..])
 902                         .expect("Hash is 32 bytes long, same as MESSAGE_SIZE");
 903                 let signature = sign_method(&hash)?;
 904
 905                 Ok(SignedRawInvoice {
 906                         raw_invoice: self,
 907                         hash: raw_hash,
 908                         signature: InvoiceSignature(signature),
 909                 })
 910         }
 911
 912         /// Returns an iterator over all tagged fields with known semantics.
 913         ///
 914         /// This is not exported to bindings users as there is not yet a manual mapping for a FilterMap
 915         pub fn known_tagged_fields(&self)
 916                 -> FilterMap<Iter<RawTaggedField>, fn(&RawTaggedField) -> Option<&TaggedField>>
 917         {
 918                 // For 1.14.0 compatibility: closures' types can't be written an fn()->() in the
 919                 // function's type signature.
 920                 // TODO: refactor once impl Trait is available
 921                 fn match_raw(raw: &RawTaggedField) -> Option<&TaggedField> {
 922                         match *raw {
 923                                 RawTaggedField::KnownSemantics(ref tf) => Some(tf),
 924                                 _ => None,
 925                         }
 926                 }
 927
 928                 self.data.tagged_fields.iter().filter_map(match_raw )
 929         }
 930
 931         pub fn payment_hash(&self) -> Option<&Sha256> {
 932                 find_extract!(self.known_tagged_fields(), TaggedField::PaymentHash(ref x), x)
 933         }
 934
 935         pub fn description(&self) -> Option<&Description> {
 936                 find_extract!(self.known_tagged_fields(), TaggedField::Description(ref x), x)
 937         }
 938
 939         pub fn payee_pub_key(&self) -> Option<&PayeePubKey> {
 940                 find_extract!(self.known_tagged_fields(), TaggedField::PayeePubKey(ref x), x)
 941         }
 942
 943         pub fn description_hash(&self) -> Option<&Sha256> {
 944                 find_extract!(self.known_tagged_fields(), TaggedField::DescriptionHash(ref x), x)
 945         }
 946
 947         pub fn expiry_time(&self) -> Option<&ExpiryTime> {
 948                 find_extract!(self.known_tagged_fields(), TaggedField::ExpiryTime(ref x), x)
 949         }
 950
 951         pub fn min_final_cltv_expiry_delta(&self) -> Option<&MinFinalCltvExpiryDelta> {
 952                 find_extract!(self.known_tagged_fields(), TaggedField::MinFinalCltvExpiryDelta(ref x), x)
 953         }
 954
 955         pub fn payment_secret(&self) -> Option<&PaymentSecret> {
 956                 find_extract!(self.known_tagged_fields(), TaggedField::PaymentSecret(ref x), x)
 957         }
 958
 959         pub fn payment_metadata(&self) -> Option<&Vec<u8>> {
 960                 find_extract!(self.known_tagged_fields(), TaggedField::PaymentMetadata(ref x), x)
 961         }
 962
 963         pub fn features(&self) -> Option<&InvoiceFeatures> {
 964                 find_extract!(self.known_tagged_fields(), TaggedField::Features(ref x), x)
 965         }
 966
 967         /// This is not exported to bindings users as we don't support Vec<&NonOpaqueType>
 968         pub fn fallbacks(&self) -> Vec<&Fallback> {
 969                 find_all_extract!(self.known_tagged_fields(), TaggedField::Fallback(ref x), x).collect()
 970         }
 971
 972         pub fn private_routes(&self) -> Vec<&PrivateRoute> {
 973                 find_all_extract!(self.known_tagged_fields(), TaggedField::PrivateRoute(ref x), x).collect()
 974         }
 975
 976         pub fn amount_pico_btc(&self) -> Option<u64> {
 977                 self.hrp.raw_amount.map(|v| {
 978                         v * self.hrp.si_prefix.as_ref().map_or(1_000_000_000_000, |si| { si.multiplier() })
 979                 })
 980         }
 981
 982         pub fn currency(&self) -> Currency {
 983                 self.hrp.currency.clone()
 984         }
 985 }
 986
 987 impl PositiveTimestamp {
 988         /// Creates a `PositiveTimestamp` from a Unix timestamp in the range `0..=MAX_TIMESTAMP`.
 989         ///
 990         /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`].
 991         pub fn from_unix_timestamp(unix_seconds: u64) -> Result<Self, CreationError> {
 992                 if unix_seconds <= MAX_TIMESTAMP {
 993                         Ok(Self(Duration::from_secs(unix_seconds)))
 994                 } else {
 995                         Err(CreationError::TimestampOutOfBounds)
 996                 }
 997         }
 998
 999         /// Creates a `PositiveTimestamp` from a [`SystemTime`] with a corresponding Unix timestamp in
1000         /// the range `0..=MAX_TIMESTAMP`.
1001         ///
1002         /// Note that the subsecond part is dropped as it is not representable in BOLT 11 invoices.
1003         ///
1004         /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`].
1005         #[cfg(feature = "std")]
1006         pub fn from_system_time(time: SystemTime) -> Result<Self, CreationError> {
1007                 time.duration_since(SystemTime::UNIX_EPOCH)
1008                         .map(Self::from_duration_since_epoch)
1009                         .unwrap_or(Err(CreationError::TimestampOutOfBounds))
1010         }
1011
1012         /// Creates a `PositiveTimestamp` from a [`Duration`] since the Unix epoch in the range
1013         /// `0..=MAX_TIMESTAMP`.
1014         ///
1015         /// Note that the subsecond part is dropped as it is not representable in BOLT 11 invoices.
1016         ///
1017         /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`].
1018         pub fn from_duration_since_epoch(duration: Duration) -> Result<Self, CreationError> {
1019                 Self::from_unix_timestamp(duration.as_secs())
1020         }
1021
1022         /// Returns the Unix timestamp representing the stored time
1023         pub fn as_unix_timestamp(&self) -> u64 {
1024                 self.0.as_secs()
1025         }
1026
1027         /// Returns the duration of the stored time since the Unix epoch
1028         pub fn as_duration_since_epoch(&self) -> Duration {
1029                 self.0
1030         }
1031
1032         /// Returns the [`SystemTime`] representing the stored time
1033         #[cfg(feature = "std")]
1034         pub fn as_time(&self) -> SystemTime {
1035                 SystemTime::UNIX_EPOCH + self.0
1036         }
1037 }
1038
1039 #[cfg(feature = "std")]
1040 impl From<PositiveTimestamp> for SystemTime {
1041         fn from(val: PositiveTimestamp) -> Self {
1042                 SystemTime::UNIX_EPOCH + val.0
1043         }
1044 }
1045
1046 impl Invoice {
1047         /// The hash of the [`RawInvoice`] that was signed.
1048         pub fn signable_hash(&self) -> [u8; 32] {
1049                 self.signed_invoice.hash
1050         }
1051
1052         /// Transform the `Invoice` into it's unchecked version
1053         pub fn into_signed_raw(self) -> SignedRawInvoice {
1054                 self.signed_invoice
1055         }
1056
1057         /// Check that all mandatory fields are present
1058         fn check_field_counts(&self) -> Result<(), SemanticError> {
1059                 // "A writer MUST include exactly one p field […]."
1060                 let payment_hash_cnt = self.tagged_fields().filter(|&tf| match *tf {
1061                         TaggedField::PaymentHash(_) => true,
1062                         _ => false,
1063                 }).count();
1064                 if payment_hash_cnt < 1 {
1065                         return Err(SemanticError::NoPaymentHash);
1066                 } else if payment_hash_cnt > 1 {
1067                         return Err(SemanticError::MultiplePaymentHashes);
1068                 }
1069
1070                 // "A writer MUST include either exactly one d or exactly one h field."
1071                 let description_cnt = self.tagged_fields().filter(|&tf| match *tf {
1072                         TaggedField::Description(_) | TaggedField::DescriptionHash(_) => true,
1073                         _ => false,
1074                 }).count();
1075                 if  description_cnt < 1 {
1076                         return Err(SemanticError::NoDescription);
1077                 } else if description_cnt > 1 {
1078                         return  Err(SemanticError::MultipleDescriptions);
1079                 }
1080
1081                 self.check_payment_secret()?;
1082
1083                 Ok(())
1084         }
1085
1086         /// Checks that there is exactly one payment secret field
1087         fn check_payment_secret(&self) -> Result<(), SemanticError> {
1088                 // "A writer MUST include exactly one `s` field."
1089                 let payment_secret_count = self.tagged_fields().filter(|&tf| match *tf {
1090                         TaggedField::PaymentSecret(_) => true,
1091                         _ => false,
1092                 }).count();
1093                 if payment_secret_count < 1 {
1094                         return Err(SemanticError::NoPaymentSecret);
1095                 } else if payment_secret_count > 1 {
1096                         return Err(SemanticError::MultiplePaymentSecrets);
1097                 }
1098
1099                 Ok(())
1100         }
1101
1102         /// Check that amount is a whole number of millisatoshis
1103         fn check_amount(&self) -> Result<(), SemanticError> {
1104                 if let Some(amount_pico_btc) = self.amount_pico_btc() {
1105                         if amount_pico_btc % 10 != 0 {
1106                                 return Err(SemanticError::ImpreciseAmount);
1107                         }
1108                 }
1109                 Ok(())
1110         }
1111
1112         /// Check that feature bits are set as required
1113         fn check_feature_bits(&self) -> Result<(), SemanticError> {
1114                 self.check_payment_secret()?;
1115
1116                 // "A writer MUST set an s field if and only if the payment_secret feature is set."
1117                 // (this requirement has been since removed, and we now require the payment secret
1118                 // feature bit always).
1119                 let features = self.tagged_fields().find(|&tf| match *tf {
1120                         TaggedField::Features(_) => true,
1121                         _ => false,
1122                 });
1123                 match features {
1124                         None => Err(SemanticError::InvalidFeatures),
1125                         Some(TaggedField::Features(features)) => {
1126                                 if features.requires_unknown_bits() {
1127                                         Err(SemanticError::InvalidFeatures)
1128                                 } else if !features.supports_payment_secret() {
1129                                         Err(SemanticError::InvalidFeatures)
1130                                 } else {
1131                                         Ok(())
1132                                 }
1133                         },
1134                         Some(_) => unreachable!(),
1135                 }
1136         }
1137
1138         /// Check that the invoice is signed correctly and that key recovery works
1139         pub fn check_signature(&self) -> Result<(), SemanticError> {
1140                 match self.signed_invoice.recover_payee_pub_key() {
1141                         Err(secp256k1::Error::InvalidRecoveryId) =>
1142                                 return Err(SemanticError::InvalidRecoveryId),
1143                         Err(secp256k1::Error::InvalidSignature) =>
1144                                 return Err(SemanticError::InvalidSignature),
1145                         Err(e) => panic!("no other error may occur, got {:?}", e),
1146                         Ok(_) => {},
1147                 }
1148
1149                 if !self.signed_invoice.check_signature() {
1150                         return Err(SemanticError::InvalidSignature);
1151                 }
1152
1153                 Ok(())
1154         }
1155
1156         /// Constructs an `Invoice` from a [`SignedRawInvoice`] by checking all its invariants.
1157         /// ```
1158         /// use lightning_invoice::*;
1159         ///
1160         /// let invoice = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\
1161         /// h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\
1162         /// 5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\
1163         /// h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\
1164         /// j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\
1165         /// ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\
1166         /// guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\
1167         /// ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\
1168         /// p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\
1169         /// 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\
1170         /// j5r6drg6k6zcqj0fcwg";
1171         ///
1172         /// let signed = invoice.parse::<SignedRawInvoice>().unwrap();
1173         ///
1174         /// assert!(Invoice::from_signed(signed).is_ok());
1175         /// ```
1176         pub fn from_signed(signed_invoice: SignedRawInvoice) -> Result<Self, SemanticError> {
1177                 let invoice = Invoice {
1178                         signed_invoice,
1179                 };
1180                 invoice.check_field_counts()?;
1181                 invoice.check_feature_bits()?;
1182                 invoice.check_signature()?;
1183                 invoice.check_amount()?;
1184
1185                 Ok(invoice)
1186         }
1187
1188         /// Returns the `Invoice`'s timestamp (should equal its creation time)
1189         #[cfg(feature = "std")]
1190         pub fn timestamp(&self) -> SystemTime {
1191                 self.signed_invoice.raw_invoice().data.timestamp.as_time()
1192         }
1193
1194         /// Returns the `Invoice`'s timestamp as a duration since the Unix epoch
1195         pub fn duration_since_epoch(&self) -> Duration {
1196                 self.signed_invoice.raw_invoice().data.timestamp.0
1197         }
1198
1199         /// Returns an iterator over all tagged fields of this Invoice.
1200         ///
1201         /// This is not exported to bindings users as there is not yet a manual mapping for a FilterMap
1202         pub fn tagged_fields(&self)
1203                 -> FilterMap<Iter<RawTaggedField>, fn(&RawTaggedField) -> Option<&TaggedField>> {
1204                 self.signed_invoice.raw_invoice().known_tagged_fields()
1205         }
1206
1207         /// Returns the hash to which we will receive the preimage on completion of the payment
1208         pub fn payment_hash(&self) -> &sha256::Hash {
1209                 &self.signed_invoice.payment_hash().expect("checked by constructor").0
1210         }
1211
1212         /// Return the description or a hash of it for longer ones
1213         ///
1214         /// This is not exported to bindings users because we don't yet export InvoiceDescription
1215         pub fn description(&self) -> InvoiceDescription {
1216                 if let Some(direct) = self.signed_invoice.description() {
1217                         return InvoiceDescription::Direct(direct);
1218                 } else if let Some(hash) = self.signed_invoice.description_hash() {
1219                         return InvoiceDescription::Hash(hash);
1220                 }
1221                 unreachable!("ensured by constructor");
1222         }
1223
1224         /// Get the payee's public key if one was included in the invoice
1225         pub fn payee_pub_key(&self) -> Option<&PublicKey> {
1226                 self.signed_invoice.payee_pub_key().map(|x| &x.0)
1227         }
1228
1229         /// Get the payment secret if one was included in the invoice
1230         pub fn payment_secret(&self) -> &PaymentSecret {
1231                 self.signed_invoice.payment_secret().expect("was checked by constructor")
1232         }
1233
1234         /// Get the payment metadata blob if one was included in the invoice
1235         pub fn payment_metadata(&self) -> Option<&Vec<u8>> {
1236                 self.signed_invoice.payment_metadata()
1237         }
1238
1239         /// Get the invoice features if they were included in the invoice
1240         pub fn features(&self) -> Option<&InvoiceFeatures> {
1241                 self.signed_invoice.features()
1242         }
1243
1244         /// Recover the payee's public key (only to be used if none was included in the invoice)
1245         pub fn recover_payee_pub_key(&self) -> PublicKey {
1246                 self.signed_invoice.recover_payee_pub_key().expect("was checked by constructor").0
1247         }
1248
1249         /// Returns the Duration since the Unix epoch at which the invoice expires.
1250         /// Returning None if overflow occurred.
1251         pub fn expires_at(&self) -> Option<Duration> {
1252                 self.duration_since_epoch().checked_add(self.expiry_time())
1253         }
1254
1255         /// Returns the invoice's expiry time, if present, otherwise [`DEFAULT_EXPIRY_TIME`].
1256         pub fn expiry_time(&self) -> Duration {
1257                 self.signed_invoice.expiry_time()
1258                         .map(|x| x.0)
1259                         .unwrap_or(Duration::from_secs(DEFAULT_EXPIRY_TIME))
1260         }
1261
1262         /// Returns whether the invoice has expired.
1263         #[cfg(feature = "std")]
1264         pub fn is_expired(&self) -> bool {
1265                 Self::is_expired_from_epoch(&self.timestamp(), self.expiry_time())
1266         }
1267
1268         /// Returns whether the expiry time from the given epoch has passed.
1269         #[cfg(feature = "std")]
1270         pub(crate) fn is_expired_from_epoch(epoch: &SystemTime, expiry_time: Duration) -> bool {
1271                 match epoch.elapsed() {
1272                         Ok(elapsed) => elapsed > expiry_time,
1273                         Err(_) => false,
1274                 }
1275         }
1276
1277         /// Returns the Duration remaining until the invoice expires.
1278         #[cfg(feature = "std")]
1279         pub fn duration_until_expiry(&self) -> Duration {
1280                 SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)
1281                         .map(|now| self.expiration_remaining_from_epoch(now))
1282                         .unwrap_or(Duration::from_nanos(0))
1283         }
1284
1285         /// Returns the Duration remaining until the invoice expires given the current time.
1286         /// `time` is the timestamp as a duration since the Unix epoch.
1287         pub fn expiration_remaining_from_epoch(&self, time: Duration) -> Duration {
1288                 self.expires_at().map(|x| x.checked_sub(time)).flatten().unwrap_or(Duration::from_nanos(0))
1289         }
1290
1291         /// Returns whether the expiry time would pass at the given point in time.
1292         /// `at_time` is the timestamp as a duration since the Unix epoch.
1293         pub fn would_expire(&self, at_time: Duration) -> bool {
1294                 self.duration_since_epoch()
1295                         .checked_add(self.expiry_time())
1296                         .unwrap_or_else(|| Duration::new(u64::max_value(), 1_000_000_000 - 1)) < at_time
1297         }
1298
1299         /// Returns the invoice's `min_final_cltv_expiry_delta` time, if present, otherwise
1300         /// [`DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA`].
1301         pub fn min_final_cltv_expiry_delta(&self) -> u64 {
1302                 self.signed_invoice.min_final_cltv_expiry_delta()
1303                         .map(|x| x.0)
1304                         .unwrap_or(DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA)
1305         }
1306
1307         /// Returns a list of all fallback addresses
1308         ///
1309         /// This is not exported to bindings users as we don't support Vec<&NonOpaqueType>
1310         pub fn fallbacks(&self) -> Vec<&Fallback> {
1311                 self.signed_invoice.fallbacks()
1312         }
1313
1314         /// Returns a list of all fallback addresses as [`Address`]es
1315         pub fn fallback_addresses(&self) -> Vec<Address> {
1316                 self.fallbacks().iter().map(|fallback| {
1317                         let network = match self.currency() {
1318                                 Currency::Bitcoin => Network::Bitcoin,
1319                                 Currency::BitcoinTestnet => Network::Testnet,
1320                                 Currency::Regtest => Network::Regtest,
1321                                 Currency::Simnet => Network::Regtest,
1322                                 Currency::Signet => Network::Signet,
1323                         };
1324
1325                         let payload = match fallback {
1326                                 Fallback::SegWitProgram { version, program } => {
1327                                         Payload::WitnessProgram { version: *version, program: program.to_vec() }
1328                                 }
1329                                 Fallback::PubKeyHash(pkh) => {
1330                                         Payload::PubkeyHash(*pkh)
1331                                 }
1332                                 Fallback::ScriptHash(sh) => {
1333                                         Payload::ScriptHash(*sh)
1334                                 }
1335                         };
1336
1337                         Address { payload, network }
1338                 }).collect()
1339         }
1340
1341         /// Returns a list of all routes included in the invoice
1342         pub fn private_routes(&self) -> Vec<&PrivateRoute> {
1343                 self.signed_invoice.private_routes()
1344         }
1345
1346         /// Returns a list of all routes included in the invoice as the underlying hints
1347         pub fn route_hints(&self) -> Vec<RouteHint> {
1348                 find_all_extract!(
1349                         self.signed_invoice.known_tagged_fields(), TaggedField::PrivateRoute(ref x), x
1350                 ).map(|route| (**route).clone()).collect()
1351         }
1352
1353         /// Returns the currency for which the invoice was issued
1354         pub fn currency(&self) -> Currency {
1355                 self.signed_invoice.currency()
1356         }
1357
1358         /// Returns the amount if specified in the invoice as millisatoshis.
1359         pub fn amount_milli_satoshis(&self) -> Option<u64> {
1360                 self.signed_invoice.amount_pico_btc().map(|v| v / 10)
1361         }
1362
1363         /// Returns the amount if specified in the invoice as pico BTC.
1364         fn amount_pico_btc(&self) -> Option<u64> {
1365                 self.signed_invoice.amount_pico_btc()
1366         }
1367 }
1368
1369 impl From<TaggedField> for RawTaggedField {
1370         fn from(tf: TaggedField) -> Self {
1371                 RawTaggedField::KnownSemantics(tf)
1372         }
1373 }
1374
1375 impl TaggedField {
1376         /// Numeric representation of the field's tag
1377         pub fn tag(&self) -> u5 {
1378                 let tag = match *self {
1379                         TaggedField::PaymentHash(_) => constants::TAG_PAYMENT_HASH,
1380                         TaggedField::Description(_) => constants::TAG_DESCRIPTION,
1381                         TaggedField::PayeePubKey(_) => constants::TAG_PAYEE_PUB_KEY,
1382                         TaggedField::DescriptionHash(_) => constants::TAG_DESCRIPTION_HASH,
1383                         TaggedField::ExpiryTime(_) => constants::TAG_EXPIRY_TIME,
1384                         TaggedField::MinFinalCltvExpiryDelta(_) => constants::TAG_MIN_FINAL_CLTV_EXPIRY_DELTA,
1385                         TaggedField::Fallback(_) => constants::TAG_FALLBACK,
1386                         TaggedField::PrivateRoute(_) => constants::TAG_PRIVATE_ROUTE,
1387                         TaggedField::PaymentSecret(_) => constants::TAG_PAYMENT_SECRET,
1388                         TaggedField::PaymentMetadata(_) => constants::TAG_PAYMENT_METADATA,
1389                         TaggedField::Features(_) => constants::TAG_FEATURES,
1390                 };
1391
1392                 u5::try_from_u8(tag).expect("all tags defined are <32")
1393         }
1394 }
1395
1396 impl Description {
1397
1398         /// Creates a new `Description` if `description` is at most 1023 __bytes__ long,
1399         /// returns [`CreationError::DescriptionTooLong`] otherwise
1400         ///
1401         /// Please note that single characters may use more than one byte due to UTF8 encoding.
1402         pub fn new(description: String) -> Result<Description, CreationError> {
1403                 if description.len() > 639 {
1404                         Err(CreationError::DescriptionTooLong)
1405                 } else {
1406                         Ok(Description(description))
1407                 }
1408         }
1409
1410         /// Returns the underlying description [`String`]
1411         pub fn into_inner(self) -> String {
1412                 self.0
1413         }
1414 }
1415
1416 impl From<Description> for String {
1417         fn from(val: Description) -> Self {
1418                 val.into_inner()
1419         }
1420 }
1421
1422 impl Deref for Description {
1423         type Target = str;
1424
1425         fn deref(&self) -> &str {
1426                 &self.0
1427         }
1428 }
1429
1430 impl From<PublicKey> for PayeePubKey {
1431         fn from(pk: PublicKey) -> Self {
1432                 PayeePubKey(pk)
1433         }
1434 }
1435
1436 impl Deref for PayeePubKey {
1437         type Target = PublicKey;
1438
1439         fn deref(&self) -> &PublicKey {
1440                 &self.0
1441         }
1442 }
1443
1444 impl ExpiryTime {
1445         /// Construct an `ExpiryTime` from seconds.
1446         pub fn from_seconds(seconds: u64) -> ExpiryTime {
1447                 ExpiryTime(Duration::from_secs(seconds))
1448         }
1449
1450         /// Construct an `ExpiryTime` from a [`Duration`], dropping the sub-second part.
1451         pub fn from_duration(duration: Duration) -> ExpiryTime {
1452                 Self::from_seconds(duration.as_secs())
1453         }
1454
1455         /// Returns the expiry time in seconds
1456         pub fn as_seconds(&self) -> u64 {
1457                 self.0.as_secs()
1458         }
1459
1460         /// Returns a reference to the underlying [`Duration`] (=expiry time)
1461         pub fn as_duration(&self) -> &Duration {
1462                 &self.0
1463         }
1464 }
1465
1466 impl PrivateRoute {
1467         /// Creates a new (partial) route from a list of hops
1468         pub fn new(hops: RouteHint) -> Result<PrivateRoute, CreationError> {
1469                 if hops.0.len() <= 12 {
1470                         Ok(PrivateRoute(hops))
1471                 } else {
1472                         Err(CreationError::RouteTooLong)
1473                 }
1474         }
1475
1476         /// Returns the underlying list of hops
1477         pub fn into_inner(self) -> RouteHint {
1478                 self.0
1479         }
1480 }
1481
1482 impl From<PrivateRoute> for RouteHint {
1483         fn from(val: PrivateRoute) -> Self {
1484                 val.into_inner()
1485         }
1486 }
1487
1488 impl Deref for PrivateRoute {
1489         type Target = RouteHint;
1490
1491         fn deref(&self) -> &RouteHint {
1492                 &self.0
1493         }
1494 }
1495
1496 impl Deref for InvoiceSignature {
1497         type Target = RecoverableSignature;
1498
1499         fn deref(&self) -> &RecoverableSignature {
1500                 &self.0
1501         }
1502 }
1503
1504 impl Deref for SignedRawInvoice {
1505         type Target = RawInvoice;
1506
1507         fn deref(&self) -> &RawInvoice {
1508                 &self.raw_invoice
1509         }
1510 }
1511
1512 /// Errors that may occur when constructing a new [`RawInvoice`] or [`Invoice`]
1513 #[derive(Eq, PartialEq, Debug, Clone)]
1514 pub enum CreationError {
1515         /// The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
1516         DescriptionTooLong,
1517
1518         /// The specified route has too many hops and can't be encoded
1519         RouteTooLong,
1520
1521         /// The Unix timestamp of the supplied date is less than zero or greater than 35-bits
1522         TimestampOutOfBounds,
1523
1524         /// The supplied millisatoshi amount was greater than the total bitcoin supply.
1525         InvalidAmount,
1526
1527         /// Route hints were required for this invoice and were missing. Applies to
1528         /// [phantom invoices].
1529         ///
1530         /// [phantom invoices]: crate::utils::create_phantom_invoice
1531         MissingRouteHints,
1532
1533         /// The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
1534         ///
1535         /// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
1536         MinFinalCltvExpiryDeltaTooShort,
1537 }
1538
1539 impl Display for CreationError {
1540         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1541                 match self {
1542                         CreationError::DescriptionTooLong => f.write_str("The supplied description string was longer than 639 bytes"),
1543                         CreationError::RouteTooLong => f.write_str("The specified route has too many hops and can't be encoded"),
1544                         CreationError::TimestampOutOfBounds => f.write_str("The Unix timestamp of the supplied date is less than zero or greater than 35-bits"),
1545                         CreationError::InvalidAmount => f.write_str("The supplied millisatoshi amount was greater than the total bitcoin supply"),
1546                         CreationError::MissingRouteHints => f.write_str("The invoice required route hints and they weren't provided"),
1547                         CreationError::MinFinalCltvExpiryDeltaTooShort => f.write_str(
1548                                 "The supplied final CLTV expiry delta was less than LDK's `MIN_FINAL_CLTV_EXPIRY_DELTA`"),
1549                 }
1550         }
1551 }
1552
1553 #[cfg(feature = "std")]
1554 impl std::error::Error for CreationError { }
1555
1556 /// Errors that may occur when converting a [`RawInvoice`] to an [`Invoice`]. They relate to the
1557 /// requirements sections in BOLT #11
1558 #[derive(Eq, PartialEq, Debug, Clone)]
1559 pub enum SemanticError {
1560         /// The invoice is missing the mandatory payment hash
1561         NoPaymentHash,
1562
1563         /// The invoice has multiple payment hashes which isn't allowed
1564         MultiplePaymentHashes,
1565
1566         /// No description or description hash are part of the invoice
1567         NoDescription,
1568
1569         /// The invoice contains multiple descriptions and/or description hashes which isn't allowed
1570         MultipleDescriptions,
1571
1572         /// The invoice is missing the mandatory payment secret, which all modern lightning nodes
1573         /// should provide.
1574         NoPaymentSecret,
1575
1576         /// The invoice contains multiple payment secrets
1577         MultiplePaymentSecrets,
1578
1579         /// The invoice's features are invalid
1580         InvalidFeatures,
1581
1582         /// The recovery id doesn't fit the signature/pub key
1583         InvalidRecoveryId,
1584
1585         /// The invoice's signature is invalid
1586         InvalidSignature,
1587
1588         /// The invoice's amount was not a whole number of millisatoshis
1589         ImpreciseAmount,
1590 }
1591
1592 impl Display for SemanticError {
1593         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1594                 match self {
1595                         SemanticError::NoPaymentHash => f.write_str("The invoice is missing the mandatory payment hash"),
1596                         SemanticError::MultiplePaymentHashes => f.write_str("The invoice has multiple payment hashes which isn't allowed"),
1597                         SemanticError::NoDescription => f.write_str("No description or description hash are part of the invoice"),
1598                         SemanticError::MultipleDescriptions => f.write_str("The invoice contains multiple descriptions and/or description hashes which isn't allowed"),
1599                         SemanticError::NoPaymentSecret => f.write_str("The invoice is missing the mandatory payment secret"),
1600                         SemanticError::MultiplePaymentSecrets => f.write_str("The invoice contains multiple payment secrets"),
1601                         SemanticError::InvalidFeatures => f.write_str("The invoice's features are invalid"),
1602                         SemanticError::InvalidRecoveryId => f.write_str("The recovery id doesn't fit the signature/pub key"),
1603                         SemanticError::InvalidSignature => f.write_str("The invoice's signature is invalid"),
1604                         SemanticError::ImpreciseAmount => f.write_str("The invoice's amount was not a whole number of millisatoshis"),
1605                 }
1606         }
1607 }
1608
1609 #[cfg(feature = "std")]
1610 impl std::error::Error for SemanticError { }
1611
1612 /// When signing using a fallible method either an user-supplied `SignError` or a [`CreationError`]
1613 /// may occur.
1614 #[derive(Eq, PartialEq, Debug, Clone)]
1615 pub enum SignOrCreationError<S = ()> {
1616         /// An error occurred during signing
1617         SignError(S),
1618
1619         /// An error occurred while building the transaction
1620         CreationError(CreationError),
1621 }
1622
1623 impl<S> Display for SignOrCreationError<S> {
1624         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1625                 match self {
1626                         SignOrCreationError::SignError(_) => f.write_str("An error occurred during signing"),
1627                         SignOrCreationError::CreationError(err) => err.fmt(f),
1628                 }
1629         }
1630 }
1631
1632 #[cfg(feature = "serde")]
1633 impl Serialize for Invoice {
1634         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
1635                 serializer.serialize_str(self.to_string().as_str())
1636         }
1637 }
1638 #[cfg(feature = "serde")]
1639 impl<'de> Deserialize<'de> for Invoice {
1640         fn deserialize<D>(deserializer: D) -> Result<Invoice, D::Error> where D: Deserializer<'de> {
1641                 let bolt11 = String::deserialize(deserializer)?
1642                         .parse::<Invoice>()
1643                         .map_err(|e| D::Error::custom(format!("{:?}", e)))?;
1644
1645                 Ok(bolt11)
1646         }
1647 }
1648
1649 #[cfg(test)]
1650 mod test {
1651         use bitcoin::Script;
1652         use bitcoin_hashes::hex::FromHex;
1653         use bitcoin_hashes::sha256;
1654
1655         #[test]
1656         fn test_system_time_bounds_assumptions() {
1657                 assert_eq!(
1658                         crate::PositiveTimestamp::from_unix_timestamp(crate::MAX_TIMESTAMP + 1),
1659                         Err(crate::CreationError::TimestampOutOfBounds)
1660                 );
1661         }
1662
1663         #[test]
1664         fn test_calc_invoice_hash() {
1665                 use crate::{RawInvoice, RawHrp, RawDataPart, Currency, PositiveTimestamp};
1666                 use crate::TaggedField::*;
1667
1668                 let invoice = RawInvoice {
1669                         hrp: RawHrp {
1670                                 currency: Currency::Bitcoin,
1671                                 raw_amount: None,
1672                                 si_prefix: None,
1673                         },
1674                         data: RawDataPart {
1675                                 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1676                                 tagged_fields: vec![
1677                                         PaymentHash(crate::Sha256(sha256::Hash::from_hex(
1678                                                 "0001020304050607080900010203040506070809000102030405060708090102"
1679                                         ).unwrap())).into(),
1680                                         Description(crate::Description::new(
1681                                                 "Please consider supporting this project".to_owned()
1682                                         ).unwrap()).into(),
1683                                 ],
1684                         },
1685                 };
1686
1687                 let expected_hash = [
1688                         0xc3, 0xd4, 0xe8, 0x3f, 0x64, 0x6f, 0xa7, 0x9a, 0x39, 0x3d, 0x75, 0x27, 0x7b, 0x1d,
1689                         0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7, 0x83, 0x5d, 0xb2, 0xec,
1690                         0xd5, 0x18, 0xe1, 0xc9
1691                 ];
1692
1693                 assert_eq!(invoice.signable_hash(), expected_hash)
1694         }
1695
1696         #[test]
1697         fn test_check_signature() {
1698                 use crate::TaggedField::*;
1699                 use secp256k1::Secp256k1;
1700                 use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
1701                 use secp256k1::{SecretKey, PublicKey};
1702                 use crate::{SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256,
1703                          PositiveTimestamp};
1704
1705                 let invoice = SignedRawInvoice {
1706                         raw_invoice: RawInvoice {
1707                                 hrp: RawHrp {
1708                                         currency: Currency::Bitcoin,
1709                                         raw_amount: None,
1710                                         si_prefix: None,
1711                                 },
1712                                 data: RawDataPart {
1713                                         timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1714                                         tagged_fields: vec ! [
1715                                                 PaymentHash(Sha256(sha256::Hash::from_hex(
1716                                                         "0001020304050607080900010203040506070809000102030405060708090102"
1717                                                 ).unwrap())).into(),
1718                                                 Description(
1719                                                         crate::Description::new(
1720                                                                 "Please consider supporting this project".to_owned()
1721                                                         ).unwrap()
1722                                                 ).into(),
1723                                         ],
1724                                 },
1725                         },
1726                         hash: [
1727                                 0xc3, 0xd4, 0xe8, 0x3f, 0x64, 0x6f, 0xa7, 0x9a, 0x39, 0x3d, 0x75, 0x27,
1728                                 0x7b, 0x1d, 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7,
1729                                 0x83, 0x5d, 0xb2, 0xec, 0xd5, 0x18, 0xe1, 0xc9
1730                         ],
1731                         signature: InvoiceSignature(RecoverableSignature::from_compact(
1732                                 & [
1733                                         0x38u8, 0xec, 0x68, 0x91, 0x34, 0x5e, 0x20, 0x41, 0x45, 0xbe, 0x8a,
1734                                         0x3a, 0x99, 0xde, 0x38, 0xe9, 0x8a, 0x39, 0xd6, 0xa5, 0x69, 0x43,
1735                                         0x4e, 0x18, 0x45, 0xc8, 0xaf, 0x72, 0x05, 0xaf, 0xcf, 0xcc, 0x7f,
1736                                         0x42, 0x5f, 0xcd, 0x14, 0x63, 0xe9, 0x3c, 0x32, 0x88, 0x1e, 0xad,
1737                                         0x0d, 0x6e, 0x35, 0x6d, 0x46, 0x7e, 0xc8, 0xc0, 0x25, 0x53, 0xf9,
1738                                         0xaa, 0xb1, 0x5e, 0x57, 0x38, 0xb1, 0x1f, 0x12, 0x7f
1739                                 ],
1740                                 RecoveryId::from_i32(0).unwrap()
1741                         ).unwrap()),
1742                 };
1743
1744                 assert!(invoice.check_signature());
1745
1746                 let private_key = SecretKey::from_slice(
1747                         &[
1748                                 0xe1, 0x26, 0xf6, 0x8f, 0x7e, 0xaf, 0xcc, 0x8b, 0x74, 0xf5, 0x4d, 0x26, 0x9f, 0xe2,
1749                                 0x06, 0xbe, 0x71, 0x50, 0x00, 0xf9, 0x4d, 0xac, 0x06, 0x7d, 0x1c, 0x04, 0xa8, 0xca,
1750                                 0x3b, 0x2d, 0xb7, 0x34
1751                         ][..]
1752                 ).unwrap();
1753                 let public_key = PublicKey::from_secret_key(&Secp256k1::new(), &private_key);
1754
1755                 assert_eq!(invoice.recover_payee_pub_key(), Ok(crate::PayeePubKey(public_key)));
1756
1757                 let (raw_invoice, _, _) = invoice.into_parts();
1758                 let new_signed = raw_invoice.sign::<_, ()>(|hash| {
1759                         Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
1760                 }).unwrap();
1761
1762                 assert!(new_signed.check_signature());
1763         }
1764
1765         #[test]
1766         fn test_check_feature_bits() {
1767                 use crate::TaggedField::*;
1768                 use lightning::ln::features::InvoiceFeatures;
1769                 use secp256k1::Secp256k1;
1770                 use secp256k1::SecretKey;
1771                 use crate::{RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp, Invoice,
1772                          SemanticError};
1773
1774                 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
1775                 let payment_secret = lightning::ln::PaymentSecret([21; 32]);
1776                 let invoice_template = RawInvoice {
1777                         hrp: RawHrp {
1778                                 currency: Currency::Bitcoin,
1779                                 raw_amount: None,
1780                                 si_prefix: None,
1781                         },
1782                         data: RawDataPart {
1783                                 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1784                                 tagged_fields: vec ! [
1785                                         PaymentHash(Sha256(sha256::Hash::from_hex(
1786                                                 "0001020304050607080900010203040506070809000102030405060708090102"
1787                                         ).unwrap())).into(),
1788                                         Description(
1789                                                 crate::Description::new(
1790                                                         "Please consider supporting this project".to_owned()
1791                                                 ).unwrap()
1792                                         ).into(),
1793                                 ],
1794                         },
1795                 };
1796
1797                 // Missing features
1798                 let invoice = {
1799                         let mut invoice = invoice_template.clone();
1800                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1801                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1802                 }.unwrap();
1803                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures));
1804
1805                 // Missing feature bits
1806                 let invoice = {
1807                         let mut invoice = invoice_template.clone();
1808                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1809                         invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into());
1810                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1811                 }.unwrap();
1812                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures));
1813
1814                 let mut payment_secret_features = InvoiceFeatures::empty();
1815                 payment_secret_features.set_payment_secret_required();
1816
1817                 // Including payment secret and feature bits
1818                 let invoice = {
1819                         let mut invoice = invoice_template.clone();
1820                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1821                         invoice.data.tagged_fields.push(Features(payment_secret_features.clone()).into());
1822                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1823                 }.unwrap();
1824                 assert!(Invoice::from_signed(invoice).is_ok());
1825
1826                 // No payment secret or features
1827                 let invoice = {
1828                         let invoice = invoice_template.clone();
1829                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1830                 }.unwrap();
1831                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret));
1832
1833                 // No payment secret or feature bits
1834                 let invoice = {
1835                         let mut invoice = invoice_template.clone();
1836                         invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into());
1837                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1838                 }.unwrap();
1839                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret));
1840
1841                 // Missing payment secret
1842                 let invoice = {
1843                         let mut invoice = invoice_template.clone();
1844                         invoice.data.tagged_fields.push(Features(payment_secret_features).into());
1845                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1846                 }.unwrap();
1847                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret));
1848
1849                 // Multiple payment secrets
1850                 let invoice = {
1851                         let mut invoice = invoice_template;
1852                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1853                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1854                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1855                 }.unwrap();
1856                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::MultiplePaymentSecrets));
1857         }
1858
1859         #[test]
1860         fn test_builder_amount() {
1861                 use crate::*;
1862
1863                 let builder = InvoiceBuilder::new(Currency::Bitcoin)
1864                         .description("Test".into())
1865                         .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
1866                         .duration_since_epoch(Duration::from_secs(1234567));
1867
1868                 let invoice = builder.clone()
1869                         .amount_milli_satoshis(1500)
1870                         .build_raw()
1871                         .unwrap();
1872
1873                 assert_eq!(invoice.hrp.si_prefix, Some(SiPrefix::Nano));
1874                 assert_eq!(invoice.hrp.raw_amount, Some(15));
1875
1876
1877                 let invoice = builder
1878                         .amount_milli_satoshis(150)
1879                         .build_raw()
1880                         .unwrap();
1881
1882                 assert_eq!(invoice.hrp.si_prefix, Some(SiPrefix::Pico));
1883                 assert_eq!(invoice.hrp.raw_amount, Some(1500));
1884         }
1885
1886         #[test]
1887         fn test_builder_fail() {
1888                 use crate::*;
1889                 use lightning::routing::router::RouteHintHop;
1890                 use std::iter::FromIterator;
1891                 use secp256k1::PublicKey;
1892
1893                 let builder = InvoiceBuilder::new(Currency::Bitcoin)
1894                         .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
1895                         .duration_since_epoch(Duration::from_secs(1234567))
1896                         .min_final_cltv_expiry_delta(144);
1897
1898                 let too_long_string = String::from_iter(
1899                         (0..1024).map(|_| '?')
1900                 );
1901
1902                 let long_desc_res = builder.clone()
1903                         .description(too_long_string)
1904                         .build_raw();
1905                 assert_eq!(long_desc_res, Err(CreationError::DescriptionTooLong));
1906
1907                 let route_hop = RouteHintHop {
1908                         src_node_id: PublicKey::from_slice(
1909                                         &[
1910                                                 0x03, 0x9e, 0x03, 0xa9, 0x01, 0xb8, 0x55, 0x34, 0xff, 0x1e, 0x92, 0xc4,
1911                                                 0x3c, 0x74, 0x43, 0x1f, 0x7c, 0xe7, 0x20, 0x46, 0x06, 0x0f, 0xcf, 0x7a,
1912                                                 0x95, 0xc3, 0x7e, 0x14, 0x8f, 0x78, 0xc7, 0x72, 0x55
1913                                         ][..]
1914                                 ).unwrap(),
1915                         short_channel_id: 0,
1916                         fees: RoutingFees {
1917                                 base_msat: 0,
1918                                 proportional_millionths: 0,
1919                         },
1920                         cltv_expiry_delta: 0,
1921                         htlc_minimum_msat: None,
1922                         htlc_maximum_msat: None,
1923                 };
1924                 let too_long_route = RouteHint(vec![route_hop; 13]);
1925                 let long_route_res = builder.clone()
1926                         .description("Test".into())
1927                         .private_route(too_long_route)
1928                         .build_raw();
1929                 assert_eq!(long_route_res, Err(CreationError::RouteTooLong));
1930
1931                 let sign_error_res = builder
1932                         .description("Test".into())
1933                         .payment_secret(PaymentSecret([0; 32]))
1934                         .try_build_signed(|_| {
1935                                 Err("ImaginaryError")
1936                         });
1937                 assert_eq!(sign_error_res, Err(SignOrCreationError::SignError("ImaginaryError")));
1938         }
1939
1940         #[test]
1941         fn test_builder_ok() {
1942                 use crate::*;
1943                 use lightning::routing::router::RouteHintHop;
1944                 use secp256k1::Secp256k1;
1945                 use secp256k1::{SecretKey, PublicKey};
1946                 use std::time::{UNIX_EPOCH, Duration};
1947
1948                 let secp_ctx = Secp256k1::new();
1949
1950                 let private_key = SecretKey::from_slice(
1951                         &[
1952                                 0xe1, 0x26, 0xf6, 0x8f, 0x7e, 0xaf, 0xcc, 0x8b, 0x74, 0xf5, 0x4d, 0x26, 0x9f, 0xe2,
1953                                 0x06, 0xbe, 0x71, 0x50, 0x00, 0xf9, 0x4d, 0xac, 0x06, 0x7d, 0x1c, 0x04, 0xa8, 0xca,
1954                                 0x3b, 0x2d, 0xb7, 0x34
1955                         ][..]
1956                 ).unwrap();
1957                 let public_key = PublicKey::from_secret_key(&secp_ctx, &private_key);
1958
1959                 let route_1 = RouteHint(vec![
1960                         RouteHintHop {
1961                                 src_node_id: public_key,
1962                                 short_channel_id: de::parse_int_be(&[123; 8], 256).expect("short chan ID slice too big?"),
1963                                 fees: RoutingFees {
1964                                         base_msat: 2,
1965                                         proportional_millionths: 1,
1966                                 },
1967                                 cltv_expiry_delta: 145,
1968                                 htlc_minimum_msat: None,
1969                                 htlc_maximum_msat: None,
1970                         },
1971                         RouteHintHop {
1972                                 src_node_id: public_key,
1973                                 short_channel_id: de::parse_int_be(&[42; 8], 256).expect("short chan ID slice too big?"),
1974                                 fees: RoutingFees {
1975                                         base_msat: 3,
1976                                         proportional_millionths: 2,
1977                                 },
1978                                 cltv_expiry_delta: 146,
1979                                 htlc_minimum_msat: None,
1980                                 htlc_maximum_msat: None,
1981                         }
1982                 ]);
1983
1984                 let route_2 = RouteHint(vec![
1985                         RouteHintHop {
1986                                 src_node_id: public_key,
1987                                 short_channel_id: 0,
1988                                 fees: RoutingFees {
1989                                         base_msat: 4,
1990                                         proportional_millionths: 3,
1991                                 },
1992                                 cltv_expiry_delta: 147,
1993                                 htlc_minimum_msat: None,
1994                                 htlc_maximum_msat: None,
1995                         },
1996                         RouteHintHop {
1997                                 src_node_id: public_key,
1998                                 short_channel_id: de::parse_int_be(&[1; 8], 256).expect("short chan ID slice too big?"),
1999                                 fees: RoutingFees {
2000                                         base_msat: 5,
2001                                         proportional_millionths: 4,
2002                                 },
2003                                 cltv_expiry_delta: 148,
2004                                 htlc_minimum_msat: None,
2005                                 htlc_maximum_msat: None,
2006                         }
2007                 ]);
2008
2009                 let builder = InvoiceBuilder::new(Currency::BitcoinTestnet)
2010                         .amount_milli_satoshis(123)
2011                         .duration_since_epoch(Duration::from_secs(1234567))
2012                         .payee_pub_key(public_key)
2013                         .expiry_time(Duration::from_secs(54321))
2014                         .min_final_cltv_expiry_delta(144)
2015                         .fallback(Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap()))
2016                         .private_route(route_1.clone())
2017                         .private_route(route_2.clone())
2018                         .description_hash(sha256::Hash::from_slice(&[3;32][..]).unwrap())
2019                         .payment_hash(sha256::Hash::from_slice(&[21;32][..]).unwrap())
2020                         .payment_secret(PaymentSecret([42; 32]))
2021                         .basic_mpp();
2022
2023                 let invoice = builder.clone().build_signed(|hash| {
2024                         secp_ctx.sign_ecdsa_recoverable(hash, &private_key)
2025                 }).unwrap();
2026
2027                 assert!(invoice.check_signature().is_ok());
2028                 assert_eq!(invoice.tagged_fields().count(), 10);
2029
2030                 assert_eq!(invoice.amount_milli_satoshis(), Some(123));
2031                 assert_eq!(invoice.amount_pico_btc(), Some(1230));
2032                 assert_eq!(invoice.currency(), Currency::BitcoinTestnet);
2033                 #[cfg(feature = "std")]
2034                 assert_eq!(
2035                         invoice.timestamp().duration_since(UNIX_EPOCH).unwrap().as_secs(),
2036                         1234567
2037                 );
2038                 assert_eq!(invoice.payee_pub_key(), Some(&public_key));
2039                 assert_eq!(invoice.expiry_time(), Duration::from_secs(54321));
2040                 assert_eq!(invoice.min_final_cltv_expiry_delta(), 144);
2041                 assert_eq!(invoice.fallbacks(), vec![&Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap())]);
2042                 let address = Address::from_script(&Script::new_p2pkh(&PubkeyHash::from_slice(&[0;20]).unwrap()), Network::Testnet).unwrap();
2043                 assert_eq!(invoice.fallback_addresses(), vec![address]);
2044                 assert_eq!(invoice.private_routes(), vec![&PrivateRoute(route_1), &PrivateRoute(route_2)]);
2045                 assert_eq!(
2046                         invoice.description(),
2047                         InvoiceDescription::Hash(&Sha256(sha256::Hash::from_slice(&[3;32][..]).unwrap()))
2048                 );
2049                 assert_eq!(invoice.payment_hash(), &sha256::Hash::from_slice(&[21;32][..]).unwrap());
2050                 assert_eq!(invoice.payment_secret(), &PaymentSecret([42; 32]));
2051
2052                 let mut expected_features = InvoiceFeatures::empty();
2053                 expected_features.set_variable_length_onion_required();
2054                 expected_features.set_payment_secret_required();
2055                 expected_features.set_basic_mpp_optional();
2056                 assert_eq!(invoice.features(), Some(&expected_features));
2057
2058                 let raw_invoice = builder.build_raw().unwrap();
2059                 assert_eq!(raw_invoice, *invoice.into_signed_raw().raw_invoice())
2060         }
2061
2062         #[test]
2063         fn test_default_values() {
2064                 use crate::*;
2065                 use secp256k1::Secp256k1;
2066                 use secp256k1::SecretKey;
2067
2068                 let signed_invoice = InvoiceBuilder::new(Currency::Bitcoin)
2069                         .description("Test".into())
2070                         .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
2071                         .payment_secret(PaymentSecret([0; 32]))
2072                         .duration_since_epoch(Duration::from_secs(1234567))
2073                         .build_raw()
2074                         .unwrap()
2075                         .sign::<_, ()>(|hash| {
2076                                 let privkey = SecretKey::from_slice(&[41; 32]).unwrap();
2077                                 let secp_ctx = Secp256k1::new();
2078                                 Ok(secp_ctx.sign_ecdsa_recoverable(hash, &privkey))
2079                         })
2080                         .unwrap();
2081                 let invoice = Invoice::from_signed(signed_invoice).unwrap();
2082
2083                 assert_eq!(invoice.min_final_cltv_expiry_delta(), DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA);
2084                 assert_eq!(invoice.expiry_time(), Duration::from_secs(DEFAULT_EXPIRY_TIME));
2085                 assert!(!invoice.would_expire(Duration::from_secs(1234568)));
2086         }
2087
2088         #[test]
2089         fn test_expiration() {
2090                 use crate::*;
2091                 use secp256k1::Secp256k1;
2092                 use secp256k1::SecretKey;
2093
2094                 let signed_invoice = InvoiceBuilder::new(Currency::Bitcoin)
2095                         .description("Test".into())
2096                         .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
2097                         .payment_secret(PaymentSecret([0; 32]))
2098                         .duration_since_epoch(Duration::from_secs(1234567))
2099                         .build_raw()
2100                         .unwrap()
2101                         .sign::<_, ()>(|hash| {
2102                                 let privkey = SecretKey::from_slice(&[41; 32]).unwrap();
2103                                 let secp_ctx = Secp256k1::new();
2104                                 Ok(secp_ctx.sign_ecdsa_recoverable(hash, &privkey))
2105                         })
2106                         .unwrap();
2107                 let invoice = Invoice::from_signed(signed_invoice).unwrap();
2108
2109                 assert!(invoice.would_expire(Duration::from_secs(1234567 + DEFAULT_EXPIRY_TIME + 1)));
2110         }
2111
2112         #[cfg(feature = "serde")]
2113         #[test]
2114         fn test_serde() {
2115                 let invoice_str = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\
2116                         h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\
2117                         5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\
2118                         h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\
2119                         j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\
2120                         ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\
2121                         guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\
2122                         ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\
2123                         p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\
2124                         8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\
2125                         j5r6drg6k6zcqj0fcwg";
2126                 let invoice = invoice_str.parse::<super::Invoice>().unwrap();
2127                 let serialized_invoice = serde_json::to_string(&invoice).unwrap();
2128                 let deserialized_invoice: super::Invoice = serde_json::from_str(serialized_invoice.as_str()).unwrap();
2129                 assert_eq!(invoice, deserialized_invoice);
2130                 assert_eq!(invoice_str, deserialized_invoice.to_string().as_str());
2131                 assert_eq!(invoice_str, serialized_invoice.as_str().trim_matches('\"'));
2132         }
2133 }