_ 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         pub fn network(&self) -> Network {
1364                 self.signed_invoice.currency().into()
1365         }
1366
1367         /// Returns the amount if specified in the invoice as millisatoshis.
1368         pub fn amount_milli_satoshis(&self) -> Option<u64> {
1369                 self.signed_invoice.amount_pico_btc().map(|v| v / 10)
1370         }
1371
1372         /// Returns the amount if specified in the invoice as pico BTC.
1373         fn amount_pico_btc(&self) -> Option<u64> {
1374                 self.signed_invoice.amount_pico_btc()
1375         }
1376 }
1377
1378 impl From<TaggedField> for RawTaggedField {
1379         fn from(tf: TaggedField) -> Self {
1380                 RawTaggedField::KnownSemantics(tf)
1381         }
1382 }
1383
1384 impl TaggedField {
1385         /// Numeric representation of the field's tag
1386         pub fn tag(&self) -> u5 {
1387                 let tag = match *self {
1388                         TaggedField::PaymentHash(_) => constants::TAG_PAYMENT_HASH,
1389                         TaggedField::Description(_) => constants::TAG_DESCRIPTION,
1390                         TaggedField::PayeePubKey(_) => constants::TAG_PAYEE_PUB_KEY,
1391                         TaggedField::DescriptionHash(_) => constants::TAG_DESCRIPTION_HASH,
1392                         TaggedField::ExpiryTime(_) => constants::TAG_EXPIRY_TIME,
1393                         TaggedField::MinFinalCltvExpiryDelta(_) => constants::TAG_MIN_FINAL_CLTV_EXPIRY_DELTA,
1394                         TaggedField::Fallback(_) => constants::TAG_FALLBACK,
1395                         TaggedField::PrivateRoute(_) => constants::TAG_PRIVATE_ROUTE,
1396                         TaggedField::PaymentSecret(_) => constants::TAG_PAYMENT_SECRET,
1397                         TaggedField::Features(_) => constants::TAG_FEATURES,
1398                 };
1399
1400                 u5::try_from_u8(tag).expect("all tags defined are <32")
1401         }
1402 }
1403
1404 impl Description {
1405
1406         /// Creates a new `Description` if `description` is at most 1023 __bytes__ long,
1407         /// returns [`CreationError::DescriptionTooLong`] otherwise
1408         ///
1409         /// Please note that single characters may use more than one byte due to UTF8 encoding.
1410         pub fn new(description: String) -> Result<Description, CreationError> {
1411                 if description.len() > 639 {
1412                         Err(CreationError::DescriptionTooLong)
1413                 } else {
1414                         Ok(Description(description))
1415                 }
1416         }
1417
1418         /// Returns the underlying description [`String`]
1419         pub fn into_inner(self) -> String {
1420                 self.0
1421         }
1422 }
1423
1424 impl From<Description> for String {
1425         fn from(val: Description) -> Self {
1426                 val.into_inner()
1427         }
1428 }
1429
1430 impl Deref for Description {
1431         type Target = str;
1432
1433         fn deref(&self) -> &str {
1434                 &self.0
1435         }
1436 }
1437
1438 impl From<PublicKey> for PayeePubKey {
1439         fn from(pk: PublicKey) -> Self {
1440                 PayeePubKey(pk)
1441         }
1442 }
1443
1444 impl Deref for PayeePubKey {
1445         type Target = PublicKey;
1446
1447         fn deref(&self) -> &PublicKey {
1448                 &self.0
1449         }
1450 }
1451
1452 impl ExpiryTime {
1453         /// Construct an `ExpiryTime` from seconds.
1454         pub fn from_seconds(seconds: u64) -> ExpiryTime {
1455                 ExpiryTime(Duration::from_secs(seconds))
1456         }
1457
1458         /// Construct an `ExpiryTime` from a [`Duration`], dropping the sub-second part.
1459         pub fn from_duration(duration: Duration) -> ExpiryTime {
1460                 Self::from_seconds(duration.as_secs())
1461         }
1462
1463         /// Returns the expiry time in seconds
1464         pub fn as_seconds(&self) -> u64 {
1465                 self.0.as_secs()
1466         }
1467
1468         /// Returns a reference to the underlying [`Duration`] (=expiry time)
1469         pub fn as_duration(&self) -> &Duration {
1470                 &self.0
1471         }
1472 }
1473
1474 impl PrivateRoute {
1475         /// Creates a new (partial) route from a list of hops
1476         pub fn new(hops: RouteHint) -> Result<PrivateRoute, CreationError> {
1477                 if hops.0.len() <= 12 {
1478                         Ok(PrivateRoute(hops))
1479                 } else {
1480                         Err(CreationError::RouteTooLong)
1481                 }
1482         }
1483
1484         /// Returns the underlying list of hops
1485         pub fn into_inner(self) -> RouteHint {
1486                 self.0
1487         }
1488 }
1489
1490 impl From<PrivateRoute> for RouteHint {
1491         fn from(val: PrivateRoute) -> Self {
1492                 val.into_inner()
1493         }
1494 }
1495
1496 impl Deref for PrivateRoute {
1497         type Target = RouteHint;
1498
1499         fn deref(&self) -> &RouteHint {
1500                 &self.0
1501         }
1502 }
1503
1504 impl Deref for InvoiceSignature {
1505         type Target = RecoverableSignature;
1506
1507         fn deref(&self) -> &RecoverableSignature {
1508                 &self.0
1509         }
1510 }
1511
1512 impl Deref for SignedRawInvoice {
1513         type Target = RawInvoice;
1514
1515         fn deref(&self) -> &RawInvoice {
1516                 &self.raw_invoice
1517         }
1518 }
1519
1520 /// Errors that may occur when constructing a new [`RawInvoice`] or [`Invoice`]
1521 #[derive(Eq, PartialEq, Debug, Clone)]
1522 pub enum CreationError {
1523         /// The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
1524         DescriptionTooLong,
1525
1526         /// The specified route has too many hops and can't be encoded
1527         RouteTooLong,
1528
1529         /// The Unix timestamp of the supplied date is less than zero or greater than 35-bits
1530         TimestampOutOfBounds,
1531
1532         /// The supplied millisatoshi amount was greater than the total bitcoin supply.
1533         InvalidAmount,
1534
1535         /// Route hints were required for this invoice and were missing. Applies to
1536         /// [phantom invoices].
1537         ///
1538         /// [phantom invoices]: crate::utils::create_phantom_invoice
1539         MissingRouteHints,
1540
1541         /// The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
1542         ///
1543         /// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
1544         MinFinalCltvExpiryDeltaTooShort,
1545 }
1546
1547 impl Display for CreationError {
1548         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1549                 match self {
1550                         CreationError::DescriptionTooLong => f.write_str("The supplied description string was longer than 639 bytes"),
1551                         CreationError::RouteTooLong => f.write_str("The specified route has too many hops and can't be encoded"),
1552                         CreationError::TimestampOutOfBounds => f.write_str("The Unix timestamp of the supplied date is less than zero or greater than 35-bits"),
1553                         CreationError::InvalidAmount => f.write_str("The supplied millisatoshi amount was greater than the total bitcoin supply"),
1554                         CreationError::MissingRouteHints => f.write_str("The invoice required route hints and they weren't provided"),
1555                         CreationError::MinFinalCltvExpiryDeltaTooShort => f.write_str(
1556                                 "The supplied final CLTV expiry delta was less than LDK's `MIN_FINAL_CLTV_EXPIRY_DELTA`"),
1557                 }
1558         }
1559 }
1560
1561 #[cfg(feature = "std")]
1562 impl std::error::Error for CreationError { }
1563
1564 /// Errors that may occur when converting a [`RawInvoice`] to an [`Invoice`]. They relate to the
1565 /// requirements sections in BOLT #11
1566 #[derive(Eq, PartialEq, Debug, Clone)]
1567 pub enum SemanticError {
1568         /// The invoice is missing the mandatory payment hash
1569         NoPaymentHash,
1570
1571         /// The invoice has multiple payment hashes which isn't allowed
1572         MultiplePaymentHashes,
1573
1574         /// No description or description hash are part of the invoice
1575         NoDescription,
1576
1577         /// The invoice contains multiple descriptions and/or description hashes which isn't allowed
1578         MultipleDescriptions,
1579
1580         /// The invoice is missing the mandatory payment secret, which all modern lightning nodes
1581         /// should provide.
1582         NoPaymentSecret,
1583
1584         /// The invoice contains multiple payment secrets
1585         MultiplePaymentSecrets,
1586
1587         /// The invoice's features are invalid
1588         InvalidFeatures,
1589
1590         /// The recovery id doesn't fit the signature/pub key
1591         InvalidRecoveryId,
1592
1593         /// The invoice's signature is invalid
1594         InvalidSignature,
1595
1596         /// The invoice's amount was not a whole number of millisatoshis
1597         ImpreciseAmount,
1598 }
1599
1600 impl Display for SemanticError {
1601         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1602                 match self {
1603                         SemanticError::NoPaymentHash => f.write_str("The invoice is missing the mandatory payment hash"),
1604                         SemanticError::MultiplePaymentHashes => f.write_str("The invoice has multiple payment hashes which isn't allowed"),
1605                         SemanticError::NoDescription => f.write_str("No description or description hash are part of the invoice"),
1606                         SemanticError::MultipleDescriptions => f.write_str("The invoice contains multiple descriptions and/or description hashes which isn't allowed"),
1607                         SemanticError::NoPaymentSecret => f.write_str("The invoice is missing the mandatory payment secret"),
1608                         SemanticError::MultiplePaymentSecrets => f.write_str("The invoice contains multiple payment secrets"),
1609                         SemanticError::InvalidFeatures => f.write_str("The invoice's features are invalid"),
1610                         SemanticError::InvalidRecoveryId => f.write_str("The recovery id doesn't fit the signature/pub key"),
1611                         SemanticError::InvalidSignature => f.write_str("The invoice's signature is invalid"),
1612                         SemanticError::ImpreciseAmount => f.write_str("The invoice's amount was not a whole number of millisatoshis"),
1613                 }
1614         }
1615 }
1616
1617 #[cfg(feature = "std")]
1618 impl std::error::Error for SemanticError { }
1619
1620 /// When signing using a fallible method either an user-supplied `SignError` or a [`CreationError`]
1621 /// may occur.
1622 #[derive(Eq, PartialEq, Debug, Clone)]
1623 pub enum SignOrCreationError<S = ()> {
1624         /// An error occurred during signing
1625         SignError(S),
1626
1627         /// An error occurred while building the transaction
1628         CreationError(CreationError),
1629 }
1630
1631 impl<S> Display for SignOrCreationError<S> {
1632         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1633                 match self {
1634                         SignOrCreationError::SignError(_) => f.write_str("An error occurred during signing"),
1635                         SignOrCreationError::CreationError(err) => err.fmt(f),
1636                 }
1637         }
1638 }
1639
1640 #[cfg(feature = "serde")]
1641 impl Serialize for Invoice {
1642         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
1643                 serializer.serialize_str(self.to_string().as_str())
1644         }
1645 }
1646 #[cfg(feature = "serde")]
1647 impl<'de> Deserialize<'de> for Invoice {
1648         fn deserialize<D>(deserializer: D) -> Result<Invoice, D::Error> where D: Deserializer<'de> {
1649                 let bolt11 = String::deserialize(deserializer)?
1650                         .parse::<Invoice>()
1651                         .map_err(|e| D::Error::custom(alloc::format!("{:?}", e)))?;
1652
1653                 Ok(bolt11)
1654         }
1655 }
1656
1657 #[cfg(test)]
1658 mod test {
1659         use bitcoin::Script;
1660         use bitcoin_hashes::hex::FromHex;
1661         use bitcoin_hashes::sha256;
1662
1663         #[test]
1664         fn test_system_time_bounds_assumptions() {
1665                 assert_eq!(
1666                         crate::PositiveTimestamp::from_unix_timestamp(crate::MAX_TIMESTAMP + 1),
1667                         Err(crate::CreationError::TimestampOutOfBounds)
1668                 );
1669         }
1670
1671         #[test]
1672         fn test_calc_invoice_hash() {
1673                 use crate::{RawInvoice, RawHrp, RawDataPart, Currency, PositiveTimestamp};
1674                 use crate::TaggedField::*;
1675
1676                 let invoice = RawInvoice {
1677                         hrp: RawHrp {
1678                                 currency: Currency::Bitcoin,
1679                                 raw_amount: None,
1680                                 si_prefix: None,
1681                         },
1682                         data: RawDataPart {
1683                                 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1684                                 tagged_fields: vec![
1685                                         PaymentHash(crate::Sha256(sha256::Hash::from_hex(
1686                                                 "0001020304050607080900010203040506070809000102030405060708090102"
1687                                         ).unwrap())).into(),
1688                                         Description(crate::Description::new(
1689                                                 "Please consider supporting this project".to_owned()
1690                                         ).unwrap()).into(),
1691                                 ],
1692                         },
1693                 };
1694
1695                 let expected_hash = [
1696                         0xc3, 0xd4, 0xe8, 0x3f, 0x64, 0x6f, 0xa7, 0x9a, 0x39, 0x3d, 0x75, 0x27, 0x7b, 0x1d,
1697                         0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7, 0x83, 0x5d, 0xb2, 0xec,
1698                         0xd5, 0x18, 0xe1, 0xc9
1699                 ];
1700
1701                 assert_eq!(invoice.signable_hash(), expected_hash)
1702         }
1703
1704         #[test]
1705         fn test_check_signature() {
1706                 use crate::TaggedField::*;
1707                 use secp256k1::Secp256k1;
1708                 use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
1709                 use secp256k1::{SecretKey, PublicKey};
1710                 use crate::{SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256,
1711                          PositiveTimestamp};
1712
1713                 let invoice = SignedRawInvoice {
1714                         raw_invoice: RawInvoice {
1715                                 hrp: RawHrp {
1716                                         currency: Currency::Bitcoin,
1717                                         raw_amount: None,
1718                                         si_prefix: None,
1719                                 },
1720                                 data: RawDataPart {
1721                                         timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1722                                         tagged_fields: vec ! [
1723                                                 PaymentHash(Sha256(sha256::Hash::from_hex(
1724                                                         "0001020304050607080900010203040506070809000102030405060708090102"
1725                                                 ).unwrap())).into(),
1726                                                 Description(
1727                                                         crate::Description::new(
1728                                                                 "Please consider supporting this project".to_owned()
1729                                                         ).unwrap()
1730                                                 ).into(),
1731                                         ],
1732                                 },
1733                         },
1734                         hash: [
1735                                 0xc3, 0xd4, 0xe8, 0x3f, 0x64, 0x6f, 0xa7, 0x9a, 0x39, 0x3d, 0x75, 0x27,
1736                                 0x7b, 0x1d, 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7,
1737                                 0x83, 0x5d, 0xb2, 0xec, 0xd5, 0x18, 0xe1, 0xc9
1738                         ],
1739                         signature: InvoiceSignature(RecoverableSignature::from_compact(
1740                                 & [
1741                                         0x38u8, 0xec, 0x68, 0x91, 0x34, 0x5e, 0x20, 0x41, 0x45, 0xbe, 0x8a,
1742                                         0x3a, 0x99, 0xde, 0x38, 0xe9, 0x8a, 0x39, 0xd6, 0xa5, 0x69, 0x43,
1743                                         0x4e, 0x18, 0x45, 0xc8, 0xaf, 0x72, 0x05, 0xaf, 0xcf, 0xcc, 0x7f,
1744                                         0x42, 0x5f, 0xcd, 0x14, 0x63, 0xe9, 0x3c, 0x32, 0x88, 0x1e, 0xad,
1745                                         0x0d, 0x6e, 0x35, 0x6d, 0x46, 0x7e, 0xc8, 0xc0, 0x25, 0x53, 0xf9,
1746                                         0xaa, 0xb1, 0x5e, 0x57, 0x38, 0xb1, 0x1f, 0x12, 0x7f
1747                                 ],
1748                                 RecoveryId::from_i32(0).unwrap()
1749                         ).unwrap()),
1750                 };
1751
1752                 assert!(invoice.check_signature());
1753
1754                 let private_key = SecretKey::from_slice(
1755                         &[
1756                                 0xe1, 0x26, 0xf6, 0x8f, 0x7e, 0xaf, 0xcc, 0x8b, 0x74, 0xf5, 0x4d, 0x26, 0x9f, 0xe2,
1757                                 0x06, 0xbe, 0x71, 0x50, 0x00, 0xf9, 0x4d, 0xac, 0x06, 0x7d, 0x1c, 0x04, 0xa8, 0xca,
1758                                 0x3b, 0x2d, 0xb7, 0x34
1759                         ][..]
1760                 ).unwrap();
1761                 let public_key = PublicKey::from_secret_key(&Secp256k1::new(), &private_key);
1762
1763                 assert_eq!(invoice.recover_payee_pub_key(), Ok(crate::PayeePubKey(public_key)));
1764
1765                 let (raw_invoice, _, _) = invoice.into_parts();
1766                 let new_signed = raw_invoice.sign::<_, ()>(|hash| {
1767                         Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
1768                 }).unwrap();
1769
1770                 assert!(new_signed.check_signature());
1771         }
1772
1773         #[test]
1774         fn test_check_feature_bits() {
1775                 use crate::TaggedField::*;
1776                 use lightning::ln::features::InvoiceFeatures;
1777                 use secp256k1::Secp256k1;
1778                 use secp256k1::SecretKey;
1779                 use crate::{RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp, Invoice,
1780                          SemanticError};
1781
1782                 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
1783                 let payment_secret = lightning::ln::PaymentSecret([21; 32]);
1784                 let invoice_template = RawInvoice {
1785                         hrp: RawHrp {
1786                                 currency: Currency::Bitcoin,
1787                                 raw_amount: None,
1788                                 si_prefix: None,
1789                         },
1790                         data: RawDataPart {
1791                                 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1792                                 tagged_fields: vec ! [
1793                                         PaymentHash(Sha256(sha256::Hash::from_hex(
1794                                                 "0001020304050607080900010203040506070809000102030405060708090102"
1795                                         ).unwrap())).into(),
1796                                         Description(
1797                                                 crate::Description::new(
1798                                                         "Please consider supporting this project".to_owned()
1799                                                 ).unwrap()
1800                                         ).into(),
1801                                 ],
1802                         },
1803                 };
1804
1805                 // Missing features
1806                 let invoice = {
1807                         let mut invoice = invoice_template.clone();
1808                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1809                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1810                 }.unwrap();
1811                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures));
1812
1813                 // Missing feature bits
1814                 let invoice = {
1815                         let mut invoice = invoice_template.clone();
1816                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1817                         invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into());
1818                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1819                 }.unwrap();
1820                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures));
1821
1822                 let mut payment_secret_features = InvoiceFeatures::empty();
1823                 payment_secret_features.set_payment_secret_required();
1824
1825                 // Including payment secret and feature bits
1826                 let invoice = {
1827                         let mut invoice = invoice_template.clone();
1828                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1829                         invoice.data.tagged_fields.push(Features(payment_secret_features.clone()).into());
1830                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1831                 }.unwrap();
1832                 assert!(Invoice::from_signed(invoice).is_ok());
1833
1834                 // No payment secret or features
1835                 let invoice = {
1836                         let invoice = invoice_template.clone();
1837                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1838                 }.unwrap();
1839                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret));
1840
1841                 // No payment secret or feature bits
1842                 let invoice = {
1843                         let mut invoice = invoice_template.clone();
1844                         invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into());
1845                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1846                 }.unwrap();
1847                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret));
1848
1849                 // Missing payment secret
1850                 let invoice = {
1851                         let mut invoice = invoice_template.clone();
1852                         invoice.data.tagged_fields.push(Features(payment_secret_features).into());
1853                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1854                 }.unwrap();
1855                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret));
1856
1857                 // Multiple payment secrets
1858                 let invoice = {
1859                         let mut invoice = invoice_template;
1860                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1861                         invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1862                         invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1863                 }.unwrap();
1864                 assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::MultiplePaymentSecrets));
1865         }
1866
1867         #[test]
1868         fn test_builder_amount() {
1869                 use crate::*;
1870
1871                 let builder = InvoiceBuilder::new(Currency::Bitcoin)
1872                         .description("Test".into())
1873                         .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
1874                         .duration_since_epoch(Duration::from_secs(1234567));
1875
1876                 let invoice = builder.clone()
1877                         .amount_milli_satoshis(1500)
1878                         .build_raw()
1879                         .unwrap();
1880
1881                 assert_eq!(invoice.hrp.si_prefix, Some(SiPrefix::Nano));
1882                 assert_eq!(invoice.hrp.raw_amount, Some(15));
1883
1884
1885                 let invoice = builder
1886                         .amount_milli_satoshis(150)
1887                         .build_raw()
1888                         .unwrap();
1889
1890                 assert_eq!(invoice.hrp.si_prefix, Some(SiPrefix::Pico));
1891                 assert_eq!(invoice.hrp.raw_amount, Some(1500));
1892         }
1893
1894         #[test]
1895         fn test_builder_fail() {
1896                 use crate::*;
1897                 use lightning::routing::router::RouteHintHop;
1898                 use std::iter::FromIterator;
1899                 use secp256k1::PublicKey;
1900
1901                 let builder = InvoiceBuilder::new(Currency::Bitcoin)
1902                         .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
1903                         .duration_since_epoch(Duration::from_secs(1234567))
1904                         .min_final_cltv_expiry_delta(144);
1905
1906                 let too_long_string = String::from_iter(
1907                         (0..1024).map(|_| '?')
1908                 );
1909
1910                 let long_desc_res = builder.clone()
1911                         .description(too_long_string)
1912                         .build_raw();
1913                 assert_eq!(long_desc_res, Err(CreationError::DescriptionTooLong));
1914
1915                 let route_hop = RouteHintHop {
1916                         src_node_id: PublicKey::from_slice(
1917                                         &[
1918                                                 0x03, 0x9e, 0x03, 0xa9, 0x01, 0xb8, 0x55, 0x34, 0xff, 0x1e, 0x92, 0xc4,
1919                                                 0x3c, 0x74, 0x43, 0x1f, 0x7c, 0xe7, 0x20, 0x46, 0x06, 0x0f, 0xcf, 0x7a,
1920                                                 0x95, 0xc3, 0x7e, 0x14, 0x8f, 0x78, 0xc7, 0x72, 0x55
1921                                         ][..]
1922                                 ).unwrap(),
1923                         short_channel_id: 0,
1924                         fees: RoutingFees {
1925                                 base_msat: 0,
1926                                 proportional_millionths: 0,
1927                         },
1928                         cltv_expiry_delta: 0,
1929                         htlc_minimum_msat: None,
1930                         htlc_maximum_msat: None,
1931                 };
1932                 let too_long_route = RouteHint(vec![route_hop; 13]);
1933                 let long_route_res = builder.clone()
1934                         .description("Test".into())
1935                         .private_route(too_long_route)
1936                         .build_raw();
1937                 assert_eq!(long_route_res, Err(CreationError::RouteTooLong));
1938
1939                 let sign_error_res = builder
1940                         .description("Test".into())
1941                         .payment_secret(PaymentSecret([0; 32]))
1942                         .try_build_signed(|_| {
1943                                 Err("ImaginaryError")
1944                         });
1945                 assert_eq!(sign_error_res, Err(SignOrCreationError::SignError("ImaginaryError")));
1946         }
1947
1948         #[test]
1949         fn test_builder_ok() {
1950                 use crate::*;
1951                 use lightning::routing::router::RouteHintHop;
1952                 use secp256k1::Secp256k1;
1953                 use secp256k1::{SecretKey, PublicKey};
1954                 use std::time::{UNIX_EPOCH, Duration};
1955
1956                 let secp_ctx = Secp256k1::new();
1957
1958                 let private_key = SecretKey::from_slice(
1959                         &[
1960                                 0xe1, 0x26, 0xf6, 0x8f, 0x7e, 0xaf, 0xcc, 0x8b, 0x74, 0xf5, 0x4d, 0x26, 0x9f, 0xe2,
1961                                 0x06, 0xbe, 0x71, 0x50, 0x00, 0xf9, 0x4d, 0xac, 0x06, 0x7d, 0x1c, 0x04, 0xa8, 0xca,
1962                                 0x3b, 0x2d, 0xb7, 0x34
1963                         ][..]
1964                 ).unwrap();
1965                 let public_key = PublicKey::from_secret_key(&secp_ctx, &private_key);
1966
1967                 let route_1 = RouteHint(vec![
1968                         RouteHintHop {
1969                                 src_node_id: public_key,
1970                                 short_channel_id: de::parse_int_be(&[123; 8], 256).expect("short chan ID slice too big?"),
1971                                 fees: RoutingFees {
1972                                         base_msat: 2,
1973                                         proportional_millionths: 1,
1974                                 },
1975                                 cltv_expiry_delta: 145,
1976                                 htlc_minimum_msat: None,
1977                                 htlc_maximum_msat: None,
1978                         },
1979                         RouteHintHop {
1980                                 src_node_id: public_key,
1981                                 short_channel_id: de::parse_int_be(&[42; 8], 256).expect("short chan ID slice too big?"),
1982                                 fees: RoutingFees {
1983                                         base_msat: 3,
1984                                         proportional_millionths: 2,
1985                                 },
1986                                 cltv_expiry_delta: 146,
1987                                 htlc_minimum_msat: None,
1988                                 htlc_maximum_msat: None,
1989                         }
1990                 ]);
1991
1992                 let route_2 = RouteHint(vec![
1993                         RouteHintHop {
1994                                 src_node_id: public_key,
1995                                 short_channel_id: 0,
1996                                 fees: RoutingFees {
1997                                         base_msat: 4,
1998                                         proportional_millionths: 3,
1999                                 },
2000                                 cltv_expiry_delta: 147,
2001                                 htlc_minimum_msat: None,
2002                                 htlc_maximum_msat: None,
2003                         },
2004                         RouteHintHop {
2005                                 src_node_id: public_key,
2006                                 short_channel_id: de::parse_int_be(&[1; 8], 256).expect("short chan ID slice too big?"),
2007                                 fees: RoutingFees {
2008                                         base_msat: 5,
2009                                         proportional_millionths: 4,
2010                                 },
2011                                 cltv_expiry_delta: 148,
2012                                 htlc_minimum_msat: None,
2013                                 htlc_maximum_msat: None,
2014                         }
2015                 ]);
2016
2017                 let builder = InvoiceBuilder::new(Currency::BitcoinTestnet)
2018                         .amount_milli_satoshis(123)
2019                         .duration_since_epoch(Duration::from_secs(1234567))
2020                         .payee_pub_key(public_key)
2021                         .expiry_time(Duration::from_secs(54321))
2022                         .min_final_cltv_expiry_delta(144)
2023                         .fallback(Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap()))
2024                         .private_route(route_1.clone())
2025                         .private_route(route_2.clone())
2026                         .description_hash(sha256::Hash::from_slice(&[3;32][..]).unwrap())
2027                         .payment_hash(sha256::Hash::from_slice(&[21;32][..]).unwrap())
2028                         .payment_secret(PaymentSecret([42; 32]))
2029                         .basic_mpp();
2030
2031                 let invoice = builder.clone().build_signed(|hash| {
2032                         secp_ctx.sign_ecdsa_recoverable(hash, &private_key)
2033                 }).unwrap();
2034
2035                 assert!(invoice.check_signature().is_ok());
2036                 assert_eq!(invoice.tagged_fields().count(), 10);
2037
2038                 assert_eq!(invoice.amount_milli_satoshis(), Some(123));
2039                 assert_eq!(invoice.amount_pico_btc(), Some(1230));
2040                 assert_eq!(invoice.currency(), Currency::BitcoinTestnet);
2041                 #[cfg(feature = "std")]
2042                 assert_eq!(
2043                         invoice.timestamp().duration_since(UNIX_EPOCH).unwrap().as_secs(),
2044                         1234567
2045                 );
2046                 assert_eq!(invoice.payee_pub_key(), Some(&public_key));
2047                 assert_eq!(invoice.expiry_time(), Duration::from_secs(54321));
2048                 assert_eq!(invoice.min_final_cltv_expiry_delta(), 144);
2049                 assert_eq!(invoice.fallbacks(), vec![&Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap())]);
2050                 let address = Address::from_script(&Script::new_p2pkh(&PubkeyHash::from_slice(&[0;20]).unwrap()), Network::Testnet).unwrap();
2051                 assert_eq!(invoice.fallback_addresses(), vec![address]);
2052                 assert_eq!(invoice.private_routes(), vec![&PrivateRoute(route_1), &PrivateRoute(route_2)]);
2053                 assert_eq!(
2054                         invoice.description(),
2055                         InvoiceDescription::Hash(&Sha256(sha256::Hash::from_slice(&[3;32][..]).unwrap()))
2056                 );
2057                 assert_eq!(invoice.payment_hash(), &sha256::Hash::from_slice(&[21;32][..]).unwrap());
2058                 assert_eq!(invoice.payment_secret(), &PaymentSecret([42; 32]));
2059
2060                 let mut expected_features = InvoiceFeatures::empty();
2061                 expected_features.set_variable_length_onion_required();
2062                 expected_features.set_payment_secret_required();
2063                 expected_features.set_basic_mpp_optional();
2064                 assert_eq!(invoice.features(), Some(&expected_features));
2065
2066                 let raw_invoice = builder.build_raw().unwrap();
2067                 assert_eq!(raw_invoice, *invoice.into_signed_raw().raw_invoice())
2068         }
2069
2070         #[test]
2071         fn test_default_values() {
2072                 use crate::*;
2073                 use secp256k1::Secp256k1;
2074                 use secp256k1::SecretKey;
2075
2076                 let signed_invoice = InvoiceBuilder::new(Currency::Bitcoin)
2077                         .description("Test".into())
2078                         .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
2079                         .payment_secret(PaymentSecret([0; 32]))
2080                         .duration_since_epoch(Duration::from_secs(1234567))
2081                         .build_raw()
2082                         .unwrap()
2083                         .sign::<_, ()>(|hash| {
2084                                 let privkey = SecretKey::from_slice(&[41; 32]).unwrap();
2085                                 let secp_ctx = Secp256k1::new();
2086                                 Ok(secp_ctx.sign_ecdsa_recoverable(hash, &privkey))
2087                         })
2088                         .unwrap();
2089                 let invoice = Invoice::from_signed(signed_invoice).unwrap();
2090
2091                 assert_eq!(invoice.min_final_cltv_expiry_delta(), DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA);
2092                 assert_eq!(invoice.expiry_time(), Duration::from_secs(DEFAULT_EXPIRY_TIME));
2093                 assert!(!invoice.would_expire(Duration::from_secs(1234568)));
2094         }
2095
2096         #[test]
2097         fn test_expiration() {
2098                 use crate::*;
2099                 use secp256k1::Secp256k1;
2100                 use secp256k1::SecretKey;
2101
2102                 let signed_invoice = InvoiceBuilder::new(Currency::Bitcoin)
2103                         .description("Test".into())
2104                         .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
2105                         .payment_secret(PaymentSecret([0; 32]))
2106                         .duration_since_epoch(Duration::from_secs(1234567))
2107                         .build_raw()
2108                         .unwrap()
2109                         .sign::<_, ()>(|hash| {
2110                                 let privkey = SecretKey::from_slice(&[41; 32]).unwrap();
2111                                 let secp_ctx = Secp256k1::new();
2112                                 Ok(secp_ctx.sign_ecdsa_recoverable(hash, &privkey))
2113                         })
2114                         .unwrap();
2115                 let invoice = Invoice::from_signed(signed_invoice).unwrap();
2116
2117                 assert!(invoice.would_expire(Duration::from_secs(1234567 + DEFAULT_EXPIRY_TIME + 1)));
2118         }
2119
2120         #[cfg(feature = "serde")]
2121         #[test]
2122         fn test_serde() {
2123                 let invoice_str = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\
2124                         h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\
2125                         5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\
2126                         h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\
2127                         j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\
2128                         ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\
2129                         guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\
2130                         ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\
2131                         p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\
2132                         8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\
2133                         j5r6drg6k6zcqj0fcwg";
2134                 let invoice = invoice_str.parse::<super::Invoice>().unwrap();
2135                 let serialized_invoice = serde_json::to_string(&invoice).unwrap();
2136                 let deserialized_invoice: super::Invoice = serde_json::from_str(serialized_invoice.as_str()).unwrap();
2137                 assert_eq!(invoice, deserialized_invoice);
2138                 assert_eq!(invoice_str, deserialized_invoice.to_string().as_str());
2139                 assert_eq!(invoice_str, serialized_invoice.as_str().trim_matches('\"'));
2140         }
2141 }