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

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