mirror of
https://github.com/lightningdevkit/rust-lightning.git
synced 2025-02-25 07:17:40 +01:00
Check expected amount in claim_funds
Require to specify expected amount so that we can claim only payment for thhe correct amount, and reject payments for incorrect amounts (which are probably middle nodes probing to break our privacy). Send back incorrect_or_unknown_payments_details (PERM|15) to avoid the probe node learning that final node is waiting a payment with the routed hash.
This commit is contained in:
Antoine Riard
parent
ae0ad19db5
commit
6493efe329
6 changed files with 159 additions and 145 deletions
|
|
@ -609,7 +609,7 @@ pub fn do_test(data: &[u8]) {
|
|||
if $fail {
|
||||
assert!(nodes[$node].fail_htlc_backwards(&payment_hash));
|
||||
} else {
|
||||
assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0)));
|
||||
assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0), 5_000_000));
|
||||
}
|
||||
}
|
||||
},
|
||||
|
|
|
|||
|
|
@ -341,7 +341,7 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
|
|||
}, our_network_key, &[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, 15, 0], Arc::clone(&logger)));
|
||||
|
||||
let mut should_forward = false;
|
||||
let mut payments_received: Vec<PaymentHash> = Vec::new();
|
||||
let mut payments_received: Vec<(PaymentHash, u64)> = Vec::new();
|
||||
let mut payments_sent = 0;
|
||||
let mut pending_funding_generation: Vec<([u8; 32], u64, Script)> = Vec::new();
|
||||
let mut pending_funding_signatures = HashMap::new();
|
||||
|
|
@ -426,7 +426,7 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
|
|||
}
|
||||
},
|
||||
8 => {
|
||||
for payment in payments_received.drain(..) {
|
||||
for (payment, amt) in payments_received.drain(..) {
|
||||
// SHA256 is defined as XOR of all input bytes placed in the first byte, and 0s
|
||||
// for the remaining bytes. Thus, if not all remaining bytes are 0s we cannot
|
||||
// fulfill this HTLC, but if they are, we can just take the first byte and
|
||||
|
|
@ -436,12 +436,12 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
|
|||
} else {
|
||||
let mut payment_preimage = PaymentPreimage([0; 32]);
|
||||
payment_preimage.0[0] = payment.0[0];
|
||||
channelmanager.claim_funds(payment_preimage);
|
||||
channelmanager.claim_funds(payment_preimage, amt);
|
||||
}
|
||||
}
|
||||
},
|
||||
9 => {
|
||||
for payment in payments_received.drain(..) {
|
||||
for (payment, _) in payments_received.drain(..) {
|
||||
channelmanager.fail_htlc_backwards(&payment);
|
||||
}
|
||||
},
|
||||
|
|
@ -516,8 +516,9 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
|
|||
Event::FundingBroadcastSafe { funding_txo, .. } => {
|
||||
pending_funding_relay.push(pending_funding_signatures.remove(&funding_txo).unwrap());
|
||||
},
|
||||
Event::PaymentReceived { payment_hash, .. } => {
|
||||
payments_received.push(payment_hash);
|
||||
Event::PaymentReceived { payment_hash, amt } => {
|
||||
//TODO: enhance by fetching random amounts from fuzz input?
|
||||
payments_received.push((payment_hash, amt));
|
||||
},
|
||||
Event::PaymentSent {..} => {},
|
||||
Event::PaymentFailed {..} => {},
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
|
|||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
|
||||
|
||||
// Now set it to failed again...
|
||||
let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
|
||||
|
|
@ -166,7 +166,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
|
|||
|
||||
// Claim the previous payment, which will result in a update_fulfill_htlc/CS from nodes[1]
|
||||
// but nodes[0] won't respond since it is frozen.
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1));
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
|
||||
assert_eq!(events_2.len(), 1);
|
||||
|
|
@ -440,7 +440,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
|
|||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -544,7 +544,7 @@ fn test_monitor_update_fail_cs() {
|
|||
_ => panic!("Unexpected event"),
|
||||
};
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -587,7 +587,7 @@ fn test_monitor_update_fail_no_rebroadcast() {
|
|||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -597,7 +597,7 @@ fn test_monitor_update_raa_while_paused() {
|
|||
let mut nodes = create_network(2, &[None, None]);
|
||||
create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
send_payment(&nodes[0], &[&nodes[1]], 5000000);
|
||||
send_payment(&nodes[0], &[&nodes[1]], 5000000, 5_000_000);
|
||||
|
||||
let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
|
||||
let (payment_preimage_1, our_payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
|
||||
|
|
@ -655,8 +655,8 @@ fn test_monitor_update_raa_while_paused() {
|
|||
expect_pending_htlcs_forwardable!(nodes[1]);
|
||||
expect_payment_received!(nodes[1], our_payment_hash_1, 1000000);
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
|
||||
claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
|
||||
claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
|
||||
|
|
@ -666,7 +666,7 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
|
|||
let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance a bit so that we can send backwards from 2 to 1.
|
||||
send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000);
|
||||
send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
|
||||
|
||||
// Route a first payment that we'll fail backwards
|
||||
let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
|
||||
|
|
@ -897,10 +897,10 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
|
|||
Event::PaymentReceived { payment_hash, .. } => assert_eq!(payment_hash, payment_hash_4.unwrap()),
|
||||
_ => panic!("Unexpected event"),
|
||||
};
|
||||
claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap());
|
||||
claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap(), 1_000_000);
|
||||
}
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -923,7 +923,7 @@ fn test_monitor_update_fail_reestablish() {
|
|||
nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
|
||||
nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
|
||||
|
||||
assert!(nodes[2].node.claim_funds(our_payment_preimage));
|
||||
assert!(nodes[2].node.claim_funds(our_payment_preimage, 1_000_000));
|
||||
check_added_monitors!(nodes[2], 1);
|
||||
let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
|
||||
assert!(updates.update_add_htlcs.is_empty());
|
||||
|
|
@ -1092,9 +1092,9 @@ fn raa_no_response_awaiting_raa_state() {
|
|||
expect_pending_htlcs_forwardable!(nodes[1]);
|
||||
expect_payment_received!(nodes[1], payment_hash_3, 1000000);
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1114,7 +1114,7 @@ fn claim_while_disconnected_monitor_update_fail() {
|
|||
nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
|
||||
nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
|
||||
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1));
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
|
||||
nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
|
||||
|
|
@ -1211,7 +1211,7 @@ fn claim_while_disconnected_monitor_update_fail() {
|
|||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1271,7 +1271,7 @@ fn monitor_failed_no_reestablish_response() {
|
|||
expect_pending_htlcs_forwardable!(nodes[1]);
|
||||
expect_payment_received!(nodes[1], payment_hash_1, 1000000);
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1360,8 +1360,8 @@ fn first_message_on_recv_ordering() {
|
|||
expect_pending_htlcs_forwardable!(nodes[1]);
|
||||
expect_payment_received!(nodes[1], payment_hash_2, 1000000);
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1376,12 +1376,12 @@ fn test_monitor_update_fail_claim() {
|
|||
create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance a bit so that we can send backwards from 3 to 2.
|
||||
send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000);
|
||||
send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
|
||||
|
||||
let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
|
||||
|
||||
*nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1));
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
|
||||
let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
|
||||
|
|
@ -1446,7 +1446,7 @@ fn test_monitor_update_on_pending_forwards() {
|
|||
create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance a bit so that we can send backwards from 3 to 1.
|
||||
send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000);
|
||||
send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
|
||||
|
||||
let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
|
||||
assert!(nodes[2].node.fail_htlc_backwards(&payment_hash_1));
|
||||
|
|
@ -1496,7 +1496,7 @@ fn test_monitor_update_on_pending_forwards() {
|
|||
nodes[0].node.process_pending_htlc_forwards();
|
||||
expect_payment_received!(nodes[0], payment_hash_2, 1000000);
|
||||
|
||||
claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2);
|
||||
claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1524,7 +1524,7 @@ fn monitor_update_claim_fail_no_response() {
|
|||
let as_raa = commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false, true, false, true);
|
||||
|
||||
*nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1));
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
|
||||
|
||||
|
|
@ -1551,7 +1551,7 @@ fn monitor_update_claim_fail_no_response() {
|
|||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
// Note that restore_between_fails with !fail_on_generate is useless
|
||||
|
|
@ -1671,7 +1671,7 @@ fn do_during_funding_monitor_fail(fail_on_generate: bool, restore_between_fails:
|
|||
node.router.handle_channel_update(&bs_update).unwrap();
|
||||
}
|
||||
|
||||
send_payment(&nodes[0], &[&nodes[1]], 8000000);
|
||||
send_payment(&nodes[0], &[&nodes[1]], 8000000, 8_000_000);
|
||||
close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1606,8 +1606,15 @@ impl ChannelManager {
|
|||
/// generating message events for the net layer to claim the payment, if possible. Thus, you
|
||||
/// should probably kick the net layer to go send messages if this returns true!
|
||||
///
|
||||
/// You must specify the expected amounts for this HTLC, and we will only claim HTLCs
|
||||
/// available within a few percent of the expected amount. This is critical for several
|
||||
/// reasons : a) it avoids providing senders with `proof-of-payment` (in the form of the
|
||||
/// payment_preimage without having provided the full value and b) it avoids certain
|
||||
/// privacy-breaking recipient-probing attacks which may reveal payment activity to
|
||||
/// motivated attackers.
|
||||
///
|
||||
/// May panic if called except in response to a PaymentReceived event.
|
||||
pub fn claim_funds(&self, payment_preimage: PaymentPreimage) -> bool {
|
||||
pub fn claim_funds(&self, payment_preimage: PaymentPreimage, expected_amount: u64) -> bool {
|
||||
let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
|
||||
|
||||
let _ = self.total_consistency_lock.read().unwrap();
|
||||
|
|
@ -1615,12 +1622,18 @@ impl ChannelManager {
|
|||
let mut channel_state = Some(self.channel_state.lock().unwrap());
|
||||
let removed_source = channel_state.as_mut().unwrap().claimable_htlcs.remove(&payment_hash);
|
||||
if let Some(mut sources) = removed_source {
|
||||
// TODO: We should require the user specify the expected amount so that we can claim
|
||||
// only payments for the correct amount, and reject payments for incorrect amounts
|
||||
// (which are probably middle nodes probing to break our privacy).
|
||||
for (_, htlc_with_hash) in sources.drain(..) {
|
||||
for (received_amount, htlc_with_hash) in sources.drain(..) {
|
||||
if channel_state.is_none() { channel_state = Some(self.channel_state.lock().unwrap()); }
|
||||
self.claim_funds_internal(channel_state.take().unwrap(), HTLCSource::PreviousHopData(htlc_with_hash), payment_preimage);
|
||||
if received_amount < expected_amount || received_amount > expected_amount * 2 {
|
||||
let mut htlc_msat_data = byte_utils::be64_to_array(received_amount).to_vec();
|
||||
let mut height_data = byte_utils::be32_to_array(self.latest_block_height.load(Ordering::Acquire) as u32).to_vec();
|
||||
htlc_msat_data.append(&mut height_data);
|
||||
self.fail_htlc_backwards_internal(channel_state.take().unwrap(),
|
||||
HTLCSource::PreviousHopData(htlc_with_hash), &payment_hash,
|
||||
HTLCFailReason::Reason { failure_code: 0x4000|15, data: htlc_msat_data });
|
||||
} else {
|
||||
self.claim_funds_internal(channel_state.take().unwrap(), HTLCSource::PreviousHopData(htlc_with_hash), payment_preimage);
|
||||
}
|
||||
}
|
||||
true
|
||||
} else { false }
|
||||
|
|
|
|||
|
|
@ -636,8 +636,8 @@ pub fn send_along_route(origin_node: &Node, route: Route, expected_route: &[&Nod
|
|||
(our_payment_preimage, our_payment_hash)
|
||||
}
|
||||
|
||||
pub fn claim_payment_along_route(origin_node: &Node, expected_route: &[&Node], skip_last: bool, our_payment_preimage: PaymentPreimage) {
|
||||
assert!(expected_route.last().unwrap().node.claim_funds(our_payment_preimage));
|
||||
pub fn claim_payment_along_route(origin_node: &Node, expected_route: &[&Node], skip_last: bool, our_payment_preimage: PaymentPreimage, expected_amount: u64) {
|
||||
assert!(expected_route.last().unwrap().node.claim_funds(our_payment_preimage, expected_amount));
|
||||
check_added_monitors!(expected_route.last().unwrap(), 1);
|
||||
|
||||
let mut next_msgs: Option<(msgs::UpdateFulfillHTLC, msgs::CommitmentSigned)> = None;
|
||||
|
|
@ -714,8 +714,8 @@ pub fn claim_payment_along_route(origin_node: &Node, expected_route: &[&Node], s
|
|||
}
|
||||
}
|
||||
|
||||
pub fn claim_payment(origin_node: &Node, expected_route: &[&Node], our_payment_preimage: PaymentPreimage) {
|
||||
claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage);
|
||||
pub fn claim_payment(origin_node: &Node, expected_route: &[&Node], our_payment_preimage: PaymentPreimage, expected_amount: u64) {
|
||||
claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage, expected_amount);
|
||||
}
|
||||
|
||||
pub const TEST_FINAL_CLTV: u32 = 32;
|
||||
|
|
@ -746,9 +746,9 @@ pub fn route_over_limit(origin_node: &Node, expected_route: &[&Node], recv_value
|
|||
};
|
||||
}
|
||||
|
||||
pub fn send_payment(origin: &Node, expected_route: &[&Node], recv_value: u64) {
|
||||
pub fn send_payment(origin: &Node, expected_route: &[&Node], recv_value: u64, expected_value: u64) {
|
||||
let our_payment_preimage = route_payment(&origin, expected_route, recv_value).0;
|
||||
claim_payment(&origin, expected_route, our_payment_preimage);
|
||||
claim_payment(&origin, expected_route, our_payment_preimage, expected_value);
|
||||
}
|
||||
|
||||
pub fn fail_payment_along_route(origin_node: &Node, expected_route: &[&Node], skip_last: bool, our_payment_hash: PaymentHash) {
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ fn test_async_inbound_update_fee() {
|
|||
let channel_id = chan.2;
|
||||
|
||||
// balancing
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
|
||||
// A B
|
||||
// update_fee ->
|
||||
|
|
@ -218,7 +218,7 @@ fn test_update_fee_unordered_raa() {
|
|||
let channel_id = chan.2;
|
||||
|
||||
// balancing
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
|
||||
// First nodes[0] generates an update_fee
|
||||
nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
|
||||
|
|
@ -463,7 +463,7 @@ fn test_update_fee_with_fundee_update_add_htlc() {
|
|||
let channel_id = chan.2;
|
||||
|
||||
// balancing
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
|
||||
let feerate = get_feerate!(nodes[0], channel_id);
|
||||
nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
|
||||
|
|
@ -543,10 +543,10 @@ fn test_update_fee_with_fundee_update_add_htlc() {
|
|||
_ => panic!("Unexpected event"),
|
||||
};
|
||||
|
||||
claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage);
|
||||
claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage, 800_000);
|
||||
|
||||
send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000, 800_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000, 800_000);
|
||||
close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
|
||||
}
|
||||
|
||||
|
|
@ -702,7 +702,7 @@ fn updates_shutdown_wait() {
|
|||
if let Err(APIError::ChannelUnavailable {..}) = nodes[1].node.send_payment(route_2, payment_hash) {}
|
||||
else { panic!("New sends should fail!") };
|
||||
|
||||
assert!(nodes[2].node.claim_funds(our_payment_preimage));
|
||||
assert!(nodes[2].node.claim_funds(our_payment_preimage, 100_000));
|
||||
check_added_monitors!(nodes[2], 1);
|
||||
let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
|
||||
assert!(updates.update_add_htlcs.is_empty());
|
||||
|
|
@ -875,7 +875,7 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) {
|
|||
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
|
||||
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
|
||||
|
||||
assert!(nodes[2].node.claim_funds(our_payment_preimage));
|
||||
assert!(nodes[2].node.claim_funds(our_payment_preimage, 100_000));
|
||||
check_added_monitors!(nodes[2], 1);
|
||||
let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
|
||||
assert!(updates.update_add_htlcs.is_empty());
|
||||
|
|
@ -993,15 +993,15 @@ fn fake_network_test() {
|
|||
let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance the network a bit by relaying one payment through all the channels...
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
|
||||
|
||||
// Send some more payments
|
||||
send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000);
|
||||
send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000);
|
||||
send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000, 1_000_000);
|
||||
send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000, 1_000_000);
|
||||
send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000, 1_000_000);
|
||||
|
||||
// Test failure packets
|
||||
let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1;
|
||||
|
|
@ -1010,13 +1010,13 @@ fn fake_network_test() {
|
|||
// Add a new channel that skips 3
|
||||
let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000);
|
||||
send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000, 1_000_000);
|
||||
send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000, 1_000_000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
|
||||
|
||||
// Do some rebalance loop payments, simultaneously
|
||||
let mut hops = Vec::with_capacity(3);
|
||||
|
|
@ -1067,7 +1067,7 @@ fn fake_network_test() {
|
|||
|
||||
// Claim the rebalances...
|
||||
fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2);
|
||||
claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1);
|
||||
claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1, 1_000_000);
|
||||
|
||||
// Add a duplicate new channel from 2 to 4
|
||||
let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
|
@ -1081,9 +1081,9 @@ fn fake_network_test() {
|
|||
|
||||
//TODO: Test that routes work again here as we've been notified that the channel is full
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3, 3_000_000);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4, 3_000_000);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5, 3_000_000);
|
||||
|
||||
// Close down the channels...
|
||||
close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true);
|
||||
|
|
@ -1213,10 +1213,10 @@ fn holding_cell_htlc_counting() {
|
|||
}
|
||||
|
||||
for (preimage, _) in payments.drain(..) {
|
||||
claim_payment(&nodes[1], &[&nodes[2]], preimage);
|
||||
claim_payment(&nodes[1], &[&nodes[2]], preimage, 100_000);
|
||||
}
|
||||
|
||||
send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
|
||||
send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1240,9 +1240,9 @@ fn duplicate_htlc_test() {
|
|||
*nodes[0].network_payment_count.borrow_mut() -= 1;
|
||||
assert_eq!(route_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], 1000000).0, payment_preimage);
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage, 1_000_000);
|
||||
fail_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], payment_hash);
|
||||
claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage);
|
||||
claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1255,7 +1255,7 @@ fn test_duplicate_htlc_different_direction_onchain() {
|
|||
let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// balancing
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
|
||||
let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000);
|
||||
|
||||
|
|
@ -1263,7 +1263,7 @@ fn test_duplicate_htlc_different_direction_onchain() {
|
|||
send_along_route_with_hash(&nodes[1], route, &vec!(&nodes[0])[..], 800_000, payment_hash);
|
||||
|
||||
// Provide preimage to node 0 by claiming payment
|
||||
nodes[0].node.claim_funds(payment_preimage);
|
||||
nodes[0].node.claim_funds(payment_preimage, 800_000);
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
|
||||
// Broadcast node 1 commitment txn
|
||||
|
|
@ -1367,7 +1367,7 @@ fn do_channel_reserve_test(test_recv: bool) {
|
|||
if stat01.value_to_self_msat - amt_msat < stat01.channel_reserve_msat {
|
||||
break;
|
||||
}
|
||||
send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0);
|
||||
send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0, recv_value_0);
|
||||
htlc_id += 1;
|
||||
|
||||
let (stat01_, stat11_, stat12_, stat22_) = (
|
||||
|
|
@ -1550,9 +1550,9 @@ fn do_channel_reserve_test(test_recv: bool) {
|
|||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1, recv_value_1);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21, recv_value_21);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22, recv_value_22);
|
||||
|
||||
let expected_value_to_self = stat01.value_to_self_msat - (recv_value_1 + total_fee_msat) - (recv_value_21 + total_fee_msat) - (recv_value_22 + total_fee_msat);
|
||||
let stat0 = get_channel_value_stat!(nodes[0], chan_1.2);
|
||||
|
|
@ -1614,13 +1614,13 @@ fn channel_reserve_in_flight_removes() {
|
|||
|
||||
// Now claim both of the first two HTLCs on B's end, putting B in AwaitingRAA and generating an
|
||||
// initial fulfill/CS.
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1));
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1, b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
let bs_removes = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
|
||||
|
||||
// This claim goes in B's holding cell, allowing us to have a pending B->A RAA which does not
|
||||
// remove the second HTLC when we send the HTLC back from B to A.
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_2));
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_2, 20000));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
|
||||
|
||||
|
|
@ -1712,8 +1712,8 @@ fn channel_reserve_in_flight_removes() {
|
|||
expect_pending_htlcs_forwardable!(nodes[0]);
|
||||
expect_payment_received!(nodes[0], payment_hash_4, 10000);
|
||||
|
||||
claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3);
|
||||
claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4, 10_000);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 100_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1729,10 +1729,10 @@ fn channel_monitor_network_test() {
|
|||
let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance the network a bit by relaying one payment through all the channels...
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
|
||||
|
||||
// Simple case with no pending HTLCs:
|
||||
nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true);
|
||||
|
|
@ -1762,9 +1762,9 @@ fn channel_monitor_network_test() {
|
|||
assert_eq!(nodes[2].node.list_channels().len(), 1);
|
||||
|
||||
macro_rules! claim_funds {
|
||||
($node: expr, $prev_node: expr, $preimage: expr) => {
|
||||
($node: expr, $prev_node: expr, $preimage: expr, $amount: expr) => {
|
||||
{
|
||||
assert!($node.node.claim_funds($preimage));
|
||||
assert!($node.node.claim_funds($preimage, $amount));
|
||||
check_added_monitors!($node, 1);
|
||||
|
||||
let events = $node.node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -1788,7 +1788,7 @@ fn channel_monitor_network_test() {
|
|||
let node_txn = test_txn_broadcast(&nodes[2], &chan_3, None, HTLCType::TIMEOUT);
|
||||
|
||||
// Claim the payment on nodes[3], giving it knowledge of the preimage
|
||||
claim_funds!(nodes[3], nodes[2], payment_preimage_1);
|
||||
claim_funds!(nodes[3], nodes[2], payment_preimage_1, 3_000_000);
|
||||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[3].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()] }, 1);
|
||||
|
|
@ -1822,7 +1822,7 @@ fn channel_monitor_network_test() {
|
|||
let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
|
||||
|
||||
// Claim the payment on nodes[4], giving it knowledge of the preimage
|
||||
claim_funds!(nodes[4], nodes[3], payment_preimage_2);
|
||||
claim_funds!(nodes[4], nodes[3], payment_preimage_2, 3_000_000);
|
||||
|
||||
header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[4].chain_monitor.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
|
||||
|
|
@ -1871,7 +1871,7 @@ fn test_justice_tx() {
|
|||
assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
|
||||
assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
|
||||
// Revoke the old state
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 3_000_000);
|
||||
|
||||
{
|
||||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
|
|
@ -1911,7 +1911,7 @@ fn test_justice_tx() {
|
|||
assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_6.3.txid());
|
||||
assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to A are present
|
||||
// Revoke the old state
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4, 3_000_000);
|
||||
{
|
||||
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
|
||||
|
|
@ -1949,7 +1949,7 @@ fn revoked_output_claim() {
|
|||
// Only output is the full channel value back to nodes[0]:
|
||||
assert_eq!(revoked_local_txn[0].output.len(), 1);
|
||||
// Send a payment through, updating everyone's latest commitment txn
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000, 5_000_000);
|
||||
|
||||
// Inform nodes[1] that nodes[0] broadcast a stale tx
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
|
|
@ -1976,7 +1976,7 @@ fn claim_htlc_outputs_shared_tx() {
|
|||
let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance the network to generate htlc in the two directions
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
// node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx
|
||||
let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
|
||||
let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
|
||||
|
|
@ -1992,7 +1992,7 @@ fn claim_htlc_outputs_shared_tx() {
|
|||
check_spends!(revoked_local_txn[1], revoked_local_txn[0].clone());
|
||||
|
||||
//Revoke the old state
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
|
||||
|
||||
{
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
|
|
@ -2050,7 +2050,7 @@ fn claim_htlc_outputs_single_tx() {
|
|||
let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance the network to generate htlc in the two directions
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
// node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx, but this
|
||||
// time as two different claim transactions as we're gonna to timeout htlc with given a high current height
|
||||
let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
|
||||
|
|
@ -2060,7 +2060,7 @@ fn claim_htlc_outputs_single_tx() {
|
|||
let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
|
||||
|
||||
//Revoke the old state
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
|
||||
|
||||
{
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
|
|
@ -2154,8 +2154,8 @@ fn test_htlc_on_chain_success() {
|
|||
let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance the network a bit by relaying one payment through all the channels...
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
|
||||
|
||||
let (our_payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
|
||||
let (our_payment_preimage_2, _payment_hash_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
|
||||
|
|
@ -2166,8 +2166,8 @@ fn test_htlc_on_chain_success() {
|
|||
let commitment_tx = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
|
||||
assert_eq!(commitment_tx.len(), 1);
|
||||
check_spends!(commitment_tx[0], chan_2.3.clone());
|
||||
nodes[2].node.claim_funds(our_payment_preimage);
|
||||
nodes[2].node.claim_funds(our_payment_preimage_2);
|
||||
nodes[2].node.claim_funds(our_payment_preimage, 3_000_000);
|
||||
nodes[2].node.claim_funds(our_payment_preimage_2, 3_000_000);
|
||||
check_added_monitors!(nodes[2], 2);
|
||||
let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
|
||||
assert!(updates.update_add_htlcs.is_empty());
|
||||
|
|
@ -2315,8 +2315,8 @@ fn test_htlc_on_chain_timeout() {
|
|||
let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance the network a bit by relaying one payment thorugh all the channels...
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
|
||||
|
||||
let (_payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
|
||||
|
|
@ -2426,7 +2426,7 @@ fn test_simple_commitment_revoked_fail_backward() {
|
|||
// Get the will-be-revoked local txn from nodes[2]
|
||||
let revoked_local_txn = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
|
||||
// Revoke the old state
|
||||
claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
|
||||
claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, 3_000_000);
|
||||
|
||||
route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
|
||||
|
||||
|
|
@ -2495,7 +2495,7 @@ fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use
|
|||
let revoked_local_txn = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
|
||||
assert_eq!(revoked_local_txn[0].output.len(), if no_to_remote { 1 } else { 2 });
|
||||
// Revoke the old state
|
||||
claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
|
||||
claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, if no_to_remote { 10_000 } else { 3_000_000});
|
||||
|
||||
let value = if use_dust {
|
||||
// The dust limit applied to HTLC outputs considers the fee of the HTLC transaction as
|
||||
|
|
@ -2831,7 +2831,7 @@ fn test_simple_peer_disconnect() {
|
|||
let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
|
||||
let payment_hash_2 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
|
||||
fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_2);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1, 1_000_000);
|
||||
|
||||
nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
|
||||
nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
|
||||
|
|
@ -2845,7 +2845,7 @@ fn test_simple_peer_disconnect() {
|
|||
nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
|
||||
nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
|
||||
|
||||
claim_payment_along_route(&nodes[0], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3);
|
||||
claim_payment_along_route(&nodes[0], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3, 1_000_000);
|
||||
fail_payment_along_route(&nodes[0], &[&nodes[1], &nodes[2]], true, payment_hash_5);
|
||||
|
||||
reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (1, 0), (1, 0), (false, false));
|
||||
|
|
@ -2867,7 +2867,7 @@ fn test_simple_peer_disconnect() {
|
|||
}
|
||||
}
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4, 1_000_000);
|
||||
fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_6);
|
||||
}
|
||||
|
||||
|
|
@ -2967,7 +2967,7 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
|
|||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
|
||||
nodes[1].node.claim_funds(payment_preimage_1);
|
||||
nodes[1].node.claim_funds(payment_preimage_1, 1_000_000);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
|
||||
let events_3 = nodes[1].node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -3058,7 +3058,7 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
|
|||
|
||||
// Channel should still work fine...
|
||||
let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -3123,7 +3123,7 @@ fn test_funding_peer_disconnect() {
|
|||
|
||||
let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
|
||||
let (payment_preimage, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -3149,7 +3149,7 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
|
|||
_ => panic!("Unexpected event"),
|
||||
}
|
||||
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1));
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
|
||||
let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -3262,7 +3262,7 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
|
|||
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -3400,7 +3400,7 @@ fn test_no_txn_manager_serialize_deserialize() {
|
|||
node.router.handle_channel_update(&bs_update).unwrap();
|
||||
}
|
||||
|
||||
send_payment(&nodes[0], &[&nodes[1]], 1000000);
|
||||
send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -3447,7 +3447,7 @@ fn test_simple_manager_serialize_deserialize() {
|
|||
reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
|
||||
|
||||
fail_payment(&nodes[0], &[&nodes[1]], our_payment_hash);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage);
|
||||
claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage, 1_000_000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -3517,7 +3517,7 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
|
|||
reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
|
||||
reconnect_nodes(&nodes[0], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
|
||||
//... and we can even still claim the payment!
|
||||
claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage);
|
||||
claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage, 1_000_000);
|
||||
|
||||
nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id());
|
||||
let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
|
||||
|
|
@ -3697,7 +3697,7 @@ fn test_claim_on_remote_revoked_sizeable_push_msat() {
|
|||
assert_eq!(revoked_local_txn[0].input.len(), 1);
|
||||
assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
|
||||
check_closed_broadcast!(nodes[1]);
|
||||
|
|
@ -3726,7 +3726,7 @@ fn test_static_spendable_outputs_preimage_tx() {
|
|||
|
||||
// Settle A's commitment tx on B's chain
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage));
|
||||
assert!(nodes[1].node.claim_funds(payment_preimage, 3_000_000));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 1);
|
||||
let events = nodes[1].node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -3764,7 +3764,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
|
|||
assert_eq!(revoked_local_txn[0].input.len(), 1);
|
||||
assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
|
||||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
|
||||
|
|
@ -3794,7 +3794,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
|
|||
assert_eq!(revoked_local_txn[0].input.len(), 1);
|
||||
assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
|
||||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
// A will generate HTLC-Timeout from revoked commitment tx
|
||||
|
|
@ -3838,7 +3838,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
|
|||
assert_eq!(revoked_local_txn[0].input.len(), 1);
|
||||
assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
|
||||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
// B will generate HTLC-Success from revoked commitment tx
|
||||
|
|
@ -3888,14 +3888,14 @@ fn test_onchain_to_onchain_claim() {
|
|||
let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance the network a bit by relaying one payment through all the channels ...
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
|
||||
|
||||
let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
|
||||
let commitment_tx = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
|
||||
check_spends!(commitment_tx[0], chan_2.3.clone());
|
||||
nodes[2].node.claim_funds(payment_preimage);
|
||||
nodes[2].node.claim_funds(payment_preimage, 3_000_000);
|
||||
check_added_monitors!(nodes[2], 1);
|
||||
let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
|
||||
assert!(updates.update_add_htlcs.is_empty());
|
||||
|
|
@ -4003,7 +4003,7 @@ fn test_duplicate_payment_hash_one_failure_one_success() {
|
|||
htlc_timeout_tx = node_txn[1].clone();
|
||||
}
|
||||
|
||||
nodes[2].node.claim_funds(our_payment_preimage);
|
||||
nodes[2].node.claim_funds(our_payment_preimage, 900_000);
|
||||
nodes[2].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
|
||||
check_added_monitors!(nodes[2], 2);
|
||||
let events = nodes[2].node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -4094,7 +4094,7 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
|
|||
check_spends!(local_txn[0], chan_1.3.clone());
|
||||
|
||||
// Give B knowledge of preimage to be able to generate a local HTLC-Success Tx
|
||||
nodes[1].node.claim_funds(payment_preimage);
|
||||
nodes[1].node.claim_funds(payment_preimage, 9_000_000);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![local_txn[0].clone()] }, 1);
|
||||
|
|
@ -4141,8 +4141,8 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno
|
|||
create_announced_chan_between_nodes(&nodes, 3, 5, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance and check output sanity...
|
||||
send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000);
|
||||
send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000);
|
||||
send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000, 500_000);
|
||||
send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000, 500_000);
|
||||
assert_eq!(nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().last_local_commitment_txn[0].output.len(), 2);
|
||||
|
||||
let ds_dust_limit = nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
|
||||
|
|
@ -4410,7 +4410,7 @@ fn test_static_output_closing_tx() {
|
|||
|
||||
let chan = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2;
|
||||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
|
|
@ -4433,7 +4433,7 @@ fn do_htlc_claim_local_commitment_only(use_dust: bool) {
|
|||
|
||||
// Claim the payment, but don't deliver A's commitment_signed, resulting in the HTLC only being
|
||||
// present in B's local commitment transaction, but none of A's commitment transactions.
|
||||
assert!(nodes[1].node.claim_funds(our_payment_preimage));
|
||||
assert!(nodes[1].node.claim_funds(our_payment_preimage, if use_dust { 50_000 } else { 3_000_000 }));
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
|
||||
let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
|
||||
|
|
@ -4778,7 +4778,7 @@ fn test_onion_failure() {
|
|||
let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
|
||||
let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV).unwrap();
|
||||
// positve case
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000, 40_000);
|
||||
|
||||
// intermediate node failure
|
||||
run_onion_failure_test("invalid_realm", 0, &nodes, &route, &payment_hash, |msg| {
|
||||
|
|
@ -5134,7 +5134,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
|
|||
let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, LocalFeatures::new(), LocalFeatures::new());
|
||||
let max_in_flight = get_channel_value_stat!(nodes[0], chan.2).their_max_htlc_value_in_flight_msat;
|
||||
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight, max_in_flight);
|
||||
|
||||
let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], max_in_flight+1, TEST_FINAL_CLTV).unwrap();
|
||||
let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
|
||||
|
|
@ -5146,7 +5146,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
|
|||
assert!(false);
|
||||
}
|
||||
|
||||
send_payment(&nodes[0], &[&nodes[1]], max_in_flight);
|
||||
send_payment(&nodes[0], &[&nodes[1]], max_in_flight, max_in_flight);
|
||||
}
|
||||
|
||||
// BOLT 2 Requirements for the Receiver when handling an update_add_htlc message.
|
||||
|
|
@ -5449,7 +5449,7 @@ fn test_update_fulfill_htlc_bolt2_incorrect_htlc_id() {
|
|||
|
||||
let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
|
||||
|
||||
nodes[1].node.claim_funds(our_payment_preimage);
|
||||
nodes[1].node.claim_funds(our_payment_preimage, 100_000);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
|
||||
let events = nodes[1].node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -5490,7 +5490,7 @@ fn test_update_fulfill_htlc_bolt2_wrong_preimage() {
|
|||
|
||||
let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
|
||||
|
||||
nodes[1].node.claim_funds(our_payment_preimage);
|
||||
nodes[1].node.claim_funds(our_payment_preimage, 100_000);
|
||||
check_added_monitors!(nodes[1], 1);
|
||||
|
||||
let events = nodes[1].node.get_and_clear_pending_msg_events();
|
||||
|
|
@ -5741,7 +5741,7 @@ fn test_no_failure_dust_htlc_local_commitment() {
|
|||
let chan = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
|
||||
|
||||
// Rebalance a bit
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
|
||||
let as_dust_limit = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
|
||||
let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
|
||||
|
|
@ -5779,8 +5779,8 @@ fn test_no_failure_dust_htlc_local_commitment() {
|
|||
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
|
||||
assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
|
||||
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], preimage_1);
|
||||
claim_payment(&nodes[1], &vec!(&nodes[0])[..], preimage_2);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], preimage_1, bs_dust_limit*1000);
|
||||
claim_payment(&nodes[1], &vec!(&nodes[0])[..], preimage_2, as_dust_limit*1000);
|
||||
}
|
||||
|
||||
fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
|
||||
|
|
@ -5805,7 +5805,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
|
|||
// We revoked bs_commitment_tx
|
||||
if revoked {
|
||||
let (payment_preimage_3, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3);
|
||||
claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 1_000_000);
|
||||
}
|
||||
|
||||
let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
|
||||
|
|
@ -6081,8 +6081,8 @@ fn test_data_loss_protect() {
|
|||
let mut previous_chan_monitor_state = test_utils::TestVecWriter(Vec::new());
|
||||
nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut previous_chan_monitor_state).unwrap();
|
||||
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
|
||||
|
||||
nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
|
||||
nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue