X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Foffers%2Frefund.rs;h=d3798463b440ed6c0bead3034392671aa57b5555;hb=7964b9f745a18c1abeabb11b165bb588ef1474f2;hp=1e5c0f80a77dbc8f70a034e2be98bbb25fcb47a1;hpb=73e743fb53bee1e3a49504873e22afeb9e03162d;p=rust-lightning diff --git a/lightning/src/offers/refund.rs b/lightning/src/offers/refund.rs index 1e5c0f80..d3798463 100644 --- a/lightning/src/offers/refund.rs +++ b/lightning/src/offers/refund.rs @@ -102,8 +102,8 @@ pub struct RefundBuilder { } impl RefundBuilder { - /// Creates a new builder for a refund using the [`Refund::payer_id`] for signing invoices. Use - /// a different pubkey per refund to avoid correlating refunds. + /// Creates a new builder for a refund using the [`Refund::payer_id`] for the public node id to + /// send to if no [`Refund::paths`] are set. Otherwise, it may be a transient pubkey. /// /// Additionally, sets the required [`Refund::description`], [`Refund::metadata`], and /// [`Refund::amount_msats`]. @@ -183,6 +183,14 @@ impl RefundBuilder { } } +#[cfg(test)] +impl RefundBuilder { + fn features_unchecked(mut self, features: InvoiceRequestFeatures) -> Self { + self.refund.features = features; + self + } +} + /// A `Refund` is a request to send an `Invoice` without a preceding [`Offer`]. /// /// Typically, after an invoice is paid, the recipient may publish a refund allowing the sender to @@ -277,7 +285,10 @@ impl Refund { &self.contents.features } - /// A possibly transient pubkey used to sign the refund. + /// A public node id to send to in the case where there are no [`paths`]. Otherwise, a possibly + /// transient pubkey. + /// + /// [`paths`]: Self::paths pub fn payer_id(&self) -> PublicKey { self.contents.payer_id } @@ -286,6 +297,11 @@ impl Refund { pub fn payer_note(&self) -> Option { self.contents.payer_note.as_ref().map(|payer_note| PrintableString(payer_note.as_str())) } + + #[cfg(test)] + fn as_tlv_stream(&self) -> RefundTlvStreamRef { + self.contents.as_tlv_stream() + } } impl AsRef<[u8]> for Refund { @@ -472,3 +488,464 @@ impl core::fmt::Display for Refund { self.fmt_bech32_str(f) } } + +#[cfg(test)] +mod tests { + use super::{Refund, RefundBuilder, RefundTlvStreamRef}; + + use bitcoin::blockdata::constants::ChainHash; + use bitcoin::network::constants::Network; + use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, SecretKey}; + use core::convert::TryFrom; + use core::time::Duration; + use crate::ln::features::{InvoiceRequestFeatures, OfferFeatures}; + use crate::ln::msgs::{DecodeError, MAX_VALUE_MSAT}; + use crate::offers::invoice_request::InvoiceRequestTlvStreamRef; + use crate::offers::offer::OfferTlvStreamRef; + use crate::offers::parse::{ParseError, SemanticError}; + use crate::offers::payer::PayerTlvStreamRef; + use crate::onion_message::{BlindedHop, BlindedPath}; + use crate::util::ser::{BigSize, Writeable}; + use crate::util::string::PrintableString; + + fn payer_pubkey() -> PublicKey { + let secp_ctx = Secp256k1::new(); + KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()).public_key() + } + + fn pubkey(byte: u8) -> PublicKey { + let secp_ctx = Secp256k1::new(); + PublicKey::from_secret_key(&secp_ctx, &privkey(byte)) + } + + fn privkey(byte: u8) -> SecretKey { + SecretKey::from_slice(&[byte; 32]).unwrap() + } + + trait ToBytes { + fn to_bytes(&self) -> Vec; + } + + impl<'a> ToBytes for RefundTlvStreamRef<'a> { + fn to_bytes(&self) -> Vec { + let mut buffer = Vec::new(); + self.write(&mut buffer).unwrap(); + buffer + } + } + + #[test] + fn builds_refund_with_defaults() { + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .build().unwrap(); + + let mut buffer = Vec::new(); + refund.write(&mut buffer).unwrap(); + + assert_eq!(refund.bytes, buffer.as_slice()); + assert_eq!(refund.metadata(), &[1; 32]); + assert_eq!(refund.description(), PrintableString("foo")); + assert_eq!(refund.absolute_expiry(), None); + #[cfg(feature = "std")] + assert!(!refund.is_expired()); + assert_eq!(refund.paths(), &[]); + assert_eq!(refund.issuer(), None); + assert_eq!(refund.chain(), ChainHash::using_genesis_block(Network::Bitcoin)); + assert_eq!(refund.amount_msats(), 1000); + assert_eq!(refund.features(), &InvoiceRequestFeatures::empty()); + assert_eq!(refund.payer_id(), payer_pubkey()); + assert_eq!(refund.payer_note(), None); + + assert_eq!( + refund.as_tlv_stream(), + ( + PayerTlvStreamRef { metadata: Some(&vec![1; 32]) }, + OfferTlvStreamRef { + chains: None, + metadata: None, + currency: None, + amount: None, + description: Some(&String::from("foo")), + features: None, + absolute_expiry: None, + paths: None, + issuer: None, + quantity_max: None, + node_id: None, + }, + InvoiceRequestTlvStreamRef { + chain: None, + amount: Some(1000), + features: None, + quantity: None, + payer_id: Some(&payer_pubkey()), + payer_note: None, + }, + ), + ); + + if let Err(e) = Refund::try_from(buffer) { + panic!("error parsing refund: {:?}", e); + } + } + + #[test] + fn fails_building_refund_with_invalid_amount() { + match RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), MAX_VALUE_MSAT + 1) { + Ok(_) => panic!("expected error"), + Err(e) => assert_eq!(e, SemanticError::InvalidAmount), + } + } + + #[test] + fn builds_refund_with_absolute_expiry() { + let future_expiry = Duration::from_secs(u64::max_value()); + let past_expiry = Duration::from_secs(0); + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .absolute_expiry(future_expiry) + .build() + .unwrap(); + let (_, tlv_stream, _) = refund.as_tlv_stream(); + #[cfg(feature = "std")] + assert!(!refund.is_expired()); + assert_eq!(refund.absolute_expiry(), Some(future_expiry)); + assert_eq!(tlv_stream.absolute_expiry, Some(future_expiry.as_secs())); + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .absolute_expiry(future_expiry) + .absolute_expiry(past_expiry) + .build() + .unwrap(); + let (_, tlv_stream, _) = refund.as_tlv_stream(); + #[cfg(feature = "std")] + assert!(refund.is_expired()); + assert_eq!(refund.absolute_expiry(), Some(past_expiry)); + assert_eq!(tlv_stream.absolute_expiry, Some(past_expiry.as_secs())); + } + + #[test] + fn builds_refund_with_paths() { + let paths = vec![ + BlindedPath { + introduction_node_id: pubkey(40), + blinding_point: pubkey(41), + blinded_hops: vec![ + BlindedHop { blinded_node_id: pubkey(43), encrypted_payload: vec![0; 43] }, + BlindedHop { blinded_node_id: pubkey(44), encrypted_payload: vec![0; 44] }, + ], + }, + BlindedPath { + introduction_node_id: pubkey(40), + blinding_point: pubkey(41), + blinded_hops: vec![ + BlindedHop { blinded_node_id: pubkey(45), encrypted_payload: vec![0; 45] }, + BlindedHop { blinded_node_id: pubkey(46), encrypted_payload: vec![0; 46] }, + ], + }, + ]; + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .path(paths[0].clone()) + .path(paths[1].clone()) + .build() + .unwrap(); + let (_, offer_tlv_stream, invoice_request_tlv_stream) = refund.as_tlv_stream(); + assert_eq!(refund.paths(), paths.as_slice()); + assert_eq!(refund.payer_id(), pubkey(42)); + assert_ne!(pubkey(42), pubkey(44)); + assert_eq!(offer_tlv_stream.paths, Some(&paths)); + assert_eq!(invoice_request_tlv_stream.payer_id, Some(&pubkey(42))); + } + + #[test] + fn builds_refund_with_issuer() { + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .issuer("bar".into()) + .build() + .unwrap(); + let (_, tlv_stream, _) = refund.as_tlv_stream(); + assert_eq!(refund.issuer(), Some(PrintableString("bar"))); + assert_eq!(tlv_stream.issuer, Some(&String::from("bar"))); + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .issuer("bar".into()) + .issuer("baz".into()) + .build() + .unwrap(); + let (_, tlv_stream, _) = refund.as_tlv_stream(); + assert_eq!(refund.issuer(), Some(PrintableString("baz"))); + assert_eq!(tlv_stream.issuer, Some(&String::from("baz"))); + } + + #[test] + fn builds_refund_with_chain() { + let mainnet = ChainHash::using_genesis_block(Network::Bitcoin); + let testnet = ChainHash::using_genesis_block(Network::Testnet); + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .chain(Network::Bitcoin) + .build().unwrap(); + let (_, _, tlv_stream) = refund.as_tlv_stream(); + assert_eq!(refund.chain(), mainnet); + assert_eq!(tlv_stream.chain, None); + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .chain(Network::Testnet) + .build().unwrap(); + let (_, _, tlv_stream) = refund.as_tlv_stream(); + assert_eq!(refund.chain(), testnet); + assert_eq!(tlv_stream.chain, Some(&testnet)); + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .chain(Network::Regtest) + .chain(Network::Testnet) + .build().unwrap(); + let (_, _, tlv_stream) = refund.as_tlv_stream(); + assert_eq!(refund.chain(), testnet); + assert_eq!(tlv_stream.chain, Some(&testnet)); + } + + #[test] + fn builds_refund_with_payer_note() { + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .payer_note("bar".into()) + .build().unwrap(); + let (_, _, tlv_stream) = refund.as_tlv_stream(); + assert_eq!(refund.payer_note(), Some(PrintableString("bar"))); + assert_eq!(tlv_stream.payer_note, Some(&String::from("bar"))); + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .payer_note("bar".into()) + .payer_note("baz".into()) + .build().unwrap(); + let (_, _, tlv_stream) = refund.as_tlv_stream(); + assert_eq!(refund.payer_note(), Some(PrintableString("baz"))); + assert_eq!(tlv_stream.payer_note, Some(&String::from("baz"))); + } + + #[test] + fn parses_refund_with_metadata() { + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .build().unwrap(); + if let Err(e) = refund.to_string().parse::() { + panic!("error parsing refund: {:?}", e); + } + + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.0.metadata = None; + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingPayerMetadata)); + }, + } + } + + #[test] + fn parses_refund_with_description() { + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .build().unwrap(); + if let Err(e) = refund.to_string().parse::() { + panic!("error parsing refund: {:?}", e); + } + + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.1.description = None; + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingDescription)); + }, + } + } + + #[test] + fn parses_refund_with_amount() { + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .build().unwrap(); + if let Err(e) = refund.to_string().parse::() { + panic!("error parsing refund: {:?}", e); + } + + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.2.amount = None; + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingAmount)); + }, + } + + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.2.amount = Some(MAX_VALUE_MSAT + 1); + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InvalidAmount)); + }, + } + } + + #[test] + fn parses_refund_with_payer_id() { + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .build().unwrap(); + if let Err(e) = refund.to_string().parse::() { + panic!("error parsing refund: {:?}", e); + } + + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.2.payer_id = None; + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingPayerId)); + }, + } + } + + #[test] + fn parses_refund_with_optional_fields() { + let past_expiry = Duration::from_secs(0); + let paths = vec![ + BlindedPath { + introduction_node_id: pubkey(40), + blinding_point: pubkey(41), + blinded_hops: vec![ + BlindedHop { blinded_node_id: pubkey(43), encrypted_payload: vec![0; 43] }, + BlindedHop { blinded_node_id: pubkey(44), encrypted_payload: vec![0; 44] }, + ], + }, + BlindedPath { + introduction_node_id: pubkey(40), + blinding_point: pubkey(41), + blinded_hops: vec![ + BlindedHop { blinded_node_id: pubkey(45), encrypted_payload: vec![0; 45] }, + BlindedHop { blinded_node_id: pubkey(46), encrypted_payload: vec![0; 46] }, + ], + }, + ]; + + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .absolute_expiry(past_expiry) + .issuer("bar".into()) + .path(paths[0].clone()) + .path(paths[1].clone()) + .chain(Network::Testnet) + .features_unchecked(InvoiceRequestFeatures::unknown()) + .payer_note("baz".into()) + .build() + .unwrap(); + match refund.to_string().parse::() { + Ok(refund) => { + assert_eq!(refund.absolute_expiry(), Some(past_expiry)); + #[cfg(feature = "std")] + assert!(refund.is_expired()); + assert_eq!(refund.paths(), &paths[..]); + assert_eq!(refund.issuer(), Some(PrintableString("bar"))); + assert_eq!(refund.chain(), ChainHash::using_genesis_block(Network::Testnet)); + assert_eq!(refund.features(), &InvoiceRequestFeatures::unknown()); + assert_eq!(refund.payer_note(), Some(PrintableString("baz"))); + }, + Err(e) => panic!("error parsing refund: {:?}", e), + } + } + + #[test] + fn fails_parsing_refund_with_unexpected_fields() { + let refund = RefundBuilder::new("foo".into(), vec![1; 32], payer_pubkey(), 1000).unwrap() + .build().unwrap(); + if let Err(e) = refund.to_string().parse::() { + panic!("error parsing refund: {:?}", e); + } + + let chains = vec![ChainHash::using_genesis_block(Network::Testnet)]; + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.1.chains = Some(&chains); + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedChain)); + }, + } + + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.1.currency = Some(&b"USD"); + tlv_stream.1.amount = Some(1000); + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedAmount)); + }, + } + + let features = OfferFeatures::unknown(); + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.1.features = Some(&features); + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedFeatures)); + }, + } + + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.1.quantity_max = Some(10); + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedQuantity)); + }, + } + + let node_id = payer_pubkey(); + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.1.node_id = Some(&node_id); + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedSigningPubkey)); + }, + } + + let mut tlv_stream = refund.as_tlv_stream(); + tlv_stream.2.quantity = Some(10); + + match Refund::try_from(tlv_stream.to_bytes()) { + Ok(_) => panic!("expected error"), + Err(e) => { + assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedQuantity)); + }, + } + } + + #[test] + fn fails_parsing_refund_with_extra_tlv_records() { + let secp_ctx = Secp256k1::new(); + let keys = KeyPair::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); + let refund = RefundBuilder::new("foo".into(), vec![1; 32], keys.public_key(), 1000).unwrap() + .build().unwrap(); + + let mut encoded_refund = Vec::new(); + refund.write(&mut encoded_refund).unwrap(); + BigSize(1002).write(&mut encoded_refund).unwrap(); + BigSize(32).write(&mut encoded_refund).unwrap(); + [42u8; 32].write(&mut encoded_refund).unwrap(); + + match Refund::try_from(encoded_refund) { + Ok(_) => panic!("expected error"), + Err(e) => assert_eq!(e, ParseError::Decode(DecodeError::InvalidValue)), + } + } +}