X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Flib.rs;h=d953795cf8e061157f1c69e9c5bc5eae2b743ca6;hb=37a3a03f12780f0074b1a08013aebd86e9c066ad;hp=dc13b5ec76a9557590fc686b4b675218f85f6d4e;hpb=6fb34d30b318aa64f64c1182c2b6fa1f1d8960b1;p=rust-lightning diff --git a/lightning-invoice/src/lib.rs b/lightning-invoice/src/lib.rs index dc13b5ec..d953795c 100644 --- a/lightning-invoice/src/lib.rs +++ b/lightning-invoice/src/lib.rs @@ -30,8 +30,6 @@ 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; @@ -50,11 +48,7 @@ use bech32::u5; use bitcoin::{Address, Network, PubkeyHash, ScriptHash}; use bitcoin::util::address::{Payload, WitnessVersion}; use bitcoin_hashes::{Hash, sha256}; -use lightning::ln::PaymentSecret; -use lightning::ln::features::InvoiceFeatures; -#[cfg(any(doc, test))] -use lightning::routing::gossip::RoutingFees; -use lightning::routing::router::RouteHint; +use lightning::ln::features::Bolt11InvoiceFeatures; use lightning::util::invoice::construct_invoice_preimage; use secp256k1::PublicKey; @@ -73,6 +67,13 @@ use core::str; #[cfg(feature = "serde")] use serde::{Deserialize, Deserializer,Serialize, Serializer, de::Error}; +#[doc(no_inline)] +pub use lightning::ln::PaymentSecret; +#[doc(no_inline)] +pub use lightning::routing::router::{RouteHint, RouteHintHop}; +#[doc(no_inline)] +pub use lightning::routing::gossip::RoutingFees; + mod de; mod ser; mod tb; @@ -139,7 +140,7 @@ pub enum ParseOrSemanticError { ParseError(Bolt11ParseError), /// The invoice could be decoded but violates the BOLT11 standard - SemanticError(crate::SemanticError), + SemanticError(crate::Bolt11SemanticError), } /// The number of bits used to represent timestamps as defined in BOLT 11. @@ -260,7 +261,7 @@ pub struct Bolt11Invoice { /// This is not exported to bindings users as we don't have a good way to map the reference lifetimes making this /// practically impossible to use safely in languages like C. #[derive(Eq, PartialEq, Debug, Clone, Ord, PartialOrd)] -pub enum InvoiceDescription<'f> { +pub enum Bolt11InvoiceDescription<'f> { /// Reference to the directly supplied description in the invoice Direct(&'f Description), @@ -288,7 +289,7 @@ pub struct SignedRawBolt11Invoice { hash: [u8; 32], /// signature of the payment request - signature: InvoiceSignature, + signature: Bolt11InvoiceSignature, } /// Represents an syntactically correct [`Bolt11Invoice`] for a payment on the lightning network, @@ -448,7 +449,7 @@ pub enum TaggedField { PrivateRoute(PrivateRoute), PaymentSecret(PaymentSecret), PaymentMetadata(Vec), - Features(InvoiceFeatures), + Features(Bolt11InvoiceFeatures), } /// SHA-256 hash @@ -499,15 +500,15 @@ pub enum Fallback { /// Recoverable signature #[derive(Clone, Debug, Hash, Eq, PartialEq)] -pub struct InvoiceSignature(pub RecoverableSignature); +pub struct Bolt11InvoiceSignature(pub RecoverableSignature); -impl PartialOrd for InvoiceSignature { +impl PartialOrd for Bolt11InvoiceSignature { fn partial_cmp(&self, other: &Self) -> Option { - self.0.serialize_compact().1.partial_cmp(&other.0.serialize_compact().1) + Some(self.cmp(other)) } } -impl Ord for InvoiceSignature { +impl Ord for Bolt11InvoiceSignature { fn cmp(&self, other: &Self) -> Ordering { self.0.serialize_compact().1.cmp(&other.0.serialize_compact().1) } @@ -671,12 +672,12 @@ impl InvoiceBui } /// Set the description or description hash. This function is only available if no description (hash) was set. - pub fn invoice_description(self, description: InvoiceDescription) -> InvoiceBuilder { + pub fn invoice_description(self, description: Bolt11InvoiceDescription) -> InvoiceBuilder { match description { - InvoiceDescription::Direct(desc) => { + Bolt11InvoiceDescription::Direct(desc) => { self.description(desc.clone().into_inner()) } - InvoiceDescription::Hash(hash) => { + Bolt11InvoiceDescription::Hash(hash) => { self.description_hash(hash.0) } } @@ -744,7 +745,7 @@ impl InvoiceBui } self.tagged_fields.push(TaggedField::PaymentSecret(payment_secret)); if !found_features { - let mut features = InvoiceFeatures::empty(); + let mut features = Bolt11InvoiceFeatures::empty(); features.set_variable_length_onion_required(); features.set_payment_secret_required(); self.tagged_fields.push(TaggedField::Features(features)); @@ -770,7 +771,7 @@ impl InvoiceBui } } if !found_features { - let mut features = InvoiceFeatures::empty(); + let mut features = Bolt11InvoiceFeatures::empty(); features.set_payment_metadata_optional(); self.tagged_fields.push(TaggedField::Features(features)); } @@ -855,7 +856,7 @@ impl SignedRawBolt11Invoice { /// 1. raw invoice /// 2. hash of the raw invoice /// 3. signature - pub fn into_parts(self) -> (RawBolt11Invoice, [u8; 32], InvoiceSignature) { + pub fn into_parts(self) -> (RawBolt11Invoice, [u8; 32], Bolt11InvoiceSignature) { (self.raw_invoice, self.hash, self.signature) } @@ -870,7 +871,7 @@ impl SignedRawBolt11Invoice { } /// Signature for the invoice. - pub fn signature(&self) -> &InvoiceSignature { + pub fn signature(&self) -> &Bolt11InvoiceSignature { &self.signature } @@ -1004,7 +1005,7 @@ impl RawBolt11Invoice { Ok(SignedRawBolt11Invoice { raw_invoice: self, hash: raw_hash, - signature: InvoiceSignature(signature), + signature: Bolt11InvoiceSignature(signature), }) } @@ -1059,7 +1060,7 @@ impl RawBolt11Invoice { find_extract!(self.known_tagged_fields(), TaggedField::PaymentMetadata(ref x), x) } - pub fn features(&self) -> Option<&InvoiceFeatures> { + pub fn features(&self) -> Option<&Bolt11InvoiceFeatures> { find_extract!(self.known_tagged_fields(), TaggedField::Features(ref x), x) } @@ -1154,16 +1155,16 @@ impl Bolt11Invoice { } /// Check that all mandatory fields are present - fn check_field_counts(&self) -> Result<(), SemanticError> { + fn check_field_counts(&self) -> Result<(), Bolt11SemanticError> { // "A writer MUST include exactly one p field […]." let payment_hash_cnt = self.tagged_fields().filter(|&tf| match *tf { TaggedField::PaymentHash(_) => true, _ => false, }).count(); if payment_hash_cnt < 1 { - return Err(SemanticError::NoPaymentHash); + return Err(Bolt11SemanticError::NoPaymentHash); } else if payment_hash_cnt > 1 { - return Err(SemanticError::MultiplePaymentHashes); + return Err(Bolt11SemanticError::MultiplePaymentHashes); } // "A writer MUST include either exactly one d or exactly one h field." @@ -1172,9 +1173,9 @@ impl Bolt11Invoice { _ => false, }).count(); if description_cnt < 1 { - return Err(SemanticError::NoDescription); + return Err(Bolt11SemanticError::NoDescription); } else if description_cnt > 1 { - return Err(SemanticError::MultipleDescriptions); + return Err(Bolt11SemanticError::MultipleDescriptions); } self.check_payment_secret()?; @@ -1183,33 +1184,33 @@ impl Bolt11Invoice { } /// Checks that there is exactly one payment secret field - fn check_payment_secret(&self) -> Result<(), SemanticError> { + fn check_payment_secret(&self) -> Result<(), Bolt11SemanticError> { // "A writer MUST include exactly one `s` field." let payment_secret_count = self.tagged_fields().filter(|&tf| match *tf { TaggedField::PaymentSecret(_) => true, _ => false, }).count(); if payment_secret_count < 1 { - return Err(SemanticError::NoPaymentSecret); + return Err(Bolt11SemanticError::NoPaymentSecret); } else if payment_secret_count > 1 { - return Err(SemanticError::MultiplePaymentSecrets); + return Err(Bolt11SemanticError::MultiplePaymentSecrets); } Ok(()) } /// Check that amount is a whole number of millisatoshis - fn check_amount(&self) -> Result<(), SemanticError> { + fn check_amount(&self) -> Result<(), Bolt11SemanticError> { if let Some(amount_pico_btc) = self.amount_pico_btc() { if amount_pico_btc % 10 != 0 { - return Err(SemanticError::ImpreciseAmount); + return Err(Bolt11SemanticError::ImpreciseAmount); } } Ok(()) } /// Check that feature bits are set as required - fn check_feature_bits(&self) -> Result<(), SemanticError> { + fn check_feature_bits(&self) -> Result<(), Bolt11SemanticError> { self.check_payment_secret()?; // "A writer MUST set an s field if and only if the payment_secret feature is set." @@ -1220,12 +1221,12 @@ impl Bolt11Invoice { _ => false, }); match features { - None => Err(SemanticError::InvalidFeatures), + None => Err(Bolt11SemanticError::InvalidFeatures), Some(TaggedField::Features(features)) => { if features.requires_unknown_bits() { - Err(SemanticError::InvalidFeatures) + Err(Bolt11SemanticError::InvalidFeatures) } else if !features.supports_payment_secret() { - Err(SemanticError::InvalidFeatures) + Err(Bolt11SemanticError::InvalidFeatures) } else { Ok(()) } @@ -1235,18 +1236,18 @@ impl Bolt11Invoice { } /// Check that the invoice is signed correctly and that key recovery works - pub fn check_signature(&self) -> Result<(), SemanticError> { + pub fn check_signature(&self) -> Result<(), Bolt11SemanticError> { match self.signed_invoice.recover_payee_pub_key() { Err(secp256k1::Error::InvalidRecoveryId) => - return Err(SemanticError::InvalidRecoveryId), + return Err(Bolt11SemanticError::InvalidRecoveryId), Err(secp256k1::Error::InvalidSignature) => - return Err(SemanticError::InvalidSignature), + return Err(Bolt11SemanticError::InvalidSignature), Err(e) => panic!("no other error may occur, got {:?}", e), Ok(_) => {}, } if !self.signed_invoice.check_signature() { - return Err(SemanticError::InvalidSignature); + return Err(Bolt11SemanticError::InvalidSignature); } Ok(()) @@ -1272,7 +1273,7 @@ impl Bolt11Invoice { /// /// assert!(Bolt11Invoice::from_signed(signed).is_ok()); /// ``` - pub fn from_signed(signed_invoice: SignedRawBolt11Invoice) -> Result { + pub fn from_signed(signed_invoice: SignedRawBolt11Invoice) -> Result { let invoice = Bolt11Invoice { signed_invoice, }; @@ -1310,12 +1311,12 @@ impl Bolt11Invoice { /// Return the description or a hash of it for longer ones /// - /// This is not exported to bindings users because we don't yet export InvoiceDescription - pub fn description(&self) -> InvoiceDescription { + /// This is not exported to bindings users because we don't yet export Bolt11InvoiceDescription + pub fn description(&self) -> Bolt11InvoiceDescription { if let Some(direct) = self.signed_invoice.description() { - return InvoiceDescription::Direct(direct); + return Bolt11InvoiceDescription::Direct(direct); } else if let Some(hash) = self.signed_invoice.description_hash() { - return InvoiceDescription::Hash(hash); + return Bolt11InvoiceDescription::Hash(hash); } unreachable!("ensured by constructor"); } @@ -1336,7 +1337,7 @@ impl Bolt11Invoice { } /// Get the invoice features if they were included in the invoice - pub fn features(&self) -> Option<&InvoiceFeatures> { + pub fn features(&self) -> Option<&Bolt11InvoiceFeatures> { self.signed_invoice.features() } @@ -1591,7 +1592,7 @@ impl Deref for PrivateRoute { } } -impl Deref for InvoiceSignature { +impl Deref for Bolt11InvoiceSignature { type Target = RecoverableSignature; fn deref(&self) -> &RecoverableSignature { @@ -1654,7 +1655,7 @@ impl std::error::Error for CreationError { } /// Errors that may occur when converting a [`RawBolt11Invoice`] to a [`Bolt11Invoice`]. They relate to /// the requirements sections in BOLT #11 #[derive(Eq, PartialEq, Debug, Clone)] -pub enum SemanticError { +pub enum Bolt11SemanticError { /// The invoice is missing the mandatory payment hash NoPaymentHash, @@ -1687,25 +1688,25 @@ pub enum SemanticError { ImpreciseAmount, } -impl Display for SemanticError { +impl Display for Bolt11SemanticError { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { match self { - SemanticError::NoPaymentHash => f.write_str("The invoice is missing the mandatory payment hash"), - SemanticError::MultiplePaymentHashes => f.write_str("The invoice has multiple payment hashes which isn't allowed"), - SemanticError::NoDescription => f.write_str("No description or description hash are part of the invoice"), - SemanticError::MultipleDescriptions => f.write_str("The invoice contains multiple descriptions and/or description hashes which isn't allowed"), - SemanticError::NoPaymentSecret => f.write_str("The invoice is missing the mandatory payment secret"), - SemanticError::MultiplePaymentSecrets => f.write_str("The invoice contains multiple payment secrets"), - SemanticError::InvalidFeatures => f.write_str("The invoice's features are invalid"), - SemanticError::InvalidRecoveryId => f.write_str("The recovery id doesn't fit the signature/pub key"), - SemanticError::InvalidSignature => f.write_str("The invoice's signature is invalid"), - SemanticError::ImpreciseAmount => f.write_str("The invoice's amount was not a whole number of millisatoshis"), + Bolt11SemanticError::NoPaymentHash => f.write_str("The invoice is missing the mandatory payment hash"), + Bolt11SemanticError::MultiplePaymentHashes => f.write_str("The invoice has multiple payment hashes which isn't allowed"), + Bolt11SemanticError::NoDescription => f.write_str("No description or description hash are part of the invoice"), + Bolt11SemanticError::MultipleDescriptions => f.write_str("The invoice contains multiple descriptions and/or description hashes which isn't allowed"), + Bolt11SemanticError::NoPaymentSecret => f.write_str("The invoice is missing the mandatory payment secret"), + Bolt11SemanticError::MultiplePaymentSecrets => f.write_str("The invoice contains multiple payment secrets"), + Bolt11SemanticError::InvalidFeatures => f.write_str("The invoice's features are invalid"), + Bolt11SemanticError::InvalidRecoveryId => f.write_str("The recovery id doesn't fit the signature/pub key"), + Bolt11SemanticError::InvalidSignature => f.write_str("The invoice's signature is invalid"), + Bolt11SemanticError::ImpreciseAmount => f.write_str("The invoice's amount was not a whole number of millisatoshis"), } } } #[cfg(feature = "std")] -impl std::error::Error for SemanticError { } +impl std::error::Error for Bolt11SemanticError { } /// When signing using a fallible method either an user-supplied `SignError` or a [`CreationError`] /// may occur. @@ -1797,7 +1798,7 @@ mod test { use secp256k1::Secp256k1; use secp256k1::ecdsa::{RecoveryId, RecoverableSignature}; use secp256k1::{SecretKey, PublicKey}; - use crate::{SignedRawBolt11Invoice, InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, + use crate::{SignedRawBolt11Invoice, Bolt11InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp}; let invoice = SignedRawBolt11Invoice { @@ -1826,7 +1827,7 @@ mod test { 0x7b, 0x1d, 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7, 0x83, 0x5d, 0xb2, 0xec, 0xd5, 0x18, 0xe1, 0xc9 ], - signature: InvoiceSignature(RecoverableSignature::from_compact( + signature: Bolt11InvoiceSignature(RecoverableSignature::from_compact( & [ 0x38u8, 0xec, 0x68, 0x91, 0x34, 0x5e, 0x20, 0x41, 0x45, 0xbe, 0x8a, 0x3a, 0x99, 0xde, 0x38, 0xe9, 0x8a, 0x39, 0xd6, 0xa5, 0x69, 0x43, @@ -1863,11 +1864,11 @@ mod test { #[test] fn test_check_feature_bits() { use crate::TaggedField::*; - use lightning::ln::features::InvoiceFeatures; + use lightning::ln::features::Bolt11InvoiceFeatures; use secp256k1::Secp256k1; use secp256k1::SecretKey; use crate::{Bolt11Invoice, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp, - SemanticError}; + Bolt11SemanticError}; let private_key = SecretKey::from_slice(&[42; 32]).unwrap(); let payment_secret = lightning::ln::PaymentSecret([21; 32]); @@ -1898,18 +1899,18 @@ mod test { invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into()); invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); - assert_eq!(Bolt11Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures)); + assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::InvalidFeatures)); // Missing 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::empty()).into()); + invoice.data.tagged_fields.push(Features(Bolt11InvoiceFeatures::empty()).into()); invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); - assert_eq!(Bolt11Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures)); + assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::InvalidFeatures)); - let mut payment_secret_features = InvoiceFeatures::empty(); + let mut payment_secret_features = Bolt11InvoiceFeatures::empty(); payment_secret_features.set_payment_secret_required(); // Including payment secret and feature bits @@ -1926,15 +1927,15 @@ mod test { let invoice = invoice_template.clone(); invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); - assert_eq!(Bolt11Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret)); + assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::NoPaymentSecret)); // No payment secret or feature bits let invoice = { let mut invoice = invoice_template.clone(); - invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into()); + invoice.data.tagged_fields.push(Features(Bolt11InvoiceFeatures::empty()).into()); invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); - assert_eq!(Bolt11Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret)); + assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::NoPaymentSecret)); // Missing payment secret let invoice = { @@ -1942,7 +1943,7 @@ mod test { 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!(Bolt11Invoice::from_signed(invoice), Err(SemanticError::NoPaymentSecret)); + assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::NoPaymentSecret)); // Multiple payment secrets let invoice = { @@ -1951,7 +1952,7 @@ mod test { invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into()); invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))) }.unwrap(); - assert_eq!(Bolt11Invoice::from_signed(invoice), Err(SemanticError::MultiplePaymentSecrets)); + assert_eq!(Bolt11Invoice::from_signed(invoice), Err(Bolt11SemanticError::MultiplePaymentSecrets)); } #[test] @@ -2142,12 +2143,12 @@ mod test { assert_eq!(invoice.private_routes(), vec![&PrivateRoute(route_1), &PrivateRoute(route_2)]); assert_eq!( invoice.description(), - InvoiceDescription::Hash(&Sha256(sha256::Hash::from_slice(&[3;32][..]).unwrap())) + Bolt11InvoiceDescription::Hash(&Sha256(sha256::Hash::from_slice(&[3;32][..]).unwrap())) ); assert_eq!(invoice.payment_hash(), &sha256::Hash::from_slice(&[21;32][..]).unwrap()); assert_eq!(invoice.payment_secret(), &PaymentSecret([42; 32])); - let mut expected_features = InvoiceFeatures::empty(); + let mut expected_features = Bolt11InvoiceFeatures::empty(); expected_features.set_variable_length_onion_required(); expected_features.set_payment_secret_required(); expected_features.set_basic_mpp_optional();