Skip to content

Commit 77df903

Browse files
jkczyzjkczyz
committed
f - Separate payer and handler construction
1 parent 15a88d6 commit 77df903

File tree

1 file changed

+83
-81
lines changed

1 file changed

+83
-81
lines changed

‎lightning-invoice/src/payment.rs

+83-81
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ use lightning::util::logger::Logger;
4949
use std::cell::RefCell;
5050
use std::collections::hash_map::{self, HashMap};
5151
use std::ops::Deref;
52-
use std::sync::{Arc, Mutex};
52+
use std::sync::Mutex;
5353

5454
/// The maximum number of payment attempts before forwarding the [`Event::PaymentFailed`] to be
5555
/// handled.
@@ -107,40 +107,31 @@ pub enum PaymentError {
107107
}
108108

109109
/// An [`EventHandler`] decorator for retrying failed payments.
110-
pub struct PaymentRetryHandler<P: Deref, R, G, L: Deref, E>
110+
pub struct PaymentRetryHandler<I, P: Deref, R, G, L: Deref, E>
111111
where
112+
I: Deref<Target = InvoicePayer<P, R, G>>,
112113
P::Target: Payer,
113114
R: Router,
114115
G: Deref<Target = NetworkGraph>,
115116
L::Target: Logger,
116117
E: EventHandler,
117118
{
118-
invoice_payer: Arc<InvoicePayer<P, R, G>>,
119+
invoice_payer: I,
119120
payment_attempts: RefCell<HashMap<PaymentHash, usize>>,
120121
logger: L,
121122
event_handler: E,
122123
}
123124

124125
impl<P: Deref, R, G> InvoicePayer<P, R, G>
125126
where P::Target: Payer, R: Router, G: Deref<Target = NetworkGraph> {
126-
/// Creates a payer and a connected retry handler.
127-
pub fn new<L: Deref, E: EventHandler>(
128-
payer: P, router: R, network_graph: G, logger: L, event_handler: E
129-
) -> (Arc<Self>, PaymentRetryHandler<P, R, G, L, E>)
130-
where L::Target: Logger {
131-
let invoice_payer = Arc::new(Self {
127+
/// Creates an invoice payer.
128+
pub fn new(payer: P, router: R, network_graph: G) -> Self {
129+
Self {
132130
payer,
133131
router,
134132
network_graph,
135133
invoice_cache: Mutex::new(HashMap::new()),
136-
});
137-
let retry_handler = PaymentRetryHandler {
138-
invoice_payer: Arc::clone(&invoice_payer),
139-
payment_attempts: RefCell::new(HashMap::new()),
140-
logger,
141-
event_handler,
142-
};
143-
(invoice_payer, retry_handler)
134+
}
144135
}
145136

146137
/// Pays the given [`Invoice`], caching it for later use if a retry is needed.
@@ -200,8 +191,35 @@ where P::Target: Payer, R: Router, G: Deref<Target = NetworkGraph> {
200191
}
201192
}
202193

203-
impl<P: Deref, R, G, L: Deref + Clone, E> EventHandler for PaymentRetryHandler<P, R, G, L, E>
204-
where P::Target: Payer, R: Router, G: Deref<Target = NetworkGraph>, L::Target: Logger, E: EventHandler {
194+
impl<I, P: Deref, R, G, L: Deref, E> PaymentRetryHandler<I, P, R, G, L, E>
195+
where
196+
I: Deref<Target = InvoicePayer<P, R, G>>,
197+
P::Target: Payer,
198+
R: Router,
199+
G: Deref<Target = NetworkGraph>,
200+
L::Target: Logger,
201+
E: EventHandler,
202+
{
203+
/// Creates a payment retry handler.
204+
pub fn new(invoice_payer: I, logger: L, event_handler: E) -> Self {
205+
Self {
206+
invoice_payer,
207+
payment_attempts: RefCell::new(HashMap::new()),
208+
logger,
209+
event_handler,
210+
}
211+
}
212+
}
213+
214+
impl<I, P: Deref, R, G, L: Deref, E> EventHandler for PaymentRetryHandler<I, P, R, G, L, E>
215+
where
216+
I: Deref<Target = InvoicePayer<P, R, G>>,
217+
P::Target: Payer,
218+
R: Router,
219+
G: Deref<Target = NetworkGraph>,
220+
L::Target: Logger,
221+
E: EventHandler,
222+
{
205223
fn handle_event(&self, event: &Event) {
206224
match event {
207225
Event::PaymentFailed { payment_hash, rejected_by_dest, .. } => {
@@ -279,16 +297,15 @@ mod tests {
279297

280298
#[test]
281299
fn pays_invoice_on_first_attempt() {
282-
let event_handled = core::cell::RefCell::new(false);
283-
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
284-
285-
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
286-
let network_graph = NetworkGraph::new(genesis_hash);
287-
let logger = TestLogger::new();
288300
let payer = TestPayer::new();
289301
let router = NullRouter {};
290-
let (invoice_payer, retry_handler) =
291-
InvoicePayer::new(&payer, router, &network_graph, &logger, event_handler);
302+
let network_graph = NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash());
303+
let invoice_payer = InvoicePayer::new(&payer, router, &network_graph);
304+
305+
let logger = TestLogger::new();
306+
let event_handled = core::cell::RefCell::new(false);
307+
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
308+
let retry_handler = PaymentRetryHandler::new(&invoice_payer, &logger, event_handler);
292309

293310
let payment_preimage = PaymentPreimage([1; 32]);
294311
let invoice = invoice(payment_preimage);
@@ -302,16 +319,15 @@ mod tests {
302319

303320
#[test]
304321
fn pays_invoice_on_retry() {
305-
let event_handled = core::cell::RefCell::new(false);
306-
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
307-
308-
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
309-
let network_graph = NetworkGraph::new(genesis_hash);
310-
let logger = TestLogger::new();
311322
let payer = TestPayer::new();
312323
let router = NullRouter {};
313-
let (invoice_payer, retry_handler) =
314-
InvoicePayer::new(&payer, router, &network_graph, &logger, event_handler);
324+
let network_graph = NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash());
325+
let invoice_payer = InvoicePayer::new(&payer, router, &network_graph);
326+
327+
let logger = TestLogger::new();
328+
let event_handled = core::cell::RefCell::new(false);
329+
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
330+
let retry_handler = PaymentRetryHandler::new(&invoice_payer, &logger, event_handler);
315331

316332
let payment_preimage = PaymentPreimage([1; 32]);
317333
let invoice = invoice(payment_preimage);
@@ -330,16 +346,15 @@ mod tests {
330346

331347
#[test]
332348
fn fails_paying_invoice_after_max_retries() {
333-
let event_handled = core::cell::RefCell::new(false);
334-
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
335-
336-
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
337-
let network_graph = NetworkGraph::new(genesis_hash);
338-
let logger = TestLogger::new();
339349
let payer = TestPayer::new();
340350
let router = NullRouter {};
341-
let (invoice_payer, retry_handler) =
342-
InvoicePayer::new(&payer, router, &network_graph, &logger, event_handler);
351+
let network_graph = NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash());
352+
let invoice_payer = InvoicePayer::new(&payer, router, &network_graph);
353+
354+
let logger = TestLogger::new();
355+
let event_handled = core::cell::RefCell::new(false);
356+
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
357+
let retry_handler = PaymentRetryHandler::new(&invoice_payer, &logger, event_handler);
343358

344359
let payment_preimage = PaymentPreimage([1; 32]);
345360
let invoice = invoice(payment_preimage);
@@ -362,16 +377,15 @@ mod tests {
362377

363378
#[test]
364379
fn fails_paying_invoice_after_retry_error() {
365-
let event_handled = core::cell::RefCell::new(false);
366-
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
367-
368-
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
369-
let network_graph = NetworkGraph::new(genesis_hash);
370-
let logger = TestLogger::new();
371380
let payer = TestPayer::new().fails_on_attempt(2);
372381
let router = NullRouter {};
373-
let (invoice_payer, retry_handler) =
374-
InvoicePayer::new(&payer, router, &network_graph, &logger, event_handler);
382+
let network_graph = NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash());
383+
let invoice_payer = InvoicePayer::new(&payer, router, &network_graph);
384+
385+
let logger = TestLogger::new();
386+
let event_handled = core::cell::RefCell::new(false);
387+
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
388+
let retry_handler = PaymentRetryHandler::new(&invoice_payer, &logger, event_handler);
375389

376390
let payment_preimage = PaymentPreimage([1; 32]);
377391
let invoice = invoice(payment_preimage);
@@ -386,16 +400,15 @@ mod tests {
386400

387401
#[test]
388402
fn fails_paying_invoice_after_rejected_by_payee() {
389-
let event_handled = core::cell::RefCell::new(false);
390-
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
391-
392-
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
393-
let network_graph = NetworkGraph::new(genesis_hash);
394-
let logger = TestLogger::new();
395403
let payer = TestPayer::new();
396404
let router = NullRouter {};
397-
let (invoice_payer, retry_handler) =
398-
InvoicePayer::new(&payer, router, &network_graph, &logger, event_handler);
405+
let network_graph = NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash());
406+
let invoice_payer = InvoicePayer::new(&payer, router, &network_graph);
407+
408+
let logger = TestLogger::new();
409+
let event_handled = core::cell::RefCell::new(false);
410+
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
411+
let retry_handler = PaymentRetryHandler::new(&invoice_payer, &logger, event_handler);
399412

400413
let payment_preimage = PaymentPreimage([1; 32]);
401414
let invoice = invoice(payment_preimage);
@@ -410,16 +423,15 @@ mod tests {
410423

411424
#[test]
412425
fn fails_repaying_invoice_with_pending_payment() {
413-
let event_handled = core::cell::RefCell::new(false);
414-
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
415-
416-
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
417-
let network_graph = NetworkGraph::new(genesis_hash);
418-
let logger = TestLogger::new();
419426
let payer = TestPayer::new();
420427
let router = NullRouter {};
421-
let (invoice_payer, retry_handler) =
422-
InvoicePayer::new(&payer, router, &network_graph, &logger, event_handler);
428+
let network_graph = NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash());
429+
let invoice_payer = InvoicePayer::new(&payer, router, &network_graph);
430+
431+
let logger = TestLogger::new();
432+
let event_handled = core::cell::RefCell::new(false);
433+
let event_handler = |_: &_| { *event_handled.borrow_mut() = true; };
434+
let retry_handler = PaymentRetryHandler::new(&invoice_payer, &logger, event_handler);
423435

424436
let payment_preimage = PaymentPreimage([1; 32]);
425437
let invoice = invoice(payment_preimage);
@@ -445,15 +457,10 @@ mod tests {
445457

446458
#[test]
447459
fn fails_paying_invoice_with_routing_errors() {
448-
let event_handler = |_: &_| {};
449-
450-
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
451-
let network_graph = NetworkGraph::new(genesis_hash);
452-
let logger = TestLogger::new();
453460
let payer = TestPayer::new();
454461
let router = FailingRouter {};
455-
let (invoice_payer, _) =
456-
InvoicePayer::new(&payer, router, &network_graph, &logger, event_handler);
462+
let network_graph = NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash());
463+
let invoice_payer = InvoicePayer::new(&payer, router, &network_graph);
457464

458465
let payment_preimage = PaymentPreimage([1; 32]);
459466
let invoice = invoice(payment_preimage);
@@ -466,15 +473,10 @@ mod tests {
466473

467474
#[test]
468475
fn fails_paying_invoice_with_sending_errors() {
469-
let event_handler = |_: &_| {};
470-
471-
let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
472-
let network_graph = NetworkGraph::new(genesis_hash);
473-
let logger = TestLogger::new();
474476
let payer = TestPayer::new().fails_on_attempt(1);
475477
let router = NullRouter {};
476-
let (invoice_payer, _) =
477-
InvoicePayer::new(&payer, router, &network_graph, &logger, event_handler);
478+
let network_graph = NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash());
479+
let invoice_payer = InvoicePayer::new(&payer, router, &network_graph);
478480

479481
let payment_preimage = PaymentPreimage([1; 32]);
480482
let invoice = invoice(payment_preimage);

0 commit comments

Comments
 (0)