X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Foffers_tests.rs;h=24ff1c25c8f7692975eeca9ebb195ee111c57ed8;hb=db7e69667303fb4ba8c2ae6e792d09442260d7ad;hp=6af4cb6b17faa32c926e4dd81866ab5552fe6ce0;hpb=5e9a998194ca3f424d96acb0ffbbe9d3fd6b4f76;p=rust-lightning diff --git a/lightning/src/ln/offers_tests.rs b/lightning/src/ln/offers_tests.rs index 6af4cb6b..24ff1c25 100644 --- a/lightning/src/ln/offers_tests.rs +++ b/lightning/src/ln/offers_tests.rs @@ -40,15 +40,18 @@ //! Nodes without channels are disconnected and connected as needed to ensure that deterministic //! blinded paths are used. +use bitcoin::network::constants::Network; use core::time::Duration; -use crate::blinded_path::BlindedPath; +use crate::blinded_path::{BlindedPath, IntroductionNode}; +use crate::blinded_path::payment::{Bolt12OfferContext, Bolt12RefundContext, PaymentContext}; use crate::events::{Event, MessageSendEventsProvider, PaymentPurpose}; use crate::ln::channelmanager::{PaymentId, RecentPaymentDetails, Retry, self}; +use crate::ln::features::InvoiceRequestFeatures; use crate::ln::functional_test_utils::*; use crate::ln::msgs::{ChannelMessageHandler, Init, NodeAnnouncement, OnionMessage, OnionMessageHandler, RoutingMessageHandler, SocketAddress, UnsignedGossipMessage, UnsignedNodeAnnouncement}; use crate::offers::invoice::Bolt12Invoice; use crate::offers::invoice_error::InvoiceError; -use crate::offers::invoice_request::InvoiceRequest; +use crate::offers::invoice_request::{InvoiceRequest, InvoiceRequestFields}; use crate::offers::parse::Bolt12SemanticError; use crate::onion_message::messenger::PeeledOnion; use crate::onion_message::offers::OffersMessage; @@ -145,21 +148,33 @@ fn route_bolt12_payment<'a, 'b, 'c>( // invoice contains the payment_hash but it was encrypted inside an onion message. let amount_msats = invoice.amount_msats(); let payment_hash = invoice.payment_hash(); - do_pass_along_path( - node, path, amount_msats, payment_hash, None, ev, false, false, None, false - ); + let args = PassAlongPathArgs::new(node, path, amount_msats, payment_hash, ev) + .without_clearing_recipient_events(); + do_pass_along_path(args); } -fn claim_bolt12_payment<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, path: &[&Node<'a, 'b, 'c>]) { +fn claim_bolt12_payment<'a, 'b, 'c>( + node: &Node<'a, 'b, 'c>, path: &[&Node<'a, 'b, 'c>], expected_payment_context: PaymentContext +) { let recipient = &path[path.len() - 1]; - match get_event!(recipient, Event::PaymentClaimable) { - Event::PaymentClaimable { - purpose: PaymentPurpose::InvoicePayment { - payment_preimage: Some(payment_preimage), .. - }, .. - } => claim_payment(node, path, payment_preimage), - _ => panic!(), + let payment_purpose = match get_event!(recipient, Event::PaymentClaimable) { + Event::PaymentClaimable { purpose, .. } => purpose, + _ => panic!("No Event::PaymentClaimable"), + }; + let payment_preimage = match payment_purpose.preimage() { + Some(preimage) => preimage, + None => panic!("No preimage in Event::PaymentClaimable"), }; + match payment_purpose { + PaymentPurpose::Bolt12OfferPayment { payment_context, .. } => { + assert_eq!(PaymentContext::Bolt12Offer(payment_context), expected_payment_context); + }, + PaymentPurpose::Bolt12RefundPayment { payment_context, .. } => { + assert_eq!(PaymentContext::Bolt12Refund(payment_context), expected_payment_context); + }, + _ => panic!("Unexpected payment purpose: {:?}", payment_purpose), + } + claim_payment(node, path, payment_preimage); } fn extract_invoice_request<'a, 'b, 'c>( @@ -250,16 +265,31 @@ fn prefers_non_tor_nodes_in_blinded_paths() { disconnect_peers(david, &[bob, &nodes[4], &nodes[5]]); let tor = SocketAddress::OnionV2([255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]); - announce_node_address(charlie, &[alice, bob, david, &nodes[4], &nodes[5]], tor); + announce_node_address(charlie, &[alice, bob, david, &nodes[4], &nodes[5]], tor.clone()); let offer = bob.node - .create_offer_builder("coffee".to_string()).unwrap() + .create_offer_builder().unwrap() .amount_msats(10_000_000) .build().unwrap(); - assert_ne!(offer.signing_pubkey(), bob_id); + assert_ne!(offer.signing_pubkey(), Some(bob_id)); assert!(!offer.paths().is_empty()); for path in offer.paths() { - assert_ne!(path.introduction_node_id, charlie_id); + assert_ne!(path.introduction_node, IntroductionNode::NodeId(bob_id)); + assert_ne!(path.introduction_node, IntroductionNode::NodeId(charlie_id)); + } + + // Use a one-hop blinded path when Bob is announced and all his peers are Tor-only. + announce_node_address(&nodes[4], &[alice, bob, charlie, david, &nodes[5]], tor.clone()); + announce_node_address(&nodes[5], &[alice, bob, charlie, david, &nodes[4]], tor.clone()); + + let offer = bob.node + .create_offer_builder().unwrap() + .amount_msats(10_000_000) + .build().unwrap(); + assert_ne!(offer.signing_pubkey(), Some(bob_id)); + assert!(!offer.paths().is_empty()); + for path in offer.paths() { + assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id)); } } @@ -303,13 +333,13 @@ fn prefers_more_connected_nodes_in_blinded_paths() { disconnect_peers(david, &[bob, &nodes[4], &nodes[5]]); let offer = bob.node - .create_offer_builder("coffee".to_string()).unwrap() + .create_offer_builder().unwrap() .amount_msats(10_000_000) .build().unwrap(); - assert_ne!(offer.signing_pubkey(), bob_id); + assert_ne!(offer.signing_pubkey(), Some(bob_id)); assert!(!offer.paths().is_empty()); for path in offer.paths() { - assert_eq!(path.introduction_node_id, nodes[4].node.get_our_node_id()); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(nodes[4].node.get_our_node_id())); } } @@ -352,13 +382,14 @@ fn creates_and_pays_for_offer_using_two_hop_blinded_path() { disconnect_peers(david, &[bob, &nodes[4], &nodes[5]]); let offer = alice.node - .create_offer_builder("coffee".to_string()).unwrap() + .create_offer_builder() + .unwrap() .amount_msats(10_000_000) .build().unwrap(); - assert_ne!(offer.signing_pubkey(), alice_id); + assert_ne!(offer.signing_pubkey(), Some(alice_id)); assert!(!offer.paths().is_empty()); for path in offer.paths() { - assert_eq!(path.introduction_node_id, bob_id); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id)); } let payment_id = PaymentId([1; 32]); @@ -377,9 +408,19 @@ fn creates_and_pays_for_offer_using_two_hop_blinded_path() { alice.onion_messenger.handle_onion_message(&bob_id, &onion_message); let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message); + let payment_context = PaymentContext::Bolt12Offer(Bolt12OfferContext { + offer_id: offer.id(), + invoice_request: InvoiceRequestFields { + payer_id: invoice_request.payer_id(), + amount_msats: None, + features: InvoiceRequestFeatures::empty(), + quantity: None, + payer_note_truncated: None, + }, + }); assert_eq!(invoice_request.amount_msats(), None); assert_ne!(invoice_request.payer_id(), david_id); - assert_eq!(reply_path.unwrap().introduction_node_id, charlie_id); + assert_eq!(reply_path.unwrap().introduction_node, IntroductionNode::NodeId(charlie_id)); let onion_message = alice.onion_messenger.next_onion_message_for_peer(charlie_id).unwrap(); charlie.onion_messenger.handle_onion_message(&alice_id, &onion_message); @@ -392,13 +433,13 @@ fn creates_and_pays_for_offer_using_two_hop_blinded_path() { assert_ne!(invoice.signing_pubkey(), alice_id); assert!(!invoice.payment_paths().is_empty()); for (_, path) in invoice.payment_paths() { - assert_eq!(path.introduction_node_id, bob_id); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id)); } route_bolt12_payment(david, &[charlie, bob, alice], &invoice); expect_recent_payment!(david, RecentPaymentDetails::Pending, payment_id); - claim_bolt12_payment(david, &[charlie, bob, alice]); + claim_bolt12_payment(david, &[charlie, bob, alice], payment_context); expect_recent_payment!(david, RecentPaymentDetails::Fulfilled, payment_id); } @@ -443,9 +484,7 @@ fn creates_and_pays_for_refund_using_two_hop_blinded_path() { let absolute_expiry = Duration::from_secs(u64::MAX); let payment_id = PaymentId([1; 32]); let refund = david.node - .create_refund_builder( - "refund".to_string(), 10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None - ) + .create_refund_builder(10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None) .unwrap() .build().unwrap(); assert_eq!(refund.amount_msats(), 10_000_000); @@ -453,11 +492,12 @@ fn creates_and_pays_for_refund_using_two_hop_blinded_path() { assert_ne!(refund.payer_id(), david_id); assert!(!refund.paths().is_empty()); for path in refund.paths() { - assert_eq!(path.introduction_node_id, charlie_id); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(charlie_id)); } expect_recent_payment!(david, RecentPaymentDetails::AwaitingInvoice, payment_id); - alice.node.request_refund_payment(&refund).unwrap(); + let payment_context = PaymentContext::Bolt12Refund(Bolt12RefundContext {}); + let expected_invoice = alice.node.request_refund_payment(&refund).unwrap(); connect_peers(alice, charlie); @@ -468,17 +508,19 @@ fn creates_and_pays_for_refund_using_two_hop_blinded_path() { david.onion_messenger.handle_onion_message(&charlie_id, &onion_message); let invoice = extract_invoice(david, &onion_message); + assert_eq!(invoice, expected_invoice); + assert_eq!(invoice.amount_msats(), 10_000_000); assert_ne!(invoice.signing_pubkey(), alice_id); assert!(!invoice.payment_paths().is_empty()); for (_, path) in invoice.payment_paths() { - assert_eq!(path.introduction_node_id, bob_id); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id)); } route_bolt12_payment(david, &[charlie, bob, alice], &invoice); expect_recent_payment!(david, RecentPaymentDetails::Pending, payment_id); - claim_bolt12_payment(david, &[charlie, bob, alice]); + claim_bolt12_payment(david, &[charlie, bob, alice], payment_context); expect_recent_payment!(david, RecentPaymentDetails::Fulfilled, payment_id); } @@ -500,13 +542,13 @@ fn creates_and_pays_for_offer_using_one_hop_blinded_path() { let bob_id = bob.node.get_our_node_id(); let offer = alice.node - .create_offer_builder("coffee".to_string()).unwrap() + .create_offer_builder().unwrap() .amount_msats(10_000_000) .build().unwrap(); - assert_ne!(offer.signing_pubkey(), alice_id); + assert_ne!(offer.signing_pubkey(), Some(alice_id)); assert!(!offer.paths().is_empty()); for path in offer.paths() { - assert_eq!(path.introduction_node_id, alice_id); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(alice_id)); } let payment_id = PaymentId([1; 32]); @@ -517,9 +559,19 @@ fn creates_and_pays_for_offer_using_one_hop_blinded_path() { alice.onion_messenger.handle_onion_message(&bob_id, &onion_message); let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message); + let payment_context = PaymentContext::Bolt12Offer(Bolt12OfferContext { + offer_id: offer.id(), + invoice_request: InvoiceRequestFields { + payer_id: invoice_request.payer_id(), + amount_msats: None, + features: InvoiceRequestFeatures::empty(), + quantity: None, + payer_note_truncated: None, + }, + }); assert_eq!(invoice_request.amount_msats(), None); assert_ne!(invoice_request.payer_id(), bob_id); - assert_eq!(reply_path.unwrap().introduction_node_id, bob_id); + assert_eq!(reply_path.unwrap().introduction_node, IntroductionNode::NodeId(bob_id)); let onion_message = alice.onion_messenger.next_onion_message_for_peer(bob_id).unwrap(); bob.onion_messenger.handle_onion_message(&alice_id, &onion_message); @@ -529,13 +581,13 @@ fn creates_and_pays_for_offer_using_one_hop_blinded_path() { assert_ne!(invoice.signing_pubkey(), alice_id); assert!(!invoice.payment_paths().is_empty()); for (_, path) in invoice.payment_paths() { - assert_eq!(path.introduction_node_id, alice_id); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(alice_id)); } route_bolt12_payment(bob, &[alice], &invoice); expect_recent_payment!(bob, RecentPaymentDetails::Pending, payment_id); - claim_bolt12_payment(bob, &[alice]); + claim_bolt12_payment(bob, &[alice], payment_context); expect_recent_payment!(bob, RecentPaymentDetails::Fulfilled, payment_id); } @@ -559,9 +611,7 @@ fn creates_and_pays_for_refund_using_one_hop_blinded_path() { let absolute_expiry = Duration::from_secs(u64::MAX); let payment_id = PaymentId([1; 32]); let refund = bob.node - .create_refund_builder( - "refund".to_string(), 10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None - ) + .create_refund_builder(10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None) .unwrap() .build().unwrap(); assert_eq!(refund.amount_msats(), 10_000_000); @@ -569,27 +619,30 @@ fn creates_and_pays_for_refund_using_one_hop_blinded_path() { assert_ne!(refund.payer_id(), bob_id); assert!(!refund.paths().is_empty()); for path in refund.paths() { - assert_eq!(path.introduction_node_id, bob_id); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id)); } expect_recent_payment!(bob, RecentPaymentDetails::AwaitingInvoice, payment_id); - alice.node.request_refund_payment(&refund).unwrap(); + let payment_context = PaymentContext::Bolt12Refund(Bolt12RefundContext {}); + let expected_invoice = alice.node.request_refund_payment(&refund).unwrap(); let onion_message = alice.onion_messenger.next_onion_message_for_peer(bob_id).unwrap(); bob.onion_messenger.handle_onion_message(&alice_id, &onion_message); let invoice = extract_invoice(bob, &onion_message); + assert_eq!(invoice, expected_invoice); + assert_eq!(invoice.amount_msats(), 10_000_000); assert_ne!(invoice.signing_pubkey(), alice_id); assert!(!invoice.payment_paths().is_empty()); for (_, path) in invoice.payment_paths() { - assert_eq!(path.introduction_node_id, alice_id); + assert_eq!(path.introduction_node, IntroductionNode::NodeId(alice_id)); } route_bolt12_payment(bob, &[alice], &invoice); expect_recent_payment!(bob, RecentPaymentDetails::Pending, payment_id); - claim_bolt12_payment(bob, &[alice]); + claim_bolt12_payment(bob, &[alice], payment_context); expect_recent_payment!(bob, RecentPaymentDetails::Fulfilled, payment_id); } @@ -611,11 +664,11 @@ fn pays_for_offer_without_blinded_paths() { let bob_id = bob.node.get_our_node_id(); let offer = alice.node - .create_offer_builder("coffee".to_string()).unwrap() + .create_offer_builder().unwrap() .clear_paths() .amount_msats(10_000_000) .build().unwrap(); - assert_eq!(offer.signing_pubkey(), alice_id); + assert_eq!(offer.signing_pubkey(), Some(alice_id)); assert!(offer.paths().is_empty()); let payment_id = PaymentId([1; 32]); @@ -625,6 +678,18 @@ fn pays_for_offer_without_blinded_paths() { let onion_message = bob.onion_messenger.next_onion_message_for_peer(alice_id).unwrap(); alice.onion_messenger.handle_onion_message(&bob_id, &onion_message); + let (invoice_request, _) = extract_invoice_request(alice, &onion_message); + let payment_context = PaymentContext::Bolt12Offer(Bolt12OfferContext { + offer_id: offer.id(), + invoice_request: InvoiceRequestFields { + payer_id: invoice_request.payer_id(), + amount_msats: None, + features: InvoiceRequestFeatures::empty(), + quantity: None, + payer_note_truncated: None, + }, + }); + let onion_message = alice.onion_messenger.next_onion_message_for_peer(bob_id).unwrap(); bob.onion_messenger.handle_onion_message(&alice_id, &onion_message); @@ -632,7 +697,7 @@ fn pays_for_offer_without_blinded_paths() { route_bolt12_payment(bob, &[alice], &invoice); expect_recent_payment!(bob, RecentPaymentDetails::Pending, payment_id); - claim_bolt12_payment(bob, &[alice]); + claim_bolt12_payment(bob, &[alice], payment_context); expect_recent_payment!(bob, RecentPaymentDetails::Fulfilled, payment_id); } @@ -655,9 +720,7 @@ fn pays_for_refund_without_blinded_paths() { let absolute_expiry = Duration::from_secs(u64::MAX); let payment_id = PaymentId([1; 32]); let refund = bob.node - .create_refund_builder( - "refund".to_string(), 10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None - ) + .create_refund_builder(10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None) .unwrap() .clear_paths() .build().unwrap(); @@ -665,16 +728,19 @@ fn pays_for_refund_without_blinded_paths() { assert!(refund.paths().is_empty()); expect_recent_payment!(bob, RecentPaymentDetails::AwaitingInvoice, payment_id); - alice.node.request_refund_payment(&refund).unwrap(); + let payment_context = PaymentContext::Bolt12Refund(Bolt12RefundContext {}); + let expected_invoice = alice.node.request_refund_payment(&refund).unwrap(); let onion_message = alice.onion_messenger.next_onion_message_for_peer(bob_id).unwrap(); bob.onion_messenger.handle_onion_message(&alice_id, &onion_message); let invoice = extract_invoice(bob, &onion_message); + assert_eq!(invoice, expected_invoice); + route_bolt12_payment(bob, &[alice], &invoice); expect_recent_payment!(bob, RecentPaymentDetails::Pending, payment_id); - claim_bolt12_payment(bob, &[alice]); + claim_bolt12_payment(bob, &[alice], payment_context); expect_recent_payment!(bob, RecentPaymentDetails::Fulfilled, payment_id); } @@ -688,7 +754,7 @@ fn fails_creating_offer_without_blinded_paths() { create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 1_000_000_000); - match nodes[0].node.create_offer_builder("coffee".to_string()) { + match nodes[0].node.create_offer_builder() { Ok(_) => panic!("Expected error"), Err(e) => assert_eq!(e, Bolt12SemanticError::MissingPaths), } @@ -708,7 +774,7 @@ fn fails_creating_refund_without_blinded_paths() { let payment_id = PaymentId([1; 32]); match nodes[0].node.create_refund_builder( - "refund".to_string(), 10_000, absolute_expiry, payment_id, Retry::Attempts(0), None + 10_000, absolute_expiry, payment_id, Retry::Attempts(0), None ) { Ok(_) => panic!("Expected error"), Err(e) => assert_eq!(e, Bolt12SemanticError::MissingPaths), @@ -717,6 +783,59 @@ fn fails_creating_refund_without_blinded_paths() { assert!(nodes[0].node.list_recent_payments().is_empty()); } +/// Fails creating an invoice request when the offer contains an unsupported chain. +#[test] +fn fails_creating_invoice_request_for_unsupported_chain() { + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 1_000_000_000); + + let alice = &nodes[0]; + let bob = &nodes[1]; + + let offer = alice.node + .create_offer_builder().unwrap() + .clear_chains() + .chain(Network::Signet) + .build().unwrap(); + + let payment_id = PaymentId([1; 32]); + match bob.node.pay_for_offer(&offer, None, None, None, payment_id, Retry::Attempts(0), None) { + Ok(_) => panic!("Expected error"), + Err(e) => assert_eq!(e, Bolt12SemanticError::UnsupportedChain), + } +} + +/// Fails requesting a payment when the refund contains an unsupported chain. +#[test] +fn fails_sending_invoice_with_unsupported_chain_for_refund() { + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 1_000_000_000); + + let alice = &nodes[0]; + let bob = &nodes[1]; + + let absolute_expiry = Duration::from_secs(u64::MAX); + let payment_id = PaymentId([1; 32]); + let refund = bob.node + .create_refund_builder(10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None) + .unwrap() + .chain(Network::Signet) + .build().unwrap(); + + match alice.node.request_refund_payment(&refund) { + Ok(_) => panic!("Expected error"), + Err(e) => assert_eq!(e, Bolt12SemanticError::UnsupportedChain), + } +} + /// Fails creating an invoice request when a blinded reply path cannot be created without exposing /// the node's id. #[test] @@ -738,7 +857,7 @@ fn fails_creating_invoice_request_without_blinded_reply_path() { disconnect_peers(david, &[bob, &nodes[4], &nodes[5]]); let offer = alice.node - .create_offer_builder("coffee".to_string()).unwrap() + .create_offer_builder().unwrap() .amount_msats(10_000_000) .build().unwrap(); @@ -772,7 +891,7 @@ fn fails_creating_invoice_request_with_duplicate_payment_id() { disconnect_peers(alice, &[charlie, david, &nodes[4], &nodes[5]]); let offer = alice.node - .create_offer_builder("coffee".to_string()).unwrap() + .create_offer_builder().unwrap() .amount_msats(10_000_000) .build().unwrap(); @@ -805,13 +924,13 @@ fn fails_creating_refund_with_duplicate_payment_id() { let payment_id = PaymentId([1; 32]); assert!( nodes[0].node.create_refund_builder( - "refund".to_string(), 10_000, absolute_expiry, payment_id, Retry::Attempts(0), None + 10_000, absolute_expiry, payment_id, Retry::Attempts(0), None ).is_ok() ); expect_recent_payment!(nodes[0], RecentPaymentDetails::AwaitingInvoice, payment_id); match nodes[0].node.create_refund_builder( - "refund".to_string(), 10_000, absolute_expiry, payment_id, Retry::Attempts(0), None + 10_000, absolute_expiry, payment_id, Retry::Attempts(0), None ) { Ok(_) => panic!("Expected error"), Err(e) => assert_eq!(e, Bolt12SemanticError::DuplicatePaymentId), @@ -858,7 +977,7 @@ fn fails_sending_invoice_without_blinded_payment_paths_for_offer() { disconnect_peers(david, &[bob, &nodes[4], &nodes[5]]); let offer = alice.node - .create_offer_builder("coffee".to_string()).unwrap() + .create_offer_builder().unwrap() .amount_msats(10_000_000) .build().unwrap(); @@ -922,9 +1041,7 @@ fn fails_sending_invoice_without_blinded_payment_paths_for_refund() { let absolute_expiry = Duration::from_secs(u64::MAX); let payment_id = PaymentId([1; 32]); let refund = david.node - .create_refund_builder( - "refund".to_string(), 10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None - ) + .create_refund_builder(10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None) .unwrap() .build().unwrap(); @@ -973,9 +1090,7 @@ fn fails_paying_invoice_more_than_once() { let absolute_expiry = Duration::from_secs(u64::MAX); let payment_id = PaymentId([1; 32]); let refund = david.node - .create_refund_builder( - "refund".to_string(), 10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None - ) + .create_refund_builder(10_000_000, absolute_expiry, payment_id, Retry::Attempts(0), None) .unwrap() .build().unwrap(); expect_recent_payment!(david, RecentPaymentDetails::AwaitingInvoice, payment_id); @@ -992,12 +1107,13 @@ fn fails_paying_invoice_more_than_once() { david.onion_messenger.handle_onion_message(&charlie_id, &onion_message); // David pays the first invoice + let payment_context = PaymentContext::Bolt12Refund(Bolt12RefundContext {}); let invoice1 = extract_invoice(david, &onion_message); route_bolt12_payment(david, &[charlie, bob, alice], &invoice1); expect_recent_payment!(david, RecentPaymentDetails::Pending, payment_id); - claim_bolt12_payment(david, &[charlie, bob, alice]); + claim_bolt12_payment(david, &[charlie, bob, alice], payment_context); expect_recent_payment!(david, RecentPaymentDetails::Fulfilled, payment_id); disconnect_peers(alice, &[charlie]);