1 // Prefix these with `rustdoc::` when we update our MSRV to be >= 1.52 to remove warnings.
2 #![deny(broken_intra_doc_links)]
3 #![deny(private_intra_doc_links)]
6 #![deny(non_upper_case_globals)]
7 #![deny(non_camel_case_types)]
8 #![deny(non_snake_case)]
11 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
13 #![cfg_attr(feature = "strict", deny(warnings))]
14 #![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
16 //! This crate provides data structures to represent
17 //! [lightning BOLT11](https://github.com/lightning/bolts/blob/master/11-payment-encoding.md)
18 //! invoices and functions to create, encode and decode these. If you just want to use the standard
19 //! en-/decoding functionality this should get you started:
21 //! * For parsing use `str::parse::<Bolt11Invoice>(&self)` (see [`Bolt11Invoice::from_str`])
22 //! * For constructing invoices use the [`InvoiceBuilder`]
23 //! * For serializing invoices use the [`Display`]/[`ToString`] traits
25 //! [`Bolt11Invoice::from_str`]: crate::Bolt11Invoice#impl-FromStr
27 #[cfg(not(any(feature = "std", feature = "no-std")))]
28 compile_error!("at least one of the `std` or `no-std` features must be enabled");
34 extern crate bitcoin_hashes;
35 #[macro_use] extern crate lightning;
36 extern crate num_traits;
37 extern crate secp256k1;
39 #[cfg(any(test, feature = "std"))]
41 #[cfg(feature = "serde")]
44 #[cfg(feature = "std")]
45 use std::time::SystemTime;
48 use bitcoin::{Address, Network, PubkeyHash, ScriptHash};
49 use bitcoin::util::address::{Payload, WitnessVersion};
50 use bitcoin_hashes::{Hash, sha256};
51 use lightning::ln::features::Bolt11InvoiceFeatures;
52 use lightning::util::invoice::construct_invoice_preimage;
54 use secp256k1::PublicKey;
55 use secp256k1::{Message, Secp256k1};
56 use secp256k1::ecdsa::RecoverableSignature;
58 use core::cmp::Ordering;
59 use core::fmt::{Display, Formatter, self};
60 use core::iter::FilterMap;
61 use core::num::ParseIntError;
63 use core::slice::Iter;
64 use core::time::Duration;
67 #[cfg(feature = "serde")]
68 use serde::{Deserialize, Deserializer,Serialize, Serializer, de::Error};
71 pub use lightning::ln::PaymentSecret;
73 pub use lightning::routing::router::{RouteHint, RouteHintHop};
75 pub use lightning::routing::gossip::RoutingFees;
82 #[cfg(feature = "hashbrown")]
83 extern crate hashbrown;
85 pub use alloc::{vec, vec::Vec, string::String, collections::VecDeque, boxed::Box};
86 #[cfg(not(feature = "hashbrown"))]
87 pub use std::collections::{HashMap, HashSet, hash_map};
88 #[cfg(feature = "hashbrown")]
89 pub use self::hashbrown::{HashMap, HashSet, hash_map};
91 pub use alloc::string::ToString;
94 use crate::prelude::*;
96 /// Sync compat for std/no_std
97 #[cfg(feature = "std")]
99 pub use ::std::sync::{Mutex, MutexGuard};
102 /// Sync compat for std/no_std
103 #[cfg(not(feature = "std"))]
106 /// Errors that indicate what is wrong with the invoice. They have some granularity for debug
107 /// reasons, but should generally result in an "invalid BOLT11 invoice" message for the user.
108 #[allow(missing_docs)]
109 #[derive(PartialEq, Eq, Debug, Clone)]
110 pub enum Bolt11ParseError {
111 Bech32Error(bech32::Error),
112 ParseAmountError(ParseIntError),
113 MalformedSignature(secp256k1::Error),
119 UnexpectedEndOfTaggedFields,
120 DescriptionDecodeError(str::Utf8Error),
122 IntegerOverflowError,
123 InvalidSegWitProgramLength,
124 InvalidPubKeyHashLength,
125 InvalidScriptHashLength,
127 InvalidSliceLength(String),
129 /// Not an error, but used internally to signal that a part of the invoice should be ignored
130 /// according to BOLT11
134 /// Indicates that something went wrong while parsing or validating the invoice. Parsing errors
135 /// should be mostly seen as opaque and are only there for debugging reasons. Semantic errors
136 /// like wrong signatures, missing fields etc. could mean that someone tampered with the invoice.
137 #[derive(PartialEq, Eq, Debug, Clone)]
138 pub enum ParseOrSemanticError {
139 /// The invoice couldn't be decoded
140 ParseError(Bolt11ParseError),
142 /// The invoice could be decoded but violates the BOLT11 standard
143 SemanticError(crate::Bolt11SemanticError),
146 /// The number of bits used to represent timestamps as defined in BOLT 11.
147 const TIMESTAMP_BITS: usize = 35;
149 /// The maximum timestamp as [`Duration::as_secs`] since the Unix epoch allowed by [`BOLT 11`].
151 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
152 pub const MAX_TIMESTAMP: u64 = (1 << TIMESTAMP_BITS) - 1;
154 /// Default expiry time as defined by [BOLT 11].
156 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
157 pub const DEFAULT_EXPIRY_TIME: u64 = 3600;
159 /// Default minimum final CLTV expiry as defined by [BOLT 11].
161 /// Note that this is *not* the same value as rust-lightning's minimum CLTV expiry, which is
162 /// provided in [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
164 /// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
165 /// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
166 pub const DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA: u64 = 18;
168 /// Builder for [`Bolt11Invoice`]s. It's the most convenient and advised way to use this library. It
169 /// ensures that only a semantically and syntactically correct invoice can be built using it.
172 /// extern crate secp256k1;
173 /// extern crate lightning;
174 /// extern crate lightning_invoice;
175 /// extern crate bitcoin_hashes;
177 /// use bitcoin_hashes::Hash;
178 /// use bitcoin_hashes::sha256;
180 /// use secp256k1::Secp256k1;
181 /// use secp256k1::SecretKey;
183 /// use lightning::ln::PaymentSecret;
185 /// use lightning_invoice::{Currency, InvoiceBuilder};
187 /// # #[cfg(not(feature = "std"))]
189 /// # #[cfg(feature = "std")]
191 /// let private_key = SecretKey::from_slice(
193 /// 0xe1, 0x26, 0xf6, 0x8f, 0x7e, 0xaf, 0xcc, 0x8b, 0x74, 0xf5, 0x4d, 0x26, 0x9f,
194 /// 0xe2, 0x06, 0xbe, 0x71, 0x50, 0x00, 0xf9, 0x4d, 0xac, 0x06, 0x7d, 0x1c, 0x04,
195 /// 0xa8, 0xca, 0x3b, 0x2d, 0xb7, 0x34
199 /// let payment_hash = sha256::Hash::from_slice(&[0; 32][..]).unwrap();
200 /// let payment_secret = PaymentSecret([42u8; 32]);
202 /// let invoice = InvoiceBuilder::new(Currency::Bitcoin)
203 /// .description("Coins pls!".into())
204 /// .payment_hash(payment_hash)
205 /// .payment_secret(payment_secret)
206 /// .current_timestamp()
207 /// .min_final_cltv_expiry_delta(144)
208 /// .build_signed(|hash| {
209 /// Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)
213 /// assert!(invoice.to_string().starts_with("lnbc1"));
217 /// # Type parameters
218 /// The two parameters `D` and `H` signal if the builder already contains the correct amount of the
220 /// * `D`: exactly one [`TaggedField::Description`] or [`TaggedField::DescriptionHash`]
221 /// * `H`: exactly one [`TaggedField::PaymentHash`]
222 /// * `T`: the timestamp is set
223 /// * `C`: the CLTV expiry is set
224 /// * `S`: the payment secret is set
225 /// * `M`: payment metadata is set
227 /// This is not exported to bindings users as we likely need to manually select one set of boolean type parameters.
228 #[derive(Eq, PartialEq, Debug, Clone)]
229 pub struct InvoiceBuilder<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool, M: tb::Bool> {
232 si_prefix: Option<SiPrefix>,
233 timestamp: Option<PositiveTimestamp>,
234 tagged_fields: Vec<TaggedField>,
235 error: Option<CreationError>,
237 phantom_d: core::marker::PhantomData<D>,
238 phantom_h: core::marker::PhantomData<H>,
239 phantom_t: core::marker::PhantomData<T>,
240 phantom_c: core::marker::PhantomData<C>,
241 phantom_s: core::marker::PhantomData<S>,
242 phantom_m: core::marker::PhantomData<M>,
245 /// Represents a syntactically and semantically correct lightning BOLT11 invoice.
247 /// There are three ways to construct a `Bolt11Invoice`:
248 /// 1. using [`InvoiceBuilder`]
249 /// 2. using [`Bolt11Invoice::from_signed`]
250 /// 3. using `str::parse::<Bolt11Invoice>(&str)` (see [`Bolt11Invoice::from_str`])
252 /// [`Bolt11Invoice::from_str`]: crate::Bolt11Invoice#impl-FromStr
253 #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)]
254 pub struct Bolt11Invoice {
255 signed_invoice: SignedRawBolt11Invoice,
258 /// Represents the description of an invoice which has to be either a directly included string or
259 /// a hash of a description provided out of band.
261 /// This is not exported to bindings users as we don't have a good way to map the reference lifetimes making this
262 /// practically impossible to use safely in languages like C.
263 #[derive(Eq, PartialEq, Debug, Clone, Ord, PartialOrd)]
264 pub enum Bolt11InvoiceDescription<'f> {
265 /// Reference to the directly supplied description in the invoice
266 Direct(&'f Description),
268 /// Reference to the description's hash included in the invoice
272 impl<'f> Display for Bolt11InvoiceDescription<'f> {
273 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
275 Bolt11InvoiceDescription::Direct(desc) => write!(f, "{}", desc.0),
276 Bolt11InvoiceDescription::Hash(hash) => write!(f, "{}", hash.0),
281 /// Represents a signed [`RawBolt11Invoice`] with cached hash. The signature is not checked and may be
285 /// The hash has to be either from the deserialized invoice or from the serialized [`RawBolt11Invoice`].
286 #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)]
287 pub struct SignedRawBolt11Invoice {
288 /// The raw invoice that the signature belongs to
289 raw_invoice: RawBolt11Invoice,
291 /// Hash of the [`RawBolt11Invoice`] that will be used to check the signature.
293 /// * if the `SignedRawBolt11Invoice` was deserialized the hash is of from the original encoded form,
294 /// since it's not guaranteed that encoding it again will lead to the same result since integers
295 /// could have been encoded with leading zeroes etc.
296 /// * if the `SignedRawBolt11Invoice` was constructed manually the hash will be the calculated hash
297 /// from the [`RawBolt11Invoice`]
300 /// signature of the payment request
301 signature: Bolt11InvoiceSignature,
304 /// Represents an syntactically correct [`Bolt11Invoice`] for a payment on the lightning network,
305 /// but without the signature information.
306 /// Decoding and encoding should not lead to information loss but may lead to different hashes.
308 /// For methods without docs see the corresponding methods in [`Bolt11Invoice`].
309 #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)]
310 pub struct RawBolt11Invoice {
311 /// human readable part
315 pub data: RawDataPart,
318 /// Data of the [`RawBolt11Invoice`] that is encoded in the human readable part.
320 /// This is not exported to bindings users as we don't yet support `Option<Enum>`
321 #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)]
323 /// The currency deferred from the 3rd and 4th character of the bech32 transaction
324 pub currency: Currency,
326 /// The amount that, multiplied by the SI prefix, has to be payed
327 pub raw_amount: Option<u64>,
329 /// SI prefix that gets multiplied with the `raw_amount`
330 pub si_prefix: Option<SiPrefix>,
333 /// Data of the [`RawBolt11Invoice`] that is encoded in the data part
334 #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)]
335 pub struct RawDataPart {
336 /// generation time of the invoice
337 pub timestamp: PositiveTimestamp,
339 /// tagged fields of the payment request
340 pub tagged_fields: Vec<RawTaggedField>,
343 /// A timestamp that refers to a date after 1 January 1970.
347 /// The Unix timestamp representing the stored time has to be positive and no greater than
348 /// [`MAX_TIMESTAMP`].
349 #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)]
350 pub struct PositiveTimestamp(Duration);
352 /// SI prefixes for the human readable part
353 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash, Ord, PartialOrd)]
366 /// Returns the multiplier to go from a BTC value to picoBTC implied by this SiPrefix.
367 /// This is effectively 10^12 * the prefix multiplier
368 pub fn multiplier(&self) -> u64 {
370 SiPrefix::Milli => 1_000_000_000,
371 SiPrefix::Micro => 1_000_000,
372 SiPrefix::Nano => 1_000,
377 /// Returns all enum variants of `SiPrefix` sorted in descending order of their associated
380 /// This is not exported to bindings users as we don't yet support a slice of enums, and also because this function
381 /// isn't the most critical to expose.
382 pub fn values_desc() -> &'static [SiPrefix] {
383 use crate::SiPrefix::*;
384 static VALUES: [SiPrefix; 4] = [Milli, Micro, Nano, Pico];
389 /// Enum representing the crypto currencies (or networks) supported by this library
390 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
408 impl From<Network> for Currency {
409 fn from(network: Network) -> Self {
411 Network::Bitcoin => Currency::Bitcoin,
412 Network::Testnet => Currency::BitcoinTestnet,
413 Network::Regtest => Currency::Regtest,
414 Network::Signet => Currency::Signet,
419 impl From<Currency> for Network {
420 fn from(currency: Currency) -> Self {
422 Currency::Bitcoin => Network::Bitcoin,
423 Currency::BitcoinTestnet => Network::Testnet,
424 Currency::Regtest => Network::Regtest,
425 Currency::Simnet => Network::Regtest,
426 Currency::Signet => Network::Signet,
431 /// Tagged field which may have an unknown tag
433 /// This is not exported to bindings users as we don't currently support TaggedField
434 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
435 pub enum RawTaggedField {
436 /// Parsed tagged field with known tag
437 KnownSemantics(TaggedField),
438 /// tagged field which was not parsed due to an unknown tag or undefined field semantics
439 UnknownSemantics(Vec<u5>),
442 /// Tagged field with known tag
444 /// For descriptions of the enum values please refer to the enclosed type's docs.
446 /// This is not exported to bindings users as we don't yet support enum variants with the same name the struct contained
448 #[allow(missing_docs)]
449 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
450 pub enum TaggedField {
452 Description(Description),
453 PayeePubKey(PayeePubKey),
454 DescriptionHash(Sha256),
455 ExpiryTime(ExpiryTime),
456 MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta),
458 PrivateRoute(PrivateRoute),
459 PaymentSecret(PaymentSecret),
460 PaymentMetadata(Vec<u8>),
461 Features(Bolt11InvoiceFeatures),
465 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
466 pub struct Sha256(/// This is not exported to bindings users as the native hash types are not currently mapped
470 /// Constructs a new [`Sha256`] from the given bytes, which are assumed to be the output of a
471 /// single sha256 hash.
473 pub fn from_bytes(bytes: &[u8; 32]) -> Self {
474 Self(sha256::Hash::from_slice(bytes).expect("from_slice only fails if len is not 32"))
478 /// Description string
481 /// The description can be at most 639 __bytes__ long
482 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd, Default)]
483 pub struct Description(String);
486 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
487 pub struct PayeePubKey(pub PublicKey);
489 /// Positive duration that defines when (relatively to the timestamp) in the future the invoice
491 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
492 pub struct ExpiryTime(Duration);
494 /// `min_final_cltv_expiry_delta` to use for the last HTLC in the route
495 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
496 pub struct MinFinalCltvExpiryDelta(pub u64);
498 /// Fallback address in case no LN payment is possible
499 #[allow(missing_docs)]
500 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
503 version: WitnessVersion,
506 PubKeyHash(PubkeyHash),
507 ScriptHash(ScriptHash),
510 /// Recoverable signature
511 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
512 pub struct Bolt11InvoiceSignature(pub RecoverableSignature);
514 impl PartialOrd for Bolt11InvoiceSignature {
515 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
516 Some(self.cmp(other))
520 impl Ord for Bolt11InvoiceSignature {
521 fn cmp(&self, other: &Self) -> Ordering {
522 self.0.serialize_compact().1.cmp(&other.0.serialize_compact().1)
526 /// Private routing information
529 /// The encoded route has to be <1024 5bit characters long (<=639 bytes or <=12 hops)
531 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
532 pub struct PrivateRoute(pub RouteHint);
534 /// Tag constants as specified in BOLT11
535 #[allow(missing_docs)]
537 pub const TAG_PAYMENT_HASH: u8 = 1;
538 pub const TAG_DESCRIPTION: u8 = 13;
539 pub const TAG_PAYEE_PUB_KEY: u8 = 19;
540 pub const TAG_DESCRIPTION_HASH: u8 = 23;
541 pub const TAG_EXPIRY_TIME: u8 = 6;
542 pub const TAG_MIN_FINAL_CLTV_EXPIRY_DELTA: u8 = 24;
543 pub const TAG_FALLBACK: u8 = 9;
544 pub const TAG_PRIVATE_ROUTE: u8 = 3;
545 pub const TAG_PAYMENT_SECRET: u8 = 16;
546 pub const TAG_PAYMENT_METADATA: u8 = 27;
547 pub const TAG_FEATURES: u8 = 5;
550 impl InvoiceBuilder<tb::False, tb::False, tb::False, tb::False, tb::False, tb::False> {
551 /// Construct new, empty `InvoiceBuilder`. All necessary fields have to be filled first before
552 /// `InvoiceBuilder::build(self)` becomes available.
553 pub fn new(currency: Currency) -> Self {
559 tagged_fields: Vec::new(),
562 phantom_d: core::marker::PhantomData,
563 phantom_h: core::marker::PhantomData,
564 phantom_t: core::marker::PhantomData,
565 phantom_c: core::marker::PhantomData,
566 phantom_s: core::marker::PhantomData,
567 phantom_m: core::marker::PhantomData,
572 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool, M: tb::Bool> InvoiceBuilder<D, H, T, C, S, M> {
573 /// Helper function to set the completeness flags.
574 fn set_flags<DN: tb::Bool, HN: tb::Bool, TN: tb::Bool, CN: tb::Bool, SN: tb::Bool, MN: tb::Bool>(self) -> InvoiceBuilder<DN, HN, TN, CN, SN, MN> {
575 InvoiceBuilder::<DN, HN, TN, CN, SN, MN> {
576 currency: self.currency,
578 si_prefix: self.si_prefix,
579 timestamp: self.timestamp,
580 tagged_fields: self.tagged_fields,
583 phantom_d: core::marker::PhantomData,
584 phantom_h: core::marker::PhantomData,
585 phantom_t: core::marker::PhantomData,
586 phantom_c: core::marker::PhantomData,
587 phantom_s: core::marker::PhantomData,
588 phantom_m: core::marker::PhantomData,
592 /// Sets the amount in millisatoshis. The optimal SI prefix is chosen automatically.
593 pub fn amount_milli_satoshis(mut self, amount_msat: u64) -> Self {
594 let amount = amount_msat * 10; // Invoices are denominated in "pico BTC"
595 let biggest_possible_si_prefix = SiPrefix::values_desc()
597 .find(|prefix| amount % prefix.multiplier() == 0)
598 .expect("Pico should always match");
599 self.amount = Some(amount / biggest_possible_si_prefix.multiplier());
600 self.si_prefix = Some(*biggest_possible_si_prefix);
604 /// Sets the payee's public key.
605 pub fn payee_pub_key(mut self, pub_key: PublicKey) -> Self {
606 self.tagged_fields.push(TaggedField::PayeePubKey(PayeePubKey(pub_key)));
610 /// Sets the expiry time, dropping the subsecond part (which is not representable in BOLT 11
612 pub fn expiry_time(mut self, expiry_time: Duration) -> Self {
613 self.tagged_fields.push(TaggedField::ExpiryTime(ExpiryTime::from_duration(expiry_time)));
617 /// Adds a fallback address.
618 pub fn fallback(mut self, fallback: Fallback) -> Self {
619 self.tagged_fields.push(TaggedField::Fallback(fallback));
623 /// Adds a private route.
624 pub fn private_route(mut self, hint: RouteHint) -> Self {
625 match PrivateRoute::new(hint) {
626 Ok(r) => self.tagged_fields.push(TaggedField::PrivateRoute(r)),
627 Err(e) => self.error = Some(e),
633 impl<D: tb::Bool, H: tb::Bool, C: tb::Bool, S: tb::Bool, M: tb::Bool> InvoiceBuilder<D, H, tb::True, C, S, M> {
634 /// Builds a [`RawBolt11Invoice`] if no [`CreationError`] occurred while construction any of the
636 pub fn build_raw(self) -> Result<RawBolt11Invoice, CreationError> {
638 // If an error occurred at any time before, return it now
639 if let Some(e) = self.error {
644 currency: self.currency,
645 raw_amount: self.amount,
646 si_prefix: self.si_prefix,
649 let timestamp = self.timestamp.expect("ensured to be Some(t) by type T");
651 let tagged_fields = self.tagged_fields.into_iter().map(|tf| {
652 RawTaggedField::KnownSemantics(tf)
653 }).collect::<Vec<_>>();
655 let data = RawDataPart {
660 Ok(RawBolt11Invoice {
667 impl<H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool, M: tb::Bool> InvoiceBuilder<tb::False, H, T, C, S, M> {
668 /// Set the description. This function is only available if no description (hash) was set.
669 pub fn description(mut self, description: String) -> InvoiceBuilder<tb::True, H, T, C, S, M> {
670 match Description::new(description) {
671 Ok(d) => self.tagged_fields.push(TaggedField::Description(d)),
672 Err(e) => self.error = Some(e),
677 /// Set the description hash. This function is only available if no description (hash) was set.
678 pub fn description_hash(mut self, description_hash: sha256::Hash) -> InvoiceBuilder<tb::True, H, T, C, S, M> {
679 self.tagged_fields.push(TaggedField::DescriptionHash(Sha256(description_hash)));
683 /// Set the description or description hash. This function is only available if no description (hash) was set.
684 pub fn invoice_description(self, description: Bolt11InvoiceDescription) -> InvoiceBuilder<tb::True, H, T, C, S, M> {
686 Bolt11InvoiceDescription::Direct(desc) => {
687 self.description(desc.clone().into_inner())
689 Bolt11InvoiceDescription::Hash(hash) => {
690 self.description_hash(hash.0)
696 impl<D: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool, M: tb::Bool> InvoiceBuilder<D, tb::False, T, C, S, M> {
697 /// Set the payment hash. This function is only available if no payment hash was set.
698 pub fn payment_hash(mut self, hash: sha256::Hash) -> InvoiceBuilder<D, tb::True, T, C, S, M> {
699 self.tagged_fields.push(TaggedField::PaymentHash(Sha256(hash)));
704 impl<D: tb::Bool, H: tb::Bool, C: tb::Bool, S: tb::Bool, M: tb::Bool> InvoiceBuilder<D, H, tb::False, C, S, M> {
705 /// Sets the timestamp to a specific [`SystemTime`].
706 #[cfg(feature = "std")]
707 pub fn timestamp(mut self, time: SystemTime) -> InvoiceBuilder<D, H, tb::True, C, S, M> {
708 match PositiveTimestamp::from_system_time(time) {
709 Ok(t) => self.timestamp = Some(t),
710 Err(e) => self.error = Some(e),
716 /// Sets the timestamp to a duration since the Unix epoch, dropping the subsecond part (which
717 /// is not representable in BOLT 11 invoices).
718 pub fn duration_since_epoch(mut self, time: Duration) -> InvoiceBuilder<D, H, tb::True, C, S, M> {
719 match PositiveTimestamp::from_duration_since_epoch(time) {
720 Ok(t) => self.timestamp = Some(t),
721 Err(e) => self.error = Some(e),
727 /// Sets the timestamp to the current system time.
728 #[cfg(feature = "std")]
729 pub fn current_timestamp(mut self) -> InvoiceBuilder<D, H, tb::True, C, S, M> {
730 let now = PositiveTimestamp::from_system_time(SystemTime::now());
731 self.timestamp = Some(now.expect("for the foreseeable future this shouldn't happen"));
736 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, S: tb::Bool, M: tb::Bool> InvoiceBuilder<D, H, T, tb::False, S, M> {
737 /// Sets `min_final_cltv_expiry_delta`.
738 pub fn min_final_cltv_expiry_delta(mut self, min_final_cltv_expiry_delta: u64) -> InvoiceBuilder<D, H, T, tb::True, S, M> {
739 self.tagged_fields.push(TaggedField::MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta(min_final_cltv_expiry_delta)));
744 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, M: tb::Bool> InvoiceBuilder<D, H, T, C, tb::False, M> {
745 /// Sets the payment secret and relevant features.
746 pub fn payment_secret(mut self, payment_secret: PaymentSecret) -> InvoiceBuilder<D, H, T, C, tb::True, M> {
747 let mut found_features = false;
748 for field in self.tagged_fields.iter_mut() {
749 if let TaggedField::Features(f) = field {
750 found_features = true;
751 f.set_variable_length_onion_required();
752 f.set_payment_secret_required();
755 self.tagged_fields.push(TaggedField::PaymentSecret(payment_secret));
757 let mut features = Bolt11InvoiceFeatures::empty();
758 features.set_variable_length_onion_required();
759 features.set_payment_secret_required();
760 self.tagged_fields.push(TaggedField::Features(features));
766 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBuilder<D, H, T, C, S, tb::False> {
767 /// Sets the payment metadata.
769 /// By default features are set to *optionally* allow the sender to include the payment metadata.
770 /// If you wish to require that the sender include the metadata (and fail to parse the invoice if
771 /// they don't support payment metadata fields), you need to call
772 /// [`InvoiceBuilder::require_payment_metadata`] after this.
773 pub fn payment_metadata(mut self, payment_metadata: Vec<u8>) -> InvoiceBuilder<D, H, T, C, S, tb::True> {
774 self.tagged_fields.push(TaggedField::PaymentMetadata(payment_metadata));
775 let mut found_features = false;
776 for field in self.tagged_fields.iter_mut() {
777 if let TaggedField::Features(f) = field {
778 found_features = true;
779 f.set_payment_metadata_optional();
783 let mut features = Bolt11InvoiceFeatures::empty();
784 features.set_payment_metadata_optional();
785 self.tagged_fields.push(TaggedField::Features(features));
791 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool> InvoiceBuilder<D, H, T, C, S, tb::True> {
792 /// Sets forwarding of payment metadata as required. A reader of the invoice which does not
793 /// support sending payment metadata will fail to read the invoice.
794 pub fn require_payment_metadata(mut self) -> InvoiceBuilder<D, H, T, C, S, tb::True> {
795 for field in self.tagged_fields.iter_mut() {
796 if let TaggedField::Features(f) = field {
797 f.set_payment_metadata_required();
804 impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, M: tb::Bool> InvoiceBuilder<D, H, T, C, tb::True, M> {
805 /// Sets the `basic_mpp` feature as optional.
806 pub fn basic_mpp(mut self) -> Self {
807 for field in self.tagged_fields.iter_mut() {
808 if let TaggedField::Features(f) = field {
809 f.set_basic_mpp_optional();
816 impl<M: tb::Bool> InvoiceBuilder<tb::True, tb::True, tb::True, tb::True, tb::True, M> {
817 /// Builds and signs an invoice using the supplied `sign_function`. This function MAY NOT fail
818 /// and MUST produce a recoverable signature valid for the given hash and if applicable also for
819 /// the included payee public key.
820 pub fn build_signed<F>(self, sign_function: F) -> Result<Bolt11Invoice, CreationError>
821 where F: FnOnce(&Message) -> RecoverableSignature
823 let invoice = self.try_build_signed::<_, ()>(|hash| {
824 Ok(sign_function(hash))
829 Err(SignOrCreationError::CreationError(e)) => Err(e),
830 Err(SignOrCreationError::SignError(())) => unreachable!(),
834 /// Builds and signs an invoice using the supplied `sign_function`. This function MAY fail with
835 /// an error of type `E` and MUST produce a recoverable signature valid for the given hash and
836 /// if applicable also for the included payee public key.
837 pub fn try_build_signed<F, E>(self, sign_function: F) -> Result<Bolt11Invoice, SignOrCreationError<E>>
838 where F: FnOnce(&Message) -> Result<RecoverableSignature, E>
840 let raw = match self.build_raw() {
842 Err(e) => return Err(SignOrCreationError::CreationError(e)),
845 let signed = match raw.sign(sign_function) {
847 Err(e) => return Err(SignOrCreationError::SignError(e)),
850 let invoice = Bolt11Invoice {
851 signed_invoice: signed,
854 invoice.check_field_counts().expect("should be ensured by type signature of builder");
855 invoice.check_feature_bits().expect("should be ensured by type signature of builder");
856 invoice.check_amount().expect("should be ensured by type signature of builder");
863 impl SignedRawBolt11Invoice {
864 /// Disassembles the `SignedRawBolt11Invoice` into its three parts:
866 /// 2. hash of the raw invoice
868 pub fn into_parts(self) -> (RawBolt11Invoice, [u8; 32], Bolt11InvoiceSignature) {
869 (self.raw_invoice, self.hash, self.signature)
872 /// The [`RawBolt11Invoice`] which was signed.
873 pub fn raw_invoice(&self) -> &RawBolt11Invoice {
877 /// The hash of the [`RawBolt11Invoice`] that was signed.
878 pub fn signable_hash(&self) -> &[u8; 32] {
882 /// Signature for the invoice.
883 pub fn signature(&self) -> &Bolt11InvoiceSignature {
887 /// Recovers the public key used for signing the invoice from the recoverable signature.
888 pub fn recover_payee_pub_key(&self) -> Result<PayeePubKey, secp256k1::Error> {
889 let hash = Message::from_slice(&self.hash[..])
890 .expect("Hash is 32 bytes long, same as MESSAGE_SIZE");
892 Ok(PayeePubKey(Secp256k1::new().recover_ecdsa(
898 /// Checks if the signature is valid for the included payee public key or if none exists if it's
899 /// valid for the recovered signature (which should always be true?).
900 pub fn check_signature(&self) -> bool {
901 let included_pub_key = self.raw_invoice.payee_pub_key();
903 let mut recovered_pub_key = Option::None;
904 if recovered_pub_key.is_none() {
905 let recovered = match self.recover_payee_pub_key() {
907 Err(_) => return false,
909 recovered_pub_key = Some(recovered);
912 let pub_key = included_pub_key.or(recovered_pub_key.as_ref())
913 .expect("One is always present");
915 let hash = Message::from_slice(&self.hash[..])
916 .expect("Hash is 32 bytes long, same as MESSAGE_SIZE");
918 let secp_context = Secp256k1::new();
919 let verification_result = secp_context.verify_ecdsa(
921 &self.signature.to_standard(),
925 match verification_result {
932 /// Finds the first element of an enum stream of a given variant and extracts one member of the
933 /// variant. If no element was found `None` gets returned.
935 /// The following example would extract the first B.
943 /// let elements = vec![Enum::A(1), Enum::A(2), Enum::B(3), Enum::A(4)];
945 /// assert_eq!(find_extract!(elements.iter(), Enum::B(x), x), Some(3u16));
947 macro_rules! find_extract {
948 ($iter:expr, $enm:pat, $enm_var:ident) => {
949 find_all_extract!($iter, $enm, $enm_var).next()
953 /// Finds the all elements of an enum stream of a given variant and extracts one member of the
954 /// variant through an iterator.
956 /// The following example would extract all A.
964 /// let elements = vec![Enum::A(1), Enum::A(2), Enum::B(3), Enum::A(4)];
967 /// find_all_extract!(elements.iter(), Enum::A(x), x).collect::<Vec<u8>>(),
968 /// vec![1u8, 2u8, 4u8]
971 macro_rules! find_all_extract {
972 ($iter:expr, $enm:pat, $enm_var:ident) => {
973 $iter.filter_map(|tf| match *tf {
974 $enm => Some($enm_var),
980 #[allow(missing_docs)]
981 impl RawBolt11Invoice {
982 /// Hash the HRP as bytes and signatureless data part.
983 fn hash_from_parts(hrp_bytes: &[u8], data_without_signature: &[u5]) -> [u8; 32] {
984 let preimage = construct_invoice_preimage(hrp_bytes, data_without_signature);
985 let mut hash: [u8; 32] = Default::default();
986 hash.copy_from_slice(&sha256::Hash::hash(&preimage)[..]);
990 /// Calculate the hash of the encoded `RawBolt11Invoice` which should be signed.
991 pub fn signable_hash(&self) -> [u8; 32] {
992 use bech32::ToBase32;
994 RawBolt11Invoice::hash_from_parts(
995 self.hrp.to_string().as_bytes(),
996 &self.data.to_base32()
1000 /// Signs the invoice using the supplied `sign_method`. This function MAY fail with an error of
1001 /// type `E`. Since the signature of a [`SignedRawBolt11Invoice`] is not required to be valid there
1002 /// are no constraints regarding the validity of the produced signature.
1004 /// This is not exported to bindings users as we don't currently support passing function pointers into methods
1006 pub fn sign<F, E>(self, sign_method: F) -> Result<SignedRawBolt11Invoice, E>
1007 where F: FnOnce(&Message) -> Result<RecoverableSignature, E>
1009 let raw_hash = self.signable_hash();
1010 let hash = Message::from_slice(&raw_hash[..])
1011 .expect("Hash is 32 bytes long, same as MESSAGE_SIZE");
1012 let signature = sign_method(&hash)?;
1014 Ok(SignedRawBolt11Invoice {
1017 signature: Bolt11InvoiceSignature(signature),
1021 /// Returns an iterator over all tagged fields with known semantics.
1023 /// This is not exported to bindings users as there is not yet a manual mapping for a FilterMap
1024 pub fn known_tagged_fields(&self)
1025 -> FilterMap<Iter<RawTaggedField>, fn(&RawTaggedField) -> Option<&TaggedField>>
1027 // For 1.14.0 compatibility: closures' types can't be written an fn()->() in the
1028 // function's type signature.
1029 // TODO: refactor once impl Trait is available
1030 fn match_raw(raw: &RawTaggedField) -> Option<&TaggedField> {
1032 RawTaggedField::KnownSemantics(ref tf) => Some(tf),
1037 self.data.tagged_fields.iter().filter_map(match_raw )
1040 pub fn payment_hash(&self) -> Option<&Sha256> {
1041 find_extract!(self.known_tagged_fields(), TaggedField::PaymentHash(ref x), x)
1044 pub fn description(&self) -> Option<&Description> {
1045 find_extract!(self.known_tagged_fields(), TaggedField::Description(ref x), x)
1048 pub fn payee_pub_key(&self) -> Option<&PayeePubKey> {
1049 find_extract!(self.known_tagged_fields(), TaggedField::PayeePubKey(ref x), x)
1052 pub fn description_hash(&self) -> Option<&Sha256> {
1053 find_extract!(self.known_tagged_fields(), TaggedField::DescriptionHash(ref x), x)
1056 pub fn expiry_time(&self) -> Option<&ExpiryTime> {
1057 find_extract!(self.known_tagged_fields(), TaggedField::ExpiryTime(ref x), x)
1060 pub fn min_final_cltv_expiry_delta(&self) -> Option<&MinFinalCltvExpiryDelta> {
1061 find_extract!(self.known_tagged_fields(), TaggedField::MinFinalCltvExpiryDelta(ref x), x)
1064 pub fn payment_secret(&self) -> Option<&PaymentSecret> {
1065 find_extract!(self.known_tagged_fields(), TaggedField::PaymentSecret(ref x), x)
1068 pub fn payment_metadata(&self) -> Option<&Vec<u8>> {
1069 find_extract!(self.known_tagged_fields(), TaggedField::PaymentMetadata(ref x), x)
1072 pub fn features(&self) -> Option<&Bolt11InvoiceFeatures> {
1073 find_extract!(self.known_tagged_fields(), TaggedField::Features(ref x), x)
1076 /// This is not exported to bindings users as we don't support Vec<&NonOpaqueType>
1077 pub fn fallbacks(&self) -> Vec<&Fallback> {
1078 find_all_extract!(self.known_tagged_fields(), TaggedField::Fallback(ref x), x).collect()
1081 pub fn private_routes(&self) -> Vec<&PrivateRoute> {
1082 find_all_extract!(self.known_tagged_fields(), TaggedField::PrivateRoute(ref x), x).collect()
1085 pub fn amount_pico_btc(&self) -> Option<u64> {
1086 self.hrp.raw_amount.map(|v| {
1087 v * self.hrp.si_prefix.as_ref().map_or(1_000_000_000_000, |si| { si.multiplier() })
1091 pub fn currency(&self) -> Currency {
1092 self.hrp.currency.clone()
1096 impl PositiveTimestamp {
1097 /// Creates a `PositiveTimestamp` from a Unix timestamp in the range `0..=MAX_TIMESTAMP`.
1099 /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`].
1100 pub fn from_unix_timestamp(unix_seconds: u64) -> Result<Self, CreationError> {
1101 if unix_seconds <= MAX_TIMESTAMP {
1102 Ok(Self(Duration::from_secs(unix_seconds)))
1104 Err(CreationError::TimestampOutOfBounds)
1108 /// Creates a `PositiveTimestamp` from a [`SystemTime`] with a corresponding Unix timestamp in
1109 /// the range `0..=MAX_TIMESTAMP`.
1111 /// Note that the subsecond part is dropped as it is not representable in BOLT 11 invoices.
1113 /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`].
1114 #[cfg(feature = "std")]
1115 pub fn from_system_time(time: SystemTime) -> Result<Self, CreationError> {
1116 time.duration_since(SystemTime::UNIX_EPOCH)
1117 .map(Self::from_duration_since_epoch)
1118 .unwrap_or(Err(CreationError::TimestampOutOfBounds))
1121 /// Creates a `PositiveTimestamp` from a [`Duration`] since the Unix epoch in the range
1122 /// `0..=MAX_TIMESTAMP`.
1124 /// Note that the subsecond part is dropped as it is not representable in BOLT 11 invoices.
1126 /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`].
1127 pub fn from_duration_since_epoch(duration: Duration) -> Result<Self, CreationError> {
1128 Self::from_unix_timestamp(duration.as_secs())
1131 /// Returns the Unix timestamp representing the stored time
1132 pub fn as_unix_timestamp(&self) -> u64 {
1136 /// Returns the duration of the stored time since the Unix epoch
1137 pub fn as_duration_since_epoch(&self) -> Duration {
1141 /// Returns the [`SystemTime`] representing the stored time
1142 #[cfg(feature = "std")]
1143 pub fn as_time(&self) -> SystemTime {
1144 SystemTime::UNIX_EPOCH + self.0
1148 impl From<PositiveTimestamp> for Duration {
1149 fn from(val: PositiveTimestamp) -> Self {
1154 #[cfg(feature = "std")]
1155 impl From<PositiveTimestamp> for SystemTime {
1156 fn from(val: PositiveTimestamp) -> Self {
1157 SystemTime::UNIX_EPOCH + val.0
1161 impl Bolt11Invoice {
1162 /// The hash of the [`RawBolt11Invoice`] that was signed.
1163 pub fn signable_hash(&self) -> [u8; 32] {
1164 self.signed_invoice.hash
1167 /// Transform the `Bolt11Invoice` into its unchecked version.
1168 pub fn into_signed_raw(self) -> SignedRawBolt11Invoice {
1172 /// Check that all mandatory fields are present
1173 fn check_field_counts(&self) -> Result<(), Bolt11SemanticError> {
1174 // "A writer MUST include exactly one p field […]."
1175 let payment_hash_cnt = self.tagged_fields().filter(|&tf| match *tf {
1176 TaggedField::PaymentHash(_) => true,
1179 if payment_hash_cnt < 1 {
1180 return Err(Bolt11SemanticError::NoPaymentHash);
1181 } else if payment_hash_cnt > 1 {
1182 return Err(Bolt11SemanticError::MultiplePaymentHashes);
1185 // "A writer MUST include either exactly one d or exactly one h field."
1186 let description_cnt = self.tagged_fields().filter(|&tf| match *tf {
1187 TaggedField::Description(_) | TaggedField::DescriptionHash(_) => true,
1190 if description_cnt < 1 {
1191 return Err(Bolt11SemanticError::NoDescription);
1192 } else if description_cnt > 1 {
1193 return Err(Bolt11SemanticError::MultipleDescriptions);
1196 self.check_payment_secret()?;
1201 /// Checks that there is exactly one payment secret field
1202 fn check_payment_secret(&self) -> Result<(), Bolt11SemanticError> {
1203 // "A writer MUST include exactly one `s` field."
1204 let payment_secret_count = self.tagged_fields().filter(|&tf| match *tf {
1205 TaggedField::PaymentSecret(_) => true,
1208 if payment_secret_count < 1 {
1209 return Err(Bolt11SemanticError::NoPaymentSecret);
1210 } else if payment_secret_count > 1 {
1211 return Err(Bolt11SemanticError::MultiplePaymentSecrets);
1217 /// Check that amount is a whole number of millisatoshis
1218 fn check_amount(&self) -> Result<(), Bolt11SemanticError> {
1219 if let Some(amount_pico_btc) = self.amount_pico_btc() {
1220 if amount_pico_btc % 10 != 0 {
1221 return Err(Bolt11SemanticError::ImpreciseAmount);
1227 /// Check that feature bits are set as required
1228 fn check_feature_bits(&self) -> Result<(), Bolt11SemanticError> {
1229 self.check_payment_secret()?;
1231 // "A writer MUST set an s field if and only if the payment_secret feature is set."
1232 // (this requirement has been since removed, and we now require the payment secret
1233 // feature bit always).
1234 let features = self.tagged_fields().find(|&tf| match *tf {
1235 TaggedField::Features(_) => true,
1239 None => Err(Bolt11SemanticError::InvalidFeatures),
1240 Some(TaggedField::Features(features)) => {
1241 if features.requires_unknown_bits() {
1242 Err(Bolt11SemanticError::InvalidFeatures)
1243 } else if !features.supports_payment_secret() {
1244 Err(Bolt11SemanticError::InvalidFeatures)
1249 Some(_) => unreachable!(),
1253 /// Check that the invoice is signed correctly and that key recovery works
1254 pub fn check_signature(&self) -> Result<(), Bolt11SemanticError> {
1255 match self.signed_invoice.recover_payee_pub_key() {
1256 Err(secp256k1::Error::InvalidRecoveryId) =>
1257 return Err(Bolt11SemanticError::InvalidRecoveryId),
1258 Err(secp256k1::Error::InvalidSignature) =>
1259 return Err(Bolt11SemanticError::InvalidSignature),
1260 Err(e) => panic!("no other error may occur, got {:?}", e),
1264 if !self.signed_invoice.check_signature() {
1265 return Err(Bolt11SemanticError::InvalidSignature);
1271 /// Constructs a `Bolt11Invoice` from a [`SignedRawBolt11Invoice`] by checking all its invariants.
1273 /// use lightning_invoice::*;
1275 /// let invoice = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\
1276 /// h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\
1277 /// 5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\
1278 /// h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\
1279 /// j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\
1280 /// ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\
1281 /// guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\
1282 /// ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\
1283 /// p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\
1284 /// 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\
1285 /// j5r6drg6k6zcqj0fcwg";
1287 /// let signed = invoice.parse::<SignedRawBolt11Invoice>().unwrap();
1289 /// assert!(Bolt11Invoice::from_signed(signed).is_ok());
1291 pub fn from_signed(signed_invoice: SignedRawBolt11Invoice) -> Result<Self, Bolt11SemanticError> {
1292 let invoice = Bolt11Invoice {
1295 invoice.check_field_counts()?;
1296 invoice.check_feature_bits()?;
1297 invoice.check_signature()?;
1298 invoice.check_amount()?;
1303 /// Returns the `Bolt11Invoice`'s timestamp (should equal its creation time)
1304 #[cfg(feature = "std")]
1305 pub fn timestamp(&self) -> SystemTime {
1306 self.signed_invoice.raw_invoice().data.timestamp.as_time()
1309 /// Returns the `Bolt11Invoice`'s timestamp as a duration since the Unix epoch
1310 pub fn duration_since_epoch(&self) -> Duration {
1311 self.signed_invoice.raw_invoice().data.timestamp.0
1314 /// Returns an iterator over all tagged fields of this `Bolt11Invoice`.
1316 /// This is not exported to bindings users as there is not yet a manual mapping for a FilterMap
1317 pub fn tagged_fields(&self)
1318 -> FilterMap<Iter<RawTaggedField>, fn(&RawTaggedField) -> Option<&TaggedField>> {
1319 self.signed_invoice.raw_invoice().known_tagged_fields()
1322 /// Returns the hash to which we will receive the preimage on completion of the payment
1323 pub fn payment_hash(&self) -> &sha256::Hash {
1324 &self.signed_invoice.payment_hash().expect("checked by constructor").0
1327 /// Return the description or a hash of it for longer ones
1329 /// This is not exported to bindings users because we don't yet export Bolt11InvoiceDescription
1330 pub fn description(&self) -> Bolt11InvoiceDescription {
1331 if let Some(direct) = self.signed_invoice.description() {
1332 return Bolt11InvoiceDescription::Direct(direct);
1333 } else if let Some(hash) = self.signed_invoice.description_hash() {
1334 return Bolt11InvoiceDescription::Hash(hash);
1336 unreachable!("ensured by constructor");
1339 /// Get the payee's public key if one was included in the invoice
1340 pub fn payee_pub_key(&self) -> Option<&PublicKey> {
1341 self.signed_invoice.payee_pub_key().map(|x| &x.0)
1344 /// Get the payment secret if one was included in the invoice
1345 pub fn payment_secret(&self) -> &PaymentSecret {
1346 self.signed_invoice.payment_secret().expect("was checked by constructor")
1349 /// Get the payment metadata blob if one was included in the invoice
1350 pub fn payment_metadata(&self) -> Option<&Vec<u8>> {
1351 self.signed_invoice.payment_metadata()
1354 /// Get the invoice features if they were included in the invoice
1355 pub fn features(&self) -> Option<&Bolt11InvoiceFeatures> {
1356 self.signed_invoice.features()
1359 /// Recover the payee's public key (only to be used if none was included in the invoice)
1360 pub fn recover_payee_pub_key(&self) -> PublicKey {
1361 self.signed_invoice.recover_payee_pub_key().expect("was checked by constructor").0
1364 /// Returns the Duration since the Unix epoch at which the invoice expires.
1365 /// Returning None if overflow occurred.
1366 pub fn expires_at(&self) -> Option<Duration> {
1367 self.duration_since_epoch().checked_add(self.expiry_time())
1370 /// Returns the invoice's expiry time, if present, otherwise [`DEFAULT_EXPIRY_TIME`].
1371 pub fn expiry_time(&self) -> Duration {
1372 self.signed_invoice.expiry_time()
1374 .unwrap_or(Duration::from_secs(DEFAULT_EXPIRY_TIME))
1377 /// Returns whether the invoice has expired.
1378 #[cfg(feature = "std")]
1379 pub fn is_expired(&self) -> bool {
1380 Self::is_expired_from_epoch(&self.timestamp(), self.expiry_time())
1383 /// Returns whether the expiry time from the given epoch has passed.
1384 #[cfg(feature = "std")]
1385 pub(crate) fn is_expired_from_epoch(epoch: &SystemTime, expiry_time: Duration) -> bool {
1386 match epoch.elapsed() {
1387 Ok(elapsed) => elapsed > expiry_time,
1392 /// Returns the Duration remaining until the invoice expires.
1393 #[cfg(feature = "std")]
1394 pub fn duration_until_expiry(&self) -> Duration {
1395 SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)
1396 .map(|now| self.expiration_remaining_from_epoch(now))
1397 .unwrap_or(Duration::from_nanos(0))
1400 /// Returns the Duration remaining until the invoice expires given the current time.
1401 /// `time` is the timestamp as a duration since the Unix epoch.
1402 pub fn expiration_remaining_from_epoch(&self, time: Duration) -> Duration {
1403 self.expires_at().map(|x| x.checked_sub(time)).flatten().unwrap_or(Duration::from_nanos(0))
1406 /// Returns whether the expiry time would pass at the given point in time.
1407 /// `at_time` is the timestamp as a duration since the Unix epoch.
1408 pub fn would_expire(&self, at_time: Duration) -> bool {
1409 self.duration_since_epoch()
1410 .checked_add(self.expiry_time())
1411 .unwrap_or_else(|| Duration::new(u64::max_value(), 1_000_000_000 - 1)) < at_time
1414 /// Returns the invoice's `min_final_cltv_expiry_delta` time, if present, otherwise
1415 /// [`DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA`].
1416 pub fn min_final_cltv_expiry_delta(&self) -> u64 {
1417 self.signed_invoice.min_final_cltv_expiry_delta()
1419 .unwrap_or(DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA)
1422 /// Returns a list of all fallback addresses
1424 /// This is not exported to bindings users as we don't support Vec<&NonOpaqueType>
1425 pub fn fallbacks(&self) -> Vec<&Fallback> {
1426 self.signed_invoice.fallbacks()
1429 /// Returns a list of all fallback addresses as [`Address`]es
1430 pub fn fallback_addresses(&self) -> Vec<Address> {
1431 self.fallbacks().iter().map(|fallback| {
1432 let payload = match fallback {
1433 Fallback::SegWitProgram { version, program } => {
1434 Payload::WitnessProgram { version: *version, program: program.to_vec() }
1436 Fallback::PubKeyHash(pkh) => {
1437 Payload::PubkeyHash(*pkh)
1439 Fallback::ScriptHash(sh) => {
1440 Payload::ScriptHash(*sh)
1444 Address { payload, network: self.network() }
1448 /// Returns a list of all routes included in the invoice
1449 pub fn private_routes(&self) -> Vec<&PrivateRoute> {
1450 self.signed_invoice.private_routes()
1453 /// Returns a list of all routes included in the invoice as the underlying hints
1454 pub fn route_hints(&self) -> Vec<RouteHint> {
1456 self.signed_invoice.known_tagged_fields(), TaggedField::PrivateRoute(ref x), x
1457 ).map(|route| (**route).clone()).collect()
1460 /// Returns the currency for which the invoice was issued
1461 pub fn currency(&self) -> Currency {
1462 self.signed_invoice.currency()
1465 /// Returns the network for which the invoice was issued
1467 /// This is not exported to bindings users, see [`Self::currency`] instead.
1468 pub fn network(&self) -> Network {
1469 self.signed_invoice.currency().into()
1472 /// Returns the amount if specified in the invoice as millisatoshis.
1473 pub fn amount_milli_satoshis(&self) -> Option<u64> {
1474 self.signed_invoice.amount_pico_btc().map(|v| v / 10)
1477 /// Returns the amount if specified in the invoice as pico BTC.
1478 fn amount_pico_btc(&self) -> Option<u64> {
1479 self.signed_invoice.amount_pico_btc()
1483 impl From<TaggedField> for RawTaggedField {
1484 fn from(tf: TaggedField) -> Self {
1485 RawTaggedField::KnownSemantics(tf)
1490 /// Numeric representation of the field's tag
1491 pub fn tag(&self) -> u5 {
1492 let tag = match *self {
1493 TaggedField::PaymentHash(_) => constants::TAG_PAYMENT_HASH,
1494 TaggedField::Description(_) => constants::TAG_DESCRIPTION,
1495 TaggedField::PayeePubKey(_) => constants::TAG_PAYEE_PUB_KEY,
1496 TaggedField::DescriptionHash(_) => constants::TAG_DESCRIPTION_HASH,
1497 TaggedField::ExpiryTime(_) => constants::TAG_EXPIRY_TIME,
1498 TaggedField::MinFinalCltvExpiryDelta(_) => constants::TAG_MIN_FINAL_CLTV_EXPIRY_DELTA,
1499 TaggedField::Fallback(_) => constants::TAG_FALLBACK,
1500 TaggedField::PrivateRoute(_) => constants::TAG_PRIVATE_ROUTE,
1501 TaggedField::PaymentSecret(_) => constants::TAG_PAYMENT_SECRET,
1502 TaggedField::PaymentMetadata(_) => constants::TAG_PAYMENT_METADATA,
1503 TaggedField::Features(_) => constants::TAG_FEATURES,
1506 u5::try_from_u8(tag).expect("all tags defined are <32")
1512 /// Creates a new `Description` if `description` is at most 1023 __bytes__ long,
1513 /// returns [`CreationError::DescriptionTooLong`] otherwise
1515 /// Please note that single characters may use more than one byte due to UTF8 encoding.
1516 pub fn new(description: String) -> Result<Description, CreationError> {
1517 if description.len() > 639 {
1518 Err(CreationError::DescriptionTooLong)
1520 Ok(Description(description))
1524 /// Returns the underlying description [`String`]
1525 pub fn into_inner(self) -> String {
1530 impl From<Description> for String {
1531 fn from(val: Description) -> Self {
1536 impl Deref for Description {
1539 fn deref(&self) -> &str {
1544 impl Display for Description {
1545 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1546 write!(f, "{}", self.0)
1550 impl From<PublicKey> for PayeePubKey {
1551 fn from(pk: PublicKey) -> Self {
1556 impl Deref for PayeePubKey {
1557 type Target = PublicKey;
1559 fn deref(&self) -> &PublicKey {
1565 /// Construct an `ExpiryTime` from seconds.
1566 pub fn from_seconds(seconds: u64) -> ExpiryTime {
1567 ExpiryTime(Duration::from_secs(seconds))
1570 /// Construct an `ExpiryTime` from a [`Duration`], dropping the sub-second part.
1571 pub fn from_duration(duration: Duration) -> ExpiryTime {
1572 Self::from_seconds(duration.as_secs())
1575 /// Returns the expiry time in seconds
1576 pub fn as_seconds(&self) -> u64 {
1580 /// Returns a reference to the underlying [`Duration`] (=expiry time)
1581 pub fn as_duration(&self) -> &Duration {
1587 /// Creates a new (partial) route from a list of hops
1588 pub fn new(hops: RouteHint) -> Result<PrivateRoute, CreationError> {
1589 if hops.0.len() <= 12 {
1590 Ok(PrivateRoute(hops))
1592 Err(CreationError::RouteTooLong)
1596 /// Returns the underlying list of hops
1597 pub fn into_inner(self) -> RouteHint {
1602 impl From<PrivateRoute> for RouteHint {
1603 fn from(val: PrivateRoute) -> Self {
1608 impl Deref for PrivateRoute {
1609 type Target = RouteHint;
1611 fn deref(&self) -> &RouteHint {
1616 impl Deref for Bolt11InvoiceSignature {
1617 type Target = RecoverableSignature;
1619 fn deref(&self) -> &RecoverableSignature {
1624 impl Deref for SignedRawBolt11Invoice {
1625 type Target = RawBolt11Invoice;
1627 fn deref(&self) -> &RawBolt11Invoice {
1632 /// Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`]
1633 #[derive(Eq, PartialEq, Debug, Clone)]
1634 pub enum CreationError {
1635 /// The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
1638 /// The specified route has too many hops and can't be encoded
1641 /// The Unix timestamp of the supplied date is less than zero or greater than 35-bits
1642 TimestampOutOfBounds,
1644 /// The supplied millisatoshi amount was greater than the total bitcoin supply.
1647 /// Route hints were required for this invoice and were missing. Applies to
1648 /// [phantom invoices].
1650 /// [phantom invoices]: crate::utils::create_phantom_invoice
1653 /// The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
1655 /// [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
1656 MinFinalCltvExpiryDeltaTooShort,
1659 impl Display for CreationError {
1660 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1662 CreationError::DescriptionTooLong => f.write_str("The supplied description string was longer than 639 bytes"),
1663 CreationError::RouteTooLong => f.write_str("The specified route has too many hops and can't be encoded"),
1664 CreationError::TimestampOutOfBounds => f.write_str("The Unix timestamp of the supplied date is less than zero or greater than 35-bits"),
1665 CreationError::InvalidAmount => f.write_str("The supplied millisatoshi amount was greater than the total bitcoin supply"),
1666 CreationError::MissingRouteHints => f.write_str("The invoice required route hints and they weren't provided"),
1667 CreationError::MinFinalCltvExpiryDeltaTooShort => f.write_str(
1668 "The supplied final CLTV expiry delta was less than LDK's `MIN_FINAL_CLTV_EXPIRY_DELTA`"),
1673 #[cfg(feature = "std")]
1674 impl std::error::Error for CreationError { }
1676 /// Errors that may occur when converting a [`RawBolt11Invoice`] to a [`Bolt11Invoice`]. They relate to
1677 /// the requirements sections in BOLT #11
1678 #[derive(Eq, PartialEq, Debug, Clone)]
1679 pub enum Bolt11SemanticError {
1680 /// The invoice is missing the mandatory payment hash
1683 /// The invoice has multiple payment hashes which isn't allowed
1684 MultiplePaymentHashes,
1686 /// No description or description hash are part of the invoice
1689 /// The invoice contains multiple descriptions and/or description hashes which isn't allowed
1690 MultipleDescriptions,
1692 /// The invoice is missing the mandatory payment secret, which all modern lightning nodes
1696 /// The invoice contains multiple payment secrets
1697 MultiplePaymentSecrets,
1699 /// The invoice's features are invalid
1702 /// The recovery id doesn't fit the signature/pub key
1705 /// The invoice's signature is invalid
1708 /// The invoice's amount was not a whole number of millisatoshis
1712 impl Display for Bolt11SemanticError {
1713 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1715 Bolt11SemanticError::NoPaymentHash => f.write_str("The invoice is missing the mandatory payment hash"),
1716 Bolt11SemanticError::MultiplePaymentHashes => f.write_str("The invoice has multiple payment hashes which isn't allowed"),
1717 Bolt11SemanticError::NoDescription => f.write_str("No description or description hash are part of the invoice"),
1718 Bolt11SemanticError::MultipleDescriptions => f.write_str("The invoice contains multiple descriptions and/or description hashes which isn't allowed"),
1719 Bolt11SemanticError::NoPaymentSecret => f.write_str("The invoice is missing the mandatory payment secret"),
1720 Bolt11SemanticError::MultiplePaymentSecrets => f.write_str("The invoice contains multiple payment secrets"),
1721 Bolt11SemanticError::InvalidFeatures => f.write_str("The invoice's features are invalid"),
1722 Bolt11SemanticError::InvalidRecoveryId => f.write_str("The recovery id doesn't fit the signature/pub key"),
1723 Bolt11SemanticError::InvalidSignature => f.write_str("The invoice's signature is invalid"),
1724 Bolt11SemanticError::ImpreciseAmount => f.write_str("The invoice's amount was not a whole number of millisatoshis"),
1729 #[cfg(feature = "std")]
1730 impl std::error::Error for Bolt11SemanticError { }
1732 /// When signing using a fallible method either an user-supplied `SignError` or a [`CreationError`]
1734 #[derive(Eq, PartialEq, Debug, Clone)]
1735 pub enum SignOrCreationError<S = ()> {
1736 /// An error occurred during signing
1739 /// An error occurred while building the transaction
1740 CreationError(CreationError),
1743 impl<S> Display for SignOrCreationError<S> {
1744 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1746 SignOrCreationError::SignError(_) => f.write_str("An error occurred during signing"),
1747 SignOrCreationError::CreationError(err) => err.fmt(f),
1752 #[cfg(feature = "serde")]
1753 impl Serialize for Bolt11Invoice {
1754 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
1755 serializer.serialize_str(self.to_string().as_str())
1758 #[cfg(feature = "serde")]
1759 impl<'de> Deserialize<'de> for Bolt11Invoice {
1760 fn deserialize<D>(deserializer: D) -> Result<Bolt11Invoice, D::Error> where D: Deserializer<'de> {
1761 let bolt11 = String::deserialize(deserializer)?
1762 .parse::<Bolt11Invoice>()
1763 .map_err(|e| D::Error::custom(format_args!("{:?}", e)))?;
1771 use bitcoin::Script;
1772 use bitcoin_hashes::hex::FromHex;
1773 use bitcoin_hashes::sha256;
1776 fn test_system_time_bounds_assumptions() {
1778 crate::PositiveTimestamp::from_unix_timestamp(crate::MAX_TIMESTAMP + 1),
1779 Err(crate::CreationError::TimestampOutOfBounds)
1784 fn test_calc_invoice_hash() {
1785 use crate::{RawBolt11Invoice, RawHrp, RawDataPart, Currency, PositiveTimestamp};
1786 use crate::TaggedField::*;
1788 let invoice = RawBolt11Invoice {
1790 currency: Currency::Bitcoin,
1795 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1796 tagged_fields: vec![
1797 PaymentHash(crate::Sha256(sha256::Hash::from_hex(
1798 "0001020304050607080900010203040506070809000102030405060708090102"
1799 ).unwrap())).into(),
1800 Description(crate::Description::new(
1801 "Please consider supporting this project".to_owned()
1807 let expected_hash = [
1808 0xc3, 0xd4, 0xe8, 0x3f, 0x64, 0x6f, 0xa7, 0x9a, 0x39, 0x3d, 0x75, 0x27, 0x7b, 0x1d,
1809 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7, 0x83, 0x5d, 0xb2, 0xec,
1810 0xd5, 0x18, 0xe1, 0xc9
1813 assert_eq!(invoice.signable_hash(), expected_hash)
1817 fn test_check_signature() {
1818 use crate::TaggedField::*;
1819 use secp256k1::Secp256k1;
1820 use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
1821 use secp256k1::{SecretKey, PublicKey};
1822 use crate::{SignedRawBolt11Invoice, Bolt11InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256,
1825 let invoice = SignedRawBolt11Invoice {
1826 raw_invoice: RawBolt11Invoice {
1828 currency: Currency::Bitcoin,
1833 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1834 tagged_fields: vec ! [
1835 PaymentHash(Sha256(sha256::Hash::from_hex(
1836 "0001020304050607080900010203040506070809000102030405060708090102"
1837 ).unwrap())).into(),
1839 crate::Description::new(
1840 "Please consider supporting this project".to_owned()
1847 0xc3, 0xd4, 0xe8, 0x3f, 0x64, 0x6f, 0xa7, 0x9a, 0x39, 0x3d, 0x75, 0x27,
1848 0x7b, 0x1d, 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7,
1849 0x83, 0x5d, 0xb2, 0xec, 0xd5, 0x18, 0xe1, 0xc9
1851 signature: Bolt11InvoiceSignature(RecoverableSignature::from_compact(
1853 0x38u8, 0xec, 0x68, 0x91, 0x34, 0x5e, 0x20, 0x41, 0x45, 0xbe, 0x8a,
1854 0x3a, 0x99, 0xde, 0x38, 0xe9, 0x8a, 0x39, 0xd6, 0xa5, 0x69, 0x43,
1855 0x4e, 0x18, 0x45, 0xc8, 0xaf, 0x72, 0x05, 0xaf, 0xcf, 0xcc, 0x7f,
1856 0x42, 0x5f, 0xcd, 0x14, 0x63, 0xe9, 0x3c, 0x32, 0x88, 0x1e, 0xad,
1857 0x0d, 0x6e, 0x35, 0x6d, 0x46, 0x7e, 0xc8, 0xc0, 0x25, 0x53, 0xf9,
1858 0xaa, 0xb1, 0x5e, 0x57, 0x38, 0xb1, 0x1f, 0x12, 0x7f
1860 RecoveryId::from_i32(0).unwrap()
1864 assert!(invoice.check_signature());
1866 let private_key = SecretKey::from_slice(
1868 0xe1, 0x26, 0xf6, 0x8f, 0x7e, 0xaf, 0xcc, 0x8b, 0x74, 0xf5, 0x4d, 0x26, 0x9f, 0xe2,
1869 0x06, 0xbe, 0x71, 0x50, 0x00, 0xf9, 0x4d, 0xac, 0x06, 0x7d, 0x1c, 0x04, 0xa8, 0xca,
1870 0x3b, 0x2d, 0xb7, 0x34
1873 let public_key = PublicKey::from_secret_key(&Secp256k1::new(), &private_key);
1875 assert_eq!(invoice.recover_payee_pub_key(), Ok(crate::PayeePubKey(public_key)));
1877 let (raw_invoice, _, _) = invoice.into_parts();
1878 let new_signed = raw_invoice.sign::<_, ()>(|hash| {
1879 Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
1882 assert!(new_signed.check_signature());
1886 fn test_check_feature_bits() {
1887 use crate::TaggedField::*;
1888 use lightning::ln::features::Bolt11InvoiceFeatures;
1889 use secp256k1::Secp256k1;
1890 use secp256k1::SecretKey;
1891 use crate::{Bolt11Invoice, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp,
1892 Bolt11SemanticError};
1894 let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
1895 let payment_secret = lightning::ln::PaymentSecret([21; 32]);
1896 let invoice_template = RawBolt11Invoice {
1898 currency: Currency::Bitcoin,
1903 timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
1904 tagged_fields: vec ! [
1905 PaymentHash(Sha256(sha256::Hash::from_hex(
1906 "0001020304050607080900010203040506070809000102030405060708090102"
1907 ).unwrap())).into(),
1909 crate::Description::new(
1910 "Please consider supporting this project".to_owned()
1919 let mut invoice = invoice_template.clone();
1920 invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1921 invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1923 assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::InvalidFeatures));
1925 // Missing feature bits
1927 let mut invoice = invoice_template.clone();
1928 invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1929 invoice.data.tagged_fields.push(Features(Bolt11InvoiceFeatures::empty()).into());
1930 invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1932 assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::InvalidFeatures));
1934 let mut payment_secret_features = Bolt11InvoiceFeatures::empty();
1935 payment_secret_features.set_payment_secret_required();
1937 // Including payment secret and feature bits
1939 let mut invoice = invoice_template.clone();
1940 invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1941 invoice.data.tagged_fields.push(Features(payment_secret_features.clone()).into());
1942 invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1944 assert!(Bolt11Invoice::from_signed(invoice).is_ok());
1946 // No payment secret or features
1948 let invoice = invoice_template.clone();
1949 invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1951 assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::NoPaymentSecret));
1953 // No payment secret or feature bits
1955 let mut invoice = invoice_template.clone();
1956 invoice.data.tagged_fields.push(Features(Bolt11InvoiceFeatures::empty()).into());
1957 invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1959 assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::NoPaymentSecret));
1961 // Missing payment secret
1963 let mut invoice = invoice_template.clone();
1964 invoice.data.tagged_fields.push(Features(payment_secret_features).into());
1965 invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1967 assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::NoPaymentSecret));
1969 // Multiple payment secrets
1971 let mut invoice = invoice_template;
1972 invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1973 invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
1974 invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)))
1976 assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::MultiplePaymentSecrets));
1980 fn test_builder_amount() {
1983 let builder = InvoiceBuilder::new(Currency::Bitcoin)
1984 .description("Test".into())
1985 .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
1986 .duration_since_epoch(Duration::from_secs(1234567));
1988 let invoice = builder.clone()
1989 .amount_milli_satoshis(1500)
1993 assert_eq!(invoice.hrp.si_prefix, Some(SiPrefix::Nano));
1994 assert_eq!(invoice.hrp.raw_amount, Some(15));
1997 let invoice = builder
1998 .amount_milli_satoshis(150)
2002 assert_eq!(invoice.hrp.si_prefix, Some(SiPrefix::Pico));
2003 assert_eq!(invoice.hrp.raw_amount, Some(1500));
2007 fn test_builder_fail() {
2009 use lightning::routing::router::RouteHintHop;
2010 use std::iter::FromIterator;
2011 use secp256k1::PublicKey;
2013 let builder = InvoiceBuilder::new(Currency::Bitcoin)
2014 .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
2015 .duration_since_epoch(Duration::from_secs(1234567))
2016 .min_final_cltv_expiry_delta(144);
2018 let too_long_string = String::from_iter(
2019 (0..1024).map(|_| '?')
2022 let long_desc_res = builder.clone()
2023 .description(too_long_string)
2025 assert_eq!(long_desc_res, Err(CreationError::DescriptionTooLong));
2027 let route_hop = RouteHintHop {
2028 src_node_id: PublicKey::from_slice(
2030 0x03, 0x9e, 0x03, 0xa9, 0x01, 0xb8, 0x55, 0x34, 0xff, 0x1e, 0x92, 0xc4,
2031 0x3c, 0x74, 0x43, 0x1f, 0x7c, 0xe7, 0x20, 0x46, 0x06, 0x0f, 0xcf, 0x7a,
2032 0x95, 0xc3, 0x7e, 0x14, 0x8f, 0x78, 0xc7, 0x72, 0x55
2035 short_channel_id: 0,
2038 proportional_millionths: 0,
2040 cltv_expiry_delta: 0,
2041 htlc_minimum_msat: None,
2042 htlc_maximum_msat: None,
2044 let too_long_route = RouteHint(vec![route_hop; 13]);
2045 let long_route_res = builder.clone()
2046 .description("Test".into())
2047 .private_route(too_long_route)
2049 assert_eq!(long_route_res, Err(CreationError::RouteTooLong));
2051 let sign_error_res = builder
2052 .description("Test".into())
2053 .payment_secret(PaymentSecret([0; 32]))
2054 .try_build_signed(|_| {
2055 Err("ImaginaryError")
2057 assert_eq!(sign_error_res, Err(SignOrCreationError::SignError("ImaginaryError")));
2061 fn test_builder_ok() {
2063 use lightning::routing::router::RouteHintHop;
2064 use secp256k1::Secp256k1;
2065 use secp256k1::{SecretKey, PublicKey};
2066 use std::time::{UNIX_EPOCH, Duration};
2068 let secp_ctx = Secp256k1::new();
2070 let private_key = SecretKey::from_slice(
2072 0xe1, 0x26, 0xf6, 0x8f, 0x7e, 0xaf, 0xcc, 0x8b, 0x74, 0xf5, 0x4d, 0x26, 0x9f, 0xe2,
2073 0x06, 0xbe, 0x71, 0x50, 0x00, 0xf9, 0x4d, 0xac, 0x06, 0x7d, 0x1c, 0x04, 0xa8, 0xca,
2074 0x3b, 0x2d, 0xb7, 0x34
2077 let public_key = PublicKey::from_secret_key(&secp_ctx, &private_key);
2079 let route_1 = RouteHint(vec![
2081 src_node_id: public_key,
2082 short_channel_id: de::parse_int_be(&[123; 8], 256).expect("short chan ID slice too big?"),
2085 proportional_millionths: 1,
2087 cltv_expiry_delta: 145,
2088 htlc_minimum_msat: None,
2089 htlc_maximum_msat: None,
2092 src_node_id: public_key,
2093 short_channel_id: de::parse_int_be(&[42; 8], 256).expect("short chan ID slice too big?"),
2096 proportional_millionths: 2,
2098 cltv_expiry_delta: 146,
2099 htlc_minimum_msat: None,
2100 htlc_maximum_msat: None,
2104 let route_2 = RouteHint(vec![
2106 src_node_id: public_key,
2107 short_channel_id: 0,
2110 proportional_millionths: 3,
2112 cltv_expiry_delta: 147,
2113 htlc_minimum_msat: None,
2114 htlc_maximum_msat: None,
2117 src_node_id: public_key,
2118 short_channel_id: de::parse_int_be(&[1; 8], 256).expect("short chan ID slice too big?"),
2121 proportional_millionths: 4,
2123 cltv_expiry_delta: 148,
2124 htlc_minimum_msat: None,
2125 htlc_maximum_msat: None,
2129 let builder = InvoiceBuilder::new(Currency::BitcoinTestnet)
2130 .amount_milli_satoshis(123)
2131 .duration_since_epoch(Duration::from_secs(1234567))
2132 .payee_pub_key(public_key)
2133 .expiry_time(Duration::from_secs(54321))
2134 .min_final_cltv_expiry_delta(144)
2135 .fallback(Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap()))
2136 .private_route(route_1.clone())
2137 .private_route(route_2.clone())
2138 .description_hash(sha256::Hash::from_slice(&[3;32][..]).unwrap())
2139 .payment_hash(sha256::Hash::from_slice(&[21;32][..]).unwrap())
2140 .payment_secret(PaymentSecret([42; 32]))
2143 let invoice = builder.clone().build_signed(|hash| {
2144 secp_ctx.sign_ecdsa_recoverable(hash, &private_key)
2147 assert!(invoice.check_signature().is_ok());
2148 assert_eq!(invoice.tagged_fields().count(), 10);
2150 assert_eq!(invoice.amount_milli_satoshis(), Some(123));
2151 assert_eq!(invoice.amount_pico_btc(), Some(1230));
2152 assert_eq!(invoice.currency(), Currency::BitcoinTestnet);
2153 #[cfg(feature = "std")]
2155 invoice.timestamp().duration_since(UNIX_EPOCH).unwrap().as_secs(),
2158 assert_eq!(invoice.payee_pub_key(), Some(&public_key));
2159 assert_eq!(invoice.expiry_time(), Duration::from_secs(54321));
2160 assert_eq!(invoice.min_final_cltv_expiry_delta(), 144);
2161 assert_eq!(invoice.fallbacks(), vec![&Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap())]);
2162 let address = Address::from_script(&Script::new_p2pkh(&PubkeyHash::from_slice(&[0;20]).unwrap()), Network::Testnet).unwrap();
2163 assert_eq!(invoice.fallback_addresses(), vec![address]);
2164 assert_eq!(invoice.private_routes(), vec![&PrivateRoute(route_1), &PrivateRoute(route_2)]);
2166 invoice.description(),
2167 Bolt11InvoiceDescription::Hash(&Sha256(sha256::Hash::from_slice(&[3;32][..]).unwrap()))
2169 assert_eq!(invoice.payment_hash(), &sha256::Hash::from_slice(&[21;32][..]).unwrap());
2170 assert_eq!(invoice.payment_secret(), &PaymentSecret([42; 32]));
2172 let mut expected_features = Bolt11InvoiceFeatures::empty();
2173 expected_features.set_variable_length_onion_required();
2174 expected_features.set_payment_secret_required();
2175 expected_features.set_basic_mpp_optional();
2176 assert_eq!(invoice.features(), Some(&expected_features));
2178 let raw_invoice = builder.build_raw().unwrap();
2179 assert_eq!(raw_invoice, *invoice.into_signed_raw().raw_invoice())
2183 fn test_default_values() {
2185 use secp256k1::Secp256k1;
2186 use secp256k1::SecretKey;
2188 let signed_invoice = InvoiceBuilder::new(Currency::Bitcoin)
2189 .description("Test".into())
2190 .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
2191 .payment_secret(PaymentSecret([0; 32]))
2192 .duration_since_epoch(Duration::from_secs(1234567))
2195 .sign::<_, ()>(|hash| {
2196 let privkey = SecretKey::from_slice(&[41; 32]).unwrap();
2197 let secp_ctx = Secp256k1::new();
2198 Ok(secp_ctx.sign_ecdsa_recoverable(hash, &privkey))
2201 let invoice = Bolt11Invoice::from_signed(signed_invoice).unwrap();
2203 assert_eq!(invoice.min_final_cltv_expiry_delta(), DEFAULT_MIN_FINAL_CLTV_EXPIRY_DELTA);
2204 assert_eq!(invoice.expiry_time(), Duration::from_secs(DEFAULT_EXPIRY_TIME));
2205 assert!(!invoice.would_expire(Duration::from_secs(1234568)));
2209 fn test_expiration() {
2211 use secp256k1::Secp256k1;
2212 use secp256k1::SecretKey;
2214 let signed_invoice = InvoiceBuilder::new(Currency::Bitcoin)
2215 .description("Test".into())
2216 .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap())
2217 .payment_secret(PaymentSecret([0; 32]))
2218 .duration_since_epoch(Duration::from_secs(1234567))
2221 .sign::<_, ()>(|hash| {
2222 let privkey = SecretKey::from_slice(&[41; 32]).unwrap();
2223 let secp_ctx = Secp256k1::new();
2224 Ok(secp_ctx.sign_ecdsa_recoverable(hash, &privkey))
2227 let invoice = Bolt11Invoice::from_signed(signed_invoice).unwrap();
2229 assert!(invoice.would_expire(Duration::from_secs(1234567 + DEFAULT_EXPIRY_TIME + 1)));
2232 #[cfg(feature = "serde")]
2235 let invoice_str = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\
2236 h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\
2237 5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\
2238 h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\
2239 j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\
2240 ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\
2241 guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\
2242 ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\
2243 p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\
2244 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\
2245 j5r6drg6k6zcqj0fcwg";
2246 let invoice = invoice_str.parse::<super::Bolt11Invoice>().unwrap();
2247 let serialized_invoice = serde_json::to_string(&invoice).unwrap();
2248 let deserialized_invoice: super::Bolt11Invoice = serde_json::from_str(serialized_invoice.as_str()).unwrap();
2249 assert_eq!(invoice, deserialized_invoice);
2250 assert_eq!(invoice_str, deserialized_invoice.to_string().as_str());
2251 assert_eq!(invoice_str, serialized_invoice.as_str().trim_matches('\"'));