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_builder_methods_common;
+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 {}
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, 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);
+ 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);
+ 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);
+ 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);
+ 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};