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