X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Flib.rs;h=4737173eef5da6e1f0ebdf16d8d235b536db4dce;hb=fc9a4c22d195a75ad5942eed271757f285452214;hp=d676f6c28d6faf7926fa970030ffb1d258fa1af7;hpb=c417a51b65af7da3f1015f453e3c42d0077a34bf;p=rust-lightning diff --git a/lightning-invoice/src/lib.rs b/lightning-invoice/src/lib.rs index d676f6c2..4737173e 100644 --- a/lightning-invoice/src/lib.rs +++ b/lightning-invoice/src/lib.rs @@ -1,15 +1,20 @@ +// Prefix these with `rustdoc::` when we update our MSRV to be >= 1.52 to remove warnings. +#![deny(broken_intra_doc_links)] +#![deny(private_intra_doc_links)] + #![deny(missing_docs)] #![deny(non_upper_case_globals)] #![deny(non_camel_case_types)] #![deny(non_snake_case)] #![deny(unused_mut)] -#![deny(broken_intra_doc_links)] + +#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![cfg_attr(feature = "strict", deny(warnings))] #![cfg_attr(all(not(feature = "std"), not(test)), no_std)] //! This crate provides data structures to represent -//! [lightning BOLT11](https://github.com/lightningnetwork/lightning-rfc/blob/master/11-payment-encoding.md) +//! [lightning BOLT11](https://github.com/lightning/bolts/blob/master/11-payment-encoding.md) //! invoices and functions to create, encode and decode these. If you just want to use the standard //! en-/decoding functionality this should get you started: //! @@ -23,6 +28,8 @@ compile_error!("at least one of the `std` or `no-std` features must be enabled") pub mod payment; pub mod utils; +pub(crate) mod time_utils; + extern crate bech32; extern crate bitcoin_hashes; #[macro_use] extern crate lightning; @@ -31,6 +38,8 @@ extern crate secp256k1; extern crate alloc; #[cfg(any(test, feature = "std"))] extern crate core; +#[cfg(feature = "serde")] +extern crate serde; #[cfg(feature = "std")] use std::time::SystemTime; @@ -41,19 +50,24 @@ use bitcoin_hashes::sha256; use lightning::ln::PaymentSecret; use lightning::ln::features::InvoiceFeatures; #[cfg(any(doc, test))] -use lightning::routing::network_graph::RoutingFees; +use lightning::routing::gossip::RoutingFees; use lightning::routing::router::RouteHint; use lightning::util::invoice::construct_invoice_preimage; -use secp256k1::key::PublicKey; +use secp256k1::PublicKey; use secp256k1::{Message, Secp256k1}; -use secp256k1::recovery::RecoverableSignature; +use secp256k1::ecdsa::RecoverableSignature; use core::fmt::{Display, Formatter, self}; use core::iter::FilterMap; +use core::num::ParseIntError; use core::ops::Deref; use core::slice::Iter; use core::time::Duration; +use core::str; + +#[cfg(feature = "serde")] +use serde::{Deserialize, Deserializer,Serialize, Serializer, de::Error}; mod de; mod ser; @@ -72,7 +86,7 @@ mod prelude { pub use alloc::string::ToString; } -use prelude::*; +use crate::prelude::*; /// Sync compat for std/no_std #[cfg(feature = "std")] @@ -84,7 +98,45 @@ mod sync { #[cfg(not(feature = "std"))] mod sync; -pub use de::{ParseError, ParseOrSemanticError}; +/// Errors that indicate what is wrong with the invoice. They have some granularity for debug +/// reasons, but should generally result in an "invalid BOLT11 invoice" message for the user. +#[allow(missing_docs)] +#[derive(PartialEq, Eq, Debug, Clone)] +pub enum ParseError { + Bech32Error(bech32::Error), + ParseAmountError(ParseIntError), + MalformedSignature(secp256k1::Error), + BadPrefix, + UnknownCurrency, + UnknownSiPrefix, + MalformedHRP, + TooShortDataPart, + UnexpectedEndOfTaggedFields, + DescriptionDecodeError(str::Utf8Error), + PaddingError, + IntegerOverflowError, + InvalidSegWitProgramLength, + InvalidPubKeyHashLength, + InvalidScriptHashLength, + InvalidRecoveryId, + InvalidSliceLength(String), + + /// Not an error, but used internally to signal that a part of the invoice should be ignored + /// according to BOLT11 + Skip, +} + +/// Indicates that something went wrong while parsing or validating the invoice. Parsing errors +/// should be mostly seen as opaque and are only there for debugging reasons. Semantic errors +/// like wrong signatures, missing fields etc. could mean that someone tampered with the invoice. +#[derive(PartialEq, Eq, Debug, Clone)] +pub enum ParseOrSemanticError { + /// The invoice couldn't be decoded + ParseError(ParseError), + + /// The invoice could be decoded but violates the BOLT11 standard + SemanticError(crate::SemanticError), +} /// The number of bits used to represent timestamps as defined in BOLT 11. const TIMESTAMP_BITS: usize = 35; @@ -121,7 +173,7 @@ pub const DEFAULT_MIN_FINAL_CLTV_EXPIRY: u64 = 18; /// use bitcoin_hashes::sha256; /// /// use secp256k1::Secp256k1; -/// use secp256k1::key::SecretKey; +/// use secp256k1::SecretKey; /// /// use lightning::ln::PaymentSecret; /// @@ -149,7 +201,7 @@ pub const DEFAULT_MIN_FINAL_CLTV_EXPIRY: u64 = 18; /// .current_timestamp() /// .min_final_cltv_expiry(144) /// .build_signed(|hash| { -/// Secp256k1::new().sign_recoverable(hash, &private_key) +/// Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key) /// }) /// .unwrap(); /// @@ -187,7 +239,7 @@ pub struct InvoiceBuilder(&str)` -#[derive(Eq, PartialEq, Debug, Clone)] +#[derive(Eq, PartialEq, Debug, Clone, Hash)] pub struct Invoice { signed_invoice: SignedRawInvoice, } @@ -211,7 +263,7 @@ pub enum InvoiceDescription<'f> { /// /// # Invariants /// The hash has to be either from the deserialized invoice or from the serialized `raw_invoice`. -#[derive(Eq, PartialEq, Debug, Clone)] +#[derive(Eq, PartialEq, Debug, Clone, Hash)] pub struct SignedRawInvoice { /// The rawInvoice that the signature belongs to raw_invoice: RawInvoice, @@ -234,7 +286,7 @@ pub struct SignedRawInvoice { /// De- and encoding should not lead to information loss but may lead to different hashes. /// /// For methods without docs see the corresponding methods in `Invoice`. -#[derive(Eq, PartialEq, Debug, Clone)] +#[derive(Eq, PartialEq, Debug, Clone, Hash)] pub struct RawInvoice { /// human readable part pub hrp: RawHrp, @@ -246,7 +298,7 @@ pub struct RawInvoice { /// Data of the `RawInvoice` that is encoded in the human readable part /// /// (C-not exported) As we don't yet support Option -#[derive(Eq, PartialEq, Debug, Clone)] +#[derive(Eq, PartialEq, Debug, Clone, Hash)] pub struct RawHrp { /// The currency deferred from the 3rd and 4th character of the bech32 transaction pub currency: Currency, @@ -259,7 +311,7 @@ pub struct RawHrp { } /// Data of the `RawInvoice` that is encoded in the data part -#[derive(Eq, PartialEq, Debug, Clone)] +#[derive(Eq, PartialEq, Debug, Clone, Hash)] pub struct RawDataPart { /// generation time of the invoice pub timestamp: PositiveTimestamp, @@ -274,11 +326,11 @@ pub struct RawDataPart { /// /// The Unix timestamp representing the stored time has to be positive and no greater than /// [`MAX_TIMESTAMP`]. -#[derive(Eq, PartialEq, Debug, Clone)] +#[derive(Eq, PartialEq, Debug, Clone, Hash)] pub struct PositiveTimestamp(Duration); /// SI prefixes for the human readable part -#[derive(Eq, PartialEq, Debug, Clone, Copy)] +#[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)] pub enum SiPrefix { /// 10^-3 Milli, @@ -308,7 +360,7 @@ impl SiPrefix { /// (C-not exported) As we don't yet support a slice of enums, and also because this function /// isn't the most critical to expose. pub fn values_desc() -> &'static [SiPrefix] { - use SiPrefix::*; + use crate::SiPrefix::*; static VALUES: [SiPrefix; 4] = [Milli, Micro, Nano, Pico]; &VALUES } @@ -404,7 +456,7 @@ pub enum Fallback { } /// Recoverable signature -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Clone, Debug, Hash, Eq, PartialEq)] pub struct InvoiceSignature(pub RecoverableSignature); /// Private routing information @@ -488,7 +540,8 @@ impl InvoiceBui self } - /// Sets the expiry time + /// Sets the expiry time, dropping the subsecond part (which is not representable in BOLT 11 + /// invoices). pub fn expiry_time(mut self, expiry_time: Duration) -> Self { self.tagged_fields.push(TaggedField::ExpiryTime(ExpiryTime::from_duration(expiry_time))); self @@ -580,7 +633,8 @@ impl InvoiceBuilder InvoiceBuilder { match PositiveTimestamp::from_duration_since_epoch(time) { Ok(t) => self.timestamp = Some(t), @@ -610,9 +664,9 @@ impl InvoiceBuilder InvoiceBuilder { /// Sets the payment secret and relevant features. pub fn payment_secret(mut self, payment_secret: PaymentSecret) -> InvoiceBuilder { - let features = InvoiceFeatures::empty() - .set_variable_length_onion_required() - .set_payment_secret_required(); + let mut features = InvoiceFeatures::empty(); + features.set_variable_length_onion_required(); + features.set_payment_secret_required(); self.tagged_fields.push(TaggedField::PaymentSecret(payment_secret)); self.tagged_fields.push(TaggedField::Features(features)); self.set_flags() @@ -622,13 +676,11 @@ impl InvoiceBuilder InvoiceBuilder { /// Sets the `basic_mpp` feature as optional. pub fn basic_mpp(mut self) -> Self { - self.tagged_fields = self.tagged_fields - .drain(..) - .map(|field| match field { - TaggedField::Features(f) => TaggedField::Features(f.set_basic_mpp_optional()), - _ => field, - }) - .collect(); + for field in self.tagged_fields.iter_mut() { + if let TaggedField::Features(f) = field { + f.set_basic_mpp_optional(); + } + } self } } @@ -695,7 +747,7 @@ impl SignedRawInvoice { } /// The hash of the `RawInvoice` that was signed. - pub fn hash(&self) -> &[u8; 32] { + pub fn signable_hash(&self) -> &[u8; 32] { &self.hash } @@ -709,7 +761,7 @@ impl SignedRawInvoice { let hash = Message::from_slice(&self.hash[..]) .expect("Hash is 32 bytes long, same as MESSAGE_SIZE"); - Ok(PayeePubKey(Secp256k1::new().recover( + Ok(PayeePubKey(Secp256k1::new().recover_ecdsa( &hash, &self.signature )?)) @@ -736,7 +788,7 @@ impl SignedRawInvoice { .expect("Hash is 32 bytes long, same as MESSAGE_SIZE"); let secp_context = Secp256k1::new(); - let verification_result = secp_context.verify( + let verification_result = secp_context.verify_ecdsa( &hash, &self.signature.to_standard(), pub_key @@ -753,18 +805,15 @@ impl SignedRawInvoice { /// variant. If no element was found `None` gets returned. /// /// The following example would extract the first B. -/// ``` -/// use Enum::* /// /// enum Enum { /// A(u8), /// B(u16) /// } /// -/// let elements = vec![A(1), A(2), B(3), A(4)] +/// let elements = vec![Enum::A(1), Enum::A(2), Enum::B(3), Enum::A(4)]; /// -/// assert_eq!(find_extract!(elements.iter(), Enum::B(ref x), x), Some(3u16)) -/// ``` +/// assert_eq!(find_extract!(elements.iter(), Enum::B(x), x), Some(3u16)); macro_rules! find_extract { ($iter:expr, $enm:pat, $enm_var:ident) => { find_all_extract!($iter, $enm, $enm_var).next() @@ -775,20 +824,18 @@ macro_rules! find_extract { /// variant through an iterator. /// /// The following example would extract all A. -/// ``` -/// use Enum::* /// /// enum Enum { /// A(u8), /// B(u16) /// } /// -/// let elements = vec![A(1), A(2), B(3), A(4)] +/// let elements = vec![Enum::A(1), Enum::A(2), Enum::B(3), Enum::A(4)]; /// /// assert_eq!( -/// find_all_extract!(elements.iter(), Enum::A(ref x), x).collect::>(), -/// vec![1u8, 2u8, 4u8]) -/// ``` +/// find_all_extract!(elements.iter(), Enum::A(x), x).collect::>(), +/// vec![1u8, 2u8, 4u8] +/// ); macro_rules! find_all_extract { ($iter:expr, $enm:pat, $enm_var:ident) => { $iter.filter_map(|tf| match *tf { @@ -808,8 +855,8 @@ impl RawInvoice { hash } - /// Calculate the hash of the encoded `RawInvoice` - pub fn hash(&self) -> [u8; 32] { + /// Calculate the hash of the encoded `RawInvoice` which should be signed. + pub fn signable_hash(&self) -> [u8; 32] { use bech32::ToBase32; RawInvoice::hash_from_parts( @@ -827,7 +874,7 @@ impl RawInvoice { pub fn sign(self, sign_method: F) -> Result where F: FnOnce(&Message) -> Result { - let raw_hash = self.hash(); + let raw_hash = self.signable_hash(); let hash = Message::from_slice(&raw_hash[..]) .expect("Hash is 32 bytes long, same as MESSAGE_SIZE"); let signature = sign_method(&hash)?; @@ -915,12 +962,18 @@ impl PositiveTimestamp { /// /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`]. pub fn from_unix_timestamp(unix_seconds: u64) -> Result { - Self::from_duration_since_epoch(Duration::from_secs(unix_seconds)) + if unix_seconds <= MAX_TIMESTAMP { + Ok(Self(Duration::from_secs(unix_seconds))) + } else { + Err(CreationError::TimestampOutOfBounds) + } } /// Creates a `PositiveTimestamp` from a [`SystemTime`] with a corresponding Unix timestamp in /// the range `0..=MAX_TIMESTAMP`. /// + /// Note that the subsecond part is dropped as it is not representable in BOLT 11 invoices. + /// /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`]. #[cfg(feature = "std")] pub fn from_system_time(time: SystemTime) -> Result { @@ -932,13 +985,11 @@ impl PositiveTimestamp { /// Creates a `PositiveTimestamp` from a [`Duration`] since the Unix epoch in the range /// `0..=MAX_TIMESTAMP`. /// + /// Note that the subsecond part is dropped as it is not representable in BOLT 11 invoices. + /// /// Otherwise, returns a [`CreationError::TimestampOutOfBounds`]. pub fn from_duration_since_epoch(duration: Duration) -> Result { - if duration.as_secs() <= MAX_TIMESTAMP { - Ok(PositiveTimestamp(duration)) - } else { - Err(CreationError::TimestampOutOfBounds) - } + Self::from_unix_timestamp(duration.as_secs()) } /// Returns the Unix timestamp representing the stored time @@ -1311,9 +1362,9 @@ impl ExpiryTime { ExpiryTime(Duration::from_secs(seconds)) } - /// Construct an `ExpiryTime` from a `Duration`. + /// Construct an `ExpiryTime` from a `Duration`, dropping the sub-second part. pub fn from_duration(duration: Duration) -> ExpiryTime { - ExpiryTime(duration) + Self::from_seconds(duration.as_secs()) } /// Returns the expiry time in seconds @@ -1486,6 +1537,23 @@ impl Display for SignOrCreationError { } } +#[cfg(feature = "serde")] +impl Serialize for Invoice { + fn serialize(&self, serializer: S) -> Result where S: Serializer { + serializer.serialize_str(self.to_string().as_str()) + } +} +#[cfg(feature = "serde")] +impl<'de> Deserialize<'de> for Invoice { + fn deserialize(deserializer: D) -> Result where D: Deserializer<'de> { + let bolt11 = String::deserialize(deserializer)? + .parse::() + .map_err(|e| D::Error::custom(format!("{:?}", e)))?; + + Ok(bolt11) + } +} + #[cfg(test)] mod test { use bitcoin_hashes::hex::FromHex; @@ -1494,15 +1562,15 @@ mod test { #[test] fn test_system_time_bounds_assumptions() { assert_eq!( - ::PositiveTimestamp::from_unix_timestamp(::MAX_TIMESTAMP + 1), - Err(::CreationError::TimestampOutOfBounds) + crate::PositiveTimestamp::from_unix_timestamp(crate::MAX_TIMESTAMP + 1), + Err(crate::CreationError::TimestampOutOfBounds) ); } #[test] fn test_calc_invoice_hash() { - use ::{RawInvoice, RawHrp, RawDataPart, Currency, PositiveTimestamp}; - use ::TaggedField::*; + use crate::{RawInvoice, RawHrp, RawDataPart, Currency, PositiveTimestamp}; + use crate::TaggedField::*; let invoice = RawInvoice { hrp: RawHrp { @@ -1513,10 +1581,10 @@ mod test { data: RawDataPart { timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(), tagged_fields: vec![ - PaymentHash(::Sha256(sha256::Hash::from_hex( + PaymentHash(crate::Sha256(sha256::Hash::from_hex( "0001020304050607080900010203040506070809000102030405060708090102" ).unwrap())).into(), - Description(::Description::new( + Description(crate::Description::new( "Please consider supporting this project".to_owned() ).unwrap()).into(), ], @@ -1529,16 +1597,16 @@ mod test { 0xd5, 0x18, 0xe1, 0xc9 ]; - assert_eq!(invoice.hash(), expected_hash) + assert_eq!(invoice.signable_hash(), expected_hash) } #[test] fn test_check_signature() { - use TaggedField::*; + use crate::TaggedField::*; use secp256k1::Secp256k1; - use secp256k1::recovery::{RecoveryId, RecoverableSignature}; - use secp256k1::key::{SecretKey, PublicKey}; - use {SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256, + use secp256k1::ecdsa::{RecoveryId, RecoverableSignature}; + use secp256k1::{SecretKey, PublicKey}; + use crate::{SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp}; let invoice = SignedRawInvoice { @@ -1555,7 +1623,7 @@ mod test { "0001020304050607080900010203040506070809000102030405060708090102" ).unwrap())).into(), Description( - ::Description::new( + crate::Description::new( "Please consider supporting this project".to_owned() ).unwrap() ).into(), @@ -1591,11 +1659,11 @@ mod test { ).unwrap(); let public_key = PublicKey::from_secret_key(&Secp256k1::new(), &private_key); - assert_eq!(invoice.recover_payee_pub_key(), Ok(::PayeePubKey(public_key))); + assert_eq!(invoice.recover_payee_pub_key(), Ok(crate::PayeePubKey(public_key))); let (raw_invoice, _, _) = invoice.into_parts(); let new_signed = raw_invoice.sign::<_, ()>(|hash| { - Ok(Secp256k1::new().sign_recoverable(hash, &private_key)) + Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key)) }).unwrap(); assert!(new_signed.check_signature()); @@ -1603,11 +1671,11 @@ mod test { #[test] fn test_check_feature_bits() { - use TaggedField::*; + use crate::TaggedField::*; use lightning::ln::features::InvoiceFeatures; use secp256k1::Secp256k1; - use secp256k1::key::SecretKey; - use {RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp, Invoice, + use secp256k1::SecretKey; + use crate::{RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp, Invoice, SemanticError}; let private_key = SecretKey::from_slice(&[42; 32]).unwrap(); @@ -1625,7 +1693,7 @@ mod test { "0001020304050607080900010203040506070809000102030405060708090102" ).unwrap())).into(), Description( - ::Description::new( + crate::Description::new( "Please consider supporting this project".to_owned() ).unwrap() ).into(), @@ -1637,7 +1705,7 @@ mod test { let invoice = { let mut invoice = invoice_template.clone(); invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into()); - invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key))) + invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures)); @@ -1646,23 +1714,26 @@ mod test { let mut invoice = invoice_template.clone(); invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into()); invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into()); - invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key))) + invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures)); + let mut payment_secret_features = InvoiceFeatures::empty(); + payment_secret_features.set_payment_secret_required(); + // Including payment secret and feature bits let invoice = { let mut invoice = invoice_template.clone(); invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into()); - invoice.data.tagged_fields.push(Features(InvoiceFeatures::known()).into()); - invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key))) + invoice.data.tagged_fields.push(Features(payment_secret_features.clone()).into()); + invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); assert!(Invoice::from_signed(invoice).is_ok()); // No payment secret or features let invoice = { let invoice = invoice_template.clone(); - invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key))) + invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret)); @@ -1670,15 +1741,15 @@ mod test { let invoice = { let mut invoice = invoice_template.clone(); invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into()); - invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key))) + invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret)); // Missing payment secret let invoice = { let mut invoice = invoice_template.clone(); - invoice.data.tagged_fields.push(Features(InvoiceFeatures::known()).into()); - invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key))) + invoice.data.tagged_fields.push(Features(payment_secret_features).into()); + invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret)); @@ -1687,14 +1758,14 @@ mod test { let mut invoice = invoice_template.clone(); invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into()); invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into()); - invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key))) + invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::MultiplePaymentSecrets)); } #[test] fn test_builder_amount() { - use ::*; + use crate::*; let builder = InvoiceBuilder::new(Currency::Bitcoin) .description("Test".into()) @@ -1721,10 +1792,10 @@ mod test { #[test] fn test_builder_fail() { - use ::*; + use crate::*; use lightning::routing::router::RouteHintHop; use std::iter::FromIterator; - use secp256k1::key::PublicKey; + use secp256k1::PublicKey; let builder = InvoiceBuilder::new(Currency::Bitcoin) .payment_hash(sha256::Hash::from_slice(&[0;32][..]).unwrap()) @@ -1775,10 +1846,10 @@ mod test { #[test] fn test_builder_ok() { - use ::*; + use crate::*; use lightning::routing::router::RouteHintHop; use secp256k1::Secp256k1; - use secp256k1::key::{SecretKey, PublicKey}; + use secp256k1::{SecretKey, PublicKey}; use std::time::{UNIX_EPOCH, Duration}; let secp_ctx = Secp256k1::new(); @@ -1857,7 +1928,7 @@ mod test { .basic_mpp(); let invoice = builder.clone().build_signed(|hash| { - secp_ctx.sign_recoverable(hash, &private_key) + secp_ctx.sign_ecdsa_recoverable(hash, &private_key) }).unwrap(); assert!(invoice.check_signature().is_ok()); @@ -1882,7 +1953,12 @@ mod test { ); assert_eq!(invoice.payment_hash(), &sha256::Hash::from_slice(&[21;32][..]).unwrap()); assert_eq!(invoice.payment_secret(), &PaymentSecret([42; 32])); - assert_eq!(invoice.features(), Some(&InvoiceFeatures::known())); + + let mut expected_features = InvoiceFeatures::empty(); + expected_features.set_variable_length_onion_required(); + expected_features.set_payment_secret_required(); + expected_features.set_basic_mpp_optional(); + assert_eq!(invoice.features(), Some(&expected_features)); let raw_invoice = builder.build_raw().unwrap(); assert_eq!(raw_invoice, *invoice.into_signed_raw().raw_invoice()) @@ -1890,9 +1966,9 @@ mod test { #[test] fn test_default_values() { - use ::*; + use crate::*; use secp256k1::Secp256k1; - use secp256k1::key::SecretKey; + use secp256k1::SecretKey; let signed_invoice = InvoiceBuilder::new(Currency::Bitcoin) .description("Test".into()) @@ -1904,7 +1980,7 @@ mod test { .sign::<_, ()>(|hash| { let privkey = SecretKey::from_slice(&[41; 32]).unwrap(); let secp_ctx = Secp256k1::new(); - Ok(secp_ctx.sign_recoverable(hash, &privkey)) + Ok(secp_ctx.sign_ecdsa_recoverable(hash, &privkey)) }) .unwrap(); let invoice = Invoice::from_signed(signed_invoice).unwrap(); @@ -1916,9 +1992,9 @@ mod test { #[test] fn test_expiration() { - use ::*; + use crate::*; use secp256k1::Secp256k1; - use secp256k1::key::SecretKey; + use secp256k1::SecretKey; let signed_invoice = InvoiceBuilder::new(Currency::Bitcoin) .description("Test".into()) @@ -1930,11 +2006,33 @@ mod test { .sign::<_, ()>(|hash| { let privkey = SecretKey::from_slice(&[41; 32]).unwrap(); let secp_ctx = Secp256k1::new(); - Ok(secp_ctx.sign_recoverable(hash, &privkey)) + Ok(secp_ctx.sign_ecdsa_recoverable(hash, &privkey)) }) .unwrap(); let invoice = Invoice::from_signed(signed_invoice).unwrap(); assert!(invoice.would_expire(Duration::from_secs(1234567 + DEFAULT_EXPIRY_TIME + 1))); } + + #[cfg(feature = "serde")] + #[test] + fn test_serde() { + let invoice_str = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\ + h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\ + 5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\ + h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\ + j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\ + ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\ + guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\ + ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\ + p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\ + 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\ + j5r6drg6k6zcqj0fcwg"; + let invoice = invoice_str.parse::().unwrap(); + let serialized_invoice = serde_json::to_string(&invoice).unwrap(); + let deserialized_invoice: super::Invoice = serde_json::from_str(serialized_invoice.as_str()).unwrap(); + assert_eq!(invoice, deserialized_invoice); + assert_eq!(invoice_str, deserialized_invoice.to_string().as_str()); + assert_eq!(invoice_str, serialized_invoice.as_str().trim_matches('\"')); + } }