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