]> git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/offers/refund.rs
Persist scorer upon update based on event handling
[rust-lightning] / lightning / src / offers / refund.rs
1 // This file is Copyright its original authors, visible in version control
2 // history.
3 //
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
8 // licenses.
9
10 //! Data structures and encoding for refunds.
11 //!
12 //! A [`Refund`] is an "offer for money" and is typically constructed by a merchant and presented
13 //! directly to the customer. The recipient responds with an [`Invoice`] to be paid.
14 //!
15 //! This is an [`InvoiceRequest`] produced *not* in response to an [`Offer`].
16 //!
17 //! [`Invoice`]: crate::offers::invoice::Invoice
18 //! [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
19 //! [`Offer`]: crate::offers::offer::Offer
20 //!
21 //! ```
22 //! extern crate bitcoin;
23 //! extern crate core;
24 //! extern crate lightning;
25 //!
26 //! use core::convert::TryFrom;
27 //! use core::time::Duration;
28 //!
29 //! use bitcoin::network::constants::Network;
30 //! use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, SecretKey};
31 //! use lightning::offers::parse::ParseError;
32 //! use lightning::offers::refund::{Refund, RefundBuilder};
33 //! use lightning::util::ser::{Readable, Writeable};
34 //!
35 //! # use lightning::blinded_path::BlindedPath;
36 //! # #[cfg(feature = "std")]
37 //! # use std::time::SystemTime;
38 //! #
39 //! # fn create_blinded_path() -> BlindedPath { unimplemented!() }
40 //! # fn create_another_blinded_path() -> BlindedPath { unimplemented!() }
41 //! #
42 //! # #[cfg(feature = "std")]
43 //! # fn build() -> Result<(), ParseError> {
44 //! let secp_ctx = Secp256k1::new();
45 //! let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
46 //! let pubkey = PublicKey::from(keys);
47 //!
48 //! let expiration = SystemTime::now() + Duration::from_secs(24 * 60 * 60);
49 //! let refund = RefundBuilder::new("coffee, large".to_string(), vec![1; 32], pubkey, 20_000)?
50 //!     .absolute_expiry(expiration.duration_since(SystemTime::UNIX_EPOCH).unwrap())
51 //!     .issuer("Foo Bar".to_string())
52 //!     .path(create_blinded_path())
53 //!     .path(create_another_blinded_path())
54 //!     .chain(Network::Bitcoin)
55 //!     .payer_note("refund for order #12345".to_string())
56 //!     .build()?;
57 //!
58 //! // Encode as a bech32 string for use in a QR code.
59 //! let encoded_refund = refund.to_string();
60 //!
61 //! // Parse from a bech32 string after scanning from a QR code.
62 //! let refund = encoded_refund.parse::<Refund>()?;
63 //!
64 //! // Encode refund as raw bytes.
65 //! let mut bytes = Vec::new();
66 //! refund.write(&mut bytes).unwrap();
67 //!
68 //! // Decode raw bytes into an refund.
69 //! let refund = Refund::try_from(bytes)?;
70 //! # Ok(())
71 //! # }
72 //! ```
73
74 use bitcoin::blockdata::constants::ChainHash;
75 use bitcoin::network::constants::Network;
76 use bitcoin::secp256k1::{PublicKey, Secp256k1, self};
77 use core::convert::TryFrom;
78 use core::ops::Deref;
79 use core::str::FromStr;
80 use core::time::Duration;
81 use crate::chain::keysinterface::EntropySource;
82 use crate::io;
83 use crate::blinded_path::BlindedPath;
84 use crate::ln::PaymentHash;
85 use crate::ln::features::InvoiceRequestFeatures;
86 use crate::ln::inbound_payment::{ExpandedKey, IV_LEN, Nonce};
87 use crate::ln::msgs::{DecodeError, MAX_VALUE_MSAT};
88 use crate::offers::invoice::{BlindedPayInfo, DerivedSigningPubkey, ExplicitSigningPubkey, InvoiceBuilder};
89 use crate::offers::invoice_request::{InvoiceRequestTlvStream, InvoiceRequestTlvStreamRef};
90 use crate::offers::offer::{OfferTlvStream, OfferTlvStreamRef};
91 use crate::offers::parse::{Bech32Encode, ParseError, ParsedMessage, SemanticError};
92 use crate::offers::payer::{PayerContents, PayerTlvStream, PayerTlvStreamRef};
93 use crate::offers::signer::{Metadata, MetadataMaterial, self};
94 use crate::util::ser::{SeekReadable, WithoutLength, Writeable, Writer};
95 use crate::util::string::PrintableString;
96
97 use crate::prelude::*;
98
99 #[cfg(feature = "std")]
100 use std::time::SystemTime;
101
102 pub(super) const IV_BYTES: &[u8; IV_LEN] = b"LDK Refund ~~~~~";
103
104 /// Builds a [`Refund`] for the "offer for money" flow.
105 ///
106 /// See [module-level documentation] for usage.
107 ///
108 /// [module-level documentation]: self
109 pub struct RefundBuilder<'a, T: secp256k1::Signing> {
110         refund: RefundContents,
111         secp_ctx: Option<&'a Secp256k1<T>>,
112 }
113
114 impl<'a> RefundBuilder<'a, secp256k1::SignOnly> {
115         /// Creates a new builder for a refund using the [`Refund::payer_id`] for the public node id to
116         /// send to if no [`Refund::paths`] are set. Otherwise, it may be a transient pubkey.
117         ///
118         /// Additionally, sets the required [`Refund::description`], [`Refund::metadata`], and
119         /// [`Refund::amount_msats`].
120         pub fn new(
121                 description: String, metadata: Vec<u8>, payer_id: PublicKey, amount_msats: u64
122         ) -> Result<Self, SemanticError> {
123                 if amount_msats > MAX_VALUE_MSAT {
124                         return Err(SemanticError::InvalidAmount);
125                 }
126
127                 let metadata = Metadata::Bytes(metadata);
128                 Ok(Self {
129                         refund: RefundContents {
130                                 payer: PayerContents(metadata), description, absolute_expiry: None, issuer: None,
131                                 paths: None, chain: None, amount_msats, features: InvoiceRequestFeatures::empty(),
132                                 quantity: None, payer_id, payer_note: None,
133                         },
134                         secp_ctx: None,
135                 })
136         }
137 }
138
139 impl<'a, T: secp256k1::Signing> RefundBuilder<'a, T> {
140         /// Similar to [`RefundBuilder::new`] except, if [`RefundBuilder::path`] is called, the payer id
141         /// is derived from the given [`ExpandedKey`] and nonce. This provides sender privacy by using a
142         /// different payer id for each refund, assuming a different nonce is used.  Otherwise, the
143         /// provided `node_id` is used for the payer id.
144         ///
145         /// Also, sets the metadata when [`RefundBuilder::build`] is called such that it can be used to
146         /// verify that an [`InvoiceRequest`] was produced for the refund given an [`ExpandedKey`].
147         ///
148         /// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
149         /// [`ExpandedKey`]: crate::ln::inbound_payment::ExpandedKey
150         pub fn deriving_payer_id<ES: Deref>(
151                 description: String, node_id: PublicKey, expanded_key: &ExpandedKey, entropy_source: ES,
152                 secp_ctx: &'a Secp256k1<T>, amount_msats: u64
153         ) -> Result<Self, SemanticError> where ES::Target: EntropySource {
154                 if amount_msats > MAX_VALUE_MSAT {
155                         return Err(SemanticError::InvalidAmount);
156                 }
157
158                 let nonce = Nonce::from_entropy_source(entropy_source);
159                 let derivation_material = MetadataMaterial::new(nonce, expanded_key, IV_BYTES);
160                 let metadata = Metadata::DerivedSigningPubkey(derivation_material);
161                 Ok(Self {
162                         refund: RefundContents {
163                                 payer: PayerContents(metadata), description, absolute_expiry: None, issuer: None,
164                                 paths: None, chain: None, amount_msats, features: InvoiceRequestFeatures::empty(),
165                                 quantity: None, payer_id: node_id, payer_note: None,
166                         },
167                         secp_ctx: Some(secp_ctx),
168                 })
169         }
170
171         /// Sets the [`Refund::absolute_expiry`] as seconds since the Unix epoch. Any expiry that has
172         /// already passed is valid and can be checked for using [`Refund::is_expired`].
173         ///
174         /// Successive calls to this method will override the previous setting.
175         pub fn absolute_expiry(mut self, absolute_expiry: Duration) -> Self {
176                 self.refund.absolute_expiry = Some(absolute_expiry);
177                 self
178         }
179
180         /// Sets the [`Refund::issuer`].
181         ///
182         /// Successive calls to this method will override the previous setting.
183         pub fn issuer(mut self, issuer: String) -> Self {
184                 self.refund.issuer = Some(issuer);
185                 self
186         }
187
188         /// Adds a blinded path to [`Refund::paths`]. Must include at least one path if only connected
189         /// by private channels or if [`Refund::payer_id`] is not a public node id.
190         ///
191         /// Successive calls to this method will add another blinded path. Caller is responsible for not
192         /// adding duplicate paths.
193         pub fn path(mut self, path: BlindedPath) -> Self {
194                 self.refund.paths.get_or_insert_with(Vec::new).push(path);
195                 self
196         }
197
198         /// Sets the [`Refund::chain`] of the given [`Network`] for paying an invoice. If not
199         /// called, [`Network::Bitcoin`] is assumed.
200         ///
201         /// Successive calls to this method will override the previous setting.
202         pub fn chain(mut self, network: Network) -> Self {
203                 self.refund.chain = Some(ChainHash::using_genesis_block(network));
204                 self
205         }
206
207         /// Sets [`Refund::quantity`] of items. This is purely for informational purposes. It is useful
208         /// when the refund pertains to an [`Invoice`] that paid for more than one item from an
209         /// [`Offer`] as specified by [`InvoiceRequest::quantity`].
210         ///
211         /// Successive calls to this method will override the previous setting.
212         ///
213         /// [`Invoice`]: crate::offers::invoice::Invoice
214         /// [`InvoiceRequest::quantity`]: crate::offers::invoice_request::InvoiceRequest::quantity
215         /// [`Offer`]: crate::offers::offer::Offer
216         pub fn quantity(mut self, quantity: u64) -> Self {
217                 self.refund.quantity = Some(quantity);
218                 self
219         }
220
221         /// Sets the [`Refund::payer_note`].
222         ///
223         /// Successive calls to this method will override the previous setting.
224         pub fn payer_note(mut self, payer_note: String) -> Self {
225                 self.refund.payer_note = Some(payer_note);
226                 self
227         }
228
229         /// Builds a [`Refund`] after checking for valid semantics.
230         pub fn build(mut self) -> Result<Refund, SemanticError> {
231                 if self.refund.chain() == self.refund.implied_chain() {
232                         self.refund.chain = None;
233                 }
234
235                 // Create the metadata for stateless verification of an Invoice.
236                 if self.refund.payer.0.has_derivation_material() {
237                         let mut metadata = core::mem::take(&mut self.refund.payer.0);
238
239                         if self.refund.paths.is_none() {
240                                 metadata = metadata.without_keys();
241                         }
242
243                         let mut tlv_stream = self.refund.as_tlv_stream();
244                         tlv_stream.0.metadata = None;
245                         if metadata.derives_keys() {
246                                 tlv_stream.2.payer_id = None;
247                         }
248
249                         let (derived_metadata, keys) = metadata.derive_from(tlv_stream, self.secp_ctx);
250                         metadata = derived_metadata;
251                         if let Some(keys) = keys {
252                                 self.refund.payer_id = keys.public_key();
253                         }
254
255                         self.refund.payer.0 = metadata;
256                 }
257
258                 let mut bytes = Vec::new();
259                 self.refund.write(&mut bytes).unwrap();
260
261                 Ok(Refund { bytes, contents: self.refund })
262         }
263 }
264
265 #[cfg(test)]
266 impl<'a, T: secp256k1::Signing> RefundBuilder<'a, T> {
267         fn features_unchecked(mut self, features: InvoiceRequestFeatures) -> Self {
268                 self.refund.features = features;
269                 self
270         }
271 }
272
273 /// A `Refund` is a request to send an [`Invoice`] without a preceding [`Offer`].
274 ///
275 /// Typically, after an invoice is paid, the recipient may publish a refund allowing the sender to
276 /// recoup their funds. A refund may be used more generally as an "offer for money", such as with a
277 /// bitcoin ATM.
278 ///
279 /// [`Invoice`]: crate::offers::invoice::Invoice
280 /// [`Offer`]: crate::offers::offer::Offer
281 #[derive(Clone, Debug)]
282 #[cfg_attr(test, derive(PartialEq))]
283 pub struct Refund {
284         pub(super) bytes: Vec<u8>,
285         pub(super) contents: RefundContents,
286 }
287
288 /// The contents of a [`Refund`], which may be shared with an [`Invoice`].
289 ///
290 /// [`Invoice`]: crate::offers::invoice::Invoice
291 #[derive(Clone, Debug)]
292 #[cfg_attr(test, derive(PartialEq))]
293 pub(super) struct RefundContents {
294         payer: PayerContents,
295         // offer fields
296         description: String,
297         absolute_expiry: Option<Duration>,
298         issuer: Option<String>,
299         paths: Option<Vec<BlindedPath>>,
300         // invoice_request fields
301         chain: Option<ChainHash>,
302         amount_msats: u64,
303         features: InvoiceRequestFeatures,
304         quantity: Option<u64>,
305         payer_id: PublicKey,
306         payer_note: Option<String>,
307 }
308
309 impl Refund {
310         /// A complete description of the purpose of the refund. Intended to be displayed to the user
311         /// but with the caveat that it has not been verified in any way.
312         pub fn description(&self) -> PrintableString {
313                 self.contents.description()
314         }
315
316         /// Duration since the Unix epoch when an invoice should no longer be sent.
317         ///
318         /// If `None`, the refund does not expire.
319         pub fn absolute_expiry(&self) -> Option<Duration> {
320                 self.contents.absolute_expiry
321         }
322
323         /// Whether the refund has expired.
324         #[cfg(feature = "std")]
325         pub fn is_expired(&self) -> bool {
326                 self.contents.is_expired()
327         }
328
329         /// The issuer of the refund, possibly beginning with `user@domain` or `domain`. Intended to be
330         /// displayed to the user but with the caveat that it has not been verified in any way.
331         pub fn issuer(&self) -> Option<PrintableString> {
332                 self.contents.issuer.as_ref().map(|issuer| PrintableString(issuer.as_str()))
333         }
334
335         /// Paths to the sender originating from publicly reachable nodes. Blinded paths provide sender
336         /// privacy by obfuscating its node id.
337         pub fn paths(&self) -> &[BlindedPath] {
338                 self.contents.paths.as_ref().map(|paths| paths.as_slice()).unwrap_or(&[])
339         }
340
341         /// An unpredictable series of bytes, typically containing information about the derivation of
342         /// [`payer_id`].
343         ///
344         /// [`payer_id`]: Self::payer_id
345         pub fn metadata(&self) -> &[u8] {
346                 self.contents.metadata()
347         }
348
349         /// A chain that the refund is valid for.
350         pub fn chain(&self) -> ChainHash {
351                 self.contents.chain.unwrap_or_else(|| self.contents.implied_chain())
352         }
353
354         /// The amount to refund in msats (i.e., the minimum lightning-payable unit for [`chain`]).
355         ///
356         /// [`chain`]: Self::chain
357         pub fn amount_msats(&self) -> u64 {
358                 self.contents.amount_msats
359         }
360
361         /// Features pertaining to requesting an invoice.
362         pub fn features(&self) -> &InvoiceRequestFeatures {
363                 &self.contents.features
364         }
365
366         /// The quantity of an item that refund is for.
367         pub fn quantity(&self) -> Option<u64> {
368                 self.contents.quantity
369         }
370
371         /// A public node id to send to in the case where there are no [`paths`]. Otherwise, a possibly
372         /// transient pubkey.
373         ///
374         /// [`paths`]: Self::paths
375         pub fn payer_id(&self) -> PublicKey {
376                 self.contents.payer_id
377         }
378
379         /// Payer provided note to include in the invoice.
380         pub fn payer_note(&self) -> Option<PrintableString> {
381                 self.contents.payer_note.as_ref().map(|payer_note| PrintableString(payer_note.as_str()))
382         }
383
384         /// Creates an [`InvoiceBuilder`] for the refund with the given required fields and using the
385         /// [`Duration`] since [`std::time::SystemTime::UNIX_EPOCH`] as the creation time.
386         ///
387         /// See [`Refund::respond_with_no_std`] for further details where the aforementioned creation
388         /// time is used for the `created_at` parameter.
389         ///
390         /// [`Duration`]: core::time::Duration
391         #[cfg(feature = "std")]
392         pub fn respond_with(
393                 &self, payment_paths: Vec<(BlindedPath, BlindedPayInfo)>, payment_hash: PaymentHash,
394                 signing_pubkey: PublicKey,
395         ) -> Result<InvoiceBuilder<ExplicitSigningPubkey>, SemanticError> {
396                 let created_at = std::time::SystemTime::now()
397                         .duration_since(std::time::SystemTime::UNIX_EPOCH)
398                         .expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH");
399
400                 self.respond_with_no_std(payment_paths, payment_hash, signing_pubkey, created_at)
401         }
402
403         /// Creates an [`InvoiceBuilder`] for the refund with the given required fields.
404         ///
405         /// Unless [`InvoiceBuilder::relative_expiry`] is set, the invoice will expire two hours after
406         /// `created_at`, which is used to set [`Invoice::created_at`]. Useful for `no-std` builds where
407         /// [`std::time::SystemTime`] is not available.
408         ///
409         /// The caller is expected to remember the preimage of `payment_hash` in order to
410         /// claim a payment for the invoice.
411         ///
412         /// The `signing_pubkey` is required to sign the invoice since refunds are not in response to an
413         /// offer, which does have a `signing_pubkey`.
414         ///
415         /// The `payment_paths` parameter is useful for maintaining the payment recipient's privacy. It
416         /// must contain one or more elements ordered from most-preferred to least-preferred, if there's
417         /// a preference. Note, however, that any privacy is lost if a public node id is used for
418         /// `signing_pubkey`.
419         ///
420         /// Errors if the request contains unknown required features.
421         ///
422         /// [`Invoice::created_at`]: crate::offers::invoice::Invoice::created_at
423         pub fn respond_with_no_std(
424                 &self, payment_paths: Vec<(BlindedPath, BlindedPayInfo)>, payment_hash: PaymentHash,
425                 signing_pubkey: PublicKey, created_at: Duration
426         ) -> Result<InvoiceBuilder<ExplicitSigningPubkey>, SemanticError> {
427                 if self.features().requires_unknown_bits() {
428                         return Err(SemanticError::UnknownRequiredFeatures);
429                 }
430
431                 InvoiceBuilder::for_refund(self, payment_paths, created_at, payment_hash, signing_pubkey)
432         }
433
434         /// Creates an [`InvoiceBuilder`] for the refund using the given required fields and that uses
435         /// derived signing keys to sign the [`Invoice`].
436         ///
437         /// See [`Refund::respond_with`] for further details.
438         ///
439         /// [`Invoice`]: crate::offers::invoice::Invoice
440         #[cfg(feature = "std")]
441         pub fn respond_using_derived_keys<ES: Deref>(
442                 &self, payment_paths: Vec<(BlindedPath, BlindedPayInfo)>, payment_hash: PaymentHash,
443                 expanded_key: &ExpandedKey, entropy_source: ES
444         ) -> Result<InvoiceBuilder<DerivedSigningPubkey>, SemanticError>
445         where
446                 ES::Target: EntropySource,
447         {
448                 let created_at = std::time::SystemTime::now()
449                         .duration_since(std::time::SystemTime::UNIX_EPOCH)
450                         .expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH");
451
452                 self.respond_using_derived_keys_no_std(
453                         payment_paths, payment_hash, created_at, expanded_key, entropy_source
454                 )
455         }
456
457         /// Creates an [`InvoiceBuilder`] for the refund using the given required fields and that uses
458         /// derived signing keys to sign the [`Invoice`].
459         ///
460         /// See [`Refund::respond_with_no_std`] for further details.
461         ///
462         /// [`Invoice`]: crate::offers::invoice::Invoice
463         pub fn respond_using_derived_keys_no_std<ES: Deref>(
464                 &self, payment_paths: Vec<(BlindedPath, BlindedPayInfo)>, payment_hash: PaymentHash,
465                 created_at: core::time::Duration, expanded_key: &ExpandedKey, entropy_source: ES
466         ) -> Result<InvoiceBuilder<DerivedSigningPubkey>, SemanticError>
467         where
468                 ES::Target: EntropySource,
469         {
470                 if self.features().requires_unknown_bits() {
471                         return Err(SemanticError::UnknownRequiredFeatures);
472                 }
473
474                 let nonce = Nonce::from_entropy_source(entropy_source);
475                 let keys = signer::derive_keys(nonce, expanded_key);
476                 InvoiceBuilder::for_refund_using_keys(self, payment_paths, created_at, payment_hash, keys)
477         }
478
479         #[cfg(test)]
480         fn as_tlv_stream(&self) -> RefundTlvStreamRef {
481                 self.contents.as_tlv_stream()
482         }
483 }
484
485 impl AsRef<[u8]> for Refund {
486         fn as_ref(&self) -> &[u8] {
487                 &self.bytes
488         }
489 }
490
491 impl RefundContents {
492         pub fn description(&self) -> PrintableString {
493                 PrintableString(&self.description)
494         }
495
496         #[cfg(feature = "std")]
497         pub(super) fn is_expired(&self) -> bool {
498                 match self.absolute_expiry {
499                         Some(seconds_from_epoch) => match SystemTime::UNIX_EPOCH.elapsed() {
500                                 Ok(elapsed) => elapsed > seconds_from_epoch,
501                                 Err(_) => false,
502                         },
503                         None => false,
504                 }
505         }
506
507         pub(super) fn metadata(&self) -> &[u8] {
508                 self.payer.0.as_bytes().map(|bytes| bytes.as_slice()).unwrap_or(&[])
509         }
510
511         pub(super) fn chain(&self) -> ChainHash {
512                 self.chain.unwrap_or_else(|| self.implied_chain())
513         }
514
515         pub fn implied_chain(&self) -> ChainHash {
516                 ChainHash::using_genesis_block(Network::Bitcoin)
517         }
518
519         pub(super) fn derives_keys(&self) -> bool {
520                 self.payer.0.derives_keys()
521         }
522
523         pub(super) fn payer_id(&self) -> PublicKey {
524                 self.payer_id
525         }
526
527         pub(super) fn as_tlv_stream(&self) -> RefundTlvStreamRef {
528                 let payer = PayerTlvStreamRef {
529                         metadata: self.payer.0.as_bytes(),
530                 };
531
532                 let offer = OfferTlvStreamRef {
533                         chains: None,
534                         metadata: None,
535                         currency: None,
536                         amount: None,
537                         description: Some(&self.description),
538                         features: None,
539                         absolute_expiry: self.absolute_expiry.map(|duration| duration.as_secs()),
540                         paths: self.paths.as_ref(),
541                         issuer: self.issuer.as_ref(),
542                         quantity_max: None,
543                         node_id: None,
544                 };
545
546                 let features = {
547                         if self.features == InvoiceRequestFeatures::empty() { None }
548                         else { Some(&self.features) }
549                 };
550
551                 let invoice_request = InvoiceRequestTlvStreamRef {
552                         chain: self.chain.as_ref(),
553                         amount: Some(self.amount_msats),
554                         features,
555                         quantity: self.quantity,
556                         payer_id: Some(&self.payer_id),
557                         payer_note: self.payer_note.as_ref(),
558                 };
559
560                 (payer, offer, invoice_request)
561         }
562 }
563
564 impl Writeable for Refund {
565         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
566                 WithoutLength(&self.bytes).write(writer)
567         }
568 }
569
570 impl Writeable for RefundContents {
571         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
572                 self.as_tlv_stream().write(writer)
573         }
574 }
575
576 type RefundTlvStream = (PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream);
577
578 type RefundTlvStreamRef<'a> = (
579         PayerTlvStreamRef<'a>,
580         OfferTlvStreamRef<'a>,
581         InvoiceRequestTlvStreamRef<'a>,
582 );
583
584 impl SeekReadable for RefundTlvStream {
585         fn read<R: io::Read + io::Seek>(r: &mut R) -> Result<Self, DecodeError> {
586                 let payer = SeekReadable::read(r)?;
587                 let offer = SeekReadable::read(r)?;
588                 let invoice_request = SeekReadable::read(r)?;
589
590                 Ok((payer, offer, invoice_request))
591         }
592 }
593
594 impl Bech32Encode for Refund {
595         const BECH32_HRP: &'static str = "lnr";
596 }
597
598 impl FromStr for Refund {
599         type Err = ParseError;
600
601         fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err> {
602                 Refund::from_bech32_str(s)
603         }
604 }
605
606 impl TryFrom<Vec<u8>> for Refund {
607         type Error = ParseError;
608
609         fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
610                 let refund = ParsedMessage::<RefundTlvStream>::try_from(bytes)?;
611                 let ParsedMessage { bytes, tlv_stream } = refund;
612                 let contents = RefundContents::try_from(tlv_stream)?;
613
614                 Ok(Refund { bytes, contents })
615         }
616 }
617
618 impl TryFrom<RefundTlvStream> for RefundContents {
619         type Error = SemanticError;
620
621         fn try_from(tlv_stream: RefundTlvStream) -> Result<Self, Self::Error> {
622                 let (
623                         PayerTlvStream { metadata: payer_metadata },
624                         OfferTlvStream {
625                                 chains, metadata, currency, amount: offer_amount, description,
626                                 features: offer_features, absolute_expiry, paths, issuer, quantity_max, node_id,
627                         },
628                         InvoiceRequestTlvStream { chain, amount, features, quantity, payer_id, payer_note },
629                 ) = tlv_stream;
630
631                 let payer = match payer_metadata {
632                         None => return Err(SemanticError::MissingPayerMetadata),
633                         Some(metadata) => PayerContents(Metadata::Bytes(metadata)),
634                 };
635
636                 if metadata.is_some() {
637                         return Err(SemanticError::UnexpectedMetadata);
638                 }
639
640                 if chains.is_some() {
641                         return Err(SemanticError::UnexpectedChain);
642                 }
643
644                 if currency.is_some() || offer_amount.is_some() {
645                         return Err(SemanticError::UnexpectedAmount);
646                 }
647
648                 let description = match description {
649                         None => return Err(SemanticError::MissingDescription),
650                         Some(description) => description,
651                 };
652
653                 if offer_features.is_some() {
654                         return Err(SemanticError::UnexpectedFeatures);
655                 }
656
657                 let absolute_expiry = absolute_expiry.map(Duration::from_secs);
658
659                 if quantity_max.is_some() {
660                         return Err(SemanticError::UnexpectedQuantity);
661                 }
662
663                 if node_id.is_some() {
664                         return Err(SemanticError::UnexpectedSigningPubkey);
665                 }
666
667                 let amount_msats = match amount {
668                         None => return Err(SemanticError::MissingAmount),
669                         Some(amount_msats) if amount_msats > MAX_VALUE_MSAT => {
670                                 return Err(SemanticError::InvalidAmount);
671                         },
672                         Some(amount_msats) => amount_msats,
673                 };
674
675                 let features = features.unwrap_or_else(InvoiceRequestFeatures::empty);
676
677                 let payer_id = match payer_id {
678                         None => return Err(SemanticError::MissingPayerId),
679                         Some(payer_id) => payer_id,
680                 };
681
682                 Ok(RefundContents {
683                         payer, description, absolute_expiry, issuer, paths, chain, amount_msats, features,
684                         quantity, payer_id, payer_note,
685                 })
686         }
687 }
688
689 impl core::fmt::Display for Refund {
690         fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
691                 self.fmt_bech32_str(f)
692         }
693 }
694
695 #[cfg(test)]
696 mod tests {
697         use super::{Refund, RefundBuilder, RefundTlvStreamRef};
698
699         use bitcoin::blockdata::constants::ChainHash;
700         use bitcoin::network::constants::Network;
701         use bitcoin::secp256k1::{KeyPair, Secp256k1, SecretKey};
702         use core::convert::TryFrom;
703         use core::time::Duration;
704         use crate::blinded_path::{BlindedHop, BlindedPath};
705         use crate::chain::keysinterface::KeyMaterial;
706         use crate::ln::features::{InvoiceRequestFeatures, OfferFeatures};
707         use crate::ln::inbound_payment::ExpandedKey;
708         use crate::ln::msgs::{DecodeError, MAX_VALUE_MSAT};
709         use crate::offers::invoice_request::InvoiceRequestTlvStreamRef;
710         use crate::offers::offer::OfferTlvStreamRef;
711         use crate::offers::parse::{ParseError, SemanticError};
712         use crate::offers::payer::PayerTlvStreamRef;
713         use crate::offers::test_utils::*;
714         use crate::util::ser::{BigSize, Writeable};
715         use crate::util::string::PrintableString;
716
717         trait ToBytes {
718                 fn to_bytes(&self) -> Vec<u8>;
719         }
720
721         impl<'a> ToBytes for RefundTlvStreamRef<'a> {
722                 fn to_bytes(&self) -> Vec<u8> {
723                         let mut buffer = Vec::new();
724                         self.write(&mut buffer).unwrap();
725                         buffer
726                 }
727         }
728
729         #[test]
730         fn builds_refund_with_defaults() {
731                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
732                         .build().unwrap();
733
734                 let mut buffer = Vec::new();
735                 refund.write(&mut buffer).unwrap();
736
737                 assert_eq!(refund.bytes, buffer.as_slice());
738                 assert_eq!(refund.metadata(), &[1; 32]);
739                 assert_eq!(refund.description(), PrintableString("foo"));
740                 assert_eq!(refund.absolute_expiry(), None);
741                 #[cfg(feature = "std")]
742                 assert!(!refund.is_expired());
743                 assert_eq!(refund.paths(), &[]);
744                 assert_eq!(refund.issuer(), None);
745                 assert_eq!(refund.chain(), ChainHash::using_genesis_block(Network::Bitcoin));
746                 assert_eq!(refund.amount_msats(), 1000);
747                 assert_eq!(refund.features(), &InvoiceRequestFeatures::empty());
748                 assert_eq!(refund.payer_id(), payer_pubkey());
749                 assert_eq!(refund.payer_note(), None);
750
751                 assert_eq!(
752                         refund.as_tlv_stream(),
753                         (
754                                 PayerTlvStreamRef { metadata: Some(&vec![1; 32]) },
755                                 OfferTlvStreamRef {
756                                         chains: None,
757                                         metadata: None,
758                                         currency: None,
759                                         amount: None,
760                                         description: Some(&String::from("foo")),
761                                         features: None,
762                                         absolute_expiry: None,
763                                         paths: None,
764                                         issuer: None,
765                                         quantity_max: None,
766                                         node_id: None,
767                                 },
768                                 InvoiceRequestTlvStreamRef {
769                                         chain: None,
770                                         amount: Some(1000),
771                                         features: None,
772                                         quantity: None,
773                                         payer_id: Some(&payer_pubkey()),
774                                         payer_note: None,
775                                 },
776                         ),
777                 );
778
779                 if let Err(e) = Refund::try_from(buffer) {
780                         panic!("error parsing refund: {:?}", e);
781                 }
782         }
783
784         #[test]
785         fn fails_building_refund_with_invalid_amount() {
786                 match RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), MAX_VALUE_MSAT + 1) {
787                         Ok(_) => panic!("expected error"),
788                         Err(e) => assert_eq!(e, SemanticError::InvalidAmount),
789                 }
790         }
791
792         #[test]
793         fn builds_refund_with_metadata_derived() {
794                 let desc = "foo".to_string();
795                 let node_id = payer_pubkey();
796                 let expanded_key = ExpandedKey::new(&KeyMaterial([42; 32]));
797                 let entropy = FixedEntropy {};
798                 let secp_ctx = Secp256k1::new();
799
800                 let refund = RefundBuilder
801                         ::deriving_payer_id(desc, node_id, &expanded_key, &entropy, &secp_ctx, 1000)
802                         .unwrap()
803                         .build().unwrap();
804                 assert_eq!(refund.payer_id(), node_id);
805
806                 // Fails verification with altered fields
807                 let invoice = refund
808                         .respond_with_no_std(payment_paths(), payment_hash(), recipient_pubkey(), now())
809                         .unwrap()
810                         .build().unwrap()
811                         .sign(recipient_sign).unwrap();
812                 assert!(invoice.verify(&expanded_key, &secp_ctx));
813
814                 let mut tlv_stream = refund.as_tlv_stream();
815                 tlv_stream.2.amount = Some(2000);
816
817                 let mut encoded_refund = Vec::new();
818                 tlv_stream.write(&mut encoded_refund).unwrap();
819
820                 let invoice = Refund::try_from(encoded_refund).unwrap()
821                         .respond_with_no_std(payment_paths(), payment_hash(), recipient_pubkey(), now())
822                         .unwrap()
823                         .build().unwrap()
824                         .sign(recipient_sign).unwrap();
825                 assert!(!invoice.verify(&expanded_key, &secp_ctx));
826
827                 // Fails verification with altered metadata
828                 let mut tlv_stream = refund.as_tlv_stream();
829                 let metadata = tlv_stream.0.metadata.unwrap().iter().copied().rev().collect();
830                 tlv_stream.0.metadata = Some(&metadata);
831
832                 let mut encoded_refund = Vec::new();
833                 tlv_stream.write(&mut encoded_refund).unwrap();
834
835                 let invoice = Refund::try_from(encoded_refund).unwrap()
836                         .respond_with_no_std(payment_paths(), payment_hash(), recipient_pubkey(), now())
837                         .unwrap()
838                         .build().unwrap()
839                         .sign(recipient_sign).unwrap();
840                 assert!(!invoice.verify(&expanded_key, &secp_ctx));
841         }
842
843         #[test]
844         fn builds_refund_with_derived_payer_id() {
845                 let desc = "foo".to_string();
846                 let node_id = payer_pubkey();
847                 let expanded_key = ExpandedKey::new(&KeyMaterial([42; 32]));
848                 let entropy = FixedEntropy {};
849                 let secp_ctx = Secp256k1::new();
850
851                 let blinded_path = BlindedPath {
852                         introduction_node_id: pubkey(40),
853                         blinding_point: pubkey(41),
854                         blinded_hops: vec![
855                                 BlindedHop { blinded_node_id: pubkey(43), encrypted_payload: vec![0; 43] },
856                                 BlindedHop { blinded_node_id: node_id, encrypted_payload: vec![0; 44] },
857                         ],
858                 };
859
860                 let refund = RefundBuilder
861                         ::deriving_payer_id(desc, node_id, &expanded_key, &entropy, &secp_ctx, 1000)
862                         .unwrap()
863                         .path(blinded_path)
864                         .build().unwrap();
865                 assert_ne!(refund.payer_id(), node_id);
866
867                 let invoice = refund
868                         .respond_with_no_std(payment_paths(), payment_hash(), recipient_pubkey(), now())
869                         .unwrap()
870                         .build().unwrap()
871                         .sign(recipient_sign).unwrap();
872                 assert!(invoice.verify(&expanded_key, &secp_ctx));
873
874                 // Fails verification with altered fields
875                 let mut tlv_stream = refund.as_tlv_stream();
876                 tlv_stream.2.amount = Some(2000);
877
878                 let mut encoded_refund = Vec::new();
879                 tlv_stream.write(&mut encoded_refund).unwrap();
880
881                 let invoice = Refund::try_from(encoded_refund).unwrap()
882                         .respond_with_no_std(payment_paths(), payment_hash(), recipient_pubkey(), now())
883                         .unwrap()
884                         .build().unwrap()
885                         .sign(recipient_sign).unwrap();
886                 assert!(!invoice.verify(&expanded_key, &secp_ctx));
887
888                 // Fails verification with altered payer_id
889                 let mut tlv_stream = refund.as_tlv_stream();
890                 let payer_id = pubkey(1);
891                 tlv_stream.2.payer_id = Some(&payer_id);
892
893                 let mut encoded_refund = Vec::new();
894                 tlv_stream.write(&mut encoded_refund).unwrap();
895
896                 let invoice = Refund::try_from(encoded_refund).unwrap()
897                         .respond_with_no_std(payment_paths(), payment_hash(), recipient_pubkey(), now())
898                         .unwrap()
899                         .build().unwrap()
900                         .sign(recipient_sign).unwrap();
901                 assert!(!invoice.verify(&expanded_key, &secp_ctx));
902         }
903
904         #[test]
905         fn builds_refund_with_absolute_expiry() {
906                 let future_expiry = Duration::from_secs(u64::max_value());
907                 let past_expiry = Duration::from_secs(0);
908
909                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
910                         .absolute_expiry(future_expiry)
911                         .build()
912                         .unwrap();
913                 let (_, tlv_stream, _) = refund.as_tlv_stream();
914                 #[cfg(feature = "std")]
915                 assert!(!refund.is_expired());
916                 assert_eq!(refund.absolute_expiry(), Some(future_expiry));
917                 assert_eq!(tlv_stream.absolute_expiry, Some(future_expiry.as_secs()));
918
919                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
920                         .absolute_expiry(future_expiry)
921                         .absolute_expiry(past_expiry)
922                         .build()
923                         .unwrap();
924                 let (_, tlv_stream, _) = refund.as_tlv_stream();
925                 #[cfg(feature = "std")]
926                 assert!(refund.is_expired());
927                 assert_eq!(refund.absolute_expiry(), Some(past_expiry));
928                 assert_eq!(tlv_stream.absolute_expiry, Some(past_expiry.as_secs()));
929         }
930
931         #[test]
932         fn builds_refund_with_paths() {
933                 let paths = vec![
934                         BlindedPath {
935                                 introduction_node_id: pubkey(40),
936                                 blinding_point: pubkey(41),
937                                 blinded_hops: vec![
938                                         BlindedHop { blinded_node_id: pubkey(43), encrypted_payload: vec![0; 43] },
939                                         BlindedHop { blinded_node_id: pubkey(44), encrypted_payload: vec![0; 44] },
940                                 ],
941                         },
942                         BlindedPath {
943                                 introduction_node_id: pubkey(40),
944                                 blinding_point: pubkey(41),
945                                 blinded_hops: vec![
946                                         BlindedHop { blinded_node_id: pubkey(45), encrypted_payload: vec![0; 45] },
947                                         BlindedHop { blinded_node_id: pubkey(46), encrypted_payload: vec![0; 46] },
948                                 ],
949                         },
950                 ];
951
952                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
953                         .path(paths[0].clone())
954                         .path(paths[1].clone())
955                         .build()
956                         .unwrap();
957                 let (_, offer_tlv_stream, invoice_request_tlv_stream) = refund.as_tlv_stream();
958                 assert_eq!(refund.paths(), paths.as_slice());
959                 assert_eq!(refund.payer_id(), pubkey(42));
960                 assert_ne!(pubkey(42), pubkey(44));
961                 assert_eq!(offer_tlv_stream.paths, Some(&paths));
962                 assert_eq!(invoice_request_tlv_stream.payer_id, Some(&pubkey(42)));
963         }
964
965         #[test]
966         fn builds_refund_with_issuer() {
967                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
968                         .issuer("bar".into())
969                         .build()
970                         .unwrap();
971                 let (_, tlv_stream, _) = refund.as_tlv_stream();
972                 assert_eq!(refund.issuer(), Some(PrintableString("bar")));
973                 assert_eq!(tlv_stream.issuer, Some(&String::from("bar")));
974
975                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
976                         .issuer("bar".into())
977                         .issuer("baz".into())
978                         .build()
979                         .unwrap();
980                 let (_, tlv_stream, _) = refund.as_tlv_stream();
981                 assert_eq!(refund.issuer(), Some(PrintableString("baz")));
982                 assert_eq!(tlv_stream.issuer, Some(&String::from("baz")));
983         }
984
985         #[test]
986         fn builds_refund_with_chain() {
987                 let mainnet = ChainHash::using_genesis_block(Network::Bitcoin);
988                 let testnet = ChainHash::using_genesis_block(Network::Testnet);
989
990                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
991                         .chain(Network::Bitcoin)
992                         .build().unwrap();
993                 let (_, _, tlv_stream) = refund.as_tlv_stream();
994                 assert_eq!(refund.chain(), mainnet);
995                 assert_eq!(tlv_stream.chain, None);
996
997                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
998                         .chain(Network::Testnet)
999                         .build().unwrap();
1000                 let (_, _, tlv_stream) = refund.as_tlv_stream();
1001                 assert_eq!(refund.chain(), testnet);
1002                 assert_eq!(tlv_stream.chain, Some(&testnet));
1003
1004                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1005                         .chain(Network::Regtest)
1006                         .chain(Network::Testnet)
1007                         .build().unwrap();
1008                 let (_, _, tlv_stream) = refund.as_tlv_stream();
1009                 assert_eq!(refund.chain(), testnet);
1010                 assert_eq!(tlv_stream.chain, Some(&testnet));
1011         }
1012
1013         #[test]
1014         fn builds_refund_with_quantity() {
1015                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1016                         .quantity(10)
1017                         .build().unwrap();
1018                 let (_, _, tlv_stream) = refund.as_tlv_stream();
1019                 assert_eq!(refund.quantity(), Some(10));
1020                 assert_eq!(tlv_stream.quantity, Some(10));
1021
1022                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1023                         .quantity(10)
1024                         .quantity(1)
1025                         .build().unwrap();
1026                 let (_, _, tlv_stream) = refund.as_tlv_stream();
1027                 assert_eq!(refund.quantity(), Some(1));
1028                 assert_eq!(tlv_stream.quantity, Some(1));
1029         }
1030
1031         #[test]
1032         fn builds_refund_with_payer_note() {
1033                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1034                         .payer_note("bar".into())
1035                         .build().unwrap();
1036                 let (_, _, tlv_stream) = refund.as_tlv_stream();
1037                 assert_eq!(refund.payer_note(), Some(PrintableString("bar")));
1038                 assert_eq!(tlv_stream.payer_note, Some(&String::from("bar")));
1039
1040                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1041                         .payer_note("bar".into())
1042                         .payer_note("baz".into())
1043                         .build().unwrap();
1044                 let (_, _, tlv_stream) = refund.as_tlv_stream();
1045                 assert_eq!(refund.payer_note(), Some(PrintableString("baz")));
1046                 assert_eq!(tlv_stream.payer_note, Some(&String::from("baz")));
1047         }
1048
1049         #[test]
1050         fn fails_responding_with_unknown_required_features() {
1051                 match RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1052                         .features_unchecked(InvoiceRequestFeatures::unknown())
1053                         .build().unwrap()
1054                         .respond_with_no_std(payment_paths(), payment_hash(), recipient_pubkey(), now())
1055                 {
1056                         Ok(_) => panic!("expected error"),
1057                         Err(e) => assert_eq!(e, SemanticError::UnknownRequiredFeatures),
1058                 }
1059         }
1060
1061         #[test]
1062         fn parses_refund_with_metadata() {
1063                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1064                         .build().unwrap();
1065                 if let Err(e) = refund.to_string().parse::<Refund>() {
1066                         panic!("error parsing refund: {:?}", e);
1067                 }
1068
1069                 let mut tlv_stream = refund.as_tlv_stream();
1070                 tlv_stream.0.metadata = None;
1071
1072                 match Refund::try_from(tlv_stream.to_bytes()) {
1073                         Ok(_) => panic!("expected error"),
1074                         Err(e) => {
1075                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingPayerMetadata));
1076                         },
1077                 }
1078         }
1079
1080         #[test]
1081         fn parses_refund_with_description() {
1082                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1083                         .build().unwrap();
1084                 if let Err(e) = refund.to_string().parse::<Refund>() {
1085                         panic!("error parsing refund: {:?}", e);
1086                 }
1087
1088                 let mut tlv_stream = refund.as_tlv_stream();
1089                 tlv_stream.1.description = None;
1090
1091                 match Refund::try_from(tlv_stream.to_bytes()) {
1092                         Ok(_) => panic!("expected error"),
1093                         Err(e) => {
1094                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingDescription));
1095                         },
1096                 }
1097         }
1098
1099         #[test]
1100         fn parses_refund_with_amount() {
1101                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1102                         .build().unwrap();
1103                 if let Err(e) = refund.to_string().parse::<Refund>() {
1104                         panic!("error parsing refund: {:?}", e);
1105                 }
1106
1107                 let mut tlv_stream = refund.as_tlv_stream();
1108                 tlv_stream.2.amount = None;
1109
1110                 match Refund::try_from(tlv_stream.to_bytes()) {
1111                         Ok(_) => panic!("expected error"),
1112                         Err(e) => {
1113                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingAmount));
1114                         },
1115                 }
1116
1117                 let mut tlv_stream = refund.as_tlv_stream();
1118                 tlv_stream.2.amount = Some(MAX_VALUE_MSAT + 1);
1119
1120                 match Refund::try_from(tlv_stream.to_bytes()) {
1121                         Ok(_) => panic!("expected error"),
1122                         Err(e) => {
1123                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InvalidAmount));
1124                         },
1125                 }
1126         }
1127
1128         #[test]
1129         fn parses_refund_with_payer_id() {
1130                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1131                         .build().unwrap();
1132                 if let Err(e) = refund.to_string().parse::<Refund>() {
1133                         panic!("error parsing refund: {:?}", e);
1134                 }
1135
1136                 let mut tlv_stream = refund.as_tlv_stream();
1137                 tlv_stream.2.payer_id = None;
1138
1139                 match Refund::try_from(tlv_stream.to_bytes()) {
1140                         Ok(_) => panic!("expected error"),
1141                         Err(e) => {
1142                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingPayerId));
1143                         },
1144                 }
1145         }
1146
1147         #[test]
1148         fn parses_refund_with_optional_fields() {
1149                 let past_expiry = Duration::from_secs(0);
1150                 let paths = vec![
1151                         BlindedPath {
1152                                 introduction_node_id: pubkey(40),
1153                                 blinding_point: pubkey(41),
1154                                 blinded_hops: vec![
1155                                         BlindedHop { blinded_node_id: pubkey(43), encrypted_payload: vec![0; 43] },
1156                                         BlindedHop { blinded_node_id: pubkey(44), encrypted_payload: vec![0; 44] },
1157                                 ],
1158                         },
1159                         BlindedPath {
1160                                 introduction_node_id: pubkey(40),
1161                                 blinding_point: pubkey(41),
1162                                 blinded_hops: vec![
1163                                         BlindedHop { blinded_node_id: pubkey(45), encrypted_payload: vec![0; 45] },
1164                                         BlindedHop { blinded_node_id: pubkey(46), encrypted_payload: vec![0; 46] },
1165                                 ],
1166                         },
1167                 ];
1168
1169                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1170                         .absolute_expiry(past_expiry)
1171                         .issuer("bar".into())
1172                         .path(paths[0].clone())
1173                         .path(paths[1].clone())
1174                         .chain(Network::Testnet)
1175                         .features_unchecked(InvoiceRequestFeatures::unknown())
1176                         .quantity(10)
1177                         .payer_note("baz".into())
1178                         .build()
1179                         .unwrap();
1180                 match refund.to_string().parse::<Refund>() {
1181                         Ok(refund) => {
1182                                 assert_eq!(refund.absolute_expiry(), Some(past_expiry));
1183                                 #[cfg(feature = "std")]
1184                                 assert!(refund.is_expired());
1185                                 assert_eq!(refund.paths(), &paths[..]);
1186                                 assert_eq!(refund.issuer(), Some(PrintableString("bar")));
1187                                 assert_eq!(refund.chain(), ChainHash::using_genesis_block(Network::Testnet));
1188                                 assert_eq!(refund.features(), &InvoiceRequestFeatures::unknown());
1189                                 assert_eq!(refund.quantity(), Some(10));
1190                                 assert_eq!(refund.payer_note(), Some(PrintableString("baz")));
1191                         },
1192                         Err(e) => panic!("error parsing refund: {:?}", e),
1193                 }
1194         }
1195
1196         #[test]
1197         fn fails_parsing_refund_with_unexpected_fields() {
1198                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap()
1199                         .build().unwrap();
1200                 if let Err(e) = refund.to_string().parse::<Refund>() {
1201                         panic!("error parsing refund: {:?}", e);
1202                 }
1203
1204                 let metadata = vec![42; 32];
1205                 let mut tlv_stream = refund.as_tlv_stream();
1206                 tlv_stream.1.metadata = Some(&metadata);
1207
1208                 match Refund::try_from(tlv_stream.to_bytes()) {
1209                         Ok(_) => panic!("expected error"),
1210                         Err(e) => {
1211                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedMetadata));
1212                         },
1213                 }
1214
1215                 let chains = vec![ChainHash::using_genesis_block(Network::Testnet)];
1216                 let mut tlv_stream = refund.as_tlv_stream();
1217                 tlv_stream.1.chains = Some(&chains);
1218
1219                 match Refund::try_from(tlv_stream.to_bytes()) {
1220                         Ok(_) => panic!("expected error"),
1221                         Err(e) => {
1222                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedChain));
1223                         },
1224                 }
1225
1226                 let mut tlv_stream = refund.as_tlv_stream();
1227                 tlv_stream.1.currency = Some(&b"USD");
1228                 tlv_stream.1.amount = Some(1000);
1229
1230                 match Refund::try_from(tlv_stream.to_bytes()) {
1231                         Ok(_) => panic!("expected error"),
1232                         Err(e) => {
1233                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedAmount));
1234                         },
1235                 }
1236
1237                 let features = OfferFeatures::unknown();
1238                 let mut tlv_stream = refund.as_tlv_stream();
1239                 tlv_stream.1.features = Some(&features);
1240
1241                 match Refund::try_from(tlv_stream.to_bytes()) {
1242                         Ok(_) => panic!("expected error"),
1243                         Err(e) => {
1244                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedFeatures));
1245                         },
1246                 }
1247
1248                 let mut tlv_stream = refund.as_tlv_stream();
1249                 tlv_stream.1.quantity_max = Some(10);
1250
1251                 match Refund::try_from(tlv_stream.to_bytes()) {
1252                         Ok(_) => panic!("expected error"),
1253                         Err(e) => {
1254                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedQuantity));
1255                         },
1256                 }
1257
1258                 let node_id = payer_pubkey();
1259                 let mut tlv_stream = refund.as_tlv_stream();
1260                 tlv_stream.1.node_id = Some(&node_id);
1261
1262                 match Refund::try_from(tlv_stream.to_bytes()) {
1263                         Ok(_) => panic!("expected error"),
1264                         Err(e) => {
1265                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedSigningPubkey));
1266                         },
1267                 }
1268         }
1269
1270         #[test]
1271         fn fails_parsing_refund_with_extra_tlv_records() {
1272                 let secp_ctx = Secp256k1::new();
1273                 let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1274                 let refund = RefundBuilder::new("foo".into(), vec![1; 32], keys.public_key(), 1000).unwrap()
1275                         .build().unwrap();
1276
1277                 let mut encoded_refund = Vec::new();
1278                 refund.write(&mut encoded_refund).unwrap();
1279                 BigSize(1002).write(&mut encoded_refund).unwrap();
1280                 BigSize(32).write(&mut encoded_refund).unwrap();
1281                 [42u8; 32].write(&mut encoded_refund).unwrap();
1282
1283                 match Refund::try_from(encoded_refund) {
1284                         Ok(_) => panic!("expected error"),
1285                         Err(e) => assert_eq!(e, ParseError::Decode(DecodeError::InvalidValue)),
1286                 }
1287         }
1288 }