From: Jeffrey Czyz Date: Fri, 14 Jul 2023 01:34:27 +0000 (-0500) Subject: Qualify the BOLT 11 raw invoice types X-Git-Tag: v0.0.116-rc1~3^2~5 X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=4c383a39a8a54a8c18e65fe72928d1ec98345349;p=rust-lightning Qualify the BOLT 11 raw invoice types A previous commit qualified the BOLT 11 invoice type, so any related types should be similarly qualified, if public. --- diff --git a/lightning-invoice/src/de.rs b/lightning-invoice/src/de.rs index 2e638ff1..6e2a743c 100644 --- a/lightning-invoice/src/de.rs +++ b/lightning-invoice/src/de.rs @@ -24,8 +24,8 @@ use secp256k1::ecdsa::{RecoveryId, RecoverableSignature}; use secp256k1::PublicKey; use super::{Bolt11Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp, - SemanticError, PrivateRoute, ParseError, ParseOrSemanticError, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice, - constants, SignedRawInvoice, RawDataPart, InvoiceFeatures}; + SemanticError, PrivateRoute, ParseError, ParseOrSemanticError, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawBolt11Invoice, + constants, SignedRawBolt11Invoice, RawDataPart, InvoiceFeatures}; use self::hrp_sm::parse_hrp; @@ -231,7 +231,7 @@ impl FromStr for Bolt11Invoice { type Err = ParseOrSemanticError; fn from_str(s: &str) -> Result::Err> { - let signed = s.parse::()?; + let signed = s.parse::()?; Ok(Bolt11Invoice::from_signed(signed)?) } } @@ -253,7 +253,7 @@ impl FromStr for Bolt11Invoice { /// /// let parsed_1 = invoice.parse::(); /// -/// let parsed_2 = match invoice.parse::() { +/// let parsed_2 = match invoice.parse::() { /// Ok(signed) => match Bolt11Invoice::from_signed(signed) { /// Ok(invoice) => Ok(invoice), /// Err(e) => Err(ParseOrSemanticError::SemanticError(e)), @@ -264,7 +264,7 @@ impl FromStr for Bolt11Invoice { /// assert!(parsed_1.is_ok()); /// assert_eq!(parsed_1, parsed_2); /// ``` -impl FromStr for SignedRawInvoice { +impl FromStr for SignedRawBolt11Invoice { type Err = ParseError; fn from_str(s: &str) -> Result { @@ -283,12 +283,12 @@ impl FromStr for SignedRawInvoice { let raw_hrp: RawHrp = hrp.parse()?; let data_part = RawDataPart::from_base32(&data[..data.len()-104])?; - Ok(SignedRawInvoice { - raw_invoice: RawInvoice { + Ok(SignedRawBolt11Invoice { + raw_invoice: RawBolt11Invoice { hrp: raw_hrp, data: data_part, }, - hash: RawInvoice::hash_from_parts( + hash: RawBolt11Invoice::hash_from_parts( hrp.as_bytes(), &data[..data.len()-104] ), @@ -972,14 +972,14 @@ mod test { use lightning::ln::features::InvoiceFeatures; use secp256k1::ecdsa::{RecoveryId, RecoverableSignature}; use crate::TaggedField::*; - use crate::{SiPrefix, SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, + use crate::{SiPrefix, SignedRawBolt11Invoice, InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp}; // Feature bits 9, 15, and 99 are set. let expected_features = InvoiceFeatures::from_le_bytes(vec![0, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8]); let invoice_str = "lnbc25m1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdq5vdhkven9v5sxyetpdeessp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygs9q5sqqqqqqqqqqqqqqqpqsq67gye39hfg3zd8rgc80k32tvy9xk2xunwm5lzexnvpx6fd77en8qaq424dxgt56cag2dpt359k3ssyhetktkpqh24jqnjyw6uqd08sgptq44qu"; - let invoice = SignedRawInvoice { - raw_invoice: RawInvoice { + let invoice = SignedRawBolt11Invoice { + raw_invoice: RawBolt11Invoice { hrp: RawHrp { currency: Currency::Bitcoin, raw_amount: Some(25), @@ -1018,15 +1018,15 @@ mod test { fn test_raw_signed_invoice_deserialization() { use crate::TaggedField::*; use secp256k1::ecdsa::{RecoveryId, RecoverableSignature}; - use crate::{SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256, + use crate::{SignedRawBolt11Invoice, InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp}; assert_eq!( "lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmw\ wd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d73gafnh3cax9rn449d9p5uxz9\ ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ecky03ylcqca784w".parse(), - Ok(SignedRawInvoice { - raw_invoice: RawInvoice { + Ok(SignedRawBolt11Invoice { + raw_invoice: RawBolt11Invoice { hrp: RawHrp { currency: Currency::Bitcoin, raw_amount: None, diff --git a/lightning-invoice/src/lib.rs b/lightning-invoice/src/lib.rs index 94566ba7..e840c29f 100644 --- a/lightning-invoice/src/lib.rs +++ b/lightning-invoice/src/lib.rs @@ -251,7 +251,7 @@ pub struct InvoiceBuilder { Hash(&'f Sha256), } -/// Represents a signed [`RawInvoice`] with cached hash. The signature is not checked and may be +/// Represents a signed [`RawBolt11Invoice`] with cached hash. The signature is not checked and may be /// invalid. /// /// # Invariants -/// The hash has to be either from the deserialized invoice or from the serialized [`RawInvoice`]. +/// The hash has to be either from the deserialized invoice or from the serialized [`RawBolt11Invoice`]. #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)] -pub struct SignedRawInvoice { - /// The rawInvoice that the signature belongs to - raw_invoice: RawInvoice, +pub struct SignedRawBolt11Invoice { + /// The raw invoice that the signature belongs to + raw_invoice: RawBolt11Invoice, - /// Hash of the [`RawInvoice`] that will be used to check the signature. + /// Hash of the [`RawBolt11Invoice`] that will be used to check the signature. /// - /// * if the `SignedRawInvoice` was deserialized the hash is of from the original encoded form, + /// * if the `SignedRawBolt11Invoice` was deserialized the hash is of from the original encoded form, /// since it's not guaranteed that encoding it again will lead to the same result since integers /// could have been encoded with leading zeroes etc. - /// * if the `SignedRawInvoice` was constructed manually the hash will be the calculated hash - /// from the [`RawInvoice`] + /// * if the `SignedRawBolt11Invoice` was constructed manually the hash will be the calculated hash + /// from the [`RawBolt11Invoice`] hash: [u8; 32], /// signature of the payment request @@ -297,7 +297,7 @@ pub struct SignedRawInvoice { /// /// For methods without docs see the corresponding methods in [`Bolt11Invoice`]. #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)] -pub struct RawInvoice { +pub struct RawBolt11Invoice { /// human readable part pub hrp: RawHrp, @@ -305,7 +305,7 @@ pub struct RawInvoice { pub data: RawDataPart, } -/// Data of the [`RawInvoice`] that is encoded in the human readable part. +/// Data of the [`RawBolt11Invoice`] that is encoded in the human readable part. /// /// This is not exported to bindings users as we don't yet support `Option` #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)] @@ -320,7 +320,7 @@ pub struct RawHrp { pub si_prefix: Option, } -/// Data of the [`RawInvoice`] that is encoded in the data part +/// Data of the [`RawBolt11Invoice`] that is encoded in the data part #[derive(Eq, PartialEq, Debug, Clone, Hash, Ord, PartialOrd)] pub struct RawDataPart { /// generation time of the invoice @@ -621,9 +621,9 @@ impl InvoiceBuilder { - /// Builds a [`RawInvoice`] if no [`CreationError`] occurred while construction any of the + /// Builds a [`RawBolt11Invoice`] if no [`CreationError`] occurred while construction any of the /// fields. - pub fn build_raw(self) -> Result { + pub fn build_raw(self) -> Result { // If an error occurred at any time before, return it now if let Some(e) = self.error { @@ -647,7 +647,7 @@ impl InvoiceBui tagged_fields, }; - Ok(RawInvoice { + Ok(RawBolt11Invoice { hrp, data, }) @@ -850,21 +850,21 @@ impl InvoiceBuilder (RawInvoice, [u8; 32], InvoiceSignature) { + pub fn into_parts(self) -> (RawBolt11Invoice, [u8; 32], InvoiceSignature) { (self.raw_invoice, self.hash, self.signature) } - /// The [`RawInvoice`] which was signed. - pub fn raw_invoice(&self) -> &RawInvoice { + /// The [`RawBolt11Invoice`] which was signed. + pub fn raw_invoice(&self) -> &RawBolt11Invoice { &self.raw_invoice } - /// The hash of the [`RawInvoice`] that was signed. + /// The hash of the [`RawBolt11Invoice`] that was signed. pub fn signable_hash(&self) -> &[u8; 32] { &self.hash } @@ -968,7 +968,7 @@ macro_rules! find_all_extract { } #[allow(missing_docs)] -impl RawInvoice { +impl RawBolt11Invoice { /// Hash the HRP as bytes and signatureless data part. fn hash_from_parts(hrp_bytes: &[u8], data_without_signature: &[u5]) -> [u8; 32] { let preimage = construct_invoice_preimage(hrp_bytes, data_without_signature); @@ -977,23 +977,23 @@ impl RawInvoice { hash } - /// Calculate the hash of the encoded `RawInvoice` which should be signed. + /// Calculate the hash of the encoded `RawBolt11Invoice` which should be signed. pub fn signable_hash(&self) -> [u8; 32] { use bech32::ToBase32; - RawInvoice::hash_from_parts( + RawBolt11Invoice::hash_from_parts( self.hrp.to_string().as_bytes(), &self.data.to_base32() ) } /// Signs the invoice using the supplied `sign_method`. This function MAY fail with an error of - /// type `E`. Since the signature of a [`SignedRawInvoice`] is not required to be valid there + /// type `E`. Since the signature of a [`SignedRawBolt11Invoice`] is not required to be valid there /// are no constraints regarding the validity of the produced signature. /// /// This is not exported to bindings users as we don't currently support passing function pointers into methods /// explicitly. - pub fn sign(self, sign_method: F) -> Result + pub fn sign(self, sign_method: F) -> Result where F: FnOnce(&Message) -> Result { let raw_hash = self.signable_hash(); @@ -1001,7 +1001,7 @@ impl RawInvoice { .expect("Hash is 32 bytes long, same as MESSAGE_SIZE"); let signature = sign_method(&hash)?; - Ok(SignedRawInvoice { + Ok(SignedRawBolt11Invoice { raw_invoice: self, hash: raw_hash, signature: InvoiceSignature(signature), @@ -1143,13 +1143,13 @@ impl From for SystemTime { } impl Bolt11Invoice { - /// The hash of the [`RawInvoice`] that was signed. + /// The hash of the [`RawBolt11Invoice`] that was signed. pub fn signable_hash(&self) -> [u8; 32] { self.signed_invoice.hash } /// Transform the `Bolt11Invoice` into its unchecked version. - pub fn into_signed_raw(self) -> SignedRawInvoice { + pub fn into_signed_raw(self) -> SignedRawBolt11Invoice { self.signed_invoice } @@ -1252,7 +1252,7 @@ impl Bolt11Invoice { Ok(()) } - /// Constructs a `Bolt11Invoice` from a [`SignedRawInvoice`] by checking all its invariants. + /// Constructs a `Bolt11Invoice` from a [`SignedRawBolt11Invoice`] by checking all its invariants. /// ``` /// use lightning_invoice::*; /// @@ -1268,11 +1268,11 @@ impl Bolt11Invoice { /// 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\ /// j5r6drg6k6zcqj0fcwg"; /// - /// let signed = invoice.parse::().unwrap(); + /// let signed = invoice.parse::().unwrap(); /// /// assert!(Bolt11Invoice::from_signed(signed).is_ok()); /// ``` - pub fn from_signed(signed_invoice: SignedRawInvoice) -> Result { + pub fn from_signed(signed_invoice: SignedRawBolt11Invoice) -> Result { let invoice = Bolt11Invoice { signed_invoice, }; @@ -1599,15 +1599,15 @@ impl Deref for InvoiceSignature { } } -impl Deref for SignedRawInvoice { - type Target = RawInvoice; +impl Deref for SignedRawBolt11Invoice { + type Target = RawBolt11Invoice; - fn deref(&self) -> &RawInvoice { + fn deref(&self) -> &RawBolt11Invoice { &self.raw_invoice } } -/// Errors that may occur when constructing a new [`RawInvoice`] or [`Bolt11Invoice`] +/// Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`] #[derive(Eq, PartialEq, Debug, Clone)] pub enum CreationError { /// The supplied description string was longer than 639 __bytes__ (see [`Description::new`]) @@ -1651,7 +1651,7 @@ impl Display for CreationError { #[cfg(feature = "std")] impl std::error::Error for CreationError { } -/// Errors that may occur when converting a [`RawInvoice`] to a [`Bolt11Invoice`]. They relate to +/// 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 { @@ -1760,10 +1760,10 @@ mod test { #[test] fn test_calc_invoice_hash() { - use crate::{RawInvoice, RawHrp, RawDataPart, Currency, PositiveTimestamp}; + use crate::{RawBolt11Invoice, RawHrp, RawDataPart, Currency, PositiveTimestamp}; use crate::TaggedField::*; - let invoice = RawInvoice { + let invoice = RawBolt11Invoice { hrp: RawHrp { currency: Currency::Bitcoin, raw_amount: None, @@ -1797,11 +1797,11 @@ mod test { use secp256k1::Secp256k1; use secp256k1::ecdsa::{RecoveryId, RecoverableSignature}; use secp256k1::{SecretKey, PublicKey}; - use crate::{SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256, + use crate::{SignedRawBolt11Invoice, InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp}; - let invoice = SignedRawInvoice { - raw_invoice: RawInvoice { + let invoice = SignedRawBolt11Invoice { + raw_invoice: RawBolt11Invoice { hrp: RawHrp { currency: Currency::Bitcoin, raw_amount: None, @@ -1866,12 +1866,12 @@ mod test { use lightning::ln::features::InvoiceFeatures; use secp256k1::Secp256k1; use secp256k1::SecretKey; - use crate::{Bolt11Invoice, RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp, + use crate::{Bolt11Invoice, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp, SemanticError}; let private_key = SecretKey::from_slice(&[42; 32]).unwrap(); let payment_secret = lightning::ln::PaymentSecret([21; 32]); - let invoice_template = RawInvoice { + let invoice_template = RawBolt11Invoice { hrp: RawHrp { currency: Currency::Bitcoin, raw_amount: None, diff --git a/lightning-invoice/src/ser.rs b/lightning-invoice/src/ser.rs index a29f3e66..43ddedcd 100644 --- a/lightning-invoice/src/ser.rs +++ b/lightning-invoice/src/ser.rs @@ -4,7 +4,7 @@ use bech32::{ToBase32, u5, WriteBase32, Base32Len}; use crate::prelude::*; use super::{Bolt11Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp, - PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawInvoice, RawDataPart}; + PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawBolt11Invoice, RawDataPart}; /// Converts a stream of bytes written to it to base32. On finalization the according padding will /// be applied. That means the results of writing two data blocks with one or two `BytesToBase32` @@ -112,7 +112,7 @@ impl Display for Bolt11Invoice { } } -impl Display for SignedRawInvoice { +impl Display for SignedRawBolt11Invoice { fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { let hrp = self.raw_invoice.hrp.to_string(); let mut data = self.raw_invoice.data.to_base32(); diff --git a/lightning-invoice/tests/ser_de.rs b/lightning-invoice/tests/ser_de.rs index 437d7418..4e98133f 100644 --- a/lightning-invoice/tests/ser_de.rs +++ b/lightning-invoice/tests/ser_de.rs @@ -19,7 +19,7 @@ use std::collections::HashSet; use std::time::Duration; use std::str::FromStr; -fn get_test_tuples() -> Vec<(String, SignedRawInvoice, bool, bool)> { +fn get_test_tuples() -> Vec<(String, SignedRawBolt11Invoice, bool, bool)> { vec![ ( "lnbc1pvjluezsp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygspp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq9qrsgq357wnc5r2ueh7ck6q93dj32dlqnls087fxdwk8qakdyafkq3yap9us6v52vjjsrvywa6rt52cm9r9zqt8r2t7mlcwspyetp5h2tztugp9lfyql".to_owned(), @@ -389,7 +389,7 @@ fn get_test_tuples() -> Vec<(String, SignedRawInvoice, bool, bool)> { fn invoice_deserialize() { for (serialized, deserialized, ignore_feature_diff, ignore_unknown_fields) in get_test_tuples() { eprintln!("Testing invoice {}...", serialized); - let parsed = serialized.parse::().unwrap(); + let parsed = serialized.parse::().unwrap(); let (parsed_invoice, _, parsed_sig) = parsed.into_parts(); let (deserialized_invoice, _, deserialized_sig) = deserialized.into_parts(); @@ -412,7 +412,7 @@ fn invoice_deserialize() { } assert_eq!(deserialized_hunks, parsed_hunks); - Bolt11Invoice::from_signed(serialized.parse::().unwrap()).unwrap(); + Bolt11Invoice::from_signed(serialized.parse::().unwrap()).unwrap(); } }