_ Git - rust-lightning/blob - lightning-invoice/src/lib.rs

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