From: Jeffrey Czyz Date: Wed, 16 Aug 2023 21:35:16 +0000 (-0500) Subject: Expose Offer/InvoiceRequest methods in Invoice X-Git-Tag: v0.0.117-alpha1~49^2~2 X-Git-Url: http://git.bitcoin.ninja/?a=commitdiff_plain;h=7f641da655810ef78cd61b796b79cbc4707d28bf;p=rust-lightning Expose Offer/InvoiceRequest methods in Invoice 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). --- diff --git a/lightning/src/offers/invoice.rs b/lightning/src/offers/invoice.rs index 068cc9583..05960642e 100644 --- a/lightning/src/offers/invoice.rs +++ b/lightning/src/offers/invoice.rs @@ -110,12 +110,12 @@ use core::time::Duration; use crate::io; use crate::blinded_path::BlindedPath; use crate::ln::PaymentHash; -use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures}; +use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures, InvoiceRequestFeatures, OfferFeatures}; use crate::ln::inbound_payment::ExpandedKey; use crate::ln::msgs::DecodeError; use crate::offers::invoice_request::{INVOICE_REQUEST_PAYER_ID_TYPE, INVOICE_REQUEST_TYPES, IV_BYTES as INVOICE_REQUEST_IV_BYTES, InvoiceRequest, InvoiceRequestContents, InvoiceRequestTlvStream, InvoiceRequestTlvStreamRef}; use crate::offers::merkle::{SignError, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, TlvStream, WithoutSignatures, self}; -use crate::offers::offer::{Amount, OFFER_TYPES, OfferTlvStream, OfferTlvStreamRef}; +use crate::offers::offer::{Amount, OFFER_TYPES, OfferTlvStream, OfferTlvStreamRef, Quantity}; use crate::offers::parse::{Bolt12ParseError, Bolt12SemanticError, ParsedMessage}; use crate::offers::payer::{PAYER_METADATA_TYPE, PayerTlvStream, PayerTlvStreamRef}; use crate::offers::refund::{IV_BYTES as REFUND_IV_BYTES, Refund, RefundContents}; @@ -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> { + $contents.offer_chains() + } + + /// The chain that must be used when paying the invoice; selected from [`offer_chains`] if the + /// invoice originated from an offer. + /// + /// From [`InvoiceRequest::chain`] or [`Refund::chain`]. + /// + /// [`offer_chains`]: Self::offer_chains + /// [`InvoiceRequest::chain`]: crate::offers::invoice_request::InvoiceRequest::chain + pub fn chain(&$self) -> ChainHash { + $contents.chain() + } + + /// Opaque bytes set by the originating [`Offer`]. + /// + /// From [`Offer::metadata`]; `None` if the invoice was created in response to a [`Refund`] or + /// if the [`Offer`] did not set it. + /// + /// [`Offer`]: crate::offers::offer::Offer + /// [`Offer::metadata`]: crate::offers::offer::Offer::metadata + pub fn metadata(&$self) -> Option<&Vec> { + $contents.metadata() + } + + /// The minimum amount required for a successful payment of a single item. + /// + /// From [`Offer::amount`]; `None` if the invoice was created in response to a [`Refund`] or if + /// the [`Offer`] did not set it. + /// + /// [`Offer`]: crate::offers::offer::Offer + /// [`Offer::amount`]: crate::offers::offer::Offer::amount + pub fn amount(&$self) -> Option<&Amount> { + $contents.amount() + } + + /// Features pertaining to the originating [`Offer`]. + /// + /// From [`Offer::offer_features`]; `None` if the invoice was created in response to a + /// [`Refund`]. + /// + /// [`Offer`]: crate::offers::offer::Offer + /// [`Offer::offer_features`]: crate::offers::offer::Offer::offer_features + pub fn offer_features(&$self) -> Option<&OfferFeatures> { + $contents.offer_features() + } + + /// A complete description of the purpose of the originating offer or refund. + /// + /// From [`Offer::description`] or [`Refund::description`]. + /// + /// [`Offer::description`]: crate::offers::offer::Offer::description pub fn description(&$self) -> PrintableString { $contents.description() } + /// Duration since the Unix epoch when an invoice should no longer be requested. + /// + /// From [`Offer::absolute_expiry`] or [`Refund::absolute_expiry`]. + /// + /// [`Offer::absolute_expiry`]: crate::offers::offer::Offer::absolute_expiry + pub fn absolute_expiry(&$self) -> Option { + $contents.absolute_expiry() + } + + /// The issuer of the offer or refund. + /// + /// From [`Offer::issuer`] or [`Refund::issuer`]. + /// + /// [`Offer::issuer`]: crate::offers::offer::Offer::issuer + pub fn issuer(&$self) -> Option { + $contents.issuer() + } + + /// Paths to the recipient originating from publicly reachable nodes. + /// + /// From [`Offer::paths`] or [`Refund::paths`]. + /// + /// [`Offer::paths`]: crate::offers::offer::Offer::paths + pub fn message_paths(&$self) -> &[BlindedPath] { + $contents.message_paths() + } + + /// The quantity of items supported. + /// + /// From [`Offer::supported_quantity`]; `None` if the invoice was created in response to a + /// [`Refund`]. + /// + /// [`Offer::supported_quantity`]: crate::offers::offer::Offer::supported_quantity + pub fn supported_quantity(&$self) -> Option { + $contents.supported_quantity() + } + + /// An unpredictable series of bytes from the payer. + /// + /// From [`InvoiceRequest::payer_metadata`] or [`Refund::payer_metadata`]. + pub fn payer_metadata(&$self) -> &[u8] { + $contents.payer_metadata() + } + + /// Features pertaining to requesting an invoice. + /// + /// From [`InvoiceRequest::invoice_request_features`] or [`Refund::features`]. + pub fn invoice_request_features(&$self) -> &InvoiceRequestFeatures { + &$contents.invoice_request_features() + } + + /// The quantity of items requested or refunded for. + /// + /// From [`InvoiceRequest::quantity`] or [`Refund::quantity`]. + pub fn quantity(&$self) -> Option { + $contents.quantity() + } + + /// A possibly transient pubkey used to sign the invoice request or to send an invoice for a + /// refund in case there are no [`message_paths`]. + /// + /// [`message_paths`]: Self::message_paths + pub fn payer_id(&$self) -> PublicKey { + $contents.payer_id() + } + + /// A payer-provided note reflected back in the invoice. + /// + /// From [`InvoiceRequest::payer_note`] or [`Refund::payer_note`]. + pub fn payer_note(&$self) -> Option { + $contents.payer_note() + } + /// Paths to the recipient originating from publicly reachable nodes, including information /// needed for routing payments across them. /// @@ -591,6 +720,14 @@ impl InvoiceContents { } } + fn offer_chains(&self) -> Option> { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => + Some(invoice_request.inner.offer.chains()), + InvoiceContents::ForRefund { .. } => None, + } + } + fn chain(&self) -> ChainHash { match self { InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.chain(), @@ -598,6 +735,22 @@ impl InvoiceContents { } } + fn metadata(&self) -> Option<&Vec> { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => + invoice_request.inner.offer.metadata(), + InvoiceContents::ForRefund { .. } => None, + } + } + + fn amount(&self) -> Option<&Amount> { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => + invoice_request.inner.offer.amount(), + InvoiceContents::ForRefund { .. } => None, + } + } + fn description(&self) -> PrintableString { match self { InvoiceContents::ForOffer { invoice_request, .. } => { @@ -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 { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + invoice_request.inner.offer.absolute_expiry() + }, + InvoiceContents::ForRefund { refund, .. } => refund.absolute_expiry(), + } + } + + fn issuer(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + invoice_request.inner.offer.issuer() + }, + InvoiceContents::ForRefund { refund, .. } => refund.issuer(), + } + } + + fn message_paths(&self) -> &[BlindedPath] { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + invoice_request.inner.offer.paths() + }, + InvoiceContents::ForRefund { refund, .. } => refund.paths(), + } + } + + fn supported_quantity(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => { + Some(invoice_request.inner.offer.supported_quantity()) + }, + InvoiceContents::ForRefund { .. } => None, + } + } + + fn payer_metadata(&self) -> &[u8] { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.metadata(), + InvoiceContents::ForRefund { refund, .. } => refund.metadata(), + } + } + + fn invoice_request_features(&self) -> &InvoiceRequestFeatures { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.features(), + InvoiceContents::ForRefund { refund, .. } => refund.features(), + } + } + + fn quantity(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.quantity(), + InvoiceContents::ForRefund { refund, .. } => refund.quantity(), + } + } + + fn payer_id(&self) -> PublicKey { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.payer_id(), + InvoiceContents::ForRefund { refund, .. } => refund.payer_id(), + } + } + + fn payer_note(&self) -> Option { + match self { + InvoiceContents::ForOffer { invoice_request, .. } => invoice_request.payer_note(), + InvoiceContents::ForRefund { refund, .. } => refund.payer_note(), + } + } + fn payment_paths(&self) -> &[(BlindedPayInfo, BlindedPath)] { &self.fields().payment_paths[..] } @@ -1040,6 +1273,7 @@ impl TryFrom for InvoiceContents { mod tests { use super::{Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, FallbackAddress, FullInvoiceTlvStreamRef, InvoiceTlvStreamRef, SIGNATURE_TAG, UnsignedBolt12Invoice}; + use bitcoin::blockdata::constants::ChainHash; use bitcoin::blockdata::script::Script; use bitcoin::hashes::Hash; use bitcoin::network::constants::Network; @@ -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); diff --git a/lightning/src/offers/invoice_request.rs b/lightning/src/offers/invoice_request.rs index 5704dcbd3..198e15ec5 100644 --- a/lightning/src/offers/invoice_request.rs +++ b/lightning/src/offers/invoice_request.rs @@ -635,15 +635,15 @@ impl InvoiceRequestContents { self.inner.chain() } - fn amount_msats(&self) -> Option { + pub(super) fn amount_msats(&self) -> Option { self.inner.amount_msats } - fn features(&self) -> &InvoiceRequestFeatures { + pub(super) fn features(&self) -> &InvoiceRequestFeatures { &self.inner.features } - fn quantity(&self) -> Option { + pub(super) fn quantity(&self) -> Option { self.inner.quantity } @@ -651,7 +651,7 @@ impl InvoiceRequestContents { self.payer_id } - fn payer_note(&self) -> Option { + pub(super) fn payer_note(&self) -> Option { self.inner.payer_note.as_ref() .map(|payer_note| PrintableString(payer_note.as_str())) } diff --git a/lightning/src/offers/payer.rs b/lightning/src/offers/payer.rs index b3b2f7a88..19aef2336 100644 --- a/lightning/src/offers/payer.rs +++ b/lightning/src/offers/payer.rs @@ -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, { diff --git a/lightning/src/offers/refund.rs b/lightning/src/offers/refund.rs index 2c8dffeb1..d419e8fe0 100644 --- a/lightning/src/offers/refund.rs +++ b/lightning/src/offers/refund.rs @@ -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, 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 { - 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 { - 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 { - 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 { - 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 { + 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 { + 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 { + 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 { + 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")]