-// This file is Copyright its original authors, visible in version control
+ // This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
//!
//! use bitcoin::hashes::Hash;
//! use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, SecretKey};
-//! use core::convert::{Infallible, TryFrom};
+//! use core::convert::TryFrom;
+//! use lightning::offers::invoice::UnsignedBolt12Invoice;
//! use lightning::offers::invoice_request::InvoiceRequest;
//! use lightning::offers::refund::Refund;
//! use lightning::util::ser::Writeable;
//!
//! # use lightning::ln::PaymentHash;
-//! # use lightning::offers::invoice::BlindedPayInfo;
+//! # use lightning::offers::invoice::{BlindedPayInfo, ExplicitSigningPubkey, InvoiceBuilder};
//! # use lightning::blinded_path::BlindedPath;
//! #
//! # fn create_payment_paths() -> Vec<(BlindedPayInfo, BlindedPath)> { unimplemented!() }
//! let secp_ctx = Secp256k1::new();
//! let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32])?);
//! let pubkey = PublicKey::from(keys);
-//! let wpubkey_hash = bitcoin::util::key::PublicKey::new(pubkey).wpubkey_hash().unwrap();
+//! let wpubkey_hash = bitcoin::key::PublicKey::new(pubkey).wpubkey_hash().unwrap();
//! let mut buffer = Vec::new();
//!
//! // Invoice for the "offer to be paid" flow.
+//! # <InvoiceBuilder<ExplicitSigningPubkey>>::from(
//! InvoiceRequest::try_from(bytes)?
#![cfg_attr(feature = "std", doc = "
.respond_with(payment_paths, payment_hash)?
#![cfg_attr(not(feature = "std"), doc = "
.respond_with_no_std(payment_paths, payment_hash, core::time::Duration::from_secs(0))?
")]
+//! # )
//! .relative_expiry(3600)
//! .allow_mpp()
//! .fallback_v0_p2wpkh(&wpubkey_hash)
//! .build()?
-//! .sign::<_, Infallible>(
-//! |message| Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
+//! .sign(|message: &UnsignedBolt12Invoice|
+//! Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
//! )
//! .expect("failed verifying signature")
//! .write(&mut buffer)
//! # let secp_ctx = Secp256k1::new();
//! # let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32])?);
//! # let pubkey = PublicKey::from(keys);
-//! # let wpubkey_hash = bitcoin::util::key::PublicKey::new(pubkey).wpubkey_hash().unwrap();
+//! # let wpubkey_hash = bitcoin::key::PublicKey::new(pubkey).wpubkey_hash().unwrap();
//! # let mut buffer = Vec::new();
//!
//! // Invoice for the "offer for money" flow.
+//! # <InvoiceBuilder<ExplicitSigningPubkey>>::from(
//! "lnr1qcp4256ypq"
//! .parse::<Refund>()?
#![cfg_attr(feature = "std", doc = "
#![cfg_attr(not(feature = "std"), doc = "
.respond_with_no_std(payment_paths, payment_hash, pubkey, core::time::Duration::from_secs(0))?
")]
+//! # )
//! .relative_expiry(3600)
//! .allow_mpp()
//! .fallback_v0_p2wpkh(&wpubkey_hash)
//! .build()?
-//! .sign::<_, Infallible>(
-//! |message| Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
+//! .sign(|message: &UnsignedBolt12Invoice|
+//! Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
//! )
//! .expect("failed verifying signature")
//! .write(&mut buffer)
use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, self};
use bitcoin::secp256k1::schnorr::Signature;
-use bitcoin::util::address::{Address, Payload, WitnessVersion};
-use bitcoin::util::schnorr::TweakedPublicKey;
-use core::convert::{AsRef, Infallible, TryFrom};
+use bitcoin::address::{Address, Payload, WitnessProgram, WitnessVersion};
+use bitcoin::key::TweakedPublicKey;
+use core::convert::{AsRef, TryFrom};
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::channelmanager::PaymentId;
+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::merkle::{SignError, SignFn, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, TlvStream, WithoutSignatures, self};
+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};
use crate::util::ser::{HighZeroBytesDroppedBigSize, Iterable, SeekReadable, WithoutLength, Writeable, Writer};
use crate::util::string::PrintableString;
+#[allow(unused_imports)]
use crate::prelude::*;
#[cfg(feature = "std")]
use std::time::SystemTime;
-const DEFAULT_RELATIVE_EXPIRY: Duration = Duration::from_secs(7200);
+pub(crate) const DEFAULT_RELATIVE_EXPIRY: Duration = Duration::from_secs(7200);
/// Tag for the hash function used when signing a [`Bolt12Invoice`]'s merkle root.
pub const SIGNATURE_TAG: &'static str = concat!("lightning", "invoice", "signature");
pub struct InvoiceBuilder<'a, S: SigningPubkeyStrategy> {
invreq_bytes: &'a Vec<u8>,
invoice: InvoiceContents,
- keys: Option<KeyPair>,
- signing_pubkey_strategy: core::marker::PhantomData<S>,
+ signing_pubkey_strategy: S,
+}
+
+/// Builds a [`Bolt12Invoice`] from either:
+/// - an [`InvoiceRequest`] for the "offer to be paid" flow or
+/// - a [`Refund`] for the "offer for money" flow.
+///
+/// See [module-level documentation] for usage.
+///
+/// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
+/// [`Refund`]: crate::offers::refund::Refund
+/// [module-level documentation]: self
+#[cfg(c_bindings)]
+pub struct InvoiceWithExplicitSigningPubkeyBuilder<'a> {
+ invreq_bytes: &'a Vec<u8>,
+ invoice: InvoiceContents,
+ signing_pubkey_strategy: ExplicitSigningPubkey,
+}
+
+/// Builds a [`Bolt12Invoice`] from either:
+/// - an [`InvoiceRequest`] for the "offer to be paid" flow or
+/// - a [`Refund`] for the "offer for money" flow.
+///
+/// See [module-level documentation] for usage.
+///
+/// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
+/// [`Refund`]: crate::offers::refund::Refund
+/// [module-level documentation]: self
+#[cfg(c_bindings)]
+pub struct InvoiceWithDerivedSigningPubkeyBuilder<'a> {
+ invreq_bytes: &'a Vec<u8>,
+ invoice: InvoiceContents,
+ signing_pubkey_strategy: DerivedSigningPubkey,
}
/// Indicates how [`Bolt12Invoice::signing_pubkey`] was set.
/// [`Bolt12Invoice::signing_pubkey`] was derived.
///
/// This is not exported to bindings users as builder patterns don't map outside of move semantics.
-pub struct DerivedSigningPubkey {}
+pub struct DerivedSigningPubkey(KeyPair);
impl SigningPubkeyStrategy for ExplicitSigningPubkey {}
impl SigningPubkeyStrategy for DerivedSigningPubkey {}
-impl<'a> InvoiceBuilder<'a, ExplicitSigningPubkey> {
+macro_rules! invoice_explicit_signing_pubkey_builder_methods { ($self: ident, $self_type: ty) => {
+ #[cfg_attr(c_bindings, allow(dead_code))]
pub(super) fn for_offer(
invoice_request: &'a InvoiceRequest, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>,
created_at: Duration, payment_hash: PaymentHash
) -> Result<Self, Bolt12SemanticError> {
- let amount_msats = Self::check_amount_msats(invoice_request)?;
+ let amount_msats = Self::amount_msats(invoice_request)?;
let signing_pubkey = invoice_request.contents.inner.offer.signing_pubkey();
let contents = InvoiceContents::ForOffer {
invoice_request: invoice_request.contents.clone(),
),
};
- Self::new(&invoice_request.bytes, contents, None)
+ Self::new(&invoice_request.bytes, contents, ExplicitSigningPubkey {})
}
+ #[cfg_attr(c_bindings, allow(dead_code))]
pub(super) fn for_refund(
refund: &'a Refund, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, created_at: Duration,
payment_hash: PaymentHash, signing_pubkey: PublicKey
),
};
- Self::new(&refund.bytes, contents, None)
+ Self::new(&refund.bytes, contents, ExplicitSigningPubkey {})
}
-}
-impl<'a> InvoiceBuilder<'a, DerivedSigningPubkey> {
+ /// Builds an unsigned [`Bolt12Invoice`] after checking for valid semantics. It can be signed by
+ /// [`UnsignedBolt12Invoice::sign`].
+ pub fn build($self: $self_type) -> Result<UnsignedBolt12Invoice, Bolt12SemanticError> {
+ #[cfg(feature = "std")] {
+ if $self.invoice.is_offer_or_refund_expired() {
+ return Err(Bolt12SemanticError::AlreadyExpired);
+ }
+ }
+
+ #[cfg(not(feature = "std"))] {
+ if $self.invoice.is_offer_or_refund_expired_no_std($self.invoice.created_at()) {
+ return Err(Bolt12SemanticError::AlreadyExpired);
+ }
+ }
+
+ let Self { invreq_bytes, invoice, .. } = $self;
+ #[cfg(not(c_bindings))] {
+ Ok(UnsignedBolt12Invoice::new(invreq_bytes, invoice))
+ }
+ #[cfg(c_bindings)] {
+ Ok(UnsignedBolt12Invoice::new(invreq_bytes, invoice.clone()))
+ }
+ }
+} }
+
+macro_rules! invoice_derived_signing_pubkey_builder_methods { ($self: ident, $self_type: ty) => {
+ #[cfg_attr(c_bindings, allow(dead_code))]
pub(super) fn for_offer_using_keys(
invoice_request: &'a InvoiceRequest, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>,
created_at: Duration, payment_hash: PaymentHash, keys: KeyPair
) -> Result<Self, Bolt12SemanticError> {
- let amount_msats = Self::check_amount_msats(invoice_request)?;
+ let amount_msats = Self::amount_msats(invoice_request)?;
let signing_pubkey = invoice_request.contents.inner.offer.signing_pubkey();
let contents = InvoiceContents::ForOffer {
invoice_request: invoice_request.contents.clone(),
),
};
- Self::new(&invoice_request.bytes, contents, Some(keys))
+ Self::new(&invoice_request.bytes, contents, DerivedSigningPubkey(keys))
}
+ #[cfg_attr(c_bindings, allow(dead_code))]
pub(super) fn for_refund_using_keys(
refund: &'a Refund, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, created_at: Duration,
payment_hash: PaymentHash, keys: KeyPair,
),
};
- Self::new(&refund.bytes, contents, Some(keys))
+ Self::new(&refund.bytes, contents, DerivedSigningPubkey(keys))
}
-}
-impl<'a, S: SigningPubkeyStrategy> InvoiceBuilder<'a, S> {
- fn check_amount_msats(invoice_request: &InvoiceRequest) -> Result<u64, Bolt12SemanticError> {
+ /// Builds a signed [`Bolt12Invoice`] after checking for valid semantics.
+ pub fn build_and_sign<T: secp256k1::Signing>(
+ $self: $self_type, secp_ctx: &Secp256k1<T>
+ ) -> Result<Bolt12Invoice, Bolt12SemanticError> {
+ #[cfg(feature = "std")] {
+ if $self.invoice.is_offer_or_refund_expired() {
+ return Err(Bolt12SemanticError::AlreadyExpired);
+ }
+ }
+
+ #[cfg(not(feature = "std"))] {
+ if $self.invoice.is_offer_or_refund_expired_no_std($self.invoice.created_at()) {
+ return Err(Bolt12SemanticError::AlreadyExpired);
+ }
+ }
+
+ let Self {
+ invreq_bytes, invoice, signing_pubkey_strategy: DerivedSigningPubkey(keys)
+ } = $self;
+ #[cfg(not(c_bindings))]
+ let unsigned_invoice = UnsignedBolt12Invoice::new(invreq_bytes, invoice);
+ #[cfg(c_bindings)]
+ let mut unsigned_invoice = UnsignedBolt12Invoice::new(invreq_bytes, invoice.clone());
+
+ let invoice = unsigned_invoice
+ .sign(|message: &UnsignedBolt12Invoice|
+ Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
+ )
+ .unwrap();
+ Ok(invoice)
+ }
+} }
+
+macro_rules! invoice_builder_methods { (
+ $self: ident, $self_type: ty, $return_type: ty, $return_value: expr, $type_param: ty $(, $self_mut: tt)?
+) => {
+ pub(crate) fn amount_msats(
+ invoice_request: &InvoiceRequest
+ ) -> Result<u64, Bolt12SemanticError> {
match invoice_request.amount_msats() {
Some(amount_msats) => Ok(amount_msats),
None => match invoice_request.contents.inner.offer.amount() {
}
}
+ #[cfg_attr(c_bindings, allow(dead_code))]
fn fields(
payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, created_at: Duration,
payment_hash: PaymentHash, amount_msats: u64, signing_pubkey: PublicKey
}
}
+ #[cfg_attr(c_bindings, allow(dead_code))]
fn new(
- invreq_bytes: &'a Vec<u8>, contents: InvoiceContents, keys: Option<KeyPair>
+ invreq_bytes: &'a Vec<u8>, contents: InvoiceContents, signing_pubkey_strategy: $type_param
) -> Result<Self, Bolt12SemanticError> {
if contents.fields().payment_paths.is_empty() {
return Err(Bolt12SemanticError::MissingPaths);
}
- Ok(Self {
- invreq_bytes,
- invoice: contents,
- keys,
- signing_pubkey_strategy: core::marker::PhantomData,
- })
+ Ok(Self { invreq_bytes, invoice: contents, signing_pubkey_strategy })
}
/// Sets the [`Bolt12Invoice::relative_expiry`] as seconds since [`Bolt12Invoice::created_at`].
/// [`Bolt12Invoice::is_expired`].
///
/// Successive calls to this method will override the previous setting.
- pub fn relative_expiry(mut self, relative_expiry_secs: u32) -> Self {
+ pub fn relative_expiry($($self_mut)* $self: $self_type, relative_expiry_secs: u32) -> $return_type {
let relative_expiry = Duration::from_secs(relative_expiry_secs as u64);
- self.invoice.fields_mut().relative_expiry = Some(relative_expiry);
- self
+ $self.invoice.fields_mut().relative_expiry = Some(relative_expiry);
+ $return_value
}
/// Adds a P2WSH address to [`Bolt12Invoice::fallbacks`].
///
/// Successive calls to this method will add another address. Caller is responsible for not
/// adding duplicate addresses and only calling if capable of receiving to P2WSH addresses.
- pub fn fallback_v0_p2wsh(mut self, script_hash: &WScriptHash) -> Self {
+ pub fn fallback_v0_p2wsh($($self_mut)* $self: $self_type, script_hash: &WScriptHash) -> $return_type {
let address = FallbackAddress {
version: WitnessVersion::V0.to_num(),
- program: Vec::from(&script_hash.into_inner()[..]),
+ program: Vec::from(script_hash.to_byte_array()),
};
- self.invoice.fields_mut().fallbacks.get_or_insert_with(Vec::new).push(address);
- self
+ $self.invoice.fields_mut().fallbacks.get_or_insert_with(Vec::new).push(address);
+ $return_value
}
/// Adds a P2WPKH address to [`Bolt12Invoice::fallbacks`].
///
/// Successive calls to this method will add another address. Caller is responsible for not
/// adding duplicate addresses and only calling if capable of receiving to P2WPKH addresses.
- pub fn fallback_v0_p2wpkh(mut self, pubkey_hash: &WPubkeyHash) -> Self {
+ pub fn fallback_v0_p2wpkh($($self_mut)* $self: $self_type, pubkey_hash: &WPubkeyHash) -> $return_type {
let address = FallbackAddress {
version: WitnessVersion::V0.to_num(),
- program: Vec::from(&pubkey_hash.into_inner()[..]),
+ program: Vec::from(pubkey_hash.to_byte_array()),
};
- self.invoice.fields_mut().fallbacks.get_or_insert_with(Vec::new).push(address);
- self
+ $self.invoice.fields_mut().fallbacks.get_or_insert_with(Vec::new).push(address);
+ $return_value
}
/// Adds a P2TR address to [`Bolt12Invoice::fallbacks`].
///
/// Successive calls to this method will add another address. Caller is responsible for not
/// adding duplicate addresses and only calling if capable of receiving to P2TR addresses.
- pub fn fallback_v1_p2tr_tweaked(mut self, output_key: &TweakedPublicKey) -> Self {
+ pub fn fallback_v1_p2tr_tweaked($($self_mut)* $self: $self_type, output_key: &TweakedPublicKey) -> $return_type {
let address = FallbackAddress {
version: WitnessVersion::V1.to_num(),
program: Vec::from(&output_key.serialize()[..]),
};
- self.invoice.fields_mut().fallbacks.get_or_insert_with(Vec::new).push(address);
- self
+ $self.invoice.fields_mut().fallbacks.get_or_insert_with(Vec::new).push(address);
+ $return_value
}
- /// Sets [`Bolt12Invoice::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
+ /// Sets [`Bolt12Invoice::invoice_features`] to indicate MPP may be used. Otherwise, MPP is
+ /// disallowed.
+ pub fn allow_mpp($($self_mut)* $self: $self_type) -> $return_type {
+ $self.invoice.fields_mut().features.set_basic_mpp_optional();
+ $return_value
}
-}
+} }
impl<'a> InvoiceBuilder<'a, ExplicitSigningPubkey> {
- /// Builds an unsigned [`Bolt12Invoice`] after checking for valid semantics. It can be signed by
- /// [`UnsignedBolt12Invoice::sign`].
- pub fn build(self) -> Result<UnsignedBolt12Invoice, Bolt12SemanticError> {
- #[cfg(feature = "std")] {
- if self.invoice.is_offer_or_refund_expired() {
- return Err(Bolt12SemanticError::AlreadyExpired);
- }
- }
-
- let InvoiceBuilder { invreq_bytes, invoice, .. } = self;
- Ok(UnsignedBolt12Invoice::new(invreq_bytes, invoice))
- }
+ invoice_explicit_signing_pubkey_builder_methods!(self, Self);
}
impl<'a> InvoiceBuilder<'a, DerivedSigningPubkey> {
- /// Builds a signed [`Bolt12Invoice`] after checking for valid semantics.
- pub fn build_and_sign<T: secp256k1::Signing>(
- self, secp_ctx: &Secp256k1<T>
- ) -> Result<Bolt12Invoice, Bolt12SemanticError> {
- #[cfg(feature = "std")] {
- if self.invoice.is_offer_or_refund_expired() {
- return Err(Bolt12SemanticError::AlreadyExpired);
- }
+ invoice_derived_signing_pubkey_builder_methods!(self, Self);
+}
+
+impl<'a, S: SigningPubkeyStrategy> InvoiceBuilder<'a, S> {
+ invoice_builder_methods!(self, Self, Self, self, S, mut);
+}
+
+#[cfg(all(c_bindings, not(test)))]
+impl<'a> InvoiceWithExplicitSigningPubkeyBuilder<'a> {
+ invoice_explicit_signing_pubkey_builder_methods!(self, &mut Self);
+ invoice_builder_methods!(self, &mut Self, (), (), ExplicitSigningPubkey);
+}
+
+#[cfg(all(c_bindings, test))]
+impl<'a> InvoiceWithExplicitSigningPubkeyBuilder<'a> {
+ invoice_explicit_signing_pubkey_builder_methods!(self, &mut Self);
+ invoice_builder_methods!(self, &mut Self, &mut Self, self, ExplicitSigningPubkey);
+}
+
+#[cfg(all(c_bindings, not(test)))]
+impl<'a> InvoiceWithDerivedSigningPubkeyBuilder<'a> {
+ invoice_derived_signing_pubkey_builder_methods!(self, &mut Self);
+ invoice_builder_methods!(self, &mut Self, (), (), DerivedSigningPubkey);
+}
+
+#[cfg(all(c_bindings, test))]
+impl<'a> InvoiceWithDerivedSigningPubkeyBuilder<'a> {
+ invoice_derived_signing_pubkey_builder_methods!(self, &mut Self);
+ invoice_builder_methods!(self, &mut Self, &mut Self, self, DerivedSigningPubkey);
+}
+
+#[cfg(c_bindings)]
+impl<'a> From<InvoiceWithExplicitSigningPubkeyBuilder<'a>>
+for InvoiceBuilder<'a, ExplicitSigningPubkey> {
+ fn from(builder: InvoiceWithExplicitSigningPubkeyBuilder<'a>) -> Self {
+ let InvoiceWithExplicitSigningPubkeyBuilder {
+ invreq_bytes, invoice, signing_pubkey_strategy,
+ } = builder;
+
+ Self {
+ invreq_bytes, invoice, signing_pubkey_strategy,
}
+ }
+}
- let InvoiceBuilder { invreq_bytes, invoice, keys, .. } = self;
- let unsigned_invoice = UnsignedBolt12Invoice::new(invreq_bytes, invoice);
+#[cfg(c_bindings)]
+impl<'a> From<InvoiceWithDerivedSigningPubkeyBuilder<'a>>
+for InvoiceBuilder<'a, DerivedSigningPubkey> {
+ fn from(builder: InvoiceWithDerivedSigningPubkeyBuilder<'a>) -> Self {
+ let InvoiceWithDerivedSigningPubkeyBuilder {
+ invreq_bytes, invoice, signing_pubkey_strategy,
+ } = builder;
- let keys = keys.unwrap();
- let invoice = unsigned_invoice
- .sign::<_, Infallible>(
- |message| Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
- )
- .unwrap();
- Ok(invoice)
+ Self {
+ invreq_bytes, invoice, signing_pubkey_strategy,
+ }
}
}
/// A semantically valid [`Bolt12Invoice`] that hasn't been signed.
+///
+/// # Serialization
+///
+/// This is serialized as a TLV stream, which includes TLV records from the originating message. As
+/// such, it may include unknown, odd TLV records.
pub struct UnsignedBolt12Invoice {
bytes: Vec<u8>,
- invoice: InvoiceContents,
+ contents: InvoiceContents,
tagged_hash: TaggedHash,
}
+/// A function for signing an [`UnsignedBolt12Invoice`].
+pub trait SignBolt12InvoiceFn {
+ /// Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+ fn sign_invoice(&self, message: &UnsignedBolt12Invoice) -> Result<Signature, ()>;
+}
+
+impl<F> SignBolt12InvoiceFn for F
+where
+ F: Fn(&UnsignedBolt12Invoice) -> Result<Signature, ()>,
+{
+ fn sign_invoice(&self, message: &UnsignedBolt12Invoice) -> Result<Signature, ()> {
+ self(message)
+ }
+}
+
+impl<F> SignFn<UnsignedBolt12Invoice> for F
+where
+ F: SignBolt12InvoiceFn,
+{
+ fn sign(&self, message: &UnsignedBolt12Invoice) -> Result<Signature, ()> {
+ self.sign_invoice(message)
+ }
+}
+
impl UnsignedBolt12Invoice {
- fn new(invreq_bytes: &[u8], invoice: InvoiceContents) -> Self {
+ fn new(invreq_bytes: &[u8], contents: InvoiceContents) -> Self {
// Use the invoice_request bytes instead of the invoice_request TLV stream as the latter may
// have contained unknown TLV records, which are not stored in `InvoiceRequestContents` or
// `RefundContents`.
- let (_, _, _, invoice_tlv_stream) = invoice.as_tlv_stream();
+ let (_, _, _, invoice_tlv_stream) = contents.as_tlv_stream();
let invoice_request_bytes = WithoutSignatures(invreq_bytes);
let unsigned_tlv_stream = (invoice_request_bytes, invoice_tlv_stream);
let tagged_hash = TaggedHash::new(SIGNATURE_TAG, &bytes);
- Self { bytes, invoice, tagged_hash }
+ Self { bytes, contents, tagged_hash }
}
- /// The public key corresponding to the key needed to sign the invoice.
- pub fn signing_pubkey(&self) -> PublicKey {
- self.invoice.fields().signing_pubkey
+ /// Returns the [`TaggedHash`] of the invoice to sign.
+ pub fn tagged_hash(&self) -> &TaggedHash {
+ &self.tagged_hash
}
+}
- /// Signs the invoice using the given function.
+macro_rules! unsigned_invoice_sign_method { ($self: ident, $self_type: ty $(, $self_mut: tt)?) => {
+ /// Signs the [`TaggedHash`] of the invoice using the given function.
///
- /// This is not exported to bindings users as functions aren't currently mapped.
- pub fn sign<F, E>(mut self, sign: F) -> Result<Bolt12Invoice, SignError<E>>
- where
- F: FnOnce(&Self) -> Result<Signature, E>
- {
- let pubkey = self.invoice.fields().signing_pubkey;
- let signature = merkle::sign_message(sign, &self, pubkey)?;
+ /// Note: The hash computation may have included unknown, odd TLV records.
+ pub fn sign<F: SignBolt12InvoiceFn>(
+ $($self_mut)* $self: $self_type, sign: F
+ ) -> Result<Bolt12Invoice, SignError> {
+ let pubkey = $self.contents.fields().signing_pubkey;
+ let signature = merkle::sign_message(sign, &$self, pubkey)?;
// Append the signature TLV record to the bytes.
let signature_tlv_stream = SignatureTlvStreamRef {
signature: Some(&signature),
};
- signature_tlv_stream.write(&mut self.bytes).unwrap();
+ signature_tlv_stream.write(&mut $self.bytes).unwrap();
Ok(Bolt12Invoice {
- bytes: self.bytes,
- contents: self.invoice,
+ #[cfg(not(c_bindings))]
+ bytes: $self.bytes,
+ #[cfg(c_bindings)]
+ bytes: $self.bytes.clone(),
+ #[cfg(not(c_bindings))]
+ contents: $self.contents,
+ #[cfg(c_bindings)]
+ contents: $self.contents.clone(),
signature,
+ #[cfg(not(c_bindings))]
+ tagged_hash: $self.tagged_hash,
+ #[cfg(c_bindings)]
+ tagged_hash: $self.tagged_hash.clone(),
})
}
+} }
+
+#[cfg(not(c_bindings))]
+impl UnsignedBolt12Invoice {
+ unsigned_invoice_sign_method!(self, Self, mut);
+}
+
+#[cfg(c_bindings)]
+impl UnsignedBolt12Invoice {
+ unsigned_invoice_sign_method!(self, &mut Self);
}
impl AsRef<TaggedHash> for UnsignedBolt12Invoice {
bytes: Vec<u8>,
contents: InvoiceContents,
signature: Signature,
+ tagged_hash: TaggedHash,
}
/// The contents of an [`Bolt12Invoice`] for responding to either an [`Offer`] or a [`Refund`].
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<Vec<ChainHash>> {
+ $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<u8>> {
+ $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<Duration> {
+ $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<PrintableString> {
+ $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<Quantity> {
+ $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<u64> {
+ $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<PrintableString> {
+ $contents.payer_note()
}
/// Paths to the recipient originating from publicly reachable nodes, including information
///
/// 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.fields().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.fields().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.fields().relative_expiry.unwrap_or(DEFAULT_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 {
- let absolute_expiry = self.created_at().checked_add(self.relative_expiry());
- match absolute_expiry {
- Some(seconds_from_epoch) => match SystemTime::UNIX_EPOCH.elapsed() {
- Ok(elapsed) => elapsed > seconds_from_epoch,
- Err(_) => false,
- },
- None => false,
- }
+ 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.fields().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.fields().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<Address> {
- let network = match self.network() {
- None => return Vec::new(),
- Some(network) => network,
- };
-
- let to_valid_address = |address: &FallbackAddress| {
- let version = match WitnessVersion::try_from(address.version) {
- Ok(version) => version,
- Err(_) => return None,
- };
-
- let program = &address.program;
- if program.len() < 2 || program.len() > 40 {
- return None;
- }
-
- let address = Address {
- payload: Payload::WitnessProgram {
- version,
- program: address.program.clone(),
- },
- network,
- };
-
- if !address.is_standard() && version == WitnessVersion::V0 {
- return None;
- }
-
- Some(address)
- };
-
- self.contents.fields().fallbacks
- .as_ref()
- .map(|fallbacks| fallbacks.iter().filter_map(to_valid_address).collect())
- .unwrap_or_else(Vec::new)
- }
-
- fn network(&self) -> Option<Network> {
- let chain = self.contents.chain();
- if chain == ChainHash::using_genesis_block(Network::Bitcoin) {
- Some(Network::Bitcoin)
- } else if chain == ChainHash::using_genesis_block(Network::Testnet) {
- Some(Network::Testnet)
- } else if chain == ChainHash::using_genesis_block(Network::Signet) {
- Some(Network::Signet)
- } else if chain == ChainHash::using_genesis_block(Network::Regtest) {
- Some(Network::Regtest)
- } else {
- None
- }
+ pub fn fallbacks(&$self) -> Vec<Address> {
+ $contents.fallbacks()
}
/// Features pertaining to paying an invoice.
- pub fn features(&self) -> &Bolt12InvoiceFeatures {
- &self.contents.fields().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.fields().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 {
/// Hash that was used for signing the invoice.
pub fn signable_hash(&self) -> [u8; 32] {
- merkle::message_digest(SIGNATURE_TAG, &self.bytes).as_ref().clone()
+ self.tagged_hash.as_digest().as_ref().clone()
}
- /// Verifies that the invoice was for a request or refund created using the given key.
+ /// Verifies that the invoice was for a request or refund created using the given key. Returns
+ /// the associated [`PaymentId`] to use when sending the payment.
pub fn verify<T: secp256k1::Signing>(
&self, key: &ExpandedKey, secp_ctx: &Secp256k1<T>
- ) -> bool {
+ ) -> Result<PaymentId, ()> {
self.contents.verify(TlvStream::new(&self.bytes), key, secp_ctx)
}
- #[cfg(test)]
- pub(super) fn as_tlv_stream(&self) -> FullInvoiceTlvStreamRef {
+ pub(crate) fn as_tlv_stream(&self) -> FullInvoiceTlvStreamRef {
let (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream) =
self.contents.as_tlv_stream();
let signature_tlv_stream = SignatureTlvStreamRef {
}
}
+ #[cfg(not(feature = "std"))]
+ fn is_offer_or_refund_expired_no_std(&self, duration_since_epoch: Duration) -> bool {
+ match self {
+ InvoiceContents::ForOffer { invoice_request, .. } =>
+ invoice_request.inner.offer.is_expired_no_std(duration_since_epoch),
+ InvoiceContents::ForRefund { refund, .. } =>
+ refund.is_expired_no_std(duration_since_epoch),
+ }
+ }
+
+ fn offer_chains(&self) -> Option<Vec<ChainHash>> {
+ 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(),
}
}
+ fn metadata(&self) -> Option<&Vec<u8>> {
+ 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, .. } => {
}
}
+ 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<Duration> {
+ match self {
+ InvoiceContents::ForOffer { invoice_request, .. } => {
+ invoice_request.inner.offer.absolute_expiry()
+ },
+ InvoiceContents::ForRefund { refund, .. } => refund.absolute_expiry(),
+ }
+ }
+
+ fn issuer(&self) -> Option<PrintableString> {
+ 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<Quantity> {
+ 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<u64> {
+ 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<PrintableString> {
+ 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[..]
+ }
+
+ fn created_at(&self) -> Duration {
+ self.fields().created_at
+ }
+
+ fn relative_expiry(&self) -> Duration {
+ self.fields().relative_expiry.unwrap_or(DEFAULT_RELATIVE_EXPIRY)
+ }
+
+ #[cfg(feature = "std")]
+ fn is_expired(&self) -> bool {
+ let absolute_expiry = self.created_at().checked_add(self.relative_expiry());
+ match absolute_expiry {
+ Some(seconds_from_epoch) => match SystemTime::UNIX_EPOCH.elapsed() {
+ Ok(elapsed) => elapsed > seconds_from_epoch,
+ Err(_) => false,
+ },
+ None => false,
+ }
+ }
+
+ fn payment_hash(&self) -> PaymentHash {
+ self.fields().payment_hash
+ }
+
+ fn amount_msats(&self) -> u64 {
+ self.fields().amount_msats
+ }
+
+ fn fallbacks(&self) -> Vec<Address> {
+ let chain = self.chain();
+ let network = if chain == ChainHash::using_genesis_block(Network::Bitcoin) {
+ Network::Bitcoin
+ } else if chain == ChainHash::using_genesis_block(Network::Testnet) {
+ Network::Testnet
+ } else if chain == ChainHash::using_genesis_block(Network::Signet) {
+ Network::Signet
+ } else if chain == ChainHash::using_genesis_block(Network::Regtest) {
+ Network::Regtest
+ } else {
+ return Vec::new()
+ };
+
+ let to_valid_address = |address: &FallbackAddress| {
+ let version = match WitnessVersion::try_from(address.version) {
+ Ok(version) => version,
+ Err(_) => return None,
+ };
+
+ let program = &address.program;
+ let witness_program = match WitnessProgram::new(version, program.clone()) {
+ Ok(witness_program) => witness_program,
+ Err(_) => return None,
+ };
+ Some(Address::new(network, Payload::WitnessProgram(witness_program)))
+ };
+
+ self.fields().fallbacks
+ .as_ref()
+ .map(|fallbacks| fallbacks.iter().filter_map(to_valid_address).collect())
+ .unwrap_or_else(Vec::new)
+ }
+
+ fn features(&self) -> &Bolt12InvoiceFeatures {
+ &self.fields().features
+ }
+
+ fn signing_pubkey(&self) -> PublicKey {
+ self.fields().signing_pubkey
+ }
+
fn fields(&self) -> &InvoiceFields {
match self {
InvoiceContents::ForOffer { fields, .. } => fields,
fn verify<T: secp256k1::Signing>(
&self, tlv_stream: TlvStream<'_>, key: &ExpandedKey, secp_ctx: &Secp256k1<T>
- ) -> bool {
+ ) -> Result<PaymentId, ()> {
let offer_records = tlv_stream.clone().range(OFFER_TYPES);
let invreq_records = tlv_stream.range(INVOICE_REQUEST_TYPES).filter(|record| {
match record.r#type {
},
};
- match signer::verify_metadata(metadata, key, iv_bytes, payer_id, tlv_stream, secp_ctx) {
- Ok(_) => true,
- Err(()) => false,
- }
+ signer::verify_payer_metadata(metadata, key, iv_bytes, payer_id, tlv_stream, secp_ctx)
}
fn derives_keys(&self) -> bool {
}
}
+impl Writeable for UnsignedBolt12Invoice {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+ WithoutLength(&self.bytes).write(writer)
+ }
+}
+
impl Writeable for Bolt12Invoice {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
WithoutLength(&self.bytes).write(writer)
}
}
+impl TryFrom<Vec<u8>> for UnsignedBolt12Invoice {
+ type Error = Bolt12ParseError;
+
+ fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
+ let invoice = ParsedMessage::<PartialInvoiceTlvStream>::try_from(bytes)?;
+ let ParsedMessage { bytes, tlv_stream } = invoice;
+ let (
+ payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream,
+ ) = tlv_stream;
+ let contents = InvoiceContents::try_from(
+ (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream)
+ )?;
+
+ let tagged_hash = TaggedHash::new(SIGNATURE_TAG, &bytes);
+
+ Ok(UnsignedBolt12Invoice { bytes, contents, tagged_hash })
+ }
+}
+
impl TryFrom<Vec<u8>> for Bolt12Invoice {
type Error = Bolt12ParseError;
type FullInvoiceTlvStream =
(PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream, InvoiceTlvStream, SignatureTlvStream);
-#[cfg(test)]
type FullInvoiceTlvStreamRef<'a> = (
PayerTlvStreamRef<'a>,
OfferTlvStreamRef<'a>,
InvoiceTlvStreamRef<'a>,
);
+impl SeekReadable for PartialInvoiceTlvStream {
+ fn read<R: io::Read + io::Seek>(r: &mut R) -> Result<Self, DecodeError> {
+ let payer = SeekReadable::read(r)?;
+ let offer = SeekReadable::read(r)?;
+ let invoice_request = SeekReadable::read(r)?;
+ let invoice = SeekReadable::read(r)?;
+
+ Ok((payer, offer, invoice_request, invoice))
+ }
+}
+
impl TryFrom<ParsedMessage<FullInvoiceTlvStream>> for Bolt12Invoice {
type Error = Bolt12ParseError;
None => return Err(Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingSignature)),
Some(signature) => signature,
};
+ let tagged_hash = TaggedHash::new(SIGNATURE_TAG, &bytes);
let pubkey = contents.fields().signing_pubkey;
- merkle::verify_signature(&signature, SIGNATURE_TAG, &bytes, pubkey)?;
+ merkle::verify_signature(&signature, &tagged_hash, pubkey)?;
- Ok(Bolt12Invoice { bytes, contents, signature })
+ Ok(Bolt12Invoice { bytes, contents, signature, tagged_hash })
}
}
#[cfg(test)]
mod tests {
- use super::{Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, FallbackAddress, FullInvoiceTlvStreamRef, InvoiceTlvStreamRef, SIGNATURE_TAG};
+ use super::{Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, FallbackAddress, FullInvoiceTlvStreamRef, InvoiceTlvStreamRef, SIGNATURE_TAG, UnsignedBolt12Invoice};
- use bitcoin::blockdata::script::Script;
+ use bitcoin::blockdata::constants::ChainHash;
+ use bitcoin::blockdata::script::ScriptBuf;
use bitcoin::hashes::Hash;
use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{Message, Secp256k1, XOnlyPublicKey, self};
- use bitcoin::util::address::{Address, Payload, WitnessVersion};
- use bitcoin::util::schnorr::TweakedPublicKey;
+ use bitcoin::address::{Address, Payload, WitnessProgram, WitnessVersion};
+ use bitcoin::key::TweakedPublicKey;
use core::convert::TryFrom;
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, OfferTlvStreamRef, Quantity};
+ #[cfg(not(c_bindings))]
+ use {
+ crate::offers::offer::OfferBuilder,
+ crate::offers::refund::RefundBuilder,
+ };
+ #[cfg(c_bindings)]
+ use {
+ crate::offers::offer::OfferWithExplicitMetadataBuilder as OfferBuilder,
+ crate::offers::refund::RefundMaybeWithDerivedMetadataBuilder as RefundBuilder,
+ };
use crate::offers::parse::{Bolt12ParseError, Bolt12SemanticError};
use crate::offers::payer::PayerTlvStreamRef;
- use crate::offers::refund::RefundBuilder;
use crate::offers::test_utils::*;
use crate::util::ser::{BigSize, Iterable, Writeable};
use crate::util::string::PrintableString;
let payment_paths = payment_paths();
let payment_hash = payment_hash();
let now = now();
- let invoice = OfferBuilder::new("foo".into(), recipient_pubkey())
+ let unsigned_invoice = OfferBuilder::new("foo".into(), recipient_pubkey())
.amount_msats(1000)
.build().unwrap()
.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
.build().unwrap()
.sign(payer_sign).unwrap()
.respond_with_no_std(payment_paths.clone(), payment_hash, now).unwrap()
- .build().unwrap()
- .sign(recipient_sign).unwrap();
+ .build().unwrap();
+
+ 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) => {
+ assert_eq!(parsed.bytes, unsigned_invoice.bytes);
+ assert_eq!(parsed.tagged_hash, unsigned_invoice.tagged_hash);
+ },
+ }
+
+ #[cfg(c_bindings)]
+ let mut unsigned_invoice = unsigned_invoice;
+ let invoice = unsigned_invoice.sign(recipient_sign).unwrap();
let mut buffer = Vec::new();
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);
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();
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);
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(),
],
};
+ #[cfg(c_bindings)]
+ use crate::offers::offer::OfferWithDerivedMetadataBuilder as OfferBuilder;
let offer = OfferBuilder
::deriving_signing_pubkey(desc, node_id, &expanded_key, &entropy, &secp_ctx)
.amount_msats(1000)
.build().unwrap()
.sign(payer_sign).unwrap();
- if let Err(e) = invoice_request
- .verify_and_respond_using_derived_keys_no_std(
- payment_paths(), payment_hash(), now(), &expanded_key, &secp_ctx
- )
- .unwrap()
+ if let Err(e) = invoice_request.clone()
+ .verify(&expanded_key, &secp_ctx).unwrap()
+ .respond_using_derived_keys_no_std(payment_paths(), payment_hash(), now()).unwrap()
.build_and_sign(&secp_ctx)
{
panic!("error building invoice: {:?}", e);
}
let expanded_key = ExpandedKey::new(&KeyMaterial([41; 32]));
- match invoice_request.verify_and_respond_using_derived_keys_no_std(
- payment_paths(), payment_hash(), now(), &expanded_key, &secp_ctx
- ) {
- Ok(_) => panic!("expected error"),
- Err(e) => assert_eq!(e, Bolt12SemanticError::InvalidMetadata),
- }
+ assert!(invoice_request.verify(&expanded_key, &secp_ctx).is_err());
let desc = "foo".to_string();
let offer = OfferBuilder
::deriving_signing_pubkey(desc, node_id, &expanded_key, &entropy, &secp_ctx)
.amount_msats(1000)
+ // Omit the path so that node_id is used for the signing pubkey instead of deriving
.build().unwrap();
let invoice_request = offer.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
.build().unwrap()
.sign(payer_sign).unwrap();
- match invoice_request.verify_and_respond_using_derived_keys_no_std(
- payment_paths(), payment_hash(), now(), &expanded_key, &secp_ctx
- ) {
+ match invoice_request
+ .verify(&expanded_key, &secp_ctx).unwrap()
+ .respond_using_derived_keys_no_std(payment_paths(), payment_hash(), now())
+ {
Ok(_) => panic!("expected error"),
Err(e) => assert_eq!(e, Bolt12SemanticError::InvalidMetadata),
}
#[test]
fn builds_invoice_with_fallback_address() {
- let script = Script::new();
- let pubkey = bitcoin::util::key::PublicKey::new(recipient_pubkey());
+ let script = ScriptBuf::new();
+ let pubkey = bitcoin::key::PublicKey::new(recipient_pubkey());
let x_only_pubkey = XOnlyPublicKey::from_keypair(&recipient_keys()).0;
let tweaked_pubkey = TweakedPublicKey::dangerous_assume_tweaked(x_only_pubkey);
Some(&vec![
FallbackAddress {
version: WitnessVersion::V0.to_num(),
- program: Vec::from(&script.wscript_hash().into_inner()[..]),
+ program: Vec::from(script.wscript_hash().to_byte_array()),
},
FallbackAddress {
version: WitnessVersion::V0.to_num(),
- program: Vec::from(&pubkey.wpubkey_hash().unwrap().into_inner()[..]),
+ program: Vec::from(pubkey.wpubkey_hash().unwrap().to_byte_array()),
},
FallbackAddress {
version: WitnessVersion::V1.to_num(),
.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));
}
.sign(payer_sign).unwrap()
.respond_with_no_std(payment_paths(), payment_hash(), now()).unwrap()
.build().unwrap()
- .sign(|_| Err(()))
+ .sign(fail_sign)
{
Ok(_) => panic!("expected error"),
- Err(e) => assert_eq!(e, SignError::Signing(())),
+ Err(e) => assert_eq!(e, SignError::Signing),
}
match OfferBuilder::new("foo".into(), recipient_pubkey())
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),
}
#[test]
fn parses_invoice_with_fallback_address() {
- let script = Script::new();
- let pubkey = bitcoin::util::key::PublicKey::new(recipient_pubkey());
+ let script = ScriptBuf::new();
+ let pubkey = bitcoin::key::PublicKey::new(recipient_pubkey());
let x_only_pubkey = XOnlyPublicKey::from_keypair(&recipient_keys()).0;
let tweaked_pubkey = TweakedPublicKey::dangerous_assume_tweaked(x_only_pubkey);
.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
.build().unwrap()
.sign(payer_sign).unwrap();
+ #[cfg(not(c_bindings))]
+ let invoice_builder = invoice_request
+ .respond_with_no_std(payment_paths(), payment_hash(), now()).unwrap();
+ #[cfg(c_bindings)]
let mut invoice_builder = invoice_request
- .respond_with_no_std(payment_paths(), payment_hash(), now()).unwrap()
+ .respond_with_no_std(payment_paths(), payment_hash(), now()).unwrap();
+ let invoice_builder = invoice_builder
.fallback_v0_p2wsh(&script.wscript_hash())
.fallback_v0_p2wpkh(&pubkey.wpubkey_hash().unwrap())
.fallback_v1_p2tr_tweaked(&tweaked_pubkey);
+ #[cfg(not(c_bindings))]
+ let mut invoice_builder = invoice_builder;
// Only standard addresses will be included.
let fallbacks = invoice_builder.invoice.fields_mut().fallbacks.as_mut().unwrap();
match Bolt12Invoice::try_from(buffer) {
Ok(invoice) => {
+ let v1_witness_program = WitnessProgram::new(WitnessVersion::V1, vec![0u8; 33]).unwrap();
+ let v2_witness_program = WitnessProgram::new(WitnessVersion::V2, vec![0u8; 40]).unwrap();
assert_eq!(
invoice.fallbacks(),
vec![
Address::p2wsh(&script, Network::Bitcoin),
Address::p2wpkh(&pubkey, Network::Bitcoin).unwrap(),
Address::p2tr_tweaked(tweaked_pubkey, Network::Bitcoin),
- Address {
- payload: Payload::WitnessProgram {
- version: WitnessVersion::V1,
- program: vec![0u8; 33],
- },
- network: Network::Bitcoin,
- },
- Address {
- payload: Payload::WitnessProgram {
- version: WitnessVersion::V2,
- program: vec![0u8; 40],
- },
- network: Network::Bitcoin,
- },
+ Address::new(Network::Bitcoin, Payload::WitnessProgram(v1_witness_program)),
+ Address::new(Network::Bitcoin, Payload::WitnessProgram(v2_witness_program)),
],
);
},
.sign(payer_sign).unwrap()
.respond_with_no_std(payment_paths(), payment_hash(), now()).unwrap()
.build().unwrap()
- .invoice
+ .contents
.write(&mut buffer).unwrap();
match Bolt12Invoice::try_from(buffer) {
projects / rust-lightning / blobdiff