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