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

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