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