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