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