git.bitcoin.ninja 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 a [`Bolt12Invoice`].
  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 //! [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
  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::invoice_request::UnsignedInvoiceRequest;
  31 //! use lightning::offers::offer::Offer;
  32 //! use lightning::util::ser::Writeable;
  33 //!
  34 //! # fn parse() -> Result<(), lightning::offers::parse::Bolt12ParseError> {
  35 //! let secp_ctx = Secp256k1::new();
  36 //! let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32])?);
  37 //! let pubkey = PublicKey::from(keys);
  38 //! let mut buffer = Vec::new();
  39 //!
  40 //! # use lightning::offers::invoice_request::{ExplicitPayerId, InvoiceRequestBuilder};
  41 //! # <InvoiceRequestBuilder<ExplicitPayerId, _>>::from(
  42 //! "lno1qcp4256ypq"
  43 //!     .parse::<Offer>()?
  44 //!     .request_invoice(vec![42; 64], pubkey)?
  45 //! # )
  46 //!     .chain(Network::Testnet)?
  47 //!     .amount_msats(1000)?
  48 //!     .quantity(5)?
  49 //!     .payer_note("foo".to_string())
  50 //!     .build()?
  51 //!     .sign(|message: &UnsignedInvoiceRequest| -> Result<_, Infallible> {
  52 //!         Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
  53 //!     })
  54 //!     .expect("failed verifying signature")
  55 //!     .write(&mut buffer)
  56 //!     .unwrap();
  57 //! # Ok(())
  58 //! # }
  59 //! ```
  60
  61 use bitcoin::blockdata::constants::ChainHash;
  62 use bitcoin::network::constants::Network;
  63 use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, self};
  64 use bitcoin::secp256k1::schnorr::Signature;
  65 use core::convert::{AsRef, Infallible, TryFrom};
  66 use core::ops::Deref;
  67 use crate::sign::EntropySource;
  68 use crate::io;
  69 use crate::blinded_path::BlindedPath;
  70 use crate::ln::PaymentHash;
  71 use crate::ln::channelmanager::PaymentId;
  72 use crate::ln::features::InvoiceRequestFeatures;
  73 use crate::ln::inbound_payment::{ExpandedKey, IV_LEN, Nonce};
  74 use crate::ln::msgs::DecodeError;
  75 use crate::offers::invoice::BlindedPayInfo;
  76 use crate::offers::merkle::{SignError, SignFn, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, self};
  77 use crate::offers::offer::{Offer, OfferContents, OfferTlvStream, OfferTlvStreamRef};
  78 use crate::offers::parse::{Bolt12ParseError, ParsedMessage, Bolt12SemanticError};
  79 use crate::offers::payer::{PayerContents, PayerTlvStream, PayerTlvStreamRef};
  80 use crate::offers::signer::{Metadata, MetadataMaterial};
  81 use crate::util::ser::{HighZeroBytesDroppedBigSize, SeekReadable, WithoutLength, Writeable, Writer};
  82 use crate::util::string::PrintableString;
  83
  84 #[cfg(not(c_bindings))]
  85 use {
  86         crate::offers::invoice::{DerivedSigningPubkey, ExplicitSigningPubkey, InvoiceBuilder},
  87 };
  88 #[cfg(c_bindings)]
  89 use {
  90         crate::offers::invoice::{InvoiceWithDerivedSigningPubkeyBuilder, InvoiceWithExplicitSigningPubkeyBuilder},
  91 };
  92
  93 use crate::prelude::*;
  94
  95 /// Tag for the hash function used when signing an [`InvoiceRequest`]'s merkle root.
  96 pub const SIGNATURE_TAG: &'static str = concat!("lightning", "invoice_request", "signature");
  97
  98 pub(super) const IV_BYTES: &[u8; IV_LEN] = b"LDK Invreq ~~~~~";
  99
 100 /// Builds an [`InvoiceRequest`] from an [`Offer`] for the "offer to be paid" flow.
 101 ///
 102 /// See [module-level documentation] for usage.
 103 ///
 104 /// This is not exported to bindings users as builder patterns don't map outside of move semantics.
 105 ///
 106 /// [module-level documentation]: self
 107 pub struct InvoiceRequestBuilder<'a, 'b, P: PayerIdStrategy, T: secp256k1::Signing> {
 108         offer: &'a Offer,
 109         invoice_request: InvoiceRequestContentsWithoutPayerId,
 110         payer_id: Option<PublicKey>,
 111         payer_id_strategy: core::marker::PhantomData<P>,
 112         secp_ctx: Option<&'b Secp256k1<T>>,
 113 }
 114
 115 /// Builds an [`InvoiceRequest`] from an [`Offer`] for the "offer to be paid" flow.
 116 ///
 117 /// See [module-level documentation] for usage.
 118 ///
 119 /// [module-level documentation]: self
 120 #[cfg(c_bindings)]
 121 pub struct InvoiceRequestWithExplicitPayerIdBuilder<'a, 'b> {
 122         offer: &'a Offer,
 123         invoice_request: InvoiceRequestContentsWithoutPayerId,
 124         payer_id: Option<PublicKey>,
 125         payer_id_strategy: core::marker::PhantomData<ExplicitPayerId>,
 126         secp_ctx: Option<&'b Secp256k1<secp256k1::All>>,
 127 }
 128
 129 /// Builds an [`InvoiceRequest`] from an [`Offer`] for the "offer to be paid" flow.
 130 ///
 131 /// See [module-level documentation] for usage.
 132 ///
 133 /// [module-level documentation]: self
 134 #[cfg(c_bindings)]
 135 pub struct InvoiceRequestWithDerivedPayerIdBuilder<'a, 'b> {
 136         offer: &'a Offer,
 137         invoice_request: InvoiceRequestContentsWithoutPayerId,
 138         payer_id: Option<PublicKey>,
 139         payer_id_strategy: core::marker::PhantomData<DerivedPayerId>,
 140         secp_ctx: Option<&'b Secp256k1<secp256k1::All>>,
 141 }
 142
 143 /// Indicates how [`InvoiceRequest::payer_id`] will be set.
 144 ///
 145 /// This is not exported to bindings users as builder patterns don't map outside of move semantics.
 146 pub trait PayerIdStrategy {}
 147
 148 /// [`InvoiceRequest::payer_id`] will be explicitly set.
 149 ///
 150 /// This is not exported to bindings users as builder patterns don't map outside of move semantics.
 151 pub struct ExplicitPayerId {}
 152
 153 /// [`InvoiceRequest::payer_id`] will be derived.
 154 ///
 155 /// This is not exported to bindings users as builder patterns don't map outside of move semantics.
 156 pub struct DerivedPayerId {}
 157
 158 impl PayerIdStrategy for ExplicitPayerId {}
 159 impl PayerIdStrategy for DerivedPayerId {}
 160
 161 macro_rules! invoice_request_explicit_payer_id_builder_methods { ($self: ident, $self_type: ty) => {
 162         #[cfg_attr(c_bindings, allow(dead_code))]
 163         pub(super) fn new(offer: &'a Offer, metadata: Vec<u8>, payer_id: PublicKey) -> Self {
 164                 Self {
 165                         offer,
 166                         invoice_request: Self::create_contents(offer, Metadata::Bytes(metadata)),
 167                         payer_id: Some(payer_id),
 168                         payer_id_strategy: core::marker::PhantomData,
 169                         secp_ctx: None,
 170                 }
 171         }
 172
 173         #[cfg_attr(c_bindings, allow(dead_code))]
 174         pub(super) fn deriving_metadata<ES: Deref>(
 175                 offer: &'a Offer, payer_id: PublicKey, expanded_key: &ExpandedKey, entropy_source: ES,
 176                 payment_id: PaymentId,
 177         ) -> Self where ES::Target: EntropySource {
 178                 let nonce = Nonce::from_entropy_source(entropy_source);
 179                 let payment_id = Some(payment_id);
 180                 let derivation_material = MetadataMaterial::new(nonce, expanded_key, IV_BYTES, payment_id);
 181                 let metadata = Metadata::Derived(derivation_material);
 182                 Self {
 183                         offer,
 184                         invoice_request: Self::create_contents(offer, metadata),
 185                         payer_id: Some(payer_id),
 186                         payer_id_strategy: core::marker::PhantomData,
 187                         secp_ctx: None,
 188                 }
 189         }
 190
 191         /// Builds an unsigned [`InvoiceRequest`] after checking for valid semantics. It can be signed
 192         /// by [`UnsignedInvoiceRequest::sign`].
 193         pub fn build($self: $self_type) -> Result<UnsignedInvoiceRequest, Bolt12SemanticError> {
 194                 let (unsigned_invoice_request, keys, _) = $self.build_with_checks()?;
 195                 debug_assert!(keys.is_none());
 196                 Ok(unsigned_invoice_request)
 197         }
 198 } }
 199
 200 macro_rules! invoice_request_derived_payer_id_builder_methods { (
 201         $self: ident, $self_type: ty, $secp_context: ty
 202 ) => {
 203         #[cfg_attr(c_bindings, allow(dead_code))]
 204         pub(super) fn deriving_payer_id<ES: Deref>(
 205                 offer: &'a Offer, expanded_key: &ExpandedKey, entropy_source: ES,
 206                 secp_ctx: &'b Secp256k1<$secp_context>, payment_id: PaymentId
 207         ) -> Self where ES::Target: EntropySource {
 208                 let nonce = Nonce::from_entropy_source(entropy_source);
 209                 let payment_id = Some(payment_id);
 210                 let derivation_material = MetadataMaterial::new(nonce, expanded_key, IV_BYTES, payment_id);
 211                 let metadata = Metadata::DerivedSigningPubkey(derivation_material);
 212                 Self {
 213                         offer,
 214                         invoice_request: Self::create_contents(offer, metadata),
 215                         payer_id: None,
 216                         payer_id_strategy: core::marker::PhantomData,
 217                         secp_ctx: Some(secp_ctx),
 218                 }
 219         }
 220
 221         /// Builds a signed [`InvoiceRequest`] after checking for valid semantics.
 222         pub fn build_and_sign($self: $self_type) -> Result<InvoiceRequest, Bolt12SemanticError> {
 223                 let (unsigned_invoice_request, keys, secp_ctx) = $self.build_with_checks()?;
 224                 #[cfg(c_bindings)]
 225                 let mut unsigned_invoice_request = unsigned_invoice_request;
 226                 debug_assert!(keys.is_some());
 227
 228                 let secp_ctx = secp_ctx.unwrap();
 229                 let keys = keys.unwrap();
 230                 let invoice_request = unsigned_invoice_request
 231                         .sign(|message: &UnsignedInvoiceRequest| -> Result<_, Infallible> {
 232                                 Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
 233                         })
 234                         .unwrap();
 235                 Ok(invoice_request)
 236         }
 237 } }
 238
 239 macro_rules! invoice_request_builder_methods { (
 240         $self: ident, $self_type: ty, $return_type: ty, $return_value: expr, $secp_context: ty $(, $self_mut: tt)?
 241 ) => {
 242         #[cfg_attr(c_bindings, allow(dead_code))]
 243         fn create_contents(offer: &Offer, metadata: Metadata) -> InvoiceRequestContentsWithoutPayerId {
 244                 let offer = offer.contents.clone();
 245                 InvoiceRequestContentsWithoutPayerId {
 246                         payer: PayerContents(metadata), offer, chain: None, amount_msats: None,
 247                         features: InvoiceRequestFeatures::empty(), quantity: None, payer_note: None,
 248                 }
 249         }
 250
 251         /// Sets the [`InvoiceRequest::chain`] of the given [`Network`] for paying an invoice. If not
 252         /// called, [`Network::Bitcoin`] is assumed. Errors if the chain for `network` is not supported
 253         /// by the offer.
 254         ///
 255         /// Successive calls to this method will override the previous setting.
 256         pub fn chain($self: $self_type, network: Network) -> Result<$return_type, Bolt12SemanticError> {
 257                 $self.chain_hash(ChainHash::using_genesis_block(network))
 258         }
 259
 260         /// Sets the [`InvoiceRequest::chain`] for paying an invoice. If not called, the chain hash of
 261         /// [`Network::Bitcoin`] is assumed. Errors if the chain for `network` is not supported by the
 262         /// offer.
 263         ///
 264         /// Successive calls to this method will override the previous setting.
 265         pub(crate) fn chain_hash($($self_mut)* $self: $self_type, chain: ChainHash) -> Result<$return_type, Bolt12SemanticError> {
 266                 if !$self.offer.supports_chain(chain) {
 267                         return Err(Bolt12SemanticError::UnsupportedChain);
 268                 }
 269
 270                 $self.invoice_request.chain = Some(chain);
 271                 Ok($return_value)
 272         }
 273
 274         /// Sets the [`InvoiceRequest::amount_msats`] for paying an invoice. Errors if `amount_msats` is
 275         /// not at least the expected invoice amount (i.e., [`Offer::amount`] times [`quantity`]).
 276         ///
 277         /// Successive calls to this method will override the previous setting.
 278         ///
 279         /// [`quantity`]: Self::quantity
 280         pub fn amount_msats($($self_mut)* $self: $self_type, amount_msats: u64) -> Result<$return_type, Bolt12SemanticError> {
 281                 $self.invoice_request.offer.check_amount_msats_for_quantity(
 282                         Some(amount_msats), $self.invoice_request.quantity
 283                 )?;
 284                 $self.invoice_request.amount_msats = Some(amount_msats);
 285                 Ok($return_value)
 286         }
 287
 288         /// Sets [`InvoiceRequest::quantity`] of items. If not set, `1` is assumed. Errors if `quantity`
 289         /// does not conform to [`Offer::is_valid_quantity`].
 290         ///
 291         /// Successive calls to this method will override the previous setting.
 292         pub fn quantity($($self_mut)* $self: $self_type, quantity: u64) -> Result<$return_type, Bolt12SemanticError> {
 293                 $self.invoice_request.offer.check_quantity(Some(quantity))?;
 294                 $self.invoice_request.quantity = Some(quantity);
 295                 Ok($return_value)
 296         }
 297
 298         /// Sets the [`InvoiceRequest::payer_note`].
 299         ///
 300         /// Successive calls to this method will override the previous setting.
 301         pub fn payer_note($($self_mut)* $self: $self_type, payer_note: String) -> $return_type {
 302                 $self.invoice_request.payer_note = Some(payer_note);
 303                 $return_value
 304         }
 305
 306         fn build_with_checks($($self_mut)* $self: $self_type) -> Result<
 307                 (UnsignedInvoiceRequest, Option<KeyPair>, Option<&'b Secp256k1<$secp_context>>),
 308                 Bolt12SemanticError
 309         > {
 310                 #[cfg(feature = "std")] {
 311                         if $self.offer.is_expired() {
 312                                 return Err(Bolt12SemanticError::AlreadyExpired);
 313                         }
 314                 }
 315
 316                 let chain = $self.invoice_request.chain();
 317                 if !$self.offer.supports_chain(chain) {
 318                         return Err(Bolt12SemanticError::UnsupportedChain);
 319                 }
 320
 321                 if chain == $self.offer.implied_chain() {
 322                         $self.invoice_request.chain = None;
 323                 }
 324
 325                 if $self.offer.amount().is_none() && $self.invoice_request.amount_msats.is_none() {
 326                         return Err(Bolt12SemanticError::MissingAmount);
 327                 }
 328
 329                 $self.invoice_request.offer.check_quantity($self.invoice_request.quantity)?;
 330                 $self.invoice_request.offer.check_amount_msats_for_quantity(
 331                         $self.invoice_request.amount_msats, $self.invoice_request.quantity
 332                 )?;
 333
 334                 Ok($self.build_without_checks())
 335         }
 336
 337         fn build_without_checks($($self_mut)* $self: $self_type) ->
 338                 (UnsignedInvoiceRequest, Option<KeyPair>, Option<&'b Secp256k1<$secp_context>>)
 339         {
 340                 // Create the metadata for stateless verification of a Bolt12Invoice.
 341                 let mut keys = None;
 342                 let secp_ctx = $self.secp_ctx.clone();
 343                 if $self.invoice_request.payer.0.has_derivation_material() {
 344                         let mut metadata = core::mem::take(&mut $self.invoice_request.payer.0);
 345
 346                         let mut tlv_stream = $self.invoice_request.as_tlv_stream();
 347                         debug_assert!(tlv_stream.2.payer_id.is_none());
 348                         tlv_stream.0.metadata = None;
 349                         if !metadata.derives_payer_keys() {
 350                                 tlv_stream.2.payer_id = $self.payer_id.as_ref();
 351                         }
 352
 353                         let (derived_metadata, derived_keys) = metadata.derive_from(tlv_stream, $self.secp_ctx);
 354                         metadata = derived_metadata;
 355                         keys = derived_keys;
 356                         if let Some(keys) = keys {
 357                                 debug_assert!($self.payer_id.is_none());
 358                                 $self.payer_id = Some(keys.public_key());
 359                         }
 360
 361                         $self.invoice_request.payer.0 = metadata;
 362                 }
 363
 364                 debug_assert!($self.invoice_request.payer.0.as_bytes().is_some());
 365                 debug_assert!($self.payer_id.is_some());
 366                 let payer_id = $self.payer_id.unwrap();
 367
 368                 let invoice_request = InvoiceRequestContents {
 369                         #[cfg(not(c_bindings))]
 370                         inner: $self.invoice_request,
 371                         #[cfg(c_bindings)]
 372                         inner: $self.invoice_request.clone(),
 373                         payer_id,
 374                 };
 375                 let unsigned_invoice_request = UnsignedInvoiceRequest::new($self.offer, invoice_request);
 376
 377                 (unsigned_invoice_request, keys, secp_ctx)
 378         }
 379 } }
 380
 381 #[cfg(test)]
 382 macro_rules! invoice_request_builder_test_methods { (
 383         $self: ident, $self_type: ty, $return_type: ty, $return_value: expr $(, $self_mut: tt)?
 384 ) => {
 385         #[cfg_attr(c_bindings, allow(dead_code))]
 386         fn chain_unchecked($($self_mut)* $self: $self_type, network: Network) -> $return_type {
 387                 let chain = ChainHash::using_genesis_block(network);
 388                 $self.invoice_request.chain = Some(chain);
 389                 $return_value
 390         }
 391
 392         #[cfg_attr(c_bindings, allow(dead_code))]
 393         fn amount_msats_unchecked($($self_mut)* $self: $self_type, amount_msats: u64) -> $return_type {
 394                 $self.invoice_request.amount_msats = Some(amount_msats);
 395                 $return_value
 396         }
 397
 398         #[cfg_attr(c_bindings, allow(dead_code))]
 399         fn features_unchecked($($self_mut)* $self: $self_type, features: InvoiceRequestFeatures) -> $return_type {
 400                 $self.invoice_request.features = features;
 401                 $return_value
 402         }
 403
 404         #[cfg_attr(c_bindings, allow(dead_code))]
 405         fn quantity_unchecked($($self_mut)* $self: $self_type, quantity: u64) -> $return_type {
 406                 $self.invoice_request.quantity = Some(quantity);
 407                 $return_value
 408         }
 409
 410         #[cfg_attr(c_bindings, allow(dead_code))]
 411         pub(super) fn build_unchecked($self: $self_type) -> UnsignedInvoiceRequest {
 412                 $self.build_without_checks().0
 413         }
 414 } }
 415
 416 impl<'a, 'b, T: secp256k1::Signing> InvoiceRequestBuilder<'a, 'b, ExplicitPayerId, T> {
 417         invoice_request_explicit_payer_id_builder_methods!(self, Self);
 418 }
 419
 420 impl<'a, 'b, T: secp256k1::Signing> InvoiceRequestBuilder<'a, 'b, DerivedPayerId, T> {
 421         invoice_request_derived_payer_id_builder_methods!(self, Self, T);
 422 }
 423
 424 impl<'a, 'b, P: PayerIdStrategy, T: secp256k1::Signing> InvoiceRequestBuilder<'a, 'b, P, T> {
 425         invoice_request_builder_methods!(self, Self, Self, self, T, mut);
 426
 427         #[cfg(test)]
 428         invoice_request_builder_test_methods!(self, Self, Self, self, mut);
 429 }
 430
 431 #[cfg(all(c_bindings, not(test)))]
 432 impl<'a, 'b> InvoiceRequestWithExplicitPayerIdBuilder<'a, 'b> {
 433         invoice_request_explicit_payer_id_builder_methods!(self, &mut Self);
 434         invoice_request_builder_methods!(self, &mut Self, (), (), secp256k1::All);
 435 }
 436
 437 #[cfg(all(c_bindings, test))]
 438 impl<'a, 'b> InvoiceRequestWithExplicitPayerIdBuilder<'a, 'b> {
 439         invoice_request_explicit_payer_id_builder_methods!(self, &mut Self);
 440         invoice_request_builder_methods!(self, &mut Self, &mut Self, self, secp256k1::All);
 441         invoice_request_builder_test_methods!(self, &mut Self, &mut Self, self);
 442 }
 443
 444 #[cfg(all(c_bindings, not(test)))]
 445 impl<'a, 'b> InvoiceRequestWithDerivedPayerIdBuilder<'a, 'b> {
 446         invoice_request_derived_payer_id_builder_methods!(self, &mut Self, secp256k1::All);
 447         invoice_request_builder_methods!(self, &mut Self, (), (), secp256k1::All);
 448 }
 449
 450 #[cfg(all(c_bindings, test))]
 451 impl<'a, 'b> InvoiceRequestWithDerivedPayerIdBuilder<'a, 'b> {
 452         invoice_request_derived_payer_id_builder_methods!(self, &mut Self, secp256k1::All);
 453         invoice_request_builder_methods!(self, &mut Self, &mut Self, self, secp256k1::All);
 454         invoice_request_builder_test_methods!(self, &mut Self, &mut Self, self);
 455 }
 456
 457 #[cfg(c_bindings)]
 458 impl<'a, 'b> From<InvoiceRequestWithExplicitPayerIdBuilder<'a, 'b>>
 459 for InvoiceRequestBuilder<'a, 'b, ExplicitPayerId, secp256k1::All> {
 460         fn from(builder: InvoiceRequestWithExplicitPayerIdBuilder<'a, 'b>) -> Self {
 461                 let InvoiceRequestWithExplicitPayerIdBuilder {
 462                         offer, invoice_request, payer_id, payer_id_strategy, secp_ctx,
 463                 } = builder;
 464
 465                 Self {
 466                         offer, invoice_request, payer_id, payer_id_strategy, secp_ctx,
 467                 }
 468         }
 469 }
 470
 471 #[cfg(c_bindings)]
 472 impl<'a, 'b> From<InvoiceRequestWithDerivedPayerIdBuilder<'a, 'b>>
 473 for InvoiceRequestBuilder<'a, 'b, DerivedPayerId, secp256k1::All> {
 474         fn from(builder: InvoiceRequestWithDerivedPayerIdBuilder<'a, 'b>) -> Self {
 475                 let InvoiceRequestWithDerivedPayerIdBuilder {
 476                         offer, invoice_request, payer_id, payer_id_strategy, secp_ctx,
 477                 } = builder;
 478
 479                 Self {
 480                         offer, invoice_request, payer_id, payer_id_strategy, secp_ctx,
 481                 }
 482         }
 483 }
 484
 485 /// A semantically valid [`InvoiceRequest`] that hasn't been signed.
 486 ///
 487 /// # Serialization
 488 ///
 489 /// This is serialized as a TLV stream, which includes TLV records from the originating message. As
 490 /// such, it may include unknown, odd TLV records.
 491 pub struct UnsignedInvoiceRequest {
 492         bytes: Vec<u8>,
 493         contents: InvoiceRequestContents,
 494         tagged_hash: TaggedHash,
 495 }
 496
 497 /// A function for signing an [`UnsignedInvoiceRequest`].
 498 pub trait SignInvoiceRequestFn {
 499         /// Error type returned by the function.
 500         type Error;
 501
 502         /// Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
 503         fn sign_invoice_request(&self, message: &UnsignedInvoiceRequest) -> Result<Signature, Self::Error>;
 504 }
 505
 506 impl<F, E> SignInvoiceRequestFn for F
 507 where
 508         F: Fn(&UnsignedInvoiceRequest) -> Result<Signature, E>,
 509 {
 510         type Error = E;
 511
 512         fn sign_invoice_request(&self, message: &UnsignedInvoiceRequest) -> Result<Signature, E> {
 513                 self(message)
 514         }
 515 }
 516
 517 impl<F, E> SignFn<UnsignedInvoiceRequest> for F
 518 where
 519         F: SignInvoiceRequestFn<Error = E>,
 520 {
 521         type Error = E;
 522
 523         fn sign(&self, message: &UnsignedInvoiceRequest) -> Result<Signature, Self::Error> {
 524                 self.sign_invoice_request(message)
 525         }
 526 }
 527
 528 impl UnsignedInvoiceRequest {
 529         fn new(offer: &Offer, contents: InvoiceRequestContents) -> Self {
 530                 // Use the offer bytes instead of the offer TLV stream as the offer may have contained
 531                 // unknown TLV records, which are not stored in `OfferContents`.
 532                 let (payer_tlv_stream, _offer_tlv_stream, invoice_request_tlv_stream) =
 533                         contents.as_tlv_stream();
 534                 let offer_bytes = WithoutLength(&offer.bytes);
 535                 let unsigned_tlv_stream = (payer_tlv_stream, offer_bytes, invoice_request_tlv_stream);
 536
 537                 let mut bytes = Vec::new();
 538                 unsigned_tlv_stream.write(&mut bytes).unwrap();
 539
 540                 let tagged_hash = TaggedHash::new(SIGNATURE_TAG, &bytes);
 541
 542                 Self { bytes, contents, tagged_hash }
 543         }
 544
 545         /// Returns the [`TaggedHash`] of the invoice to sign.
 546         pub fn tagged_hash(&self) -> &TaggedHash {
 547                 &self.tagged_hash
 548         }
 549 }
 550
 551 macro_rules! unsigned_invoice_request_sign_method { (
 552         $self: ident, $self_type: ty $(, $self_mut: tt)?
 553 ) => {
 554         /// Signs the [`TaggedHash`] of the invoice request using the given function.
 555         ///
 556         /// Note: The hash computation may have included unknown, odd TLV records.
 557         pub fn sign<F: SignInvoiceRequestFn>(
 558                 $($self_mut)* $self: $self_type, sign: F
 559         ) -> Result<InvoiceRequest, SignError<F::Error>> {
 560                 let pubkey = $self.contents.payer_id;
 561                 let signature = merkle::sign_message(sign, &$self, pubkey)?;
 562
 563                 // Append the signature TLV record to the bytes.
 564                 let signature_tlv_stream = SignatureTlvStreamRef {
 565                         signature: Some(&signature),
 566                 };
 567                 signature_tlv_stream.write(&mut $self.bytes).unwrap();
 568
 569                 Ok(InvoiceRequest {
 570                         #[cfg(not(c_bindings))]
 571                         bytes: $self.bytes,
 572                         #[cfg(c_bindings)]
 573                         bytes: $self.bytes.clone(),
 574                         #[cfg(not(c_bindings))]
 575                         contents: $self.contents,
 576                         #[cfg(c_bindings)]
 577                         contents: $self.contents.clone(),
 578                         signature,
 579                 })
 580         }
 581 } }
 582
 583 #[cfg(not(c_bindings))]
 584 impl UnsignedInvoiceRequest {
 585         unsigned_invoice_request_sign_method!(self, Self, mut);
 586 }
 587
 588 #[cfg(c_bindings)]
 589 impl UnsignedInvoiceRequest {
 590         unsigned_invoice_request_sign_method!(self, &mut Self);
 591 }
 592
 593 impl AsRef<TaggedHash> for UnsignedInvoiceRequest {
 594         fn as_ref(&self) -> &TaggedHash {
 595                 &self.tagged_hash
 596         }
 597 }
 598
 599 /// An `InvoiceRequest` is a request for a [`Bolt12Invoice`] formulated from an [`Offer`].
 600 ///
 601 /// An offer may provide choices such as quantity, amount, chain, features, etc. An invoice request
 602 /// specifies these such that its recipient can send an invoice for payment.
 603 ///
 604 /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 605 /// [`Offer`]: crate::offers::offer::Offer
 606 #[derive(Clone, Debug)]
 607 #[cfg_attr(test, derive(PartialEq))]
 608 pub struct InvoiceRequest {
 609         pub(super) bytes: Vec<u8>,
 610         pub(super) contents: InvoiceRequestContents,
 611         signature: Signature,
 612 }
 613
 614 /// An [`InvoiceRequest`] that has been verified by [`InvoiceRequest::verify`] and exposes different
 615 /// ways to respond depending on whether the signing keys were derived.
 616 #[derive(Clone, Debug)]
 617 pub struct VerifiedInvoiceRequest {
 618         /// The verified request.
 619         inner: InvoiceRequest,
 620
 621         /// Keys used for signing a [`Bolt12Invoice`] if they can be derived.
 622         ///
 623         /// If `Some`, must call [`respond_using_derived_keys`] when responding. Otherwise, call
 624         /// [`respond_with`].
 625         ///
 626         /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 627         /// [`respond_using_derived_keys`]: Self::respond_using_derived_keys
 628         /// [`respond_with`]: Self::respond_with
 629         pub keys: Option<KeyPair>,
 630 }
 631
 632 /// The contents of an [`InvoiceRequest`], which may be shared with an [`Bolt12Invoice`].
 633 ///
 634 /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 635 #[derive(Clone, Debug)]
 636 #[cfg_attr(test, derive(PartialEq))]
 637 pub(super) struct InvoiceRequestContents {
 638         pub(super) inner: InvoiceRequestContentsWithoutPayerId,
 639         payer_id: PublicKey,
 640 }
 641
 642 #[derive(Clone, Debug)]
 643 #[cfg_attr(test, derive(PartialEq))]
 644 pub(super) struct InvoiceRequestContentsWithoutPayerId {
 645         payer: PayerContents,
 646         pub(super) offer: OfferContents,
 647         chain: Option<ChainHash>,
 648         amount_msats: Option<u64>,
 649         features: InvoiceRequestFeatures,
 650         quantity: Option<u64>,
 651         payer_note: Option<String>,
 652 }
 653
 654 macro_rules! invoice_request_accessors { ($self: ident, $contents: expr) => {
 655         /// An unpredictable series of bytes, typically containing information about the derivation of
 656         /// [`payer_id`].
 657         ///
 658         /// [`payer_id`]: Self::payer_id
 659         pub fn payer_metadata(&$self) -> &[u8] {
 660                 $contents.metadata()
 661         }
 662
 663         /// A chain from [`Offer::chains`] that the offer is valid for.
 664         pub fn chain(&$self) -> ChainHash {
 665                 $contents.chain()
 666         }
 667
 668         /// The amount to pay in msats (i.e., the minimum lightning-payable unit for [`chain`]), which
 669         /// must be greater than or equal to [`Offer::amount`], converted if necessary.
 670         ///
 671         /// [`chain`]: Self::chain
 672         pub fn amount_msats(&$self) -> Option<u64> {
 673                 $contents.amount_msats()
 674         }
 675
 676         /// Features pertaining to requesting an invoice.
 677         pub fn invoice_request_features(&$self) -> &InvoiceRequestFeatures {
 678                 &$contents.features()
 679         }
 680
 681         /// The quantity of the offer's item conforming to [`Offer::is_valid_quantity`].
 682         pub fn quantity(&$self) -> Option<u64> {
 683                 $contents.quantity()
 684         }
 685
 686         /// A possibly transient pubkey used to sign the invoice request.
 687         pub fn payer_id(&$self) -> PublicKey {
 688                 $contents.payer_id()
 689         }
 690
 691         /// A payer-provided note which will be seen by the recipient and reflected back in the invoice
 692         /// response.
 693         pub fn payer_note(&$self) -> Option<PrintableString> {
 694                 $contents.payer_note()
 695         }
 696 } }
 697
 698 impl UnsignedInvoiceRequest {
 699         offer_accessors!(self, self.contents.inner.offer);
 700         invoice_request_accessors!(self, self.contents);
 701 }
 702
 703 macro_rules! invoice_request_respond_with_explicit_signing_pubkey_methods { (
 704         $self: ident, $contents: expr, $builder: ty
 705 ) => {
 706         /// Creates an [`InvoiceBuilder`] for the request with the given required fields and using the
 707         /// [`Duration`] since [`std::time::SystemTime::UNIX_EPOCH`] as the creation time.
 708         ///
 709         /// See [`InvoiceRequest::respond_with_no_std`] for further details where the aforementioned
 710         /// creation time is used for the `created_at` parameter.
 711         ///
 712         /// [`Duration`]: core::time::Duration
 713         #[cfg(feature = "std")]
 714         pub fn respond_with(
 715                 &$self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash
 716         ) -> Result<$builder, Bolt12SemanticError> {
 717                 let created_at = std::time::SystemTime::now()
 718                         .duration_since(std::time::SystemTime::UNIX_EPOCH)
 719                         .expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH");
 720
 721                 $contents.respond_with_no_std(payment_paths, payment_hash, created_at)
 722         }
 723
 724         /// Creates an [`InvoiceBuilder`] for the request with the given required fields.
 725         ///
 726         /// Unless [`InvoiceBuilder::relative_expiry`] is set, the invoice will expire two hours after
 727         /// `created_at`, which is used to set [`Bolt12Invoice::created_at`]. Useful for `no-std` builds
 728         /// where [`std::time::SystemTime`] is not available.
 729         ///
 730         /// The caller is expected to remember the preimage of `payment_hash` in order to claim a payment
 731         /// for the invoice.
 732         ///
 733         /// The `payment_paths` parameter is useful for maintaining the payment recipient's privacy. It
 734         /// must contain one or more elements ordered from most-preferred to least-preferred, if there's
 735         /// a preference. Note, however, that any privacy is lost if a public node id was used for
 736         /// [`Offer::signing_pubkey`].
 737         ///
 738         /// Errors if the request contains unknown required features.
 739         ///
 740         /// # Note
 741         ///
 742         /// If the originating [`Offer`] was created using [`OfferBuilder::deriving_signing_pubkey`],
 743         /// then use [`InvoiceRequest::verify`] and [`VerifiedInvoiceRequest`] methods instead.
 744         ///
 745         /// [`Bolt12Invoice::created_at`]: crate::offers::invoice::Bolt12Invoice::created_at
 746         /// [`OfferBuilder::deriving_signing_pubkey`]: crate::offers::offer::OfferBuilder::deriving_signing_pubkey
 747         pub fn respond_with_no_std(
 748                 &$self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash,
 749                 created_at: core::time::Duration
 750         ) -> Result<$builder, Bolt12SemanticError> {
 751                 if $contents.invoice_request_features().requires_unknown_bits() {
 752                         return Err(Bolt12SemanticError::UnknownRequiredFeatures);
 753                 }
 754
 755                 <$builder>::for_offer(&$contents, payment_paths, created_at, payment_hash)
 756         }
 757 } }
 758
 759 macro_rules! invoice_request_verify_method { ($self: ident, $self_type: ty) => {
 760         /// Verifies that the request was for an offer created using the given key. Returns the verified
 761         /// request which contains the derived keys needed to sign a [`Bolt12Invoice`] for the request
 762         /// if they could be extracted from the metadata.
 763         ///
 764         /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 765         pub fn verify<
 766                 #[cfg(not(c_bindings))]
 767                 T: secp256k1::Signing
 768         >(
 769                 $self: $self_type, key: &ExpandedKey,
 770                 #[cfg(not(c_bindings))]
 771                 secp_ctx: &Secp256k1<T>,
 772                 #[cfg(c_bindings)]
 773                 secp_ctx: &Secp256k1<secp256k1::All>,
 774         ) -> Result<VerifiedInvoiceRequest, ()> {
 775                 let keys = $self.contents.inner.offer.verify(&$self.bytes, key, secp_ctx)?;
 776                 Ok(VerifiedInvoiceRequest {
 777                         #[cfg(not(c_bindings))]
 778                         inner: $self,
 779                         #[cfg(c_bindings)]
 780                         inner: $self.clone(),
 781                         keys,
 782                 })
 783         }
 784
 785 } }
 786
 787 #[cfg(not(c_bindings))]
 788 impl InvoiceRequest {
 789         offer_accessors!(self, self.contents.inner.offer);
 790         invoice_request_accessors!(self, self.contents);
 791         invoice_request_respond_with_explicit_signing_pubkey_methods!(self, self, InvoiceBuilder<ExplicitSigningPubkey>);
 792         invoice_request_verify_method!(self, Self);
 793 }
 794
 795 #[cfg(c_bindings)]
 796 impl InvoiceRequest {
 797         offer_accessors!(self, self.contents.inner.offer);
 798         invoice_request_accessors!(self, self.contents);
 799         invoice_request_respond_with_explicit_signing_pubkey_methods!(self, self, InvoiceWithExplicitSigningPubkeyBuilder);
 800         invoice_request_verify_method!(self, &Self);
 801 }
 802
 803 impl InvoiceRequest {
 804         /// Signature of the invoice request using [`payer_id`].
 805         ///
 806         /// [`payer_id`]: Self::payer_id
 807         pub fn signature(&self) -> Signature {
 808                 self.signature
 809         }
 810
 811         pub(crate) fn as_tlv_stream(&self) -> FullInvoiceRequestTlvStreamRef {
 812                 let (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream) =
 813                         self.contents.as_tlv_stream();
 814                 let signature_tlv_stream = SignatureTlvStreamRef {
 815                         signature: Some(&self.signature),
 816                 };
 817                 (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, signature_tlv_stream)
 818         }
 819 }
 820
 821 macro_rules! invoice_request_respond_with_derived_signing_pubkey_methods { (
 822         $self: ident, $contents: expr, $builder: ty
 823 ) => {
 824         /// Creates an [`InvoiceBuilder`] for the request using the given required fields and that uses
 825         /// derived signing keys from the originating [`Offer`] to sign the [`Bolt12Invoice`]. Must use
 826         /// the same [`ExpandedKey`] as the one used to create the offer.
 827         ///
 828         /// See [`InvoiceRequest::respond_with`] for further details.
 829         ///
 830         /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 831         #[cfg(feature = "std")]
 832         pub fn respond_using_derived_keys(
 833                 &$self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash
 834         ) -> Result<$builder, Bolt12SemanticError> {
 835                 let created_at = std::time::SystemTime::now()
 836                         .duration_since(std::time::SystemTime::UNIX_EPOCH)
 837                         .expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH");
 838
 839                 $self.respond_using_derived_keys_no_std(payment_paths, payment_hash, created_at)
 840         }
 841
 842         /// Creates an [`InvoiceBuilder`] for the request using the given required fields and that uses
 843         /// derived signing keys from the originating [`Offer`] to sign the [`Bolt12Invoice`]. Must use
 844         /// the same [`ExpandedKey`] as the one used to create the offer.
 845         ///
 846         /// See [`InvoiceRequest::respond_with_no_std`] for further details.
 847         ///
 848         /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 849         pub fn respond_using_derived_keys_no_std(
 850                 &$self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash,
 851                 created_at: core::time::Duration
 852         ) -> Result<$builder, Bolt12SemanticError> {
 853                 if $self.inner.invoice_request_features().requires_unknown_bits() {
 854                         return Err(Bolt12SemanticError::UnknownRequiredFeatures);
 855                 }
 856
 857                 let keys = match $self.keys {
 858                         None => return Err(Bolt12SemanticError::InvalidMetadata),
 859                         Some(keys) => keys,
 860                 };
 861
 862                 <$builder>::for_offer_using_keys(
 863                         &$self.inner, payment_paths, created_at, payment_hash, keys
 864                 )
 865         }
 866 } }
 867
 868 impl VerifiedInvoiceRequest {
 869         offer_accessors!(self, self.inner.contents.inner.offer);
 870         invoice_request_accessors!(self, self.inner.contents);
 871         #[cfg(not(c_bindings))]
 872         invoice_request_respond_with_explicit_signing_pubkey_methods!(self, self.inner, InvoiceBuilder<ExplicitSigningPubkey>);
 873         #[cfg(c_bindings)]
 874         invoice_request_respond_with_explicit_signing_pubkey_methods!(self, self.inner, InvoiceWithExplicitSigningPubkeyBuilder);
 875         #[cfg(not(c_bindings))]
 876         invoice_request_respond_with_derived_signing_pubkey_methods!(self, self.inner, InvoiceBuilder<DerivedSigningPubkey>);
 877         #[cfg(c_bindings)]
 878         invoice_request_respond_with_derived_signing_pubkey_methods!(self, self.inner, InvoiceWithDerivedSigningPubkeyBuilder);
 879 }
 880
 881 impl InvoiceRequestContents {
 882         pub(super) fn metadata(&self) -> &[u8] {
 883                 self.inner.metadata()
 884         }
 885
 886         pub(super) fn derives_keys(&self) -> bool {
 887                 self.inner.payer.0.derives_payer_keys()
 888         }
 889
 890         pub(super) fn chain(&self) -> ChainHash {
 891                 self.inner.chain()
 892         }
 893
 894         pub(super) fn amount_msats(&self) -> Option<u64> {
 895                 self.inner.amount_msats
 896         }
 897
 898         pub(super) fn features(&self) -> &InvoiceRequestFeatures {
 899                 &self.inner.features
 900         }
 901
 902         pub(super) fn quantity(&self) -> Option<u64> {
 903                 self.inner.quantity
 904         }
 905
 906         pub(super) fn payer_id(&self) -> PublicKey {
 907                 self.payer_id
 908         }
 909
 910         pub(super) fn payer_note(&self) -> Option<PrintableString> {
 911                 self.inner.payer_note.as_ref()
 912                         .map(|payer_note| PrintableString(payer_note.as_str()))
 913         }
 914
 915         pub(super) fn as_tlv_stream(&self) -> PartialInvoiceRequestTlvStreamRef {
 916                 let (payer, offer, mut invoice_request) = self.inner.as_tlv_stream();
 917                 invoice_request.payer_id = Some(&self.payer_id);
 918                 (payer, offer, invoice_request)
 919         }
 920 }
 921
 922 impl InvoiceRequestContentsWithoutPayerId {
 923         pub(super) fn metadata(&self) -> &[u8] {
 924                 self.payer.0.as_bytes().map(|bytes| bytes.as_slice()).unwrap_or(&[])
 925         }
 926
 927         pub(super) fn chain(&self) -> ChainHash {
 928                 self.chain.unwrap_or_else(|| self.offer.implied_chain())
 929         }
 930
 931         pub(super) fn as_tlv_stream(&self) -> PartialInvoiceRequestTlvStreamRef {
 932                 let payer = PayerTlvStreamRef {
 933                         metadata: self.payer.0.as_bytes(),
 934                 };
 935
 936                 let offer = self.offer.as_tlv_stream();
 937
 938                 let features = {
 939                         if self.features == InvoiceRequestFeatures::empty() { None }
 940                         else { Some(&self.features) }
 941                 };
 942
 943                 let invoice_request = InvoiceRequestTlvStreamRef {
 944                         chain: self.chain.as_ref(),
 945                         amount: self.amount_msats,
 946                         features,
 947                         quantity: self.quantity,
 948                         payer_id: None,
 949                         payer_note: self.payer_note.as_ref(),
 950                 };
 951
 952                 (payer, offer, invoice_request)
 953         }
 954 }
 955
 956 impl Writeable for UnsignedInvoiceRequest {
 957         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 958                 WithoutLength(&self.bytes).write(writer)
 959         }
 960 }
 961
 962 impl Writeable for InvoiceRequest {
 963         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 964                 WithoutLength(&self.bytes).write(writer)
 965         }
 966 }
 967
 968 impl Writeable for InvoiceRequestContents {
 969         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 970                 self.as_tlv_stream().write(writer)
 971         }
 972 }
 973
 974 /// Valid type range for invoice_request TLV records.
 975 pub(super) const INVOICE_REQUEST_TYPES: core::ops::Range<u64> = 80..160;
 976
 977 /// TLV record type for [`InvoiceRequest::payer_id`] and [`Refund::payer_id`].
 978 ///
 979 /// [`Refund::payer_id`]: crate::offers::refund::Refund::payer_id
 980 pub(super) const INVOICE_REQUEST_PAYER_ID_TYPE: u64 = 88;
 981
 982 tlv_stream!(InvoiceRequestTlvStream, InvoiceRequestTlvStreamRef, INVOICE_REQUEST_TYPES, {
 983         (80, chain: ChainHash),
 984         (82, amount: (u64, HighZeroBytesDroppedBigSize)),
 985         (84, features: (InvoiceRequestFeatures, WithoutLength)),
 986         (86, quantity: (u64, HighZeroBytesDroppedBigSize)),
 987         (INVOICE_REQUEST_PAYER_ID_TYPE, payer_id: PublicKey),
 988         (89, payer_note: (String, WithoutLength)),
 989 });
 990
 991 type FullInvoiceRequestTlvStream =
 992         (PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream, SignatureTlvStream);
 993
 994 type FullInvoiceRequestTlvStreamRef<'a> = (
 995         PayerTlvStreamRef<'a>,
 996         OfferTlvStreamRef<'a>,
 997         InvoiceRequestTlvStreamRef<'a>,
 998         SignatureTlvStreamRef<'a>,
 999 );
1000
1001 impl SeekReadable for FullInvoiceRequestTlvStream {
1002         fn read<R: io::Read + io::Seek>(r: &mut R) -> Result<Self, DecodeError> {
1003                 let payer = SeekReadable::read(r)?;
1004                 let offer = SeekReadable::read(r)?;
1005                 let invoice_request = SeekReadable::read(r)?;
1006                 let signature = SeekReadable::read(r)?;
1007
1008                 Ok((payer, offer, invoice_request, signature))
1009         }
1010 }
1011
1012 type PartialInvoiceRequestTlvStream = (PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream);
1013
1014 type PartialInvoiceRequestTlvStreamRef<'a> = (
1015         PayerTlvStreamRef<'a>,
1016         OfferTlvStreamRef<'a>,
1017         InvoiceRequestTlvStreamRef<'a>,
1018 );
1019
1020 impl TryFrom<Vec<u8>> for UnsignedInvoiceRequest {
1021         type Error = Bolt12ParseError;
1022
1023         fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
1024                 let invoice_request = ParsedMessage::<PartialInvoiceRequestTlvStream>::try_from(bytes)?;
1025                 let ParsedMessage { bytes, tlv_stream } = invoice_request;
1026                 let (
1027                         payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream,
1028                 ) = tlv_stream;
1029                 let contents = InvoiceRequestContents::try_from(
1030                         (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
1031                 )?;
1032
1033                 let tagged_hash = TaggedHash::new(SIGNATURE_TAG, &bytes);
1034
1035                 Ok(UnsignedInvoiceRequest { bytes, contents, tagged_hash })
1036         }
1037 }
1038
1039 impl TryFrom<Vec<u8>> for InvoiceRequest {
1040         type Error = Bolt12ParseError;
1041
1042         fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
1043                 let invoice_request = ParsedMessage::<FullInvoiceRequestTlvStream>::try_from(bytes)?;
1044                 let ParsedMessage { bytes, tlv_stream } = invoice_request;
1045                 let (
1046                         payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream,
1047                         SignatureTlvStream { signature },
1048                 ) = tlv_stream;
1049                 let contents = InvoiceRequestContents::try_from(
1050                         (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
1051                 )?;
1052
1053                 let signature = match signature {
1054                         None => return Err(Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingSignature)),
1055                         Some(signature) => signature,
1056                 };
1057                 let message = TaggedHash::new(SIGNATURE_TAG, &bytes);
1058                 merkle::verify_signature(&signature, &message, contents.payer_id)?;
1059
1060                 Ok(InvoiceRequest { bytes, contents, signature })
1061         }
1062 }
1063
1064 impl TryFrom<PartialInvoiceRequestTlvStream> for InvoiceRequestContents {
1065         type Error = Bolt12SemanticError;
1066
1067         fn try_from(tlv_stream: PartialInvoiceRequestTlvStream) -> Result<Self, Self::Error> {
1068                 let (
1069                         PayerTlvStream { metadata },
1070                         offer_tlv_stream,
1071                         InvoiceRequestTlvStream { chain, amount, features, quantity, payer_id, payer_note },
1072                 ) = tlv_stream;
1073
1074                 let payer = match metadata {
1075                         None => return Err(Bolt12SemanticError::MissingPayerMetadata),
1076                         Some(metadata) => PayerContents(Metadata::Bytes(metadata)),
1077                 };
1078                 let offer = OfferContents::try_from(offer_tlv_stream)?;
1079
1080                 if !offer.supports_chain(chain.unwrap_or_else(|| offer.implied_chain())) {
1081                         return Err(Bolt12SemanticError::UnsupportedChain);
1082                 }
1083
1084                 if offer.amount().is_none() && amount.is_none() {
1085                         return Err(Bolt12SemanticError::MissingAmount);
1086                 }
1087
1088                 offer.check_quantity(quantity)?;
1089                 offer.check_amount_msats_for_quantity(amount, quantity)?;
1090
1091                 let features = features.unwrap_or_else(InvoiceRequestFeatures::empty);
1092
1093                 let payer_id = match payer_id {
1094                         None => return Err(Bolt12SemanticError::MissingPayerId),
1095                         Some(payer_id) => payer_id,
1096                 };
1097
1098                 Ok(InvoiceRequestContents {
1099                         inner: InvoiceRequestContentsWithoutPayerId {
1100                                 payer, offer, chain, amount_msats: amount, features, quantity, payer_note,
1101                         },
1102                         payer_id,
1103                 })
1104         }
1105 }
1106
1107 #[cfg(test)]
1108 mod tests {
1109         use super::{InvoiceRequest, InvoiceRequestTlvStreamRef, SIGNATURE_TAG, UnsignedInvoiceRequest};
1110
1111         use bitcoin::blockdata::constants::ChainHash;
1112         use bitcoin::network::constants::Network;
1113         use bitcoin::secp256k1::{KeyPair, Secp256k1, SecretKey, self};
1114         use core::convert::{Infallible, TryFrom};
1115         use core::num::NonZeroU64;
1116         #[cfg(feature = "std")]
1117         use core::time::Duration;
1118         use crate::sign::KeyMaterial;
1119         use crate::ln::channelmanager::PaymentId;
1120         use crate::ln::features::{InvoiceRequestFeatures, OfferFeatures};
1121         use crate::ln::inbound_payment::ExpandedKey;
1122         use crate::ln::msgs::{DecodeError, MAX_VALUE_MSAT};
1123         use crate::offers::invoice::{Bolt12Invoice, SIGNATURE_TAG as INVOICE_SIGNATURE_TAG};
1124         use crate::offers::merkle::{SignError, SignatureTlvStreamRef, TaggedHash, self};
1125         use crate::offers::offer::{Amount, OfferTlvStreamRef, Quantity};
1126         #[cfg(not(c_bindings))]
1127         use {
1128                 crate::offers::offer::OfferBuilder,
1129         };
1130         #[cfg(c_bindings)]
1131         use {
1132                 crate::offers::offer::OfferWithExplicitMetadataBuilder as OfferBuilder,
1133         };
1134         use crate::offers::parse::{Bolt12ParseError, Bolt12SemanticError};
1135         use crate::offers::payer::PayerTlvStreamRef;
1136         use crate::offers::test_utils::*;
1137         use crate::util::ser::{BigSize, Writeable};
1138         use crate::util::string::PrintableString;
1139
1140         #[test]
1141         fn builds_invoice_request_with_defaults() {
1142                 let unsigned_invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1143                         .amount_msats(1000)
1144                         .build().unwrap()
1145                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1146                         .build().unwrap();
1147                 #[cfg(c_bindings)]
1148                 let mut unsigned_invoice_request = unsigned_invoice_request;
1149
1150                 let mut buffer = Vec::new();
1151                 unsigned_invoice_request.write(&mut buffer).unwrap();
1152
1153                 assert_eq!(unsigned_invoice_request.bytes, buffer.as_slice());
1154                 assert_eq!(unsigned_invoice_request.payer_metadata(), &[1; 32]);
1155                 assert_eq!(unsigned_invoice_request.chains(), vec![ChainHash::using_genesis_block(Network::Bitcoin)]);
1156                 assert_eq!(unsigned_invoice_request.metadata(), None);
1157                 assert_eq!(unsigned_invoice_request.amount(), Some(&Amount::Bitcoin { amount_msats: 1000 }));
1158                 assert_eq!(unsigned_invoice_request.description(), PrintableString("foo"));
1159                 assert_eq!(unsigned_invoice_request.offer_features(), &OfferFeatures::empty());
1160                 assert_eq!(unsigned_invoice_request.absolute_expiry(), None);
1161                 assert_eq!(unsigned_invoice_request.paths(), &[]);
1162                 assert_eq!(unsigned_invoice_request.issuer(), None);
1163                 assert_eq!(unsigned_invoice_request.supported_quantity(), Quantity::One);
1164                 assert_eq!(unsigned_invoice_request.signing_pubkey(), recipient_pubkey());
1165                 assert_eq!(unsigned_invoice_request.chain(), ChainHash::using_genesis_block(Network::Bitcoin));
1166                 assert_eq!(unsigned_invoice_request.amount_msats(), None);
1167                 assert_eq!(unsigned_invoice_request.invoice_request_features(), &InvoiceRequestFeatures::empty());
1168                 assert_eq!(unsigned_invoice_request.quantity(), None);
1169                 assert_eq!(unsigned_invoice_request.payer_id(), payer_pubkey());
1170                 assert_eq!(unsigned_invoice_request.payer_note(), None);
1171
1172                 match UnsignedInvoiceRequest::try_from(buffer) {
1173                         Err(e) => panic!("error parsing unsigned invoice request: {:?}", e),
1174                         Ok(parsed) => {
1175                                 assert_eq!(parsed.bytes, unsigned_invoice_request.bytes);
1176                                 assert_eq!(parsed.tagged_hash, unsigned_invoice_request.tagged_hash);
1177                         },
1178                 }
1179
1180                 let invoice_request = unsigned_invoice_request.sign(payer_sign).unwrap();
1181
1182                 let mut buffer = Vec::new();
1183                 invoice_request.write(&mut buffer).unwrap();
1184
1185                 assert_eq!(invoice_request.bytes, buffer.as_slice());
1186                 assert_eq!(invoice_request.payer_metadata(), &[1; 32]);
1187                 assert_eq!(invoice_request.chains(), vec![ChainHash::using_genesis_block(Network::Bitcoin)]);
1188                 assert_eq!(invoice_request.metadata(), None);
1189                 assert_eq!(invoice_request.amount(), Some(&Amount::Bitcoin { amount_msats: 1000 }));
1190                 assert_eq!(invoice_request.description(), PrintableString("foo"));
1191                 assert_eq!(invoice_request.offer_features(), &OfferFeatures::empty());
1192                 assert_eq!(invoice_request.absolute_expiry(), None);
1193                 assert_eq!(invoice_request.paths(), &[]);
1194                 assert_eq!(invoice_request.issuer(), None);
1195                 assert_eq!(invoice_request.supported_quantity(), Quantity::One);
1196                 assert_eq!(invoice_request.signing_pubkey(), recipient_pubkey());
1197                 assert_eq!(invoice_request.chain(), ChainHash::using_genesis_block(Network::Bitcoin));
1198                 assert_eq!(invoice_request.amount_msats(), None);
1199                 assert_eq!(invoice_request.invoice_request_features(), &InvoiceRequestFeatures::empty());
1200                 assert_eq!(invoice_request.quantity(), None);
1201                 assert_eq!(invoice_request.payer_id(), payer_pubkey());
1202                 assert_eq!(invoice_request.payer_note(), None);
1203
1204                 let message = TaggedHash::new(SIGNATURE_TAG, &invoice_request.bytes);
1205                 assert!(merkle::verify_signature(&invoice_request.signature, &message, payer_pubkey()).is_ok());
1206
1207                 assert_eq!(
1208                         invoice_request.as_tlv_stream(),
1209                         (
1210                                 PayerTlvStreamRef { metadata: Some(&vec![1; 32]) },
1211                                 OfferTlvStreamRef {
1212                                         chains: None,
1213                                         metadata: None,
1214                                         currency: None,
1215                                         amount: Some(1000),
1216                                         description: Some(&String::from("foo")),
1217                                         features: None,
1218                                         absolute_expiry: None,
1219                                         paths: None,
1220                                         issuer: None,
1221                                         quantity_max: None,
1222                                         node_id: Some(&recipient_pubkey()),
1223                                 },
1224                                 InvoiceRequestTlvStreamRef {
1225                                         chain: None,
1226                                         amount: None,
1227                                         features: None,
1228                                         quantity: None,
1229                                         payer_id: Some(&payer_pubkey()),
1230                                         payer_note: None,
1231                                 },
1232                                 SignatureTlvStreamRef { signature: Some(&invoice_request.signature()) },
1233                         ),
1234                 );
1235
1236                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1237                         panic!("error parsing invoice request: {:?}", e);
1238                 }
1239         }
1240
1241         #[cfg(feature = "std")]
1242         #[test]
1243         fn builds_invoice_request_from_offer_with_expiration() {
1244                 let future_expiry = Duration::from_secs(u64::max_value());
1245                 let past_expiry = Duration::from_secs(0);
1246
1247                 if let Err(e) = OfferBuilder::new("foo".into(), recipient_pubkey())
1248                         .amount_msats(1000)
1249                         .absolute_expiry(future_expiry)
1250                         .build().unwrap()
1251                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1252                         .build()
1253                 {
1254                         panic!("error building invoice_request: {:?}", e);
1255                 }
1256
1257                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1258                         .amount_msats(1000)
1259                         .absolute_expiry(past_expiry)
1260                         .build().unwrap()
1261                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1262                         .build()
1263                 {
1264                         Ok(_) => panic!("expected error"),
1265                         Err(e) => assert_eq!(e, Bolt12SemanticError::AlreadyExpired),
1266                 }
1267         }
1268
1269         #[test]
1270         fn builds_invoice_request_with_derived_metadata() {
1271                 let payer_id = payer_pubkey();
1272                 let expanded_key = ExpandedKey::new(&KeyMaterial([42; 32]));
1273                 let entropy = FixedEntropy {};
1274                 let secp_ctx = Secp256k1::new();
1275                 let payment_id = PaymentId([1; 32]);
1276
1277                 let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
1278                         .amount_msats(1000)
1279                         .build().unwrap();
1280                 let invoice_request = offer
1281                         .request_invoice_deriving_metadata(payer_id, &expanded_key, &entropy, payment_id)
1282                         .unwrap()
1283                         .build().unwrap()
1284                         .sign(payer_sign).unwrap();
1285                 assert_eq!(invoice_request.payer_id(), payer_pubkey());
1286
1287                 let invoice = invoice_request.respond_with_no_std(payment_paths(), payment_hash(), now())
1288                         .unwrap()
1289                         .build().unwrap()
1290                         .sign(recipient_sign).unwrap();
1291                 match invoice.verify(&expanded_key, &secp_ctx) {
1292                         Ok(payment_id) => assert_eq!(payment_id, PaymentId([1; 32])),
1293                         Err(()) => panic!("verification failed"),
1294                 }
1295
1296                 // Fails verification with altered fields
1297                 let (
1298                         payer_tlv_stream, offer_tlv_stream, mut invoice_request_tlv_stream,
1299                         mut invoice_tlv_stream, mut signature_tlv_stream
1300                 ) = invoice.as_tlv_stream();
1301                 invoice_request_tlv_stream.amount = Some(2000);
1302                 invoice_tlv_stream.amount = Some(2000);
1303
1304                 let tlv_stream =
1305                         (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream);
1306                 let mut bytes = Vec::new();
1307                 tlv_stream.write(&mut bytes).unwrap();
1308
1309                 let message = TaggedHash::new(INVOICE_SIGNATURE_TAG, &bytes);
1310                 let signature = merkle::sign_message(recipient_sign, &message, recipient_pubkey()).unwrap();
1311                 signature_tlv_stream.signature = Some(&signature);
1312
1313                 let mut encoded_invoice = bytes;
1314                 signature_tlv_stream.write(&mut encoded_invoice).unwrap();
1315
1316                 let invoice = Bolt12Invoice::try_from(encoded_invoice).unwrap();
1317                 assert!(invoice.verify(&expanded_key, &secp_ctx).is_err());
1318
1319                 // Fails verification with altered metadata
1320                 let (
1321                         mut payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream,
1322                         mut signature_tlv_stream
1323                 ) = invoice.as_tlv_stream();
1324                 let metadata = payer_tlv_stream.metadata.unwrap().iter().copied().rev().collect();
1325                 payer_tlv_stream.metadata = Some(&metadata);
1326
1327                 let tlv_stream =
1328                         (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream);
1329                 let mut bytes = Vec::new();
1330                 tlv_stream.write(&mut bytes).unwrap();
1331
1332                 let message = TaggedHash::new(INVOICE_SIGNATURE_TAG, &bytes);
1333                 let signature = merkle::sign_message(recipient_sign, &message, recipient_pubkey()).unwrap();
1334                 signature_tlv_stream.signature = Some(&signature);
1335
1336                 let mut encoded_invoice = bytes;
1337                 signature_tlv_stream.write(&mut encoded_invoice).unwrap();
1338
1339                 let invoice = Bolt12Invoice::try_from(encoded_invoice).unwrap();
1340                 assert!(invoice.verify(&expanded_key, &secp_ctx).is_err());
1341         }
1342
1343         #[test]
1344         fn builds_invoice_request_with_derived_payer_id() {
1345                 let expanded_key = ExpandedKey::new(&KeyMaterial([42; 32]));
1346                 let entropy = FixedEntropy {};
1347                 let secp_ctx = Secp256k1::new();
1348                 let payment_id = PaymentId([1; 32]);
1349
1350                 let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
1351                         .amount_msats(1000)
1352                         .build().unwrap();
1353                 let invoice_request = offer
1354                         .request_invoice_deriving_payer_id(&expanded_key, &entropy, &secp_ctx, payment_id)
1355                         .unwrap()
1356                         .build_and_sign()
1357                         .unwrap();
1358
1359                 let invoice = invoice_request.respond_with_no_std(payment_paths(), payment_hash(), now())
1360                         .unwrap()
1361                         .build().unwrap()
1362                         .sign(recipient_sign).unwrap();
1363                 match invoice.verify(&expanded_key, &secp_ctx) {
1364                         Ok(payment_id) => assert_eq!(payment_id, PaymentId([1; 32])),
1365                         Err(()) => panic!("verification failed"),
1366                 }
1367
1368                 // Fails verification with altered fields
1369                 let (
1370                         payer_tlv_stream, offer_tlv_stream, mut invoice_request_tlv_stream,
1371                         mut invoice_tlv_stream, mut signature_tlv_stream
1372                 ) = invoice.as_tlv_stream();
1373                 invoice_request_tlv_stream.amount = Some(2000);
1374                 invoice_tlv_stream.amount = Some(2000);
1375
1376                 let tlv_stream =
1377                         (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream);
1378                 let mut bytes = Vec::new();
1379                 tlv_stream.write(&mut bytes).unwrap();
1380
1381                 let message = TaggedHash::new(INVOICE_SIGNATURE_TAG, &bytes);
1382                 let signature = merkle::sign_message(recipient_sign, &message, recipient_pubkey()).unwrap();
1383                 signature_tlv_stream.signature = Some(&signature);
1384
1385                 let mut encoded_invoice = bytes;
1386                 signature_tlv_stream.write(&mut encoded_invoice).unwrap();
1387
1388                 let invoice = Bolt12Invoice::try_from(encoded_invoice).unwrap();
1389                 assert!(invoice.verify(&expanded_key, &secp_ctx).is_err());
1390
1391                 // Fails verification with altered payer id
1392                 let (
1393                         payer_tlv_stream, offer_tlv_stream, mut invoice_request_tlv_stream, invoice_tlv_stream,
1394                         mut signature_tlv_stream
1395                 ) = invoice.as_tlv_stream();
1396                 let payer_id = pubkey(1);
1397                 invoice_request_tlv_stream.payer_id = Some(&payer_id);
1398
1399                 let tlv_stream =
1400                         (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream);
1401                 let mut bytes = Vec::new();
1402                 tlv_stream.write(&mut bytes).unwrap();
1403
1404                 let message = TaggedHash::new(INVOICE_SIGNATURE_TAG, &bytes);
1405                 let signature = merkle::sign_message(recipient_sign, &message, recipient_pubkey()).unwrap();
1406                 signature_tlv_stream.signature = Some(&signature);
1407
1408                 let mut encoded_invoice = bytes;
1409                 signature_tlv_stream.write(&mut encoded_invoice).unwrap();
1410
1411                 let invoice = Bolt12Invoice::try_from(encoded_invoice).unwrap();
1412                 assert!(invoice.verify(&expanded_key, &secp_ctx).is_err());
1413         }
1414
1415         #[test]
1416         fn builds_invoice_request_with_chain() {
1417                 let mainnet = ChainHash::using_genesis_block(Network::Bitcoin);
1418                 let testnet = ChainHash::using_genesis_block(Network::Testnet);
1419
1420                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1421                         .amount_msats(1000)
1422                         .build().unwrap()
1423                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1424                         .chain(Network::Bitcoin).unwrap()
1425                         .build().unwrap()
1426                         .sign(payer_sign).unwrap();
1427                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1428                 assert_eq!(invoice_request.chain(), mainnet);
1429                 assert_eq!(tlv_stream.chain, None);
1430
1431                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1432                         .amount_msats(1000)
1433                         .chain(Network::Testnet)
1434                         .build().unwrap()
1435                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1436                         .chain(Network::Testnet).unwrap()
1437                         .build().unwrap()
1438                         .sign(payer_sign).unwrap();
1439                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1440                 assert_eq!(invoice_request.chain(), testnet);
1441                 assert_eq!(tlv_stream.chain, Some(&testnet));
1442
1443                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1444                         .amount_msats(1000)
1445                         .chain(Network::Bitcoin)
1446                         .chain(Network::Testnet)
1447                         .build().unwrap()
1448                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1449                         .chain(Network::Bitcoin).unwrap()
1450                         .build().unwrap()
1451                         .sign(payer_sign).unwrap();
1452                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1453                 assert_eq!(invoice_request.chain(), mainnet);
1454                 assert_eq!(tlv_stream.chain, None);
1455
1456                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1457                         .amount_msats(1000)
1458                         .chain(Network::Bitcoin)
1459                         .chain(Network::Testnet)
1460                         .build().unwrap()
1461                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1462                         .chain(Network::Bitcoin).unwrap()
1463                         .chain(Network::Testnet).unwrap()
1464                         .build().unwrap()
1465                         .sign(payer_sign).unwrap();
1466                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1467                 assert_eq!(invoice_request.chain(), testnet);
1468                 assert_eq!(tlv_stream.chain, Some(&testnet));
1469
1470                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1471                         .amount_msats(1000)
1472                         .chain(Network::Testnet)
1473                         .build().unwrap()
1474                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1475                         .chain(Network::Bitcoin)
1476                 {
1477                         Ok(_) => panic!("expected error"),
1478                         Err(e) => assert_eq!(e, Bolt12SemanticError::UnsupportedChain),
1479                 }
1480
1481                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1482                         .amount_msats(1000)
1483                         .chain(Network::Testnet)
1484                         .build().unwrap()
1485                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1486                         .build()
1487                 {
1488                         Ok(_) => panic!("expected error"),
1489                         Err(e) => assert_eq!(e, Bolt12SemanticError::UnsupportedChain),
1490                 }
1491         }
1492
1493         #[test]
1494         fn builds_invoice_request_with_amount() {
1495                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1496                         .amount_msats(1000)
1497                         .build().unwrap()
1498                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1499                         .amount_msats(1000).unwrap()
1500                         .build().unwrap()
1501                         .sign(payer_sign).unwrap();
1502                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1503                 assert_eq!(invoice_request.amount_msats(), Some(1000));
1504                 assert_eq!(tlv_stream.amount, Some(1000));
1505
1506                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1507                         .amount_msats(1000)
1508                         .build().unwrap()
1509                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1510                         .amount_msats(1001).unwrap()
1511                         .amount_msats(1000).unwrap()
1512                         .build().unwrap()
1513                         .sign(payer_sign).unwrap();
1514                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1515                 assert_eq!(invoice_request.amount_msats(), Some(1000));
1516                 assert_eq!(tlv_stream.amount, Some(1000));
1517
1518                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1519                         .amount_msats(1000)
1520                         .build().unwrap()
1521                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1522                         .amount_msats(1001).unwrap()
1523                         .build().unwrap()
1524                         .sign(payer_sign).unwrap();
1525                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1526                 assert_eq!(invoice_request.amount_msats(), Some(1001));
1527                 assert_eq!(tlv_stream.amount, Some(1001));
1528
1529                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1530                         .amount_msats(1000)
1531                         .build().unwrap()
1532                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1533                         .amount_msats(999)
1534                 {
1535                         Ok(_) => panic!("expected error"),
1536                         Err(e) => assert_eq!(e, Bolt12SemanticError::InsufficientAmount),
1537                 }
1538
1539                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1540                         .amount_msats(1000)
1541                         .supported_quantity(Quantity::Unbounded)
1542                         .build().unwrap()
1543                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1544                         .quantity(2).unwrap()
1545                         .amount_msats(1000)
1546                 {
1547                         Ok(_) => panic!("expected error"),
1548                         Err(e) => assert_eq!(e, Bolt12SemanticError::InsufficientAmount),
1549                 }
1550
1551                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1552                         .amount_msats(1000)
1553                         .build().unwrap()
1554                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1555                         .amount_msats(MAX_VALUE_MSAT + 1)
1556                 {
1557                         Ok(_) => panic!("expected error"),
1558                         Err(e) => assert_eq!(e, Bolt12SemanticError::InvalidAmount),
1559                 }
1560
1561                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1562                         .amount_msats(1000)
1563                         .supported_quantity(Quantity::Unbounded)
1564                         .build().unwrap()
1565                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1566                         .amount_msats(1000).unwrap()
1567                         .quantity(2).unwrap()
1568                         .build()
1569                 {
1570                         Ok(_) => panic!("expected error"),
1571                         Err(e) => assert_eq!(e, Bolt12SemanticError::InsufficientAmount),
1572                 }
1573
1574                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1575                         .build().unwrap()
1576                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1577                         .build()
1578                 {
1579                         Ok(_) => panic!("expected error"),
1580                         Err(e) => assert_eq!(e, Bolt12SemanticError::MissingAmount),
1581                 }
1582
1583                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1584                         .amount_msats(1000)
1585                         .supported_quantity(Quantity::Unbounded)
1586                         .build().unwrap()
1587                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1588                         .quantity(u64::max_value()).unwrap()
1589                         .build()
1590                 {
1591                         Ok(_) => panic!("expected error"),
1592                         Err(e) => assert_eq!(e, Bolt12SemanticError::InvalidAmount),
1593                 }
1594         }
1595
1596         #[test]
1597         fn builds_invoice_request_with_features() {
1598                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1599                         .amount_msats(1000)
1600                         .build().unwrap()
1601                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1602                         .features_unchecked(InvoiceRequestFeatures::unknown())
1603                         .build().unwrap()
1604                         .sign(payer_sign).unwrap();
1605                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1606                 assert_eq!(invoice_request.invoice_request_features(), &InvoiceRequestFeatures::unknown());
1607                 assert_eq!(tlv_stream.features, Some(&InvoiceRequestFeatures::unknown()));
1608
1609                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1610                         .amount_msats(1000)
1611                         .build().unwrap()
1612                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1613                         .features_unchecked(InvoiceRequestFeatures::unknown())
1614                         .features_unchecked(InvoiceRequestFeatures::empty())
1615                         .build().unwrap()
1616                         .sign(payer_sign).unwrap();
1617                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1618                 assert_eq!(invoice_request.invoice_request_features(), &InvoiceRequestFeatures::empty());
1619                 assert_eq!(tlv_stream.features, None);
1620         }
1621
1622         #[test]
1623         fn builds_invoice_request_with_quantity() {
1624                 let one = NonZeroU64::new(1).unwrap();
1625                 let ten = NonZeroU64::new(10).unwrap();
1626
1627                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1628                         .amount_msats(1000)
1629                         .supported_quantity(Quantity::One)
1630                         .build().unwrap()
1631                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1632                         .build().unwrap()
1633                         .sign(payer_sign).unwrap();
1634                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1635                 assert_eq!(invoice_request.quantity(), None);
1636                 assert_eq!(tlv_stream.quantity, None);
1637
1638                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1639                         .amount_msats(1000)
1640                         .supported_quantity(Quantity::One)
1641                         .build().unwrap()
1642                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1643                         .amount_msats(2_000).unwrap()
1644                         .quantity(2)
1645                 {
1646                         Ok(_) => panic!("expected error"),
1647                         Err(e) => assert_eq!(e, Bolt12SemanticError::UnexpectedQuantity),
1648                 }
1649
1650                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1651                         .amount_msats(1000)
1652                         .supported_quantity(Quantity::Bounded(ten))
1653                         .build().unwrap()
1654                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1655                         .amount_msats(10_000).unwrap()
1656                         .quantity(10).unwrap()
1657                         .build().unwrap()
1658                         .sign(payer_sign).unwrap();
1659                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1660                 assert_eq!(invoice_request.amount_msats(), Some(10_000));
1661                 assert_eq!(tlv_stream.amount, Some(10_000));
1662
1663                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1664                         .amount_msats(1000)
1665                         .supported_quantity(Quantity::Bounded(ten))
1666                         .build().unwrap()
1667                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1668                         .amount_msats(11_000).unwrap()
1669                         .quantity(11)
1670                 {
1671                         Ok(_) => panic!("expected error"),
1672                         Err(e) => assert_eq!(e, Bolt12SemanticError::InvalidQuantity),
1673                 }
1674
1675                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1676                         .amount_msats(1000)
1677                         .supported_quantity(Quantity::Unbounded)
1678                         .build().unwrap()
1679                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1680                         .amount_msats(2_000).unwrap()
1681                         .quantity(2).unwrap()
1682                         .build().unwrap()
1683                         .sign(payer_sign).unwrap();
1684                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1685                 assert_eq!(invoice_request.amount_msats(), Some(2_000));
1686                 assert_eq!(tlv_stream.amount, Some(2_000));
1687
1688                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1689                         .amount_msats(1000)
1690                         .supported_quantity(Quantity::Unbounded)
1691                         .build().unwrap()
1692                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1693                         .build()
1694                 {
1695                         Ok(_) => panic!("expected error"),
1696                         Err(e) => assert_eq!(e, Bolt12SemanticError::MissingQuantity),
1697                 }
1698
1699                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1700                         .amount_msats(1000)
1701                         .supported_quantity(Quantity::Bounded(one))
1702                         .build().unwrap()
1703                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1704                         .build()
1705                 {
1706                         Ok(_) => panic!("expected error"),
1707                         Err(e) => assert_eq!(e, Bolt12SemanticError::MissingQuantity),
1708                 }
1709         }
1710
1711         #[test]
1712         fn builds_invoice_request_with_payer_note() {
1713                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1714                         .amount_msats(1000)
1715                         .build().unwrap()
1716                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1717                         .payer_note("bar".into())
1718                         .build().unwrap()
1719                         .sign(payer_sign).unwrap();
1720                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1721                 assert_eq!(invoice_request.payer_note(), Some(PrintableString("bar")));
1722                 assert_eq!(tlv_stream.payer_note, Some(&String::from("bar")));
1723
1724                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1725                         .amount_msats(1000)
1726                         .build().unwrap()
1727                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1728                         .payer_note("bar".into())
1729                         .payer_note("baz".into())
1730                         .build().unwrap()
1731                         .sign(payer_sign).unwrap();
1732                 let (_, _, tlv_stream, _) = invoice_request.as_tlv_stream();
1733                 assert_eq!(invoice_request.payer_note(), Some(PrintableString("baz")));
1734                 assert_eq!(tlv_stream.payer_note, Some(&String::from("baz")));
1735         }
1736
1737         #[test]
1738         fn fails_signing_invoice_request() {
1739                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1740                         .amount_msats(1000)
1741                         .build().unwrap()
1742                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1743                         .build().unwrap()
1744                         .sign(fail_sign)
1745                 {
1746                         Ok(_) => panic!("expected error"),
1747                         Err(e) => assert_eq!(e, SignError::Signing(())),
1748                 }
1749
1750                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1751                         .amount_msats(1000)
1752                         .build().unwrap()
1753                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1754                         .build().unwrap()
1755                         .sign(recipient_sign)
1756                 {
1757                         Ok(_) => panic!("expected error"),
1758                         Err(e) => assert_eq!(e, SignError::Verification(secp256k1::Error::InvalidSignature)),
1759                 }
1760         }
1761
1762         #[test]
1763         fn fails_responding_with_unknown_required_features() {
1764                 match OfferBuilder::new("foo".into(), recipient_pubkey())
1765                         .amount_msats(1000)
1766                         .build().unwrap()
1767                         .request_invoice(vec![42; 32], payer_pubkey()).unwrap()
1768                         .features_unchecked(InvoiceRequestFeatures::unknown())
1769                         .build().unwrap()
1770                         .sign(payer_sign).unwrap()
1771                         .respond_with_no_std(payment_paths(), payment_hash(), now())
1772                 {
1773                         Ok(_) => panic!("expected error"),
1774                         Err(e) => assert_eq!(e, Bolt12SemanticError::UnknownRequiredFeatures),
1775                 }
1776         }
1777
1778         #[test]
1779         fn parses_invoice_request_with_metadata() {
1780                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1781                         .amount_msats(1000)
1782                         .build().unwrap()
1783                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1784                         .build().unwrap()
1785                         .sign(payer_sign).unwrap();
1786
1787                 let mut buffer = Vec::new();
1788                 invoice_request.write(&mut buffer).unwrap();
1789
1790                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1791                         panic!("error parsing invoice_request: {:?}", e);
1792                 }
1793         }
1794
1795         #[test]
1796         fn parses_invoice_request_with_chain() {
1797                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1798                         .amount_msats(1000)
1799                         .build().unwrap()
1800                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1801                         .chain(Network::Bitcoin).unwrap()
1802                         .build().unwrap()
1803                         .sign(payer_sign).unwrap();
1804
1805                 let mut buffer = Vec::new();
1806                 invoice_request.write(&mut buffer).unwrap();
1807
1808                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1809                         panic!("error parsing invoice_request: {:?}", e);
1810                 }
1811
1812                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1813                         .amount_msats(1000)
1814                         .build().unwrap()
1815                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1816                         .chain_unchecked(Network::Testnet)
1817                         .build_unchecked()
1818                         .sign(payer_sign).unwrap();
1819
1820                 let mut buffer = Vec::new();
1821                 invoice_request.write(&mut buffer).unwrap();
1822
1823                 match InvoiceRequest::try_from(buffer) {
1824                         Ok(_) => panic!("expected error"),
1825                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::UnsupportedChain)),
1826                 }
1827         }
1828
1829         #[test]
1830         fn parses_invoice_request_with_amount() {
1831                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1832                         .amount_msats(1000)
1833                         .build().unwrap()
1834                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1835                         .build().unwrap()
1836                         .sign(payer_sign).unwrap();
1837
1838                 let mut buffer = Vec::new();
1839                 invoice_request.write(&mut buffer).unwrap();
1840
1841                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1842                         panic!("error parsing invoice_request: {:?}", e);
1843                 }
1844
1845                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1846                         .build().unwrap()
1847                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1848                         .amount_msats(1000).unwrap()
1849                         .build().unwrap()
1850                         .sign(payer_sign).unwrap();
1851
1852                 let mut buffer = Vec::new();
1853                 invoice_request.write(&mut buffer).unwrap();
1854
1855                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1856                         panic!("error parsing invoice_request: {:?}", e);
1857                 }
1858
1859                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1860                         .build().unwrap()
1861                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1862                         .build_unchecked()
1863                         .sign(payer_sign).unwrap();
1864
1865                 let mut buffer = Vec::new();
1866                 invoice_request.write(&mut buffer).unwrap();
1867
1868                 match InvoiceRequest::try_from(buffer) {
1869                         Ok(_) => panic!("expected error"),
1870                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingAmount)),
1871                 }
1872
1873                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1874                         .amount_msats(1000)
1875                         .build().unwrap()
1876                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1877                         .amount_msats_unchecked(999)
1878                         .build_unchecked()
1879                         .sign(payer_sign).unwrap();
1880
1881                 let mut buffer = Vec::new();
1882                 invoice_request.write(&mut buffer).unwrap();
1883
1884                 match InvoiceRequest::try_from(buffer) {
1885                         Ok(_) => panic!("expected error"),
1886                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::InsufficientAmount)),
1887                 }
1888
1889                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1890                         .amount(Amount::Currency { iso4217_code: *b"USD", amount: 1000 })
1891                         .build_unchecked()
1892                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1893                         .build_unchecked()
1894                         .sign(payer_sign).unwrap();
1895
1896                 let mut buffer = Vec::new();
1897                 invoice_request.write(&mut buffer).unwrap();
1898
1899                 match InvoiceRequest::try_from(buffer) {
1900                         Ok(_) => panic!("expected error"),
1901                         Err(e) => {
1902                                 assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::UnsupportedCurrency));
1903                         },
1904                 }
1905
1906                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1907                         .amount_msats(1000)
1908                         .supported_quantity(Quantity::Unbounded)
1909                         .build().unwrap()
1910                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1911                         .quantity(u64::max_value()).unwrap()
1912                         .build_unchecked()
1913                         .sign(payer_sign).unwrap();
1914
1915                 let mut buffer = Vec::new();
1916                 invoice_request.write(&mut buffer).unwrap();
1917
1918                 match InvoiceRequest::try_from(buffer) {
1919                         Ok(_) => panic!("expected error"),
1920                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::InvalidAmount)),
1921                 }
1922         }
1923
1924         #[test]
1925         fn parses_invoice_request_with_quantity() {
1926                 let one = NonZeroU64::new(1).unwrap();
1927                 let ten = NonZeroU64::new(10).unwrap();
1928
1929                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1930                         .amount_msats(1000)
1931                         .supported_quantity(Quantity::One)
1932                         .build().unwrap()
1933                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1934                         .build().unwrap()
1935                         .sign(payer_sign).unwrap();
1936
1937                 let mut buffer = Vec::new();
1938                 invoice_request.write(&mut buffer).unwrap();
1939
1940                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1941                         panic!("error parsing invoice_request: {:?}", e);
1942                 }
1943
1944                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1945                         .amount_msats(1000)
1946                         .supported_quantity(Quantity::One)
1947                         .build().unwrap()
1948                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1949                         .amount_msats(2_000).unwrap()
1950                         .quantity_unchecked(2)
1951                         .build_unchecked()
1952                         .sign(payer_sign).unwrap();
1953
1954                 let mut buffer = Vec::new();
1955                 invoice_request.write(&mut buffer).unwrap();
1956
1957                 match InvoiceRequest::try_from(buffer) {
1958                         Ok(_) => panic!("expected error"),
1959                         Err(e) => {
1960                                 assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::UnexpectedQuantity));
1961                         },
1962                 }
1963
1964                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1965                         .amount_msats(1000)
1966                         .supported_quantity(Quantity::Bounded(ten))
1967                         .build().unwrap()
1968                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1969                         .amount_msats(10_000).unwrap()
1970                         .quantity(10).unwrap()
1971                         .build().unwrap()
1972                         .sign(payer_sign).unwrap();
1973
1974                 let mut buffer = Vec::new();
1975                 invoice_request.write(&mut buffer).unwrap();
1976
1977                 if let Err(e) = InvoiceRequest::try_from(buffer) {
1978                         panic!("error parsing invoice_request: {:?}", e);
1979                 }
1980
1981                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
1982                         .amount_msats(1000)
1983                         .supported_quantity(Quantity::Bounded(ten))
1984                         .build().unwrap()
1985                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
1986                         .amount_msats(11_000).unwrap()
1987                         .quantity_unchecked(11)
1988                         .build_unchecked()
1989                         .sign(payer_sign).unwrap();
1990
1991                 let mut buffer = Vec::new();
1992                 invoice_request.write(&mut buffer).unwrap();
1993
1994                 match InvoiceRequest::try_from(buffer) {
1995                         Ok(_) => panic!("expected error"),
1996                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::InvalidQuantity)),
1997                 }
1998
1999                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
2000                         .amount_msats(1000)
2001                         .supported_quantity(Quantity::Unbounded)
2002                         .build().unwrap()
2003                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
2004                         .amount_msats(2_000).unwrap()
2005                         .quantity(2).unwrap()
2006                         .build().unwrap()
2007                         .sign(payer_sign).unwrap();
2008
2009                 let mut buffer = Vec::new();
2010                 invoice_request.write(&mut buffer).unwrap();
2011
2012                 if let Err(e) = InvoiceRequest::try_from(buffer) {
2013                         panic!("error parsing invoice_request: {:?}", e);
2014                 }
2015
2016                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
2017                         .amount_msats(1000)
2018                         .supported_quantity(Quantity::Unbounded)
2019                         .build().unwrap()
2020                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
2021                         .build_unchecked()
2022                         .sign(payer_sign).unwrap();
2023
2024                 let mut buffer = Vec::new();
2025                 invoice_request.write(&mut buffer).unwrap();
2026
2027                 match InvoiceRequest::try_from(buffer) {
2028                         Ok(_) => panic!("expected error"),
2029                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingQuantity)),
2030                 }
2031
2032                 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
2033                         .amount_msats(1000)
2034                         .supported_quantity(Quantity::Bounded(one))
2035                         .build().unwrap()
2036                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
2037                         .build_unchecked()
2038                         .sign(payer_sign).unwrap();
2039
2040                 let mut buffer = Vec::new();
2041                 invoice_request.write(&mut buffer).unwrap();
2042
2043                 match InvoiceRequest::try_from(buffer) {
2044                         Ok(_) => panic!("expected error"),
2045                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingQuantity)),
2046                 }
2047         }
2048
2049         #[test]
2050         fn fails_parsing_invoice_request_without_metadata() {
2051                 let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
2052                         .amount_msats(1000)
2053                         .build().unwrap();
2054                 let unsigned_invoice_request = offer.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
2055                         .build().unwrap();
2056                 let mut tlv_stream = unsigned_invoice_request.contents.as_tlv_stream();
2057                 tlv_stream.0.metadata = None;
2058
2059                 let mut buffer = Vec::new();
2060                 tlv_stream.write(&mut buffer).unwrap();
2061
2062                 match InvoiceRequest::try_from(buffer) {
2063                         Ok(_) => panic!("expected error"),
2064                         Err(e) => {
2065                                 assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingPayerMetadata));
2066                         },
2067                 }
2068         }
2069
2070         #[test]
2071         fn fails_parsing_invoice_request_without_payer_id() {
2072                 let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
2073                         .amount_msats(1000)
2074                         .build().unwrap();
2075                 let unsigned_invoice_request = offer.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
2076                         .build().unwrap();
2077                 let mut tlv_stream = unsigned_invoice_request.contents.as_tlv_stream();
2078                 tlv_stream.2.payer_id = None;
2079
2080                 let mut buffer = Vec::new();
2081                 tlv_stream.write(&mut buffer).unwrap();
2082
2083                 match InvoiceRequest::try_from(buffer) {
2084                         Ok(_) => panic!("expected error"),
2085                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingPayerId)),
2086                 }
2087         }
2088
2089         #[test]
2090         fn fails_parsing_invoice_request_without_node_id() {
2091                 let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
2092                         .amount_msats(1000)
2093                         .build().unwrap();
2094                 let unsigned_invoice_request = offer.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
2095                         .build().unwrap();
2096                 let mut tlv_stream = unsigned_invoice_request.contents.as_tlv_stream();
2097                 tlv_stream.1.node_id = None;
2098
2099                 let mut buffer = Vec::new();
2100                 tlv_stream.write(&mut buffer).unwrap();
2101
2102                 match InvoiceRequest::try_from(buffer) {
2103                         Ok(_) => panic!("expected error"),
2104                         Err(e) => {
2105                                 assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingSigningPubkey));
2106                         },
2107                 }
2108         }
2109
2110         #[test]
2111         fn fails_parsing_invoice_request_without_signature() {
2112                 let mut buffer = Vec::new();
2113                 OfferBuilder::new("foo".into(), recipient_pubkey())
2114                         .amount_msats(1000)
2115                         .build().unwrap()
2116                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
2117                         .build().unwrap()
2118                         .contents
2119                         .write(&mut buffer).unwrap();
2120
2121                 match InvoiceRequest::try_from(buffer) {
2122                         Ok(_) => panic!("expected error"),
2123                         Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingSignature)),
2124                 }
2125         }
2126
2127         #[test]
2128         fn fails_parsing_invoice_request_with_invalid_signature() {
2129                 let mut invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
2130                         .amount_msats(1000)
2131                         .build().unwrap()
2132                         .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
2133                         .build().unwrap()
2134                         .sign(payer_sign).unwrap();
2135                 let last_signature_byte = invoice_request.bytes.last_mut().unwrap();
2136                 *last_signature_byte = last_signature_byte.wrapping_add(1);
2137
2138                 let mut buffer = Vec::new();
2139                 invoice_request.write(&mut buffer).unwrap();
2140
2141                 match InvoiceRequest::try_from(buffer) {
2142                         Ok(_) => panic!("expected error"),
2143                         Err(e) => {
2144                                 assert_eq!(e, Bolt12ParseError::InvalidSignature(secp256k1::Error::InvalidSignature));
2145                         },
2146                 }
2147         }
2148
2149         #[test]
2150         fn fails_parsing_invoice_request_with_extra_tlv_records() {
2151                 let secp_ctx = Secp256k1::new();
2152                 let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
2153                 let invoice_request = OfferBuilder::new("foo".into(), keys.public_key())
2154                         .amount_msats(1000)
2155                         .build().unwrap()
2156                         .request_invoice(vec![1; 32], keys.public_key()).unwrap()
2157                         .build().unwrap()
2158                         .sign(|message: &UnsignedInvoiceRequest| -> Result<_, Infallible> {
2159                                 Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
2160                         })
2161                         .unwrap();
2162
2163                 let mut encoded_invoice_request = Vec::new();
2164                 invoice_request.write(&mut encoded_invoice_request).unwrap();
2165                 BigSize(1002).write(&mut encoded_invoice_request).unwrap();
2166                 BigSize(32).write(&mut encoded_invoice_request).unwrap();
2167                 [42u8; 32].write(&mut encoded_invoice_request).unwrap();
2168
2169                 match InvoiceRequest::try_from(encoded_invoice_request) {
2170                         Ok(_) => panic!("expected error"),
2171                         Err(e) => assert_eq!(e, Bolt12ParseError::Decode(DecodeError::InvalidValue)),
2172                 }
2173         }
2174 }