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

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