Test basic AMP payments in chanmon_consistency

diff --git a/fuzz/src/chanmon_consistency.rs b/fuzz/src/chanmon_consistency.rs
index 5f4fc1333406a008a7048db3347e22969e5ab562..44b7a29e6ede09f2c4f364adffe03e9c3ed473f9 100644 (file)
--- a/fuzz/src/chanmon_consistency.rs
+++ b/fuzz/src/chanmon_consistency.rs
@@ -27,7 +27,7 @@ use lightning::chain::chaininterface::{BroadcasterInterface,ConfirmationTarget,C
 use lightning::chain::keysinterface::{KeysInterface, InMemoryChannelKeys};
 use lightning::ln::channelmonitor;
 use lightning::ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, HTLCUpdate};
-use lightning::ln::channelmanager::{ChannelManager, PaymentHash, PaymentPreimage, ChannelManagerReadArgs};
+use lightning::ln::channelmanager::{ChannelManager, PaymentHash, PaymentPreimage, PaymentSecret, ChannelManagerReadArgs};
 use lightning::ln::router::{Route, RouteHop};
 use lightning::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
 use lightning::ln::msgs::{CommitmentUpdate, ChannelMessageHandler, ErrorAction, UpdateAddHTLC, Init};
@@ -447,6 +447,48 @@ pub fn do_test(data: &[u8]) {
                                }
                        } }
                }
+               macro_rules! send_payment_with_secret {
+                       ($source: expr, $middle: expr, $dest: expr) => { {
+                               let payment_hash = Sha256::hash(&[payment_id; 1]);
+                               payment_id = payment_id.wrapping_add(1);
+                               let payment_secret = Sha256::hash(&[payment_id; 1]);
+                               payment_id = payment_id.wrapping_add(1);
+                               if let Err(_) = $source.send_payment(Route {
+                                       paths: vec![vec![RouteHop {
+                                               pubkey: $middle.0.get_our_node_id(),
+                                               node_features: NodeFeatures::empty(),
+                                               short_channel_id: $middle.1,
+                                               channel_features: ChannelFeatures::empty(),
+                                               fee_msat: 50000,
+                                               cltv_expiry_delta: 100,
+                                       },RouteHop {
+                                               pubkey: $dest.0.get_our_node_id(),
+                                               node_features: NodeFeatures::empty(),
+                                               short_channel_id: $dest.1,
+                                               channel_features: ChannelFeatures::empty(),
+                                               fee_msat: 5000000,
+                                               cltv_expiry_delta: 200,
+                                       }],vec![RouteHop {
+                                               pubkey: $middle.0.get_our_node_id(),
+                                               node_features: NodeFeatures::empty(),
+                                               short_channel_id: $middle.1,
+                                               channel_features: ChannelFeatures::empty(),
+                                               fee_msat: 50000,
+                                               cltv_expiry_delta: 100,
+                                       },RouteHop {
+                                               pubkey: $dest.0.get_our_node_id(),
+                                               node_features: NodeFeatures::empty(),
+                                               short_channel_id: $dest.1,
+                                               channel_features: ChannelFeatures::empty(),
+                                               fee_msat: 5000000,
+                                               cltv_expiry_delta: 200,
+                                       }]],
+                               }, PaymentHash(payment_hash.into_inner()), &Some(PaymentSecret(payment_secret.into_inner()))) {
+                                       // Probably ran out of funds
+                                       test_return!();
+                               }
+                       } }
+               }
 
                macro_rules! process_msg_events {
                        ($node: expr, $corrupt_forward: expr) => { {
@@ -599,12 +641,12 @@ pub fn do_test(data: &[u8]) {
                                });
                                for event in events.drain(..) {
                                        match event {
-                                               events::Event::PaymentReceived { payment_hash, .. } => {
+                                               events::Event::PaymentReceived { payment_hash, payment_secret, .. } => {
                                                        if claim_set.insert(payment_hash.0) {
                                                                if $fail {
-                                                                       assert!(nodes[$node].fail_htlc_backwards(&payment_hash, &None));
+                                                                       assert!(nodes[$node].fail_htlc_backwards(&payment_hash, &payment_secret));
                                                                } else {
-                                                                       assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0), &None, 5_000_000));
+                                                                       assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0), &payment_secret, 5_000_000));
                                                                }
                                                        }
                                                },
@@ -734,6 +776,8 @@ pub fn do_test(data: &[u8]) {
                                nodes[2] = node_c.clone();
                                monitor_c = new_monitor_c;
                        },
+                       0x22 => send_payment_with_secret!(nodes[0], (&nodes[1], chan_a), (&nodes[2], chan_b)),
+                       0x23 => send_payment_with_secret!(nodes[2], (&nodes[1], chan_b), (&nodes[0], chan_a)),
                        // 0x24 defined above
                        _ => test_return!(),
                }

diff --git a/fuzz/src/full_stack.rs b/fuzz/src/full_stack.rs
index b3317fc416b1775e7107934cc981eb269836366b..cde58a429d2c9506e084a42c416ac916103798ec 100644 (file)
--- a/fuzz/src/full_stack.rs
+++ b/fuzz/src/full_stack.rs
@@ -406,6 +406,27 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
                                        Err(_) => return,
                                }
                        },
+                       15 => {
+                               let value = slice_to_be24(get_slice!(3)) as u64;
+                               let mut route = match router.get_route(&get_pubkey!(), None, &Vec::new(), value, 42) {
+                                       Ok(route) => route,
+                                       Err(_) => return,
+                               };
+                               route.paths.push(route.paths[0].clone());
+                               let mut payment_hash = PaymentHash([0; 32]);
+                               payment_hash.0[0..8].copy_from_slice(&be64_to_array(payments_sent));
+                               let mut sha = Sha256::engine();
+                               sha.input(&payment_hash.0[..]);
+                               payment_hash.0 = Sha256::from_engine(sha).into_inner();
+                               payments_sent += 1;
+                               let mut payment_secret = PaymentSecret([0; 32]);
+                               payment_secret.0[0..8].copy_from_slice(&be64_to_array(payments_sent));
+                               payments_sent += 1;
+                               match channelmanager.send_payment(&route, payment_hash, &Some(payment_secret)) {
+                                       Ok(_) => {},
+                                       Err(_) => return,
+                               }
+                       },
                        5 => {
                                let peer_id = get_slice!(1)[0];
                                if !peers.borrow()[peer_id as usize] { return; }
@@ -513,6 +534,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
                                channels.sort_by(|a, b| { a.channel_id.cmp(&b.channel_id) });
                                channelmanager.force_close_channel(&channels[channel_id].channel_id);
                        },
+                       // 15 is above
                        _ => return,
                }
                loss_detector.handler.process_events();