fallbacks: self.fallbacks.as_ref(),
features,
node_id: Some(&self.signing_pubkey),
+ message_paths: None,
}
}
}
(172, fallbacks: (Vec<FallbackAddress>, WithoutLength)),
(174, features: (Bolt12InvoiceFeatures, WithoutLength)),
(176, node_id: PublicKey),
+ // Only present in `StaticInvoice`s.
+ (238, message_paths: (Vec<BlindedPath>, WithoutLength)),
});
pub(super) type BlindedPathIter<'a> = core::iter::Map<
(payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream)
)?;
- let signature = match signature {
- None => return Err(Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingSignature)),
- Some(signature) => signature,
- };
+ let signature = signature.ok_or(
+ Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::MissingSignature)
+ )?;
let tagged_hash = TaggedHash::from_valid_tlv_stream_bytes(SIGNATURE_TAG, &bytes);
let pubkey = contents.fields().signing_pubkey;
merkle::verify_signature(&signature, &tagged_hash, pubkey)?;
invoice_request_tlv_stream,
InvoiceTlvStream {
paths, blindedpay, created_at, relative_expiry, payment_hash, amount, fallbacks,
- features, node_id,
+ features, node_id, message_paths,
},
) = tlv_stream;
+ if message_paths.is_some() { return Err(Bolt12SemanticError::UnexpectedPaths) }
+
let payment_paths = construct_payment_paths(blindedpay, paths)?;
let created_at = match created_at {
.map(Into::<u64>::into)
.map(Duration::from_secs);
- let payment_hash = match payment_hash {
- None => return Err(Bolt12SemanticError::MissingPaymentHash),
- Some(payment_hash) => payment_hash,
- };
+ let payment_hash = payment_hash.ok_or(Bolt12SemanticError::MissingPaymentHash)?;
- let amount_msats = match amount {
- None => return Err(Bolt12SemanticError::MissingAmount),
- Some(amount) => amount,
- };
+ let amount_msats = amount.ok_or(Bolt12SemanticError::MissingAmount)?;
let features = features.unwrap_or_else(Bolt12InvoiceFeatures::empty);
- let signing_pubkey = match node_id {
- None => return Err(Bolt12SemanticError::MissingSigningPubkey),
- Some(node_id) => node_id,
- };
+ let signing_pubkey = node_id.ok_or(Bolt12SemanticError::MissingSigningPubkey)?;
let fields = InvoiceFields {
payment_paths, created_at, relative_expiry, payment_hash, amount_msats, fallbacks,
features, signing_pubkey,
};
- match (offer_tlv_stream.node_id, &offer_tlv_stream.paths) {
- (Some(expected_signing_pubkey), _) => {
- if fields.signing_pubkey != expected_signing_pubkey {
- return Err(Bolt12SemanticError::InvalidSigningPubkey);
- }
+ check_invoice_signing_pubkey(&fields.signing_pubkey, &offer_tlv_stream)?;
- let invoice_request = InvoiceRequestContents::try_from(
- (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
- )?;
- Ok(InvoiceContents::ForOffer { invoice_request, fields })
- },
- (None, Some(paths)) => {
- if !paths
- .iter()
- .filter_map(|path| path.blinded_hops.last())
- .any(|last_hop| fields.signing_pubkey == last_hop.blinded_node_id)
- {
- return Err(Bolt12SemanticError::InvalidSigningPubkey);
- }
-
- let invoice_request = InvoiceRequestContents::try_from(
- (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
- )?;
- Ok(InvoiceContents::ForOffer { invoice_request, fields })
- },
- (None, None) => {
- let refund = RefundContents::try_from(
- (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
- )?;
- Ok(InvoiceContents::ForRefund { refund, fields })
- },
+ if offer_tlv_stream.node_id.is_none() && offer_tlv_stream.paths.is_none() {
+ let refund = RefundContents::try_from(
+ (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
+ )?;
+ Ok(InvoiceContents::ForRefund { refund, fields })
+ } else {
+ let invoice_request = InvoiceRequestContents::try_from(
+ (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
+ )?;
+ Ok(InvoiceContents::ForOffer { invoice_request, fields })
}
}
}
}
}
+pub(super) fn check_invoice_signing_pubkey(
+ invoice_signing_pubkey: &PublicKey, offer_tlv_stream: &OfferTlvStream
+) -> Result<(), Bolt12SemanticError> {
+ match (&offer_tlv_stream.node_id, &offer_tlv_stream.paths) {
+ (Some(expected_signing_pubkey), _) => {
+ if invoice_signing_pubkey != expected_signing_pubkey {
+ return Err(Bolt12SemanticError::InvalidSigningPubkey);
+ }
+ },
+ (None, Some(paths)) => {
+ if !paths
+ .iter()
+ .filter_map(|path| path.blinded_hops.last())
+ .any(|last_hop| invoice_signing_pubkey == &last_hop.blinded_node_id)
+ {
+ return Err(Bolt12SemanticError::InvalidSigningPubkey);
+ }
+ },
+ _ => {},
+ }
+ Ok(())
+}
+
#[cfg(test)]
mod tests {
use super::{Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, FallbackAddress, FullInvoiceTlvStreamRef, InvoiceTlvStreamRef, SIGNATURE_TAG, UnsignedBolt12Invoice};
fallbacks: None,
features: None,
node_id: Some(&recipient_pubkey()),
+ message_paths: None,
},
SignatureTlvStreamRef { signature: Some(&invoice.signature()) },
),
fallbacks: None,
features: None,
node_id: Some(&recipient_pubkey()),
+ message_paths: None,
},
SignatureTlvStreamRef { signature: Some(&invoice.signature()) },
),
Err(e) => assert_eq!(e, Bolt12ParseError::Decode(DecodeError::InvalidValue)),
}
}
+
+ #[test]
+ fn fails_parsing_invoice_with_message_paths() {
+ let invoice = OfferBuilder::new(recipient_pubkey())
+ .amount_msats(1000)
+ .build().unwrap()
+ .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
+ .build().unwrap()
+ .sign(payer_sign).unwrap()
+ .respond_with_no_std(payment_paths(), payment_hash(), now()).unwrap()
+ .build().unwrap()
+ .sign(recipient_sign).unwrap();
+
+ let blinded_path = BlindedPath {
+ introduction_node: IntroductionNode::NodeId(pubkey(40)),
+ blinding_point: pubkey(41),
+ blinded_hops: vec![
+ BlindedHop { blinded_node_id: pubkey(42), encrypted_payload: vec![0; 43] },
+ BlindedHop { blinded_node_id: pubkey(43), encrypted_payload: vec![0; 44] },
+ ],
+ };
+
+ let mut tlv_stream = invoice.as_tlv_stream();
+ let message_paths = vec![blinded_path];
+ tlv_stream.3.message_paths = Some(&message_paths);
+
+ match Bolt12Invoice::try_from(tlv_stream.to_bytes()) {
+ Ok(_) => panic!("expected error"),
+ Err(e) => assert_eq!(e, Bolt12ParseError::InvalidSemantics(Bolt12SemanticError::UnexpectedPaths)),
+ }
+ }
}
projects / rust-lightning / blobdiff