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