_ Git - rust-lightning/blob - lightning/src/offers/invoice_request.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 `invoice_request` messages.
  11 //!
  12 //! An [`InvoiceRequest`] can be built from a parsed [`Offer`] as an "offer to be paid". It is
  13 //! typically constructed by a customer and sent to the merchant who had published the corresponding
  14 //! offer. The recipient of the request responds with an [`Invoice`].
  15 //!
  16 //! For an "offer for money" (e.g., refund, ATM withdrawal), where an offer doesn't exist as a
  17 //! precursor, see [`Refund`].
  18 //!
  19 //! [`Invoice`]: crate::offers::invoice::Invoice
  20 //! [`Refund`]: crate::offers::refund::Refund
  21 //!
  22 //! ```
  23 //! extern crate bitcoin;
  24 //! extern crate lightning;
  25 //!
  26 //! use bitcoin::network::constants::Network;
  27 //! use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, SecretKey};
  28 //! use core::convert::Infallible;
  29 //! use lightning::ln::features::OfferFeatures;
  30 //! use lightning::offers::offer::Offer;
  31 //! use lightning::util::ser::Writeable;
  32 //!
  33 //! # fn parse() -> Result<(), lightning::offers::parse::ParseError> {
  34 //! let secp_ctx = Secp256k1::new();
  35 //! let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32])?);
  36 //! let pubkey = PublicKey::from(keys);
  37 //! let mut buffer = Vec::new();
  38 //!
  39 //! "lno1qcp4256ypq"
  40 //!     .parse::<Offer>()?
  41 //!     .request_invoice(vec![42; 64], pubkey)?
  42 //!     .chain(Network::Testnet)?
  43 //!     .amount_msats(1000)?
  44 //!     .quantity(5)?
  45 //!     .payer_note("foo".to_string())
  46 //!     .build()?
  47 //!     .sign::<_, Infallible>(|digest| Ok(secp_ctx.sign_schnorr_no_aux_rand(digest, &keys)))
  48 //!     .expect("failed verifying signature")
  49 //!     .write(&mut buffer)
  50 //!     .unwrap();
  51 //! # Ok(())
  52 //! # }
  53 //! ```
  54
  55 use bitcoin::blockdata::constants::ChainHash;
  56 use bitcoin::network::constants::Network;
  57 use bitcoin::secp256k1::{Message, PublicKey, Secp256k1, self};
  58 use bitcoin::secp256k1::schnorr::Signature;
  59 use core::convert::TryFrom;
  60 use crate::io;
  61 use crate::ln::PaymentHash;
  62 use crate::ln::features::InvoiceRequestFeatures;
  63 use crate::ln::inbound_payment::ExpandedKey;
  64 use crate::ln::msgs::DecodeError;
  65 use crate::offers::invoice::{BlindedPayInfo, InvoiceBuilder};
  66 use crate::offers::merkle::{SignError, SignatureTlvStream, SignatureTlvStreamRef, TlvStream, self};
  67 use crate::offers::offer::{Offer, OfferContents, OfferTlvStream, OfferTlvStreamRef};
  68 use crate::offers::parse::{ParseError, ParsedMessage, SemanticError};
  69 use crate::offers::payer::{PayerContents, PayerTlvStream, PayerTlvStreamRef};
  70 use crate::onion_message::BlindedPath;
  71 use crate::util::ser::{HighZeroBytesDroppedBigSize, SeekReadable, WithoutLength, Writeable, Writer};
  72 use crate::util::string::PrintableString;
  73
  74 use crate::prelude::*;
  75
  76 const SIGNATURE_TAG: &'static str = concat!("lightning", "invoice_request", "signature");
  77
  78 /// Builds an [`InvoiceRequest`] from an [`Offer`] for the "offer to be paid" flow.
  79 ///
  80 /// See [module-level documentation] for usage.
  81 ///
  82 /// [module-level documentation]: self
  83 pub struct InvoiceRequestBuilder<'a> {
  84         offer: &'a Offer,
  85         invoice_request: InvoiceRequestContents,
  86 }
  87
  88 impl<'a> InvoiceRequestBuilder<'a> {
  89         pub(super) fn new(offer: &'a Offer, metadata: Vec<u8>, payer_id: PublicKey) -> Self {
  90                 Self {
  91                         offer,
  92                         invoice_request: InvoiceRequestContents {
  93                                 inner: InvoiceRequestContentsWithoutPayerId {
  94                                         payer: PayerContents(metadata), offer: offer.contents.clone(), chain: None,
  95                                         amount_msats: None, features: InvoiceRequestFeatures::empty(), quantity: None,
  96                                         payer_note: None,
  97                                 },
  98                                 payer_id,
  99                         },
 100                 }
 101         }
 102
 103         /// Sets the [`InvoiceRequest::chain`] of the given [`Network`] for paying an invoice. If not
 104         /// called, [`Network::Bitcoin`] is assumed. Errors if the chain for `network` is not supported
 105         /// by the offer.
 106         ///
 107         /// Successive calls to this method will override the previous setting.
 108         pub fn chain(mut self, network: Network) -> Result<Self, SemanticError> {
 109                 let chain = ChainHash::using_genesis_block(network);
 110                 if !self.offer.supports_chain(chain) {
 111                         return Err(SemanticError::UnsupportedChain);
 112                 }
 113
 114                 self.invoice_request.inner.chain = Some(chain);
 115                 Ok(self)
 116         }
 117
 118         /// Sets the [`InvoiceRequest::amount_msats`] for paying an invoice. Errors if `amount_msats` is
 119         /// not at least the expected invoice amount (i.e., [`Offer::amount`] times [`quantity`]).
 120         ///
 121         /// Successive calls to this method will override the previous setting.
 122         ///
 123         /// [`quantity`]: Self::quantity
 124         pub fn amount_msats(mut self, amount_msats: u64) -> Result<Self, SemanticError> {
 125                 self.invoice_request.inner.offer.check_amount_msats_for_quantity(
 126                         Some(amount_msats), self.invoice_request.inner.quantity
 127                 )?;
 128                 self.invoice_request.inner.amount_msats = Some(amount_msats);
 129                 Ok(self)
 130         }
 131
 132         /// Sets [`InvoiceRequest::quantity`] of items. If not set, `1` is assumed. Errors if `quantity`
 133         /// does not conform to [`Offer::is_valid_quantity`].
 134         ///
 135         /// Successive calls to this method will override the previous setting.
 136         pub fn quantity(mut self, quantity: u64) -> Result<Self, SemanticError> {
 137                 self.invoice_request.inner.offer.check_quantity(Some(quantity))?;
 138                 self.invoice_request.inner.quantity = Some(quantity);
 139                 Ok(self)
 140         }
 141
 142         /// Sets the [`InvoiceRequest::payer_note`].
 143         ///
 144         /// Successive calls to this method will override the previous setting.
 145         pub fn payer_note(mut self, payer_note: String) -> Self {
 146                 self.invoice_request.inner.payer_note = Some(payer_note);
 147                 self
 148         }
 149
 150         /// Builds an unsigned [`InvoiceRequest`] after checking for valid semantics. It can be signed
 151         /// by [`UnsignedInvoiceRequest::sign`].
 152         pub fn build(mut self) -> Result<UnsignedInvoiceRequest<'a>, SemanticError> {
 153                 #[cfg(feature = "std")] {
 154                         if self.offer.is_expired() {
 155                                 return Err(SemanticError::AlreadyExpired);
 156                         }
 157                 }
 158
 159                 let chain = self.invoice_request.chain();
 160                 if !self.offer.supports_chain(chain) {
 161                         return Err(SemanticError::UnsupportedChain);
 162                 }
 163
 164                 if chain == self.offer.implied_chain() {
 165                         self.invoice_request.inner.chain = None;
 166                 }
 167
 168                 if self.offer.amount().is_none() && self.invoice_request.inner.amount_msats.is_none() {
 169                         return Err(SemanticError::MissingAmount);
 170                 }
 171
 172                 self.invoice_request.inner.offer.check_quantity(self.invoice_request.inner.quantity)?;
 173                 self.invoice_request.inner.offer.check_amount_msats_for_quantity(
 174                         self.invoice_request.inner.amount_msats, self.invoice_request.inner.quantity
 175                 )?;
 176
 177                 let InvoiceRequestBuilder { offer, invoice_request } = self;
 178                 Ok(UnsignedInvoiceRequest { offer, invoice_request })
 179         }
 180 }
 181
 182 #[cfg(test)]
 183 impl<'a> InvoiceRequestBuilder<'a> {
 184         fn chain_unchecked(mut self, network: Network) -> Self {
 185                 let chain = ChainHash::using_genesis_block(network);
 186                 self.invoice_request.inner.chain = Some(chain);
 187                 self
 188         }
 189
 190         fn amount_msats_unchecked(mut self, amount_msats: u64) -> Self {
 191                 self.invoice_request.inner.amount_msats = Some(amount_msats);
 192                 self
 193         }
 194
 195         fn features_unchecked(mut self, features: InvoiceRequestFeatures) -> Self {
 196                 self.invoice_request.inner.features = features;
 197                 self
 198         }
 199
 200         fn quantity_unchecked(mut self, quantity: u64) -> Self {
 201                 self.invoice_request.inner.quantity = Some(quantity);
 202                 self
 203         }
 204
 205         pub(super) fn build_unchecked(self) -> UnsignedInvoiceRequest<'a> {
 206                 let InvoiceRequestBuilder { offer, invoice_request } = self;
 207                 UnsignedInvoiceRequest { offer, invoice_request }
 208         }
 209 }
 210
 211 /// A semantically valid [`InvoiceRequest`] that hasn't been signed.
 212 pub struct UnsignedInvoiceRequest<'a> {
 213         offer: &'a Offer,
 214         invoice_request: InvoiceRequestContents,
 215 }
 216
 217 impl<'a> UnsignedInvoiceRequest<'a> {
 218         /// Signs the invoice request using the given function.
 219         pub fn sign<F, E>(self, sign: F) -> Result<InvoiceRequest, SignError<E>>
 220         where
 221                 F: FnOnce(&Message) -> Result<Signature, E>
 222         {
 223                 // Use the offer bytes instead of the offer TLV stream as the offer may have contained
 224                 // unknown TLV records, which are not stored in `OfferContents`.
 225                 let (payer_tlv_stream, _offer_tlv_stream, invoice_request_tlv_stream) =
 226                         self.invoice_request.as_tlv_stream();
 227                 let offer_bytes = WithoutLength(&self.offer.bytes);
 228                 let unsigned_tlv_stream = (payer_tlv_stream, offer_bytes, invoice_request_tlv_stream);
 229
 230                 let mut bytes = Vec::new();
 231                 unsigned_tlv_stream.write(&mut bytes).unwrap();
 232
 233                 let pubkey = self.invoice_request.payer_id;
 234                 let signature = merkle::sign_message(sign, SIGNATURE_TAG, &bytes, pubkey)?;
 235
 236                 // Append the signature TLV record to the bytes.
 237                 let signature_tlv_stream = SignatureTlvStreamRef {
 238                         signature: Some(&signature),
 239                 };
 240                 signature_tlv_stream.write(&mut bytes).unwrap();
 241
 242                 Ok(InvoiceRequest {
 243                         bytes,
 244                         contents: self.invoice_request,
 245                         signature,
 246                 })
 247         }
 248 }
 249
 250 /// An `InvoiceRequest` is a request for an [`Invoice`] formulated from an [`Offer`].
 251 ///
 252 /// An offer may provide choices such as quantity, amount, chain, features, etc. An invoice request
 253 /// specifies these such that its recipient can send an invoice for payment.
 254 ///
 255 /// [`Invoice`]: crate::offers::invoice::Invoice
 256 /// [`Offer`]: crate::offers::offer::Offer
 257 #[derive(Clone, Debug)]
 258 #[cfg_attr(test, derive(PartialEq))]
 259 pub struct InvoiceRequest {
 260         pub(super) bytes: Vec<u8>,
 261         pub(super) contents: InvoiceRequestContents,
 262         signature: Signature,
 263 }
 264
 265 /// The contents of an [`InvoiceRequest`], which may be shared with an [`Invoice`].
 266 ///
 267 /// [`Invoice`]: crate::offers::invoice::Invoice
 268 #[derive(Clone, Debug)]
 269 #[cfg_attr(test, derive(PartialEq))]
 270 pub(super) struct InvoiceRequestContents {
 271         pub(super) inner: InvoiceRequestContentsWithoutPayerId,
 272         payer_id: PublicKey,
 273 }
 274
 275 #[derive(Clone, Debug)]
 276 #[cfg_attr(test, derive(PartialEq))]
 277 pub(super) struct InvoiceRequestContentsWithoutPayerId {
 278         payer: PayerContents,
 279         pub(super) offer: OfferContents,
 280         chain: Option<ChainHash>,
 281         amount_msats: Option<u64>,
 282         features: InvoiceRequestFeatures,
 283         quantity: Option<u64>,
 284         payer_note: Option<String>,
 285 }
 286
 287 impl InvoiceRequest {
 288         /// An unpredictable series of bytes, typically containing information about the derivation of
 289         /// [`payer_id`].
 290         ///
 291         /// [`payer_id`]: Self::payer_id
 292         pub fn metadata(&self) -> &[u8] {
 293                 &self.contents.inner.payer.0[..]
 294         }
 295
 296         /// A chain from [`Offer::chains`] that the offer is valid for.
 297         pub fn chain(&self) -> ChainHash {
 298                 self.contents.chain()
 299         }
 300
 301         /// The amount to pay in msats (i.e., the minimum lightning-payable unit for [`chain`]), which
 302         /// must be greater than or equal to [`Offer::amount`], converted if necessary.
 303         ///
 304         /// [`chain`]: Self::chain
 305         pub fn amount_msats(&self) -> Option<u64> {
 306                 self.contents.inner.amount_msats
 307         }
 308
 309         /// Features pertaining to requesting an invoice.
 310         pub fn features(&self) -> &InvoiceRequestFeatures {
 311                 &self.contents.inner.features
 312         }
 313
 314         /// The quantity of the offer's item conforming to [`Offer::is_valid_quantity`].
 315         pub fn quantity(&self) -> Option<u64> {
 316                 self.contents.inner.quantity
 317         }
 318
 319         /// A possibly transient pubkey used to sign the invoice request.
 320         pub fn payer_id(&self) -> PublicKey {
 321                 self.contents.payer_id
 322         }
 323
 324         /// A payer-provided note which will be seen by the recipient and reflected back in the invoice
 325         /// response.
 326         pub fn payer_note(&self) -> Option<PrintableString> {
 327                 self.contents.inner.payer_note.as_ref()
 328                         .map(|payer_note| PrintableString(payer_note.as_str()))
 329         }
 330
 331         /// Signature of the invoice request using [`payer_id`].
 332         ///
 333         /// [`payer_id`]: Self::payer_id
 334         pub fn signature(&self) -> Signature {
 335                 self.signature
 336         }
 337
 338         /// Creates an [`Invoice`] for the request with the given required fields and using the
 339         /// [`Duration`] since [`std::time::SystemTime::UNIX_EPOCH`] as the creation time.
 340         ///
 341         /// See [`InvoiceRequest::respond_with_no_std`] for further details where the aforementioned
 342         /// creation time is used for the `created_at` parameter.
 343         ///
 344         /// [`Invoice`]: crate::offers::invoice::Invoice
 345         /// [`Duration`]: core::time::Duration
 346         #[cfg(feature = "std")]
 347         pub fn respond_with(
 348                 &self, payment_paths: Vec<(BlindedPath, BlindedPayInfo)>, payment_hash: PaymentHash
 349         ) -> Result<InvoiceBuilder, SemanticError> {
 350                 let created_at = std::time::SystemTime::now()
 351                         .duration_since(std::time::SystemTime::UNIX_EPOCH)
 352                         .expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH");
 353
 354                 self.respond_with_no_std(payment_paths, payment_hash, created_at)
 355         }
 356
 357         /// Creates an [`Invoice`] for the request with the given required fields.
 358         ///
 359         /// Unless [`InvoiceBuilder::relative_expiry`] is set, the invoice will expire two hours after
 360         /// `created_at`, which is used to set [`Invoice::created_at`]. Useful for `no-std` builds where
 361         /// [`std::time::SystemTime`] is not available.
 362         ///
 363         /// The caller is expected to remember the preimage of `payment_hash` in order to claim a payment
 364         /// for the invoice.
 365         ///
 366         /// The `payment_paths` parameter is useful for maintaining the payment recipient's privacy. It
 367         /// must contain one or more elements ordered from most-preferred to least-preferred, if there's
 368         /// a preference. Note, however, that any privacy is lost if a public node id was used for
 369         /// [`Offer::signing_pubkey`].
 370         ///
 371         /// Errors if the request contains unknown required features.
 372         ///
 373         /// [`Invoice`]: crate::offers::invoice::Invoice
 374         /// [`Invoice::created_at`]: crate::offers::invoice::Invoice::created_at
 375         pub fn respond_with_no_std(
 376                 &self, payment_paths: Vec<(BlindedPath, BlindedPayInfo)>, payment_hash: PaymentHash,
 377                 created_at: core::time::Duration
 378         ) -> Result<InvoiceBuilder, SemanticError> {
 379                 if self.features().requires_unknown_bits() {
 380                         return Err(SemanticError::UnknownRequiredFeatures);
 381                 }
 382
 383                 InvoiceBuilder::for_offer(self, payment_paths, created_at, payment_hash)
 384         }
 385
 386         /// Verifies that the request was for an offer created using the given key.
 387         pub fn verify<T: secp256k1::Signing>(
 388                 &self, key: &ExpandedKey, secp_ctx: &Secp256k1<T>
 389         ) -> bool {
 390                 self.contents.inner.offer.verify(TlvStream::new(&self.bytes), key, secp_ctx)
 391         }
 392
 393         #[cfg(test)]
 394         fn as_tlv_stream(&self) -> FullInvoiceRequestTlvStreamRef {
 395                 let (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream) =
 396                         self.contents.as_tlv_stream();
 397                 let signature_tlv_stream = SignatureTlvStreamRef {
 398                         signature: Some(&self.signature),
 399                 };
 400                 (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, signature_tlv_stream)
 401         }
 402 }
 403
 404 impl InvoiceRequestContents {
 405         pub(super) fn chain(&self) -> ChainHash {
 406                 self.inner.chain()
 407         }
 408
 409         pub(super) fn as_tlv_stream(&self) -> PartialInvoiceRequestTlvStreamRef {
 410                 let (payer, offer, mut invoice_request) = self.inner.as_tlv_stream();
 411                 invoice_request.payer_id = Some(&self.payer_id);
 412                 (payer, offer, invoice_request)
 413         }
 414 }
 415
 416 impl InvoiceRequestContentsWithoutPayerId {
 417         pub(super) fn chain(&self) -> ChainHash {
 418                 self.chain.unwrap_or_else(|| self.offer.implied_chain())
 419         }
 420
 421         pub(super) fn as_tlv_stream(&self) -> PartialInvoiceRequestTlvStreamRef {
 422                 let payer = PayerTlvStreamRef {
 423                         metadata: Some(&self.payer.0),
 424                 };
 425
 426                 let offer = self.offer.as_tlv_stream();
 427
 428                 let features = {
 429                         if self.features == InvoiceRequestFeatures::empty() { None }
 430                         else { Some(&self.features) }
 431                 };
 432
 433                 let invoice_request = InvoiceRequestTlvStreamRef {
 434                         chain: self.chain.as_ref(),
 435                         amount: self.amount_msats,
 436                         features,
 437                         quantity: self.quantity,
 438                         payer_id: None,
 439                         payer_note: self.payer_note.as_ref(),
 440                 };
 441
 442                 (payer, offer, invoice_request)
 443         }
 444 }
 445
 446 impl Writeable for InvoiceRequest {
 447         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 448                 WithoutLength(&self.bytes).write(writer)
 449         }
 450 }
 451
 452 impl Writeable for InvoiceRequestContents {
 453         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 454                 self.as_tlv_stream().write(writer)
 455         }
 456 }
 457
 458 tlv_stream!(InvoiceRequestTlvStream, InvoiceRequestTlvStreamRef, 80..160, {
 459         (80, chain: ChainHash),
 460         (82, amount: (u64, HighZeroBytesDroppedBigSize)),
 461         (84, features: (InvoiceRequestFeatures, WithoutLength)),
 462         (86, quantity: (u64, HighZeroBytesDroppedBigSize)),
 463         (88, payer_id: PublicKey),
 464         (89, payer_note: (String, WithoutLength)),
 465 });
 466
 467 type FullInvoiceRequestTlvStream =
 468         (PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream, SignatureTlvStream);
 469
 470 #[cfg(test)]
 471 type FullInvoiceRequestTlvStreamRef<'a> = (
 472         PayerTlvStreamRef<'a>,
 473         OfferTlvStreamRef<'a>,
 474         InvoiceRequestTlvStreamRef<'a>,
 475         SignatureTlvStreamRef<'a>,
 476 );
 477
 478 impl SeekReadable for FullInvoiceRequestTlvStream {
 479         fn read<R: io::Read + io::Seek>(r: &mut R) -> Result<Self, DecodeError> {
 480                 let payer = SeekReadable::read(r)?;
 481                 let offer = SeekReadable::read(r)?;
 482                 let invoice_request = SeekReadable::read(r)?;
 483                 let signature = SeekReadable::read(r)?;
 484
 485                 Ok((payer, offer, invoice_request, signature))
 486         }
 487 }
 488
 489 type PartialInvoiceRequestTlvStream = (PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream);
 490
 491 type PartialInvoiceRequestTlvStreamRef<'a> = (
 492         PayerTlvStreamRef<'a>,
 493         OfferTlvStreamRef<'a>,
 494         InvoiceRequestTlvStreamRef<'a>,
 495 );
 496
 497 impl TryFrom<Vec<u8>> for InvoiceRequest {
 498         type Error = ParseError;
 499
 500         fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
 501                 let invoice_request = ParsedMessage::<FullInvoiceRequestTlvStream>::try_from(bytes)?;
 502                 let ParsedMessage { bytes, tlv_stream } = invoice_request;
 503                 let (
 504                         payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream,
 505                         SignatureTlvStream { signature },
 506                 ) = tlv_stream;
 507                 let contents = InvoiceRequestContents::try_from(
 508                         (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
 509                 )?;
 510
 511                 let signature = match signature {
 512                         None => return Err(ParseError::InvalidSemantics(SemanticError::MissingSignature)),
 513                         Some(signature) => signature,
 514                 };
 515                 merkle::verify_signature(&signature, SIGNATURE_TAG, &bytes, contents.payer_id)?;
 516
 517                 Ok(InvoiceRequest { bytes, contents, signature })
 518         }
 519 }
 520
 521 impl TryFrom<PartialInvoiceRequestTlvStream> for InvoiceRequestContents {
 522         type Error = SemanticError;
 523
 524         fn try_from(tlv_stream: PartialInvoiceRequestTlvStream) -> Result<Self, Self::Error> {
 525                 let (
 526                         PayerTlvStream { metadata },
 527                         offer_tlv_stream,
 528                         InvoiceRequestTlvStream { chain, amount, features, quantity, payer_id, payer_note },
 529                 ) = tlv_stream;
 530
 531                 let payer = match metadata {
 532                         None => return Err(SemanticError::MissingPayerMetadata),
 533                         Some(metadata) => PayerContents(metadata),
 534                 };
 535                 let offer = OfferContents::try_from(offer_tlv_stream)?;
 536
 537                 if !offer.supports_chain(chain.unwrap_or_else(|| offer.implied_chain())) {
 538                         return Err(SemanticError::UnsupportedChain);
 539                 }
 540
 541                 if offer.amount().is_none() && amount.is_none() {
 542                         return Err(SemanticError::MissingAmount);
 543                 }
 544
 545                 offer.check_quantity(quantity)?;
 546                 offer.check_amount_msats_for_quantity(amount, quantity)?;
 547
 548                 let features = features.unwrap_or_else(InvoiceRequestFeatures::empty);
 549
 550                 let payer_id = match payer_id {
 551                         None => return Err(SemanticError::MissingPayerId),
 552                         Some(payer_id) => payer_id,
 553                 };
 554
 555                 Ok(InvoiceRequestContents {
 556                         inner: InvoiceRequestContentsWithoutPayerId {
 557                                 payer, offer, chain, amount_msats: amount, features, quantity, payer_note,
 558                         },
 559                         payer_id,
 560                 })
 561         }
 562 }
 563
 564 #[cfg(test)]
 565 mod tests {
 566         use super::{InvoiceRequest, InvoiceRequestTlvStreamRef, SIGNATURE_TAG};
 567
 568         use bitcoin::blockdata::constants::ChainHash;
 569         use bitcoin::network::constants::Network;
 570         use bitcoin::secp256k1::{KeyPair, Secp256k1, SecretKey, self};
 571         use core::convert::{Infallible, TryFrom};
 572         use core::num::NonZeroU64;
 573         #[cfg(feature = "std")]
 574         use core::time::Duration;
 575         use crate::ln::features::InvoiceRequestFeatures;
 576         use crate::ln::msgs::{DecodeError, MAX_VALUE_MSAT};
 577         use crate::offers::merkle::{SignError, SignatureTlvStreamRef, self};
 578         use crate::offers::offer::{Amount, OfferBuilder, OfferTlvStreamRef, Quantity};
 579         use crate::offers::parse::{ParseError, SemanticError};
 580         use crate::offers::payer::PayerTlvStreamRef;
 581         use crate::offers::test_utils::*;
 582         use crate::util::ser::{BigSize, Writeable};
 583         use crate::util::string::PrintableString;
 584
 585         #[test]
 586         fn builds_invoice_request_with_defaults() {
 587                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 588                         .amount_msats(1000)
 589                         .build().unwrap()
 590                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 591                         .build().unwrap()
 592                         .sign(payer_sign).unwrap();
 593
 594                 let mut buffer = Vec::new();
 595                 invoice_request.write(&mut buffer).unwrap();
 596
 597                 assert_eq!(invoice_request.bytes, buffer.as_slice());
 598                 assert_eq!(invoice_request.metadata(), &[1; 32]);
 599                 assert_eq!(invoice_request.chain(), ChainHash::using_genesis_block(Network::Bitcoin));
 600                 assert_eq!(invoice_request.amount_msats(), None);
 601                 assert_eq!(invoice_request.features(), &InvoiceRequestFeatures::empty());
 602                 assert_eq!(invoice_request.quantity(), None);
 603                 assert_eq!(invoice_request.payer_id(), payer_pubkey());
 604                 assert_eq!(invoice_request.payer_note(), None);
 605                 assert!(
 606                         merkle::verify_signature(
 607                                 &invoice_request.signature, SIGNATURE_TAG, &invoice_request.bytes, payer_pubkey()
 608                         ).is_ok()
 609                 );
 610
 611                 assert_eq!(
 612                         invoice_request.as_tlv_stream(),
 613                         (
 614                                 PayerTlvStreamRef { metadata: Some(&vec![1; 32]) },
 615                                 OfferTlvStreamRef {
 616                                         chains: None,
 617                                         metadata: None,
 618                                         currency: None,
 619                                         amount: Some(1000),
 620                                         description: Some(&String::from("foo")),
 621                                         features: None,
 622                                         absolute_expiry: None,
 623                                         paths: None,
 624                                         issuer: None,
 625                                         quantity_max: None,
 626                                         node_id: Some(&recipient_pubkey()),
 627                                 },
 628                                 InvoiceRequestTlvStreamRef {
 629                                         chain: None,
 630                                         amount: None,
 631                                         features: None,
 632                                         quantity: None,
 633                                         payer_id: Some(&payer_pubkey()),
 634                                         payer_note: None,
 635                                 },
 636                                 SignatureTlvStreamRef { signature: Some(&invoice_request.signature()) },
 637                         ),
 638                 );
 639
 640                 if let Err(e) = InvoiceRequest::try_from(buffer) {
 641                         panic!("error parsing invoice request: {:?}", e);
 642                 }
 643         }
 644
 645         #[cfg(feature = "std")]
 646         #[test]
 647         fn builds_invoice_request_from_offer_with_expiration() {
 648                 let future_expiry = Duration::from_secs(u64::max_value());
 649                 let past_expiry = Duration::from_secs(0);
 650
 651                 if let Err(e) = OfferBuilder::new("foo".into(), recipient_pubkey())
 652                         .amount_msats(1000)
 653                         .absolute_expiry(future_expiry)
 654                         .build().unwrap()
 655                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 656                         .build()
 657                 {
 658                         panic!("error building invoice_request: {:?}", e);
 659                 }
 660
 661                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 662                         .amount_msats(1000)
 663                         .absolute_expiry(past_expiry)
 664                         .build().unwrap()
 665                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 666                         .build()
 667                 {
 668                         Ok(_) => panic!("expected error"),
 669                         Err(e) => assert_eq!(e, SemanticError::AlreadyExpired),
 670                 }
 671         }
 672
 673         #[test]
 674         fn builds_invoice_request_with_chain() {
 675                 let mainnet = ChainHash::using_genesis_block(Network::Bitcoin);
 676                 let testnet = ChainHash::using_genesis_block(Network::Testnet);
 677
 678                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 679                         .amount_msats(1000)
 680                         .build().unwrap()
 681                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 682                         .chain(Network::Bitcoin).unwrap()
 683                         .build().unwrap()
 684                         .sign(payer_sign).unwrap();
 685                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 686                 assert_eq!(invoice_request.chain(), mainnet);
 687                 assert_eq!(tlv_stream.chain, None);
 688
 689                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 690                         .amount_msats(1000)
 691                         .chain(Network::Testnet)
 692                         .build().unwrap()
 693                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 694                         .chain(Network::Testnet).unwrap()
 695                         .build().unwrap()
 696                         .sign(payer_sign).unwrap();
 697                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 698                 assert_eq!(invoice_request.chain(), testnet);
 699                 assert_eq!(tlv_stream.chain, Some(&testnet));
 700
 701                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 702                         .amount_msats(1000)
 703                         .chain(Network::Bitcoin)
 704                         .chain(Network::Testnet)
 705                         .build().unwrap()
 706                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 707                         .chain(Network::Bitcoin).unwrap()
 708                         .build().unwrap()
 709                         .sign(payer_sign).unwrap();
 710                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 711                 assert_eq!(invoice_request.chain(), mainnet);
 712                 assert_eq!(tlv_stream.chain, None);
 713
 714                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 715                         .amount_msats(1000)
 716                         .chain(Network::Bitcoin)
 717                         .chain(Network::Testnet)
 718                         .build().unwrap()
 719                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 720                         .chain(Network::Bitcoin).unwrap()
 721                         .chain(Network::Testnet).unwrap()
 722                         .build().unwrap()
 723                         .sign(payer_sign).unwrap();
 724                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 725                 assert_eq!(invoice_request.chain(), testnet);
 726                 assert_eq!(tlv_stream.chain, Some(&testnet));
 727
 728                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 729                         .amount_msats(1000)
 730                         .chain(Network::Testnet)
 731                         .build().unwrap()
 732                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 733                         .chain(Network::Bitcoin)
 734                 {
 735                         Ok(_) => panic!("expected error"),
 736                         Err(e) => assert_eq!(e, SemanticError::UnsupportedChain),
 737                 }
 738
 739                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 740                         .amount_msats(1000)
 741                         .chain(Network::Testnet)
 742                         .build().unwrap()
 743                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 744                         .build()
 745                 {
 746                         Ok(_) => panic!("expected error"),
 747                         Err(e) => assert_eq!(e, SemanticError::UnsupportedChain),
 748                 }
 749         }
 750
 751         #[test]
 752         fn builds_invoice_request_with_amount() {
 753                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 754                         .amount_msats(1000)
 755                         .build().unwrap()
 756                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 757                         .amount_msats(1000).unwrap()
 758                         .build().unwrap()
 759                         .sign(payer_sign).unwrap();
 760                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 761                 assert_eq!(invoice_request.amount_msats(), Some(1000));
 762                 assert_eq!(tlv_stream.amount, Some(1000));
 763
 764                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 765                         .amount_msats(1000)
 766                         .build().unwrap()
 767                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 768                         .amount_msats(1001).unwrap()
 769                         .amount_msats(1000).unwrap()
 770                         .build().unwrap()
 771                         .sign(payer_sign).unwrap();
 772                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 773                 assert_eq!(invoice_request.amount_msats(), Some(1000));
 774                 assert_eq!(tlv_stream.amount, Some(1000));
 775
 776                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 777                         .amount_msats(1000)
 778                         .build().unwrap()
 779                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 780                         .amount_msats(1001).unwrap()
 781                         .build().unwrap()
 782                         .sign(payer_sign).unwrap();
 783                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 784                 assert_eq!(invoice_request.amount_msats(), Some(1001));
 785                 assert_eq!(tlv_stream.amount, Some(1001));
 786
 787                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 788                         .amount_msats(1000)
 789                         .build().unwrap()
 790                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 791                         .amount_msats(999)
 792                 {
 793                         Ok(_) => panic!("expected error"),
 794                         Err(e) => assert_eq!(e, SemanticError::InsufficientAmount),
 795                 }
 796
 797                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 798                         .amount_msats(1000)
 799                         .supported_quantity(Quantity::Unbounded)
 800                         .build().unwrap()
 801                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 802                         .quantity(2).unwrap()
 803                         .amount_msats(1000)
 804                 {
 805                         Ok(_) => panic!("expected error"),
 806                         Err(e) => assert_eq!(e, SemanticError::InsufficientAmount),
 807                 }
 808
 809                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 810                         .amount_msats(1000)
 811                         .build().unwrap()
 812                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 813                         .amount_msats(MAX_VALUE_MSAT + 1)
 814                 {
 815                         Ok(_) => panic!("expected error"),
 816                         Err(e) => assert_eq!(e, SemanticError::InvalidAmount),
 817                 }
 818
 819                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 820                         .amount_msats(1000)
 821                         .supported_quantity(Quantity::Unbounded)
 822                         .build().unwrap()
 823                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 824                         .amount_msats(1000).unwrap()
 825                         .quantity(2).unwrap()
 826                         .build()
 827                 {
 828                         Ok(_) => panic!("expected error"),
 829                         Err(e) => assert_eq!(e, SemanticError::InsufficientAmount),
 830                 }
 831
 832                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 833                         .build().unwrap()
 834                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 835                         .build()
 836                 {
 837                         Ok(_) => panic!("expected error"),
 838                         Err(e) => assert_eq!(e, SemanticError::MissingAmount),
 839                 }
 840
 841                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 842                         .amount_msats(1000)
 843                         .supported_quantity(Quantity::Unbounded)
 844                         .build().unwrap()
 845                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 846                         .quantity(u64::max_value()).unwrap()
 847                         .build()
 848                 {
 849                         Ok(_) => panic!("expected error"),
 850                         Err(e) => assert_eq!(e, SemanticError::InvalidAmount),
 851                 }
 852         }
 853
 854         #[test]
 855         fn builds_invoice_request_with_features() {
 856                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 857                         .amount_msats(1000)
 858                         .build().unwrap()
 859                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 860                         .features_unchecked(InvoiceRequestFeatures::unknown())
 861                         .build().unwrap()
 862                         .sign(payer_sign).unwrap();
 863                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 864                 assert_eq!(invoice_request.features(), &InvoiceRequestFeatures::unknown());
 865                 assert_eq!(tlv_stream.features, Some(&InvoiceRequestFeatures::unknown()));
 866
 867                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 868                         .amount_msats(1000)
 869                         .build().unwrap()
 870                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 871                         .features_unchecked(InvoiceRequestFeatures::unknown())
 872                         .features_unchecked(InvoiceRequestFeatures::empty())
 873                         .build().unwrap()
 874                         .sign(payer_sign).unwrap();
 875                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 876                 assert_eq!(invoice_request.features(), &InvoiceRequestFeatures::empty());
 877                 assert_eq!(tlv_stream.features, None);
 878         }
 879
 880         #[test]
 881         fn builds_invoice_request_with_quantity() {
 882                 let one = NonZeroU64::new(1).unwrap();
 883                 let ten = NonZeroU64::new(10).unwrap();
 884
 885                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 886                         .amount_msats(1000)
 887                         .supported_quantity(Quantity::One)
 888                         .build().unwrap()
 889                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 890                         .build().unwrap()
 891                         .sign(payer_sign).unwrap();
 892                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 893                 assert_eq!(invoice_request.quantity(), None);
 894                 assert_eq!(tlv_stream.quantity, None);
 895
 896                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 897                         .amount_msats(1000)
 898                         .supported_quantity(Quantity::One)
 899                         .build().unwrap()
 900                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 901                         .amount_msats(2_000).unwrap()
 902                         .quantity(2)
 903                 {
 904                         Ok(_) => panic!("expected error"),
 905                         Err(e) => assert_eq!(e, SemanticError::UnexpectedQuantity),
 906                 }
 907
 908                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 909                         .amount_msats(1000)
 910                         .supported_quantity(Quantity::Bounded(ten))
 911                         .build().unwrap()
 912                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 913                         .amount_msats(10_000).unwrap()
 914                         .quantity(10).unwrap()
 915                         .build().unwrap()
 916                         .sign(payer_sign).unwrap();
 917                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 918                 assert_eq!(invoice_request.amount_msats(), Some(10_000));
 919                 assert_eq!(tlv_stream.amount, Some(10_000));
 920
 921                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 922                         .amount_msats(1000)
 923                         .supported_quantity(Quantity::Bounded(ten))
 924                         .build().unwrap()
 925                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 926                         .amount_msats(11_000).unwrap()
 927                         .quantity(11)
 928                 {
 929                         Ok(_) => panic!("expected error"),
 930                         Err(e) => assert_eq!(e, SemanticError::InvalidQuantity),
 931                 }
 932
 933                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 934                         .amount_msats(1000)
 935                         .supported_quantity(Quantity::Unbounded)
 936                         .build().unwrap()
 937                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 938                         .amount_msats(2_000).unwrap()
 939                         .quantity(2).unwrap()
 940                         .build().unwrap()
 941                         .sign(payer_sign).unwrap();
 942                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 943                 assert_eq!(invoice_request.amount_msats(), Some(2_000));
 944                 assert_eq!(tlv_stream.amount, Some(2_000));
 945
 946                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 947                         .amount_msats(1000)
 948                         .supported_quantity(Quantity::Unbounded)
 949                         .build().unwrap()
 950                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 951                         .build()
 952                 {
 953                         Ok(_) => panic!("expected error"),
 954                         Err(e) => assert_eq!(e, SemanticError::MissingQuantity),
 955                 }
 956
 957                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 958                         .amount_msats(1000)
 959                         .supported_quantity(Quantity::Bounded(one))
 960                         .build().unwrap()
 961                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 962                         .build()
 963                 {
 964                         Ok(_) => panic!("expected error"),
 965                         Err(e) => assert_eq!(e, SemanticError::MissingQuantity),
 966                 }
 967         }
 968
 969         #[test]
 970         fn builds_invoice_request_with_payer_note() {
 971                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 972                         .amount_msats(1000)
 973                         .build().unwrap()
 974                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 975                         .payer_note("bar".into())
 976                         .build().unwrap()
 977                         .sign(payer_sign).unwrap();
 978                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 979                 assert_eq!(invoice_request.payer_note(), Some(PrintableString("bar")));
 980                 assert_eq!(tlv_stream.payer_note, Some(&String::from("bar")));
 981
 982                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
 983                         .amount_msats(1000)
 984                         .build().unwrap()
 985                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 986                         .payer_note("bar".into())
 987                         .payer_note("baz".into())
 988                         .build().unwrap()
 989                         .sign(payer_sign).unwrap();
 990                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
 991                 assert_eq!(invoice_request.payer_note(), Some(PrintableString("baz")));
 992                 assert_eq!(tlv_stream.payer_note, Some(&String::from("baz")));
 993         }
 994
 995         #[test]
 996         fn fails_signing_invoice_request() {
 997                 match OfferBuilder::new("foo".into(), recipient_pubkey())
 998                         .amount_msats(1000)
 999                         .build().unwrap()
1000                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1001                         .build().unwrap()
1002                         .sign(|_| Err(()))
1003                 {
1004                         Ok(_) => panic!("expected error"),
1005                         Err(e) => assert_eq!(e, SignError::Signing(())),
1006                 }
1007
1008                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1009                         .amount_msats(1000)
1010                         .build().unwrap()
1011                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1012                         .build().unwrap()
1013                         .sign(recipient_sign)
1014                 {
1015                         Ok(_) => panic!("expected error"),
1016                         Err(e) => assert_eq!(e, SignError::Verification(secp256k1::Error::InvalidSignature)),
1017                 }
1018         }
1019
1020         #[test]
1021         fn fails_responding_with_unknown_required_features() {
1022                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1023                         .amount_msats(1000)
1024                         .build().unwrap()
1025                         .request_invoice(vec![42; 32], payer_pubkey()).unwrap()
1026                         .features_unchecked(InvoiceRequestFeatures::unknown())
1027                         .build().unwrap()
1028                         .sign(payer_sign).unwrap()
1029                         .respond_with_no_std(payment_paths(), payment_hash(), now())
1030                 {
1031                         Ok(_) => panic!("expected error"),
1032                         Err(e) => assert_eq!(e, SemanticError::UnknownRequiredFeatures),
1033                 }
1034         }
1035
1036         #[test]
1037         fn parses_invoice_request_with_metadata() {
1038                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1039                         .amount_msats(1000)
1040                         .build().unwrap()
1041                         .request_invoice(vec![42; 32], payer_pubkey()).unwrap()
1042                         .build().unwrap()
1043                         .sign(payer_sign).unwrap();
1044
1045                 let mut buffer = Vec::new();
1046                 invoice_request.write(&mut buffer).unwrap();
1047
1048                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1049                         panic!("error parsing invoice_request: {:?}", e);
1050                 }
1051         }
1052
1053         #[test]
1054         fn parses_invoice_request_with_chain() {
1055                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1056                         .amount_msats(1000)
1057                         .build().unwrap()
1058                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1059                         .chain(Network::Bitcoin).unwrap()
1060                         .build().unwrap()
1061                         .sign(payer_sign).unwrap();
1062
1063                 let mut buffer = Vec::new();
1064                 invoice_request.write(&mut buffer).unwrap();
1065
1066                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1067                         panic!("error parsing invoice_request: {:?}", e);
1068                 }
1069
1070                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1071                         .amount_msats(1000)
1072                         .build().unwrap()
1073                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1074                         .chain_unchecked(Network::Testnet)
1075                         .build_unchecked()
1076                         .sign(payer_sign).unwrap();
1077
1078                 let mut buffer = Vec::new();
1079                 invoice_request.write(&mut buffer).unwrap();
1080
1081                 match InvoiceRequest::try_from(buffer) {
1082                         Ok(_) => panic!("expected error"),
1083                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnsupportedChain)),
1084                 }
1085         }
1086
1087         #[test]
1088         fn parses_invoice_request_with_amount() {
1089                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1090                         .amount_msats(1000)
1091                         .build().unwrap()
1092                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1093                         .build().unwrap()
1094                         .sign(payer_sign).unwrap();
1095
1096                 let mut buffer = Vec::new();
1097                 invoice_request.write(&mut buffer).unwrap();
1098
1099                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1100                         panic!("error parsing invoice_request: {:?}", e);
1101                 }
1102
1103                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1104                         .build().unwrap()
1105                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1106                         .amount_msats(1000).unwrap()
1107                         .build().unwrap()
1108                         .sign(payer_sign).unwrap();
1109
1110                 let mut buffer = Vec::new();
1111                 invoice_request.write(&mut buffer).unwrap();
1112
1113                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1114                         panic!("error parsing invoice_request: {:?}", e);
1115                 }
1116
1117                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1118                         .build().unwrap()
1119                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1120                         .build_unchecked()
1121                         .sign(payer_sign).unwrap();
1122
1123                 let mut buffer = Vec::new();
1124                 invoice_request.write(&mut buffer).unwrap();
1125
1126                 match InvoiceRequest::try_from(buffer) {
1127                         Ok(_) => panic!("expected error"),
1128                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingAmount)),
1129                 }
1130
1131                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1132                         .amount_msats(1000)
1133                         .build().unwrap()
1134                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1135                         .amount_msats_unchecked(999)
1136                         .build_unchecked()
1137                         .sign(payer_sign).unwrap();
1138
1139                 let mut buffer = Vec::new();
1140                 invoice_request.write(&mut buffer).unwrap();
1141
1142                 match InvoiceRequest::try_from(buffer) {
1143                         Ok(_) => panic!("expected error"),
1144                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InsufficientAmount)),
1145                 }
1146
1147                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1148                         .amount(Amount::Currency { iso4217_code: *b"USD", amount: 1000 })
1149                         .build_unchecked()
1150                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1151                         .build_unchecked()
1152                         .sign(payer_sign).unwrap();
1153
1154                 let mut buffer = Vec::new();
1155                 invoice_request.write(&mut buffer).unwrap();
1156
1157                 match InvoiceRequest::try_from(buffer) {
1158                         Ok(_) => panic!("expected error"),
1159                         Err(e) => {
1160                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnsupportedCurrency));
1161                         },
1162                 }
1163
1164                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1165                         .amount_msats(1000)
1166                         .supported_quantity(Quantity::Unbounded)
1167                         .build().unwrap()
1168                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1169                         .quantity(u64::max_value()).unwrap()
1170                         .build_unchecked()
1171                         .sign(payer_sign).unwrap();
1172
1173                 let mut buffer = Vec::new();
1174                 invoice_request.write(&mut buffer).unwrap();
1175
1176                 match InvoiceRequest::try_from(buffer) {
1177                         Ok(_) => panic!("expected error"),
1178                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InvalidAmount)),
1179                 }
1180         }
1181
1182         #[test]
1183         fn parses_invoice_request_with_quantity() {
1184                 let one = NonZeroU64::new(1).unwrap();
1185                 let ten = NonZeroU64::new(10).unwrap();
1186
1187                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1188                         .amount_msats(1000)
1189                         .supported_quantity(Quantity::One)
1190                         .build().unwrap()
1191                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1192                         .build().unwrap()
1193                         .sign(payer_sign).unwrap();
1194
1195                 let mut buffer = Vec::new();
1196                 invoice_request.write(&mut buffer).unwrap();
1197
1198                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1199                         panic!("error parsing invoice_request: {:?}", e);
1200                 }
1201
1202                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1203                         .amount_msats(1000)
1204                         .supported_quantity(Quantity::One)
1205                         .build().unwrap()
1206                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1207                         .amount_msats(2_000).unwrap()
1208                         .quantity_unchecked(2)
1209                         .build_unchecked()
1210                         .sign(payer_sign).unwrap();
1211
1212                 let mut buffer = Vec::new();
1213                 invoice_request.write(&mut buffer).unwrap();
1214
1215                 match InvoiceRequest::try_from(buffer) {
1216                         Ok(_) => panic!("expected error"),
1217                         Err(e) => {
1218                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedQuantity));
1219                         },
1220                 }
1221
1222                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1223                         .amount_msats(1000)
1224                         .supported_quantity(Quantity::Bounded(ten))
1225                         .build().unwrap()
1226                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1227                         .amount_msats(10_000).unwrap()
1228                         .quantity(10).unwrap()
1229                         .build().unwrap()
1230                         .sign(payer_sign).unwrap();
1231
1232                 let mut buffer = Vec::new();
1233                 invoice_request.write(&mut buffer).unwrap();
1234
1235                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1236                         panic!("error parsing invoice_request: {:?}", e);
1237                 }
1238
1239                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1240                         .amount_msats(1000)
1241                         .supported_quantity(Quantity::Bounded(ten))
1242                         .build().unwrap()
1243                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1244                         .amount_msats(11_000).unwrap()
1245                         .quantity_unchecked(11)
1246                         .build_unchecked()
1247                         .sign(payer_sign).unwrap();
1248
1249                 let mut buffer = Vec::new();
1250                 invoice_request.write(&mut buffer).unwrap();
1251
1252                 match InvoiceRequest::try_from(buffer) {
1253                         Ok(_) => panic!("expected error"),
1254                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InvalidQuantity)),
1255                 }
1256
1257                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1258                         .amount_msats(1000)
1259                         .supported_quantity(Quantity::Unbounded)
1260                         .build().unwrap()
1261                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1262                         .amount_msats(2_000).unwrap()
1263                         .quantity(2).unwrap()
1264                         .build().unwrap()
1265                         .sign(payer_sign).unwrap();
1266
1267                 let mut buffer = Vec::new();
1268                 invoice_request.write(&mut buffer).unwrap();
1269
1270                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1271                         panic!("error parsing invoice_request: {:?}", e);
1272                 }
1273
1274                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1275                         .amount_msats(1000)
1276                         .supported_quantity(Quantity::Unbounded)
1277                         .build().unwrap()
1278                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1279                         .build_unchecked()
1280                         .sign(payer_sign).unwrap();
1281
1282                 let mut buffer = Vec::new();
1283                 invoice_request.write(&mut buffer).unwrap();
1284
1285                 match InvoiceRequest::try_from(buffer) {
1286                         Ok(_) => panic!("expected error"),
1287                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingQuantity)),
1288                 }
1289
1290                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1291                         .amount_msats(1000)
1292                         .supported_quantity(Quantity::Bounded(one))
1293                         .build().unwrap()
1294                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1295                         .build_unchecked()
1296                         .sign(payer_sign).unwrap();
1297
1298                 let mut buffer = Vec::new();
1299                 invoice_request.write(&mut buffer).unwrap();
1300
1301                 match InvoiceRequest::try_from(buffer) {
1302                         Ok(_) => panic!("expected error"),
1303                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingQuantity)),
1304                 }
1305         }
1306
1307         #[test]
1308         fn fails_parsing_invoice_request_without_metadata() {
1309                 let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
1310                         .amount_msats(1000)
1311                         .build().unwrap();
1312                 let unsigned_invoice_request = offer.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1313                         .build().unwrap();
1314                 let mut tlv_stream = unsigned_invoice_request.invoice_request.as_tlv_stream();
1315                 tlv_stream.0.metadata = None;
1316
1317                 let mut buffer = Vec::new();
1318                 tlv_stream.write(&mut buffer).unwrap();
1319
1320                 match InvoiceRequest::try_from(buffer) {
1321                         Ok(_) => panic!("expected error"),
1322                         Err(e) => {
1323                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingPayerMetadata));
1324                         },
1325                 }
1326         }
1327
1328         #[test]
1329         fn fails_parsing_invoice_request_without_payer_id() {
1330                 let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
1331                         .amount_msats(1000)
1332                         .build().unwrap();
1333                 let unsigned_invoice_request = offer.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1334                         .build().unwrap();
1335                 let mut tlv_stream = unsigned_invoice_request.invoice_request.as_tlv_stream();
1336                 tlv_stream.2.payer_id = None;
1337
1338                 let mut buffer = Vec::new();
1339                 tlv_stream.write(&mut buffer).unwrap();
1340
1341                 match InvoiceRequest::try_from(buffer) {
1342                         Ok(_) => panic!("expected error"),
1343                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingPayerId)),
1344                 }
1345         }
1346
1347         #[test]
1348         fn fails_parsing_invoice_request_without_node_id() {
1349                 let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
1350                         .amount_msats(1000)
1351                         .build().unwrap();
1352                 let unsigned_invoice_request = offer.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1353                         .build().unwrap();
1354                 let mut tlv_stream = unsigned_invoice_request.invoice_request.as_tlv_stream();
1355                 tlv_stream.1.node_id = None;
1356
1357                 let mut buffer = Vec::new();
1358                 tlv_stream.write(&mut buffer).unwrap();
1359
1360                 match InvoiceRequest::try_from(buffer) {
1361                         Ok(_) => panic!("expected error"),
1362                         Err(e) => {
1363                                 assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingSigningPubkey));
1364                         },
1365                 }
1366         }
1367
1368         #[test]
1369         fn fails_parsing_invoice_request_without_signature() {
1370                 let mut buffer = Vec::new();
1371                 OfferBuilder::new("foo".into(), recipient_pubkey())
1372                         .amount_msats(1000)
1373                         .build().unwrap()
1374                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1375                         .build().unwrap()
1376                         .invoice_request
1377                         .write(&mut buffer).unwrap();
1378
1379                 match InvoiceRequest::try_from(buffer) {
1380                         Ok(_) => panic!("expected error"),
1381                         Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingSignature)),
1382                 }
1383         }
1384
1385         #[test]
1386         fn fails_parsing_invoice_request_with_invalid_signature() {
1387                 let mut invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1388                         .amount_msats(1000)
1389                         .build().unwrap()
1390                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1391                         .build().unwrap()
1392                         .sign(payer_sign).unwrap();
1393                 let last_signature_byte = invoice_request.bytes.last_mut().unwrap();
1394                 *last_signature_byte = last_signature_byte.wrapping_add(1);
1395
1396                 let mut buffer = Vec::new();
1397                 invoice_request.write(&mut buffer).unwrap();
1398
1399                 match InvoiceRequest::try_from(buffer) {
1400                         Ok(_) => panic!("expected error"),
1401                         Err(e) => {
1402                                 assert_eq!(e, ParseError::InvalidSignature(secp256k1::Error::InvalidSignature));
1403                         },
1404                 }
1405         }
1406
1407         #[test]
1408         fn fails_parsing_invoice_request_with_extra_tlv_records() {
1409                 let secp_ctx = Secp256k1::new();
1410                 let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1411                 let invoice_request = OfferBuilder::new("foo".into(), keys.public_key())
1412                         .amount_msats(1000)
1413                         .build().unwrap()
1414                         .request_invoice(vec![1; 32], keys.public_key()).unwrap()
1415                         .build().unwrap()
1416                         .sign::<_, Infallible>(|digest| Ok(secp_ctx.sign_schnorr_no_aux_rand(digest, &keys)))
1417                         .unwrap();
1418
1419                 let mut encoded_invoice_request = Vec::new();
1420                 invoice_request.write(&mut encoded_invoice_request).unwrap();
1421                 BigSize(1002).write(&mut encoded_invoice_request).unwrap();
1422                 BigSize(32).write(&mut encoded_invoice_request).unwrap();
1423                 [42u8; 32].write(&mut encoded_invoice_request).unwrap();
1424
1425                 match InvoiceRequest::try_from(encoded_invoice_request) {
1426                         Ok(_) => panic!("expected error"),
1427                         Err(e) => assert_eq!(e, ParseError::Decode(DecodeError::InvalidValue)),
1428                 }
1429         }
1430 }