]> git.bitcoin.ninja Git - rust-lightning/commitdiff
Expose Offer/InvoiceRequest methods in Invoice
authorJeffrey Czyz <jkczyz@gmail.com>
Wed, 16 Aug 2023 21:35:16 +0000 (16:35 -0500)
committerJeffrey Czyz <jkczyz@gmail.com>
Tue, 22 Aug 2023 00:14:29 +0000 (19:14 -0500)
Bolt12Invoice can either be for an Offer (via an InvoiceRequest) or a
Refund. It wraps those types, so expose their methods on both
Bolt12Invoice and UnsignedBolt12Invoice.

Since Refund does not have all the Offer/InvoiceRequest methods, use an
Option return type such that None can returned for refund-based
invoices.

For methods that are duplicated between Offer/InvoiceRequest and
Bolt12Invoice, prefer the (non-Option, if applicable) method from
Bolt12Invoice (e.g., amount_msats, signing_pubkey).

lightning/src/offers/invoice.rs
lightning/src/offers/invoice_request.rs
lightning/src/offers/payer.rs
lightning/src/offers/refund.rs

index 068cc958325c0968208afbf8da2c35a6d7b04749..05960642efd111e2f748a805ab2df628e1d24682 100644 (file)
@@ -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};
@@ -482,12 +482,141 @@ struct InvoiceFields {
 }
 
 macro_rules! invoice_accessors { ($self: ident, $contents: expr) => {
-       /// 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.
+       /// 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
        /// needed for routing payments across them.
        ///
@@ -591,6 +720,14 @@ impl InvoiceContents {
                }
        }
 
+       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(),
@@ -598,6 +735,22 @@ impl InvoiceContents {
                }
        }
 
+       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, .. } => {
@@ -607,6 +760,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<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[..]
        }
@@ -1040,6 +1273,7 @@ impl TryFrom<PartialInvoiceTlvStream> 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;
@@ -1050,12 +1284,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::offer::{Amount, OfferBuilder, OfferTlvStreamRef, Quantity};
        use crate::offers::parse::{Bolt12ParseError, Bolt12SemanticError};
        use crate::offers::payer::PayerTlvStreamRef;
        use crate::offers::refund::RefundBuilder;
@@ -1097,7 +1331,23 @@ mod tests {
                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);
@@ -1123,7 +1373,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);
@@ -1206,7 +1472,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);
index 5704dcbd3e2172bdf01bb0b46cdc3f8eab3ed481..198e15ec527905e064747dec01a443f9375a3b33 100644 (file)
@@ -635,15 +635,15 @@ impl InvoiceRequestContents {
                self.inner.chain()
        }
 
-       fn amount_msats(&self) -> Option<u64> {
+       pub(super) fn amount_msats(&self) -> Option<u64> {
                self.inner.amount_msats
        }
 
-       fn features(&self) -> &InvoiceRequestFeatures {
+       pub(super) fn features(&self) -> &InvoiceRequestFeatures {
                &self.inner.features
        }
 
-       fn quantity(&self) -> Option<u64> {
+       pub(super) fn quantity(&self) -> Option<u64> {
                self.inner.quantity
        }
 
@@ -651,7 +651,7 @@ impl InvoiceRequestContents {
                self.payer_id
        }
 
-       fn payer_note(&self) -> Option<PrintableString> {
+       pub(super) fn payer_note(&self) -> Option<PrintableString> {
                self.inner.payer_note.as_ref()
                        .map(|payer_note| PrintableString(payer_note.as_str()))
        }
index b3b2f7a88aee21ec776e0881ad83b682738a6e40..19aef23363d8e0afc9a5ddd758d5808098d1d03f 100644 (file)
@@ -22,10 +22,10 @@ use crate::prelude::*;
 #[cfg_attr(test, derive(PartialEq))]
 pub(super) struct PayerContents(pub Metadata);
 
-/// TLV record type for [`InvoiceRequest::payer_metadata`] and [`Refund::metadata`].
+/// TLV record type for [`InvoiceRequest::payer_metadata`] and [`Refund::payer_metadata`].
 ///
 /// [`InvoiceRequest::payer_metadata`]: crate::offers::invoice_request::InvoiceRequest::payer_metadata
-/// [`Refund::metadata`]: crate::offers::refund::Refund::metadata
+/// [`Refund::payer_metadata`]: crate::offers::refund::Refund::payer_metadata
 pub(super) const PAYER_METADATA_TYPE: u64 = 0;
 
 tlv_stream!(PayerTlvStream, PayerTlvStreamRef, 0..1, {
index 2c8dffeb1516abfa7961d144581d412657861c2a..d419e8fe0d2b41e06c8b44f5f6215d8d07a221a9 100644 (file)
@@ -117,7 +117,7 @@ impl<'a> RefundBuilder<'a, secp256k1::SignOnly> {
        /// Creates a new builder for a refund using the [`Refund::payer_id`] for the public node id to
        /// send to if no [`Refund::paths`] are set. Otherwise, it may be a transient pubkey.
        ///
-       /// Additionally, sets the required [`Refund::description`], [`Refund::metadata`], and
+       /// Additionally, sets the required [`Refund::description`], [`Refund::payer_metadata`], and
        /// [`Refund::amount_msats`].
        pub fn new(
                description: String, metadata: Vec<u8>, payer_id: PublicKey, amount_msats: u64
@@ -319,7 +319,7 @@ impl Refund {
        ///
        /// If `None`, the refund does not expire.
        pub fn absolute_expiry(&self) -> Option<Duration> {
-               self.contents.absolute_expiry
+               self.contents.absolute_expiry()
        }
 
        /// Whether the refund has expired.
@@ -331,43 +331,43 @@ impl Refund {
        /// The issuer of the refund, possibly beginning with `user@domain` or `domain`. Intended to be
        /// displayed to the user but with the caveat that it has not been verified in any way.
        pub fn issuer(&self) -> Option<PrintableString> {
-               self.contents.issuer.as_ref().map(|issuer| PrintableString(issuer.as_str()))
+               self.contents.issuer()
        }
 
        /// Paths to the sender originating from publicly reachable nodes. Blinded paths provide sender
        /// privacy by obfuscating its node id.
        pub fn paths(&self) -> &[BlindedPath] {
-               self.contents.paths.as_ref().map(|paths| paths.as_slice()).unwrap_or(&[])
+               self.contents.paths()
        }
 
        /// An unpredictable series of bytes, typically containing information about the derivation of
        /// [`payer_id`].
        ///
        /// [`payer_id`]: Self::payer_id
-       pub fn metadata(&self) -> &[u8] {
+       pub fn payer_metadata(&self) -> &[u8] {
                self.contents.metadata()
        }
 
        /// A chain that the refund is valid for.
        pub fn chain(&self) -> ChainHash {
-               self.contents.chain.unwrap_or_else(|| self.contents.implied_chain())
+               self.contents.chain()
        }
 
        /// The amount to refund in msats (i.e., the minimum lightning-payable unit for [`chain`]).
        ///
        /// [`chain`]: Self::chain
        pub fn amount_msats(&self) -> u64 {
-               self.contents.amount_msats
+               self.contents.amount_msats()
        }
 
        /// Features pertaining to requesting an invoice.
        pub fn features(&self) -> &InvoiceRequestFeatures {
-               &self.contents.features
+               &self.contents.features()
        }
 
        /// The quantity of an item that refund is for.
        pub fn quantity(&self) -> Option<u64> {
-               self.contents.quantity
+               self.contents.quantity()
        }
 
        /// A public node id to send to in the case where there are no [`paths`]. Otherwise, a possibly
@@ -375,12 +375,12 @@ impl Refund {
        ///
        /// [`paths`]: Self::paths
        pub fn payer_id(&self) -> PublicKey {
-               self.contents.payer_id
+               self.contents.payer_id()
        }
 
        /// Payer provided note to include in the invoice.
        pub fn payer_note(&self) -> Option<PrintableString> {
-               self.contents.payer_note.as_ref().map(|payer_note| PrintableString(payer_note.as_str()))
+               self.contents.payer_note()
        }
 
        /// Creates an [`InvoiceBuilder`] for the refund with the given required fields and using the
@@ -503,6 +503,10 @@ impl RefundContents {
                PrintableString(&self.description)
        }
 
+       pub fn absolute_expiry(&self) -> Option<Duration> {
+               self.absolute_expiry
+       }
+
        #[cfg(feature = "std")]
        pub(super) fn is_expired(&self) -> bool {
                match self.absolute_expiry {
@@ -514,6 +518,14 @@ impl RefundContents {
                }
        }
 
+       pub fn issuer(&self) -> Option<PrintableString> {
+               self.issuer.as_ref().map(|issuer| PrintableString(issuer.as_str()))
+       }
+
+       pub fn paths(&self) -> &[BlindedPath] {
+               self.paths.as_ref().map(|paths| paths.as_slice()).unwrap_or(&[])
+       }
+
        pub(super) fn metadata(&self) -> &[u8] {
                self.payer.0.as_bytes().map(|bytes| bytes.as_slice()).unwrap_or(&[])
        }
@@ -526,14 +538,37 @@ impl RefundContents {
                ChainHash::using_genesis_block(Network::Bitcoin)
        }
 
-       pub(super) fn derives_keys(&self) -> bool {
-               self.payer.0.derives_keys()
+       pub fn amount_msats(&self) -> u64 {
+               self.amount_msats
+       }
+
+       /// Features pertaining to requesting an invoice.
+       pub fn features(&self) -> &InvoiceRequestFeatures {
+               &self.features
        }
 
-       pub(super) fn payer_id(&self) -> PublicKey {
+       /// The quantity of an item that refund is for.
+       pub fn quantity(&self) -> Option<u64> {
+               self.quantity
+       }
+
+       /// A public node id to send to in the case where there are no [`paths`]. Otherwise, a possibly
+       /// transient pubkey.
+       ///
+       /// [`paths`]: Self::paths
+       pub fn payer_id(&self) -> PublicKey {
                self.payer_id
        }
 
+       /// Payer provided note to include in the invoice.
+       pub fn payer_note(&self) -> Option<PrintableString> {
+               self.payer_note.as_ref().map(|payer_note| PrintableString(payer_note.as_str()))
+       }
+
+       pub(super) fn derives_keys(&self) -> bool {
+               self.payer.0.derives_keys()
+       }
+
        pub(super) fn as_tlv_stream(&self) -> RefundTlvStreamRef {
                let payer = PayerTlvStreamRef {
                        metadata: self.payer.0.as_bytes(),
@@ -745,7 +780,7 @@ mod tests {
                refund.write(&mut buffer).unwrap();
 
                assert_eq!(refund.bytes, buffer.as_slice());
-               assert_eq!(refund.metadata(), &[1; 32]);
+               assert_eq!(refund.payer_metadata(), &[1; 32]);
                assert_eq!(refund.description(), PrintableString("foo"));
                assert_eq!(refund.absolute_expiry(), None);
                #[cfg(feature = "std")]