//!
//! ```
-use bitcoin::{WitnessProgram, Network, WitnessVersion, WPubkeyHash, WScriptHash};
+use bitcoin::{WitnessProgram, Network, WitnessVersion};
use bitcoin::blockdata::constants::ChainHash;
use bitcoin::secp256k1::{Keypair, PublicKey, Secp256k1, self};
use bitcoin::secp256k1::schnorr::Signature;
use bitcoin::address::{Address, Payload};
-use bitcoin::key::TweakedPublicKey;
use core::time::Duration;
use core::hash::{Hash, Hasher};
use crate::io;
use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures, InvoiceRequestFeatures, OfferFeatures};
use crate::ln::inbound_payment::ExpandedKey;
use crate::ln::msgs::DecodeError;
+use crate::offers::invoice_macros::{invoice_accessors_common, invoice_builder_methods_common};
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, SignFn, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, TlvStream, WithoutSignatures, self};
use crate::offers::offer::{Amount, OFFER_TYPES, OfferTlvStream, OfferTlvStreamRef, Quantity};
/// [`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(Keypair);
+pub struct DerivedSigningPubkey(pub(super) Keypair);
impl SigningPubkeyStrategy for ExplicitSigningPubkey {}
impl SigningPubkeyStrategy for DerivedSigningPubkey {}
Ok(Self { invreq_bytes, invoice: contents, signing_pubkey_strategy })
}
-
- /// Sets the [`Bolt12Invoice::relative_expiry`] as seconds since [`Bolt12Invoice::created_at`].
- /// Any expiry that has already passed is valid and can be checked for using
- /// [`Bolt12Invoice::is_expired`].
- ///
- /// Successive calls to this method will override the previous setting.
- 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);
- $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($($self_mut)* $self: $self_type, script_hash: &WScriptHash) -> $return_type {
- use bitcoin::hashes::Hash;
- let address = FallbackAddress {
- version: WitnessVersion::V0.to_num(),
- program: Vec::from(script_hash.to_byte_array()),
- };
- $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($($self_mut)* $self: $self_type, pubkey_hash: &WPubkeyHash) -> $return_type {
- use bitcoin::hashes::Hash;
- let address = FallbackAddress {
- version: WitnessVersion::V0.to_num(),
- program: Vec::from(pubkey_hash.to_byte_array()),
- };
- $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($($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);
- $return_value
- }
-
- /// 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> {
impl<'a, S: SigningPubkeyStrategy> InvoiceBuilder<'a, S> {
invoice_builder_methods!(self, Self, Self, self, S, mut);
+ invoice_builder_methods_common!(self, Self, self.invoice.fields_mut(), Self, self, S, Bolt12Invoice, 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);
+ invoice_builder_methods_common!(self, &mut Self, self.invoice.fields_mut(), (), (), ExplicitSigningPubkey, Bolt12Invoice);
}
#[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);
+ invoice_builder_methods_common!(self, &mut Self, self.invoice.fields_mut(), &mut Self, self, ExplicitSigningPubkey, Bolt12Invoice);
}
#[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);
+ invoice_builder_methods_common!(self, &mut Self, self.invoice.fields_mut(), (), (), DerivedSigningPubkey, Bolt12Invoice);
}
#[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);
+ invoice_builder_methods_common!(self, &mut Self, self.invoice.fields_mut(), &mut Self, self, DerivedSigningPubkey, Bolt12Invoice);
}
#[cfg(c_bindings)]
$contents.payer_note()
}
- /// Paths to the recipient originating from publicly reachable nodes, including information
- /// needed for routing payments across them.
- ///
- /// Blinded paths provide recipient privacy by obfuscating its node id. Note, however, that this
- /// privacy is lost if a public node id is used for [`Bolt12Invoice::signing_pubkey`].
- ///
- /// 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)] {
- $contents.payment_paths()
- }
-
- /// Duration since the Unix epoch when the invoice was created.
- 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 {
- $contents.relative_expiry()
- }
-
- /// Whether the invoice has expired.
- #[cfg(feature = "std")]
- 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 {
$contents.payment_hash()
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> {
- $contents.fallbacks()
- }
-
- /// Features pertaining to paying an invoice.
- 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 {
- $contents.signing_pubkey()
- }
} }
impl UnsignedBolt12Invoice {
+ invoice_accessors_common!(self, self.contents, Bolt12Invoice);
invoice_accessors!(self, self.contents);
}
impl Bolt12Invoice {
+ invoice_accessors_common!(self, self.contents, Bolt12Invoice);
invoice_accessors!(self, self.contents);
/// Signature of the invoice verified using [`Bolt12Invoice::signing_pubkey`].
#[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,
- }
+ is_expired(self.created_at(), self.relative_expiry())
}
fn payment_hash(&self) -> PaymentHash {
}
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.clone();
- let witness_program = match WitnessProgram::new(version, program) {
- 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())
+ .map(|fallbacks| filter_fallbacks(self.chain(), fallbacks))
.unwrap_or_else(Vec::new)
}
}
}
+#[cfg(feature = "std")]
+pub(super) fn is_expired(created_at: Duration, relative_expiry: Duration) -> bool {
+ let absolute_expiry = created_at.checked_add(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(super) fn filter_fallbacks(
+ chain: ChainHash, fallbacks: &Vec<FallbackAddress>
+) -> Vec<Address> {
+ 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.clone();
+ let witness_program = match WitnessProgram::new(version, program) {
+ Ok(witness_program) => witness_program,
+ Err(_) => return None,
+ };
+ Some(Address::new(network, Payload::WitnessProgram(witness_program)))
+ };
+
+ fallbacks.iter().filter_map(to_valid_address).collect()
+}
+
impl InvoiceFields {
fn as_tlv_stream(&self) -> InvoiceTlvStreamRef {
let features = {
(176, node_id: PublicKey),
});
-type BlindedPathIter<'a> = core::iter::Map<
+pub(super) type BlindedPathIter<'a> = core::iter::Map<
core::slice::Iter<'a, (BlindedPayInfo, BlindedPath)>,
for<'r> fn(&'r (BlindedPayInfo, BlindedPath)) -> &'r BlindedPath,
>;
-type BlindedPayInfoIter<'a> = core::iter::Map<
+pub(super) type BlindedPayInfoIter<'a> = core::iter::Map<
core::slice::Iter<'a, (BlindedPayInfo, BlindedPath)>,
for<'r> fn(&'r (BlindedPayInfo, BlindedPath)) -> &'r BlindedPayInfo,
>;
/// Wire representation for an on-chain fallback address.
#[derive(Clone, Debug, PartialEq)]
pub(super) struct FallbackAddress {
- version: u8,
- program: Vec<u8>,
+ pub(super) version: u8,
+ pub(super) program: Vec<u8>,
}
impl_writeable!(FallbackAddress, { version, program });
},
) = tlv_stream;
- let payment_paths = match (blindedpay, paths) {
- (_, None) => return Err(Bolt12SemanticError::MissingPaths),
- (None, _) => return Err(Bolt12SemanticError::InvalidPayInfo),
- (_, Some(paths)) if paths.is_empty() => return Err(Bolt12SemanticError::MissingPaths),
- (Some(blindedpay), Some(paths)) if paths.len() != blindedpay.len() => {
- return Err(Bolt12SemanticError::InvalidPayInfo);
- },
- (Some(blindedpay), Some(paths)) => {
- blindedpay.into_iter().zip(paths.into_iter()).collect::<Vec<_>>()
- },
- };
+ let payment_paths = construct_payment_paths(blindedpay, paths)?;
let created_at = match created_at {
None => return Err(Bolt12SemanticError::MissingCreationTime),
}
}
+pub(super) fn construct_payment_paths(
+ blinded_payinfos: Option<Vec<BlindedPayInfo>>, blinded_paths: Option<Vec<BlindedPath>>
+) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, Bolt12SemanticError> {
+ match (blinded_payinfos, blinded_paths) {
+ (_, None) => Err(Bolt12SemanticError::MissingPaths),
+ (None, _) => Err(Bolt12SemanticError::InvalidPayInfo),
+ (_, Some(paths)) if paths.is_empty() => Err(Bolt12SemanticError::MissingPaths),
+ (Some(blindedpay), Some(paths)) if paths.len() != blindedpay.len() => {
+ Err(Bolt12SemanticError::InvalidPayInfo)
+ },
+ (Some(blindedpay), Some(paths)) => {
+ Ok(blindedpay.into_iter().zip(paths.into_iter()).collect::<Vec<_>>())
+ },
+ }
+}
+
#[cfg(test)]
mod tests {
use super::{Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, FallbackAddress, FullInvoiceTlvStreamRef, InvoiceTlvStreamRef, SIGNATURE_TAG, UnsignedBolt12Invoice};
#[cfg(feature = "std")]
assert!(!unsigned_invoice.is_expired());
assert_eq!(unsigned_invoice.payment_hash(), payment_hash);
- assert_eq!(unsigned_invoice.amount_msats(), 1000);
assert!(unsigned_invoice.fallbacks().is_empty());
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),
#[cfg(feature = "std")]
assert!(!invoice.is_expired());
assert_eq!(invoice.payment_hash(), payment_hash);
- assert_eq!(invoice.amount_msats(), 1000);
assert!(invoice.fallbacks().is_empty());
assert_eq!(invoice.invoice_features(), &Bolt12InvoiceFeatures::empty());
- assert_eq!(invoice.signing_pubkey(), recipient_pubkey());
let message = TaggedHash::from_valid_tlv_stream_bytes(SIGNATURE_TAG, &invoice.bytes);
assert!(merkle::verify_signature(&invoice.signature, &message, recipient_pubkey()).is_ok());
#[cfg(feature = "std")]
assert!(!invoice.is_expired());
assert_eq!(invoice.payment_hash(), payment_hash);
- assert_eq!(invoice.amount_msats(), 1000);
assert!(invoice.fallbacks().is_empty());
assert_eq!(invoice.invoice_features(), &Bolt12InvoiceFeatures::empty());
- assert_eq!(invoice.signing_pubkey(), recipient_pubkey());
let message = TaggedHash::from_valid_tlv_stream_bytes(SIGNATURE_TAG, &invoice.bytes);
assert!(merkle::verify_signature(&invoice.signature, &message, recipient_pubkey()).is_ok());