Add commitment transaction broadcast as a ChannelMonitor event

[rust-lightning] / fuzz / src / chanmon_consistency.rs

diff --git a/fuzz/src/chanmon_consistency.rs b/fuzz/src/chanmon_consistency.rs
index 3a236cdfb46ea03ff7c5e4dd47ebc3950668d42b..0fc77c58f56c4bd1c8d6d2584639da30bfeb9d42 100644 (file)
--- a/fuzz/src/chanmon_consistency.rs
+++ b/fuzz/src/chanmon_consistency.rs
@@ -1,3 +1,12 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
 //! Test that monitor update failures don't get our channel state out of sync.
 //! One of the biggest concern with the monitor update failure handling code is that messages
 //! resent after monitor updating is restored are delivered out-of-order, resulting in
@@ -25,7 +34,7 @@ use lightning::chain::transaction::OutPoint;
 use lightning::chain::chaininterface::{BroadcasterInterface,ConfirmationTarget,ChainListener,FeeEstimator,ChainWatchInterfaceUtil,ChainWatchInterface};
 use lightning::chain::keysinterface::{KeysInterface, InMemoryChannelKeys};
 use lightning::ln::channelmonitor;
-use lightning::ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, HTLCUpdate};
+use lightning::ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, MonitorEvent};
 use lightning::ln::channelmanager::{ChannelManager, PaymentHash, PaymentPreimage, PaymentSecret, ChannelManagerReadArgs};
 use lightning::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
 use lightning::ln::msgs::{CommitmentUpdate, ChannelMessageHandler, ErrorAction, UpdateAddHTLC, Init};
@@ -52,7 +61,7 @@ use std::io::Cursor;
 
 struct FuzzEstimator {}
 impl FeeEstimator for FuzzEstimator {
-       fn get_est_sat_per_1000_weight(&self, _: ConfirmationTarget) -> u64 {
+       fn get_est_sat_per_1000_weight(&self, _: ConfirmationTarget) -> u32 {
                253
        }
 }
@@ -126,8 +135,8 @@ impl channelmonitor::ManyChannelMonitor for TestChannelMonitor {
                self.update_ret.lock().unwrap().clone()
        }
 
-       fn get_and_clear_pending_htlcs_updated(&self) -> Vec<HTLCUpdate> {
-               return self.simple_monitor.get_and_clear_pending_htlcs_updated();
+       fn get_and_clear_pending_monitor_events(&self) -> Vec<MonitorEvent> {
+               return self.simple_monitor.get_and_clear_pending_monitor_events();
        }
 }
 
@@ -166,6 +175,7 @@ impl KeysInterface for KeyProvider {
                        SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, self.node_id]).unwrap(),
                        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, self.node_id],
                        channel_value_satoshis,
+                       (0, 0),
                ))
        }
 
@@ -310,7 +320,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
                        let mut posn = Vec::with_capacity(channel_txn.len());
                        for i in 0..channel_txn.len() {
                                txn.push(&channel_txn[i]);
-                               posn.push(i as u32 + 1);
+                               posn.push(i + 1);
                        }
                        $node.block_connected(&header, 1, &txn, &posn);
                        for i in 2..100 {
@@ -407,7 +417,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 
        loop {
                macro_rules! send_payment {
-                       ($source: expr, $dest: expr) => { {
+                       ($source: expr, $dest: expr, $amt: expr) => { {
                                let payment_hash = Sha256::hash(&[payment_id; 1]);
                                payment_id = payment_id.wrapping_add(1);
                                if let Err(_) = $source.send_payment(&Route {
@@ -416,7 +426,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
                                                node_features: NodeFeatures::empty(),
                                                short_channel_id: $dest.1,
                                                channel_features: ChannelFeatures::empty(),
-                                               fee_msat: 5000000,
+                                               fee_msat: $amt,
                                                cltv_expiry_delta: 200,
                                        }]],
                                }, PaymentHash(payment_hash.into_inner()), &None) {
@@ -424,7 +434,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
                                        test_return!();
                                }
                        } };
-                       ($source: expr, $middle: expr, $dest: expr) => { {
+                       ($source: expr, $middle: expr, $dest: expr, $amt: expr) => { {
                                let payment_hash = Sha256::hash(&[payment_id; 1]);
                                payment_id = payment_id.wrapping_add(1);
                                if let Err(_) = $source.send_payment(&Route {
@@ -440,7 +450,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
                                                node_features: NodeFeatures::empty(),
                                                short_channel_id: $dest.1,
                                                channel_features: ChannelFeatures::empty(),
-                                               fee_msat: 5000000,
+                                               fee_msat: $amt,
                                                cltv_expiry_delta: 200,
                                        }]],
                                }, PaymentHash(payment_hash.into_inner()), &None) {
@@ -643,12 +653,12 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
                                });
                                for event in events.drain(..) {
                                        match event {
-                                               events::Event::PaymentReceived { payment_hash, payment_secret, .. } => {
+                                               events::Event::PaymentReceived { payment_hash, payment_secret, amt } => {
                                                        if claim_set.insert(payment_hash.0) {
                                                                if $fail {
                                                                        assert!(nodes[$node].fail_htlc_backwards(&payment_hash, &payment_secret));
                                                                } else {
-                                                                       assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0), &payment_secret, 5_000_000));
+                                                                       assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0), &payment_secret, amt));
                                                                }
                                                        }
                                                },
@@ -690,12 +700,12 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
                                        nodes[2].channel_monitor_updated(&chan_2_funding, *id);
                                }
                        },
-                       0x09 => send_payment!(nodes[0], (&nodes[1], chan_a)),
-                       0x0a => send_payment!(nodes[1], (&nodes[0], chan_a)),
-                       0x0b => send_payment!(nodes[1], (&nodes[2], chan_b)),
-                       0x0c => send_payment!(nodes[2], (&nodes[1], chan_b)),
-                       0x0d => send_payment!(nodes[0], (&nodes[1], chan_a), (&nodes[2], chan_b)),
-                       0x0e => send_payment!(nodes[2], (&nodes[1], chan_b), (&nodes[0], chan_a)),
+                       0x09 => send_payment!(nodes[0], (&nodes[1], chan_a), 5_000_000),
+                       0x0a => send_payment!(nodes[1], (&nodes[0], chan_a), 5_000_000),
+                       0x0b => send_payment!(nodes[1], (&nodes[2], chan_b), 5_000_000),
+                       0x0c => send_payment!(nodes[2], (&nodes[1], chan_b), 5_000_000),
+                       0x0d => send_payment!(nodes[0], (&nodes[1], chan_a), (&nodes[2], chan_b), 5_000_000),
+                       0x0e => send_payment!(nodes[2], (&nodes[1], chan_b), (&nodes[0], chan_a), 5_000_000),
                        0x0f => {
                                if !chan_a_disconnected {
                                        nodes[0].peer_disconnected(&nodes[1].get_our_node_id(), false);
@@ -780,6 +790,24 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
                        },
                        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)),
+                       0x25 => send_payment!(nodes[0], (&nodes[1], chan_a), 10),
+                       0x26 => send_payment!(nodes[1], (&nodes[0], chan_a), 10),
+                       0x27 => send_payment!(nodes[1], (&nodes[2], chan_b), 10),
+                       0x28 => send_payment!(nodes[2], (&nodes[1], chan_b), 10),
+                       0x29 => send_payment!(nodes[0], (&nodes[1], chan_a), (&nodes[2], chan_b), 10),
+                       0x2a => send_payment!(nodes[2], (&nodes[1], chan_b), (&nodes[0], chan_a), 10),
+                       0x2b => send_payment!(nodes[0], (&nodes[1], chan_a), 1_000),
+                       0x2c => send_payment!(nodes[1], (&nodes[0], chan_a), 1_000),
+                       0x2d => send_payment!(nodes[1], (&nodes[2], chan_b), 1_000),
+                       0x2e => send_payment!(nodes[2], (&nodes[1], chan_b), 1_000),
+                       0x2f => send_payment!(nodes[0], (&nodes[1], chan_a), (&nodes[2], chan_b), 1_000),
+                       0x30 => send_payment!(nodes[2], (&nodes[1], chan_b), (&nodes[0], chan_a), 1_000),
+                       0x31 => send_payment!(nodes[0], (&nodes[1], chan_a), 100_000),
+                       0x32 => send_payment!(nodes[1], (&nodes[0], chan_a), 100_000),
+                       0x33 => send_payment!(nodes[1], (&nodes[2], chan_b), 100_000),
+                       0x34 => send_payment!(nodes[2], (&nodes[1], chan_b), 100_000),
+                       0x35 => send_payment!(nodes[0], (&nodes[1], chan_a), (&nodes[2], chan_b), 100_000),
+                       0x36 => send_payment!(nodes[2], (&nodes[1], chan_b), (&nodes[0], chan_a), 100_000),
                        // 0x24 defined above
                        _ => test_return!(),
                }