X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Foffers%2Finvoice.rs;h=75a844cd117abe5d956ddcbdf7efde5bff44a769;hb=39012e35957922eea239c6ed33a6aaf16e7dee9c;hp=cf5d4367ecac734827e02514d26e7fbd12f583ff;hpb=68d471751b90c210d1664a11b07278fbc1c052d7;p=rust-lightning diff --git a/lightning/src/offers/invoice.rs b/lightning/src/offers/invoice.rs index cf5d4367..75a844cd 100644 --- a/lightning/src/offers/invoice.rs +++ b/lightning/src/offers/invoice.rs @@ -110,12 +110,12 @@ use core::time::Duration; use crate::io; use crate::blinded_path::BlindedPath; use crate::ln::PaymentHash; -use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures}; +use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures, InvoiceRequestFeatures, OfferFeatures}; use crate::ln::inbound_payment::ExpandedKey; use crate::ln::msgs::DecodeError; use crate::offers::invoice_request::{INVOICE_REQUEST_PAYER_ID_TYPE, INVOICE_REQUEST_TYPES, IV_BYTES as INVOICE_REQUEST_IV_BYTES, InvoiceRequest, InvoiceRequestContents, InvoiceRequestTlvStream, InvoiceRequestTlvStreamRef}; use crate::offers::merkle::{SignError, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, TlvStream, WithoutSignatures, self}; -use crate::offers::offer::{Amount, OFFER_TYPES, OfferTlvStream, OfferTlvStreamRef}; +use crate::offers::offer::{Amount, OFFER_TYPES, OfferTlvStream, OfferTlvStreamRef, Quantity}; use crate::offers::parse::{Bolt12ParseError, Bolt12SemanticError, ParsedMessage}; use crate::offers::payer::{PAYER_METADATA_TYPE, PayerTlvStream, PayerTlvStreamRef}; use crate::offers::refund::{IV_BYTES as REFUND_IV_BYTES, Refund, RefundContents}; @@ -320,7 +320,8 @@ impl<'a, S: SigningPubkeyStrategy> InvoiceBuilder<'a, S> { self } - /// Sets [`Bolt12Invoice::features`] to indicate MPP may be used. Otherwise, MPP is disallowed. + /// Sets [`Bolt12Invoice::invoice_features`] to indicate MPP may be used. Otherwise, MPP is + /// disallowed. pub fn allow_mpp(mut self) -> Self { self.invoice.fields_mut().features.set_basic_mpp_optional(); self @@ -396,9 +397,9 @@ impl UnsignedBolt12Invoice { Self { bytes, contents, tagged_hash } } - /// The public key corresponding to the key needed to sign the invoice. - pub fn signing_pubkey(&self) -> PublicKey { - self.contents.fields().signing_pubkey + /// Returns the [`TaggedHash`] of the invoice to sign. + pub fn tagged_hash(&self) -> &TaggedHash { + &self.tagged_hash } /// Signs the [`TaggedHash`] of the invoice using the given function. @@ -485,11 +486,140 @@ struct InvoiceFields { signing_pubkey: PublicKey, } -impl Bolt12Invoice { - /// A complete description of the purpose of the originating offer or refund. Intended to be - /// displayed to the user but with the caveat that it has not been verified in any way. - pub fn description(&self) -> PrintableString { - self.contents.description() +macro_rules! invoice_accessors { ($self: ident, $contents: expr) => { + /// The chains that may be used when paying a requested invoice. + /// + /// From [`Offer::chains`]; `None` if the invoice was created in response to a [`Refund`]. + /// + /// [`Offer::chains`]: crate::offers::offer::Offer::chains + pub fn offer_chains(&$self) -> Option> { + $contents.offer_chains() + } + + /// The chain that must be used when paying the invoice; selected from [`offer_chains`] if the + /// invoice originated from an offer. + /// + /// From [`InvoiceRequest::chain`] or [`Refund::chain`]. + /// + /// [`offer_chains`]: Self::offer_chains + /// [`InvoiceRequest::chain`]: crate::offers::invoice_request::InvoiceRequest::chain + pub fn chain(&$self) -> ChainHash { + $contents.chain() + } + + /// Opaque bytes set by the originating [`Offer`]. + /// + /// From [`Offer::metadata`]; `None` if the invoice was created in response to a [`Refund`] or + /// if the [`Offer`] did not set it. + /// + /// [`Offer`]: crate::offers::offer::Offer + /// [`Offer::metadata`]: crate::offers::offer::Offer::metadata + pub fn metadata(&$self) -> Option<&Vec> { + $contents.metadata() + } + + /// The minimum amount required for a successful payment of a single item. + /// + /// From [`Offer::amount`]; `None` if the invoice was created in response to a [`Refund`] or if + /// the [`Offer`] did not set it. + /// + /// [`Offer`]: crate::offers::offer::Offer + /// [`Offer::amount`]: crate::offers::offer::Offer::amount + pub fn amount(&$self) -> Option<&Amount> { + $contents.amount() + } + + /// Features pertaining to the originating [`Offer`]. + /// + /// From [`Offer::offer_features`]; `None` if the invoice was created in response to a + /// [`Refund`]. + /// + /// [`Offer`]: crate::offers::offer::Offer + /// [`Offer::offer_features`]: crate::offers::offer::Offer::offer_features + pub fn offer_features(&$self) -> Option<&OfferFeatures> { + $contents.offer_features() + } + + /// A complete description of the purpose of the originating offer or refund. + /// + /// From [`Offer::description`] or [`Refund::description`]. + /// + /// [`Offer::description`]: crate::offers::offer::Offer::description + pub fn description(&$self) -> PrintableString { + $contents.description() + } + + /// Duration since the Unix epoch when an invoice should no longer be requested. + /// + /// From [`Offer::absolute_expiry`] or [`Refund::absolute_expiry`]. + /// + /// [`Offer::absolute_expiry`]: crate::offers::offer::Offer::absolute_expiry + pub fn absolute_expiry(&$self) -> Option { + $contents.absolute_expiry() + } + + /// The issuer of the offer or refund. + /// + /// From [`Offer::issuer`] or [`Refund::issuer`]. + /// + /// [`Offer::issuer`]: crate::offers::offer::Offer::issuer + pub fn issuer(&$self) -> Option { + $contents.issuer() + } + + /// Paths to the recipient originating from publicly reachable nodes. + /// + /// From [`Offer::paths`] or [`Refund::paths`]. + /// + /// [`Offer::paths`]: crate::offers::offer::Offer::paths + pub fn message_paths(&$self) -> &[BlindedPath] { + $contents.message_paths() + } + + /// The quantity of items supported. + /// + /// From [`Offer::supported_quantity`]; `None` if the invoice was created in response to a + /// [`Refund`]. + /// + /// [`Offer::supported_quantity`]: crate::offers::offer::Offer::supported_quantity + pub fn supported_quantity(&$self) -> Option { + $contents.supported_quantity() + } + + /// An unpredictable series of bytes from the payer. + /// + /// From [`InvoiceRequest::payer_metadata`] or [`Refund::payer_metadata`]. + pub fn payer_metadata(&$self) -> &[u8] { + $contents.payer_metadata() + } + + /// Features pertaining to requesting an invoice. + /// + /// From [`InvoiceRequest::invoice_request_features`] or [`Refund::features`]. + pub fn invoice_request_features(&$self) -> &InvoiceRequestFeatures { + &$contents.invoice_request_features() + } + + /// The quantity of items requested or refunded for. + /// + /// From [`InvoiceRequest::quantity`] or [`Refund::quantity`]. + pub fn quantity(&$self) -> Option { + $contents.quantity() + } + + /// A possibly transient pubkey used to sign the invoice request or to send an invoice for a + /// refund in case there are no [`message_paths`]. + /// + /// [`message_paths`]: Self::message_paths + pub fn payer_id(&$self) -> PublicKey { + $contents.payer_id() + } + + /// A payer-provided note reflected back in the invoice. + /// + /// From [`InvoiceRequest::payer_note`] or [`Refund::payer_note`]. + pub fn payer_note(&$self) -> Option { + $contents.payer_note() } /// Paths to the recipient originating from publicly reachable nodes, including information @@ -500,52 +630,60 @@ impl Bolt12Invoice { /// /// This is not exported to bindings users as slices with non-reference types cannot be ABI /// matched in another language. - pub fn payment_paths(&self) -> &[(BlindedPayInfo, BlindedPath)] { - self.contents.payment_paths() + pub fn payment_paths(&$self) -> &[(BlindedPayInfo, BlindedPath)] { + $contents.payment_paths() } /// Duration since the Unix epoch when the invoice was created. - pub fn created_at(&self) -> Duration { - self.contents.created_at() + pub fn created_at(&$self) -> Duration { + $contents.created_at() } /// Duration since [`Bolt12Invoice::created_at`] when the invoice has expired and therefore /// should no longer be paid. - pub fn relative_expiry(&self) -> Duration { - self.contents.relative_expiry() + pub fn relative_expiry(&$self) -> Duration { + $contents.relative_expiry() } /// Whether the invoice has expired. #[cfg(feature = "std")] - pub fn is_expired(&self) -> bool { - self.contents.is_expired() + pub fn is_expired(&$self) -> bool { + $contents.is_expired() } /// SHA256 hash of the payment preimage that will be given in return for paying the invoice. - pub fn payment_hash(&self) -> PaymentHash { - self.contents.payment_hash() + pub fn payment_hash(&$self) -> PaymentHash { + $contents.payment_hash() } /// The minimum amount required for a successful payment of the invoice. - pub fn amount_msats(&self) -> u64 { - self.contents.amount_msats() + pub fn amount_msats(&$self) -> u64 { + $contents.amount_msats() } /// Fallback addresses for paying the invoice on-chain, in order of most-preferred to /// least-preferred. - pub fn fallbacks(&self) -> Vec
{ - self.contents.fallbacks() + pub fn fallbacks(&$self) -> Vec
{ + $contents.fallbacks() } /// Features pertaining to paying an invoice. - pub fn features(&self) -> &Bolt12InvoiceFeatures { - self.contents.features() + pub fn invoice_features(&$self) -> &Bolt12InvoiceFeatures { + $contents.features() } /// The public key corresponding to the key used to sign the invoice. - pub fn signing_pubkey(&self) -> PublicKey { - self.contents.signing_pubkey() + pub fn signing_pubkey(&$self) -> PublicKey { + $contents.signing_pubkey() } +} } + +impl UnsignedBolt12Invoice { + invoice_accessors!(self, self.contents); +} + +impl Bolt12Invoice { + invoice_accessors!(self, self.contents); /// Signature of the invoice verified using [`Bolt12Invoice::signing_pubkey`]. pub fn signature(&self) -> Signature { @@ -587,6 +725,14 @@ impl InvoiceContents { } } + fn offer_chains(&self) -> Option> { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => + Some(invoice_request.inner.offer.chains()), + InvoiceContents::ForRefund { .. } => None, + } + } + fn chain(&self) -> ChainHash { match self { InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.chain(), @@ -594,6 +740,22 @@ impl InvoiceContents { } } + fn metadata(&self) -> Option<&Vec> { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => + invoice_request.inner.offer.metadata(), + InvoiceContents::ForRefund { .. } => None, + } + } + + fn amount(&self) -> Option<&Amount> { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => + invoice_request.inner.offer.amount(), + InvoiceContents::ForRefund { .. } => None, + } + } + fn description(&self) -> PrintableString { match self { InvoiceContents::ForOffer { invoice_request, .. } => { @@ -603,6 +765,86 @@ impl InvoiceContents { } } + fn offer_features(&self) -> Option<&OfferFeatures> { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + Some(invoice_request.inner.offer.features()) + }, + InvoiceContents::ForRefund { .. } => None, + } + } + + fn absolute_expiry(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + invoice_request.inner.offer.absolute_expiry() + }, + InvoiceContents::ForRefund { refund, .. } => refund.absolute_expiry(), + } + } + + fn issuer(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + invoice_request.inner.offer.issuer() + }, + InvoiceContents::ForRefund { refund, .. } => refund.issuer(), + } + } + + fn message_paths(&self) -> &[BlindedPath] { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + invoice_request.inner.offer.paths() + }, + InvoiceContents::ForRefund { refund, .. } => refund.paths(), + } + } + + fn supported_quantity(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + Some(invoice_request.inner.offer.supported_quantity()) + }, + InvoiceContents::ForRefund { .. } => None, + } + } + + fn payer_metadata(&self) -> &[u8] { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.metadata(), + InvoiceContents::ForRefund { refund, .. } => refund.metadata(), + } + } + + fn invoice_request_features(&self) -> &InvoiceRequestFeatures { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.features(), + InvoiceContents::ForRefund { refund, .. } => refund.features(), + } + } + + fn quantity(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.quantity(), + InvoiceContents::ForRefund { refund, .. } => refund.quantity(), + } + } + + fn payer_id(&self) -> PublicKey { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.payer_id(), + InvoiceContents::ForRefund { refund, .. } => refund.payer_id(), + } + } + + fn payer_note(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.payer_note(), + InvoiceContents::ForRefund { refund, .. } => refund.payer_note(), + } + } + fn payment_paths(&self) -> &[(BlindedPayInfo, BlindedPath)] { &self.fields().payment_paths[..] } @@ -947,8 +1189,9 @@ impl TryFrom> for Bolt12Invoice { None => return Err(Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingSignature)), Some(signature) => signature, }; + let message = TaggedHash::new(SIGNATURE_TAG, &bytes); let pubkey = contents.fields().signing_pubkey; - merkle::verify_signature(&signature, SIGNATURE_TAG, &bytes, pubkey)?; + merkle::verify_signature(&signature, message, pubkey)?; Ok(Bolt12Invoice { bytes, contents, signature }) } @@ -1036,6 +1279,7 @@ impl TryFrom for InvoiceContents { mod tests { use super::{Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, FallbackAddress, FullInvoiceTlvStreamRef, InvoiceTlvStreamRef, SIGNATURE_TAG, UnsignedBolt12Invoice}; + use bitcoin::blockdata::constants::ChainHash; use bitcoin::blockdata::script::Script; use bitcoin::hashes::Hash; use bitcoin::network::constants::Network; @@ -1046,12 +1290,12 @@ mod tests { use core::time::Duration; use crate::blinded_path::{BlindedHop, BlindedPath}; use crate::sign::KeyMaterial; - use crate::ln::features::Bolt12InvoiceFeatures; + use crate::ln::features::{Bolt12InvoiceFeatures, InvoiceRequestFeatures, OfferFeatures}; use crate::ln::inbound_payment::ExpandedKey; use crate::ln::msgs::DecodeError; use crate::offers::invoice_request::InvoiceRequestTlvStreamRef; - use crate::offers::merkle::{SignError, SignatureTlvStreamRef, self}; - use crate::offers::offer::{OfferBuilder, OfferTlvStreamRef, Quantity}; + use crate::offers::merkle::{SignError, SignatureTlvStreamRef, TaggedHash, self}; + use crate::offers::offer::{Amount, OfferBuilder, OfferTlvStreamRef, Quantity}; use crate::offers::parse::{Bolt12ParseError, Bolt12SemanticError}; use crate::offers::payer::PayerTlvStreamRef; use crate::offers::refund::RefundBuilder; @@ -1092,6 +1336,35 @@ mod tests { let mut buffer = Vec::new(); unsigned_invoice.write(&mut buffer).unwrap(); + assert_eq!(unsigned_invoice.bytes, buffer.as_slice()); + assert_eq!(unsigned_invoice.payer_metadata(), &[1; 32]); + assert_eq!(unsigned_invoice.offer_chains(), Some(vec![ChainHash::using_genesis_block(Network::Bitcoin)])); + assert_eq!(unsigned_invoice.metadata(), None); + assert_eq!(unsigned_invoice.amount(), Some(&Amount::Bitcoin { amount_msats: 1000 })); + assert_eq!(unsigned_invoice.description(), PrintableString("foo")); + assert_eq!(unsigned_invoice.offer_features(), Some(&OfferFeatures::empty())); + assert_eq!(unsigned_invoice.absolute_expiry(), None); + assert_eq!(unsigned_invoice.message_paths(), &[]); + assert_eq!(unsigned_invoice.issuer(), None); + assert_eq!(unsigned_invoice.supported_quantity(), Some(Quantity::One)); + assert_eq!(unsigned_invoice.signing_pubkey(), recipient_pubkey()); + assert_eq!(unsigned_invoice.chain(), ChainHash::using_genesis_block(Network::Bitcoin)); + assert_eq!(unsigned_invoice.amount_msats(), 1000); + assert_eq!(unsigned_invoice.invoice_request_features(), &InvoiceRequestFeatures::empty()); + assert_eq!(unsigned_invoice.quantity(), None); + assert_eq!(unsigned_invoice.payer_id(), payer_pubkey()); + assert_eq!(unsigned_invoice.payer_note(), None); + assert_eq!(unsigned_invoice.payment_paths(), payment_paths.as_slice()); + assert_eq!(unsigned_invoice.created_at(), now); + assert_eq!(unsigned_invoice.relative_expiry(), DEFAULT_RELATIVE_EXPIRY); + #[cfg(feature = "std")] + assert!(!unsigned_invoice.is_expired()); + assert_eq!(unsigned_invoice.payment_hash(), payment_hash); + assert_eq!(unsigned_invoice.amount_msats(), 1000); + assert_eq!(unsigned_invoice.fallbacks(), vec![]); + assert_eq!(unsigned_invoice.invoice_features(), &Bolt12InvoiceFeatures::empty()); + assert_eq!(unsigned_invoice.signing_pubkey(), recipient_pubkey()); + match UnsignedBolt12Invoice::try_from(buffer) { Err(e) => panic!("error parsing unsigned invoice: {:?}", e), Ok(parsed) => { @@ -1106,7 +1379,23 @@ mod tests { invoice.write(&mut buffer).unwrap(); assert_eq!(invoice.bytes, buffer.as_slice()); + assert_eq!(invoice.payer_metadata(), &[1; 32]); + assert_eq!(invoice.offer_chains(), Some(vec![ChainHash::using_genesis_block(Network::Bitcoin)])); + assert_eq!(invoice.metadata(), None); + assert_eq!(invoice.amount(), Some(&Amount::Bitcoin { amount_msats: 1000 })); assert_eq!(invoice.description(), PrintableString("foo")); + assert_eq!(invoice.offer_features(), Some(&OfferFeatures::empty())); + assert_eq!(invoice.absolute_expiry(), None); + assert_eq!(invoice.message_paths(), &[]); + assert_eq!(invoice.issuer(), None); + assert_eq!(invoice.supported_quantity(), Some(Quantity::One)); + assert_eq!(invoice.signing_pubkey(), recipient_pubkey()); + assert_eq!(invoice.chain(), ChainHash::using_genesis_block(Network::Bitcoin)); + assert_eq!(invoice.amount_msats(), 1000); + assert_eq!(invoice.invoice_request_features(), &InvoiceRequestFeatures::empty()); + assert_eq!(invoice.quantity(), None); + assert_eq!(invoice.payer_id(), payer_pubkey()); + assert_eq!(invoice.payer_note(), None); assert_eq!(invoice.payment_paths(), payment_paths.as_slice()); assert_eq!(invoice.created_at(), now); assert_eq!(invoice.relative_expiry(), DEFAULT_RELATIVE_EXPIRY); @@ -1115,13 +1404,11 @@ mod tests { assert_eq!(invoice.payment_hash(), payment_hash); assert_eq!(invoice.amount_msats(), 1000); assert_eq!(invoice.fallbacks(), vec![]); - assert_eq!(invoice.features(), &Bolt12InvoiceFeatures::empty()); + assert_eq!(invoice.invoice_features(), &Bolt12InvoiceFeatures::empty()); assert_eq!(invoice.signing_pubkey(), recipient_pubkey()); - assert!( - merkle::verify_signature( - &invoice.signature, SIGNATURE_TAG, &invoice.bytes, recipient_pubkey() - ).is_ok() - ); + + let message = TaggedHash::new(SIGNATURE_TAG, &invoice.bytes); + assert!(merkle::verify_signature(&invoice.signature, message, recipient_pubkey()).is_ok()); let digest = Message::from_slice(&invoice.signable_hash()).unwrap(); let pubkey = recipient_pubkey().into(); @@ -1189,7 +1476,23 @@ mod tests { invoice.write(&mut buffer).unwrap(); assert_eq!(invoice.bytes, buffer.as_slice()); + assert_eq!(invoice.payer_metadata(), &[1; 32]); + assert_eq!(invoice.offer_chains(), None); + assert_eq!(invoice.metadata(), None); + assert_eq!(invoice.amount(), None); assert_eq!(invoice.description(), PrintableString("foo")); + assert_eq!(invoice.offer_features(), None); + assert_eq!(invoice.absolute_expiry(), None); + assert_eq!(invoice.message_paths(), &[]); + assert_eq!(invoice.issuer(), None); + assert_eq!(invoice.supported_quantity(), None); + assert_eq!(invoice.signing_pubkey(), recipient_pubkey()); + assert_eq!(invoice.chain(), ChainHash::using_genesis_block(Network::Bitcoin)); + assert_eq!(invoice.amount_msats(), 1000); + assert_eq!(invoice.invoice_request_features(), &InvoiceRequestFeatures::empty()); + assert_eq!(invoice.quantity(), None); + assert_eq!(invoice.payer_id(), payer_pubkey()); + assert_eq!(invoice.payer_note(), None); assert_eq!(invoice.payment_paths(), payment_paths.as_slice()); assert_eq!(invoice.created_at(), now); assert_eq!(invoice.relative_expiry(), DEFAULT_RELATIVE_EXPIRY); @@ -1198,13 +1501,11 @@ mod tests { assert_eq!(invoice.payment_hash(), payment_hash); assert_eq!(invoice.amount_msats(), 1000); assert_eq!(invoice.fallbacks(), vec![]); - assert_eq!(invoice.features(), &Bolt12InvoiceFeatures::empty()); + assert_eq!(invoice.invoice_features(), &Bolt12InvoiceFeatures::empty()); assert_eq!(invoice.signing_pubkey(), recipient_pubkey()); - assert!( - merkle::verify_signature( - &invoice.signature, SIGNATURE_TAG, &invoice.bytes, recipient_pubkey() - ).is_ok() - ); + + let message = TaggedHash::new(SIGNATURE_TAG, &invoice.bytes); + assert!(merkle::verify_signature(&invoice.signature, message, recipient_pubkey()).is_ok()); assert_eq!( invoice.as_tlv_stream(), @@ -1546,7 +1847,7 @@ mod tests { .build().unwrap() .sign(recipient_sign).unwrap(); let (_, _, _, tlv_stream, _) = invoice.as_tlv_stream(); - assert_eq!(invoice.features(), &features); + assert_eq!(invoice.invoice_features(), &features); assert_eq!(tlv_stream.features, Some(&features)); } @@ -1766,7 +2067,7 @@ mod tests { Ok(invoice) => { let mut features = Bolt12InvoiceFeatures::empty(); features.set_basic_mpp_optional(); - assert_eq!(invoice.features(), &features); + assert_eq!(invoice.invoice_features(), &features); }, Err(e) => panic!("error parsing invoice: {:?}", e), }